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                                 if(paramPair.getValue() instanceof java.lang.Long){
 272                                         hbquery.setLong(paramPair.getKey(), (long) paramPair.getValue());
 273                                 }
 274                                 else{
 275                                         hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 276                                 }
 277                         }
 278                         data = hbquery.list();
 279                         tx.commit();
 280                 } catch (Exception e) {
 281                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 282                         throw e;
 283                 }finally{
 284                         try{
 285                                 session.close();
 286                         }catch(HibernateException e1){
 287                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 288                         }
 289                 }
 290                 return data;
 291         }
 292
 293
 294         @SuppressWarnings("rawtypes")
 295         @Override
 296         public Object getEntityItem(Class className, String columnName, String key) {
 297                 Session session = sessionfactory.openSession();
 298                 Transaction tx = session.beginTransaction();
 299                 Object data = null;
 300                 try {
 301                         Criteria cr = session.createCriteria(className);
 302                         if(columnName.contains(":") && key.contains(":")){
 303                                 String[] columns = columnName.split(":");
 304                                 String[] keys = key.split(":");
 305                                 for(int i=0; i < columns.length; i++){
 306                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 307                                 }
 308                         }else{
 309                                 cr.add(Restrictions.eq(columnName, key));
 310                         }
 311                         data = cr.list().get(0);
 312                         tx.commit();
 313                 } catch (Exception e) {
 314                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 315                 }finally{
 316                         try{
 317                                 session.close();
 318                         }catch(Exception e1){
 319                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 320                         }
 321                 }
 322                 return data;
 323         }
 324
 325
 326         @Override
 327         public void updateClAlarms(String arg0, String arg1) {}
 328
 329
 330         @Override
 331         public void updateClYaml(String arg0, String arg1) {}
 332
 333
 334         @Override
 335         public void updateQuery(String query) {
 336                 Session session = sessionfactory.openSession();
 337                 Transaction tx = session.beginTransaction();
 338                 try {
 339                         Query hbquery = session.createQuery(query);
 340                         hbquery.executeUpdate();
 341                         tx.commit();
 342                 } catch (Exception e) {
 343                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e);
 344                 }finally{
 345                         try{
 346                                 session.close();
 347                         }catch(Exception e1){
 348                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 349                         }
 350                 }
 351
 352         }
 353
 354
 355         @SuppressWarnings({ "rawtypes", "unchecked" })
 356         @Override
 357         public List<String> getDataByColumn(Class className, String columnName) {
 358                 Session session = sessionfactory.openSession();
 359                 List<String> data = null;
 360                 try{
 361                         Criteria cr = session.createCriteria(className);
 362                         cr.setProjection(Projections.property(columnName));
 363                         data = cr.list();
 364                 }catch(Exception e){
 365                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 366                 }finally{
 367                         try{
 368                                 session.close();
 369                         }catch(Exception e){
 370                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
 371                         }
 372                 }
 373                 return data;
 374         }
 375
 376
 377         @SuppressWarnings({ "rawtypes", "unchecked" })
 378         @Override
 379         public List<Object> getMultipleDataOnAddingConjunction(Class className, String columnName, List<String> data) {
 380                 Session session = sessionfactory.openSession();
 381                 Transaction tx = session.beginTransaction();
 382                 List<Object> entityData = null;
 383                 try {
 384                         Criteria cr = session.createCriteria(className);
 385                         Disjunction disjunction = Restrictions.disjunction();
 386                         List<Conjunction> conjunctionList = new ArrayList<>();
 387                         String[] columNames = columnName.split(":");
 388                         for(int i =0; i < data.size(); i++){
 389                                 String[] entiySplit = data.get(i).split(":");
 390                                 Conjunction conjunction = Restrictions.conjunction();
 391                                 conjunction.add(Restrictions.eq(columNames[0], entiySplit[0]));
 392                                 conjunction.add(Restrictions.eq(columNames[1], entiySplit[1]));
 393                                 conjunctionList.add(conjunction);
 394                         }
 395                         for(int j =0 ; j < conjunctionList.size(); j++){
 396                                 disjunction.add(conjunctionList.get(j));
 397                         }
 398                         entityData = cr.add(disjunction).list();
 399                         tx.commit();
 400                 } catch (Exception e) {
 401                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" +className +e);
 402                 }finally{
 403                         try{
 404                                 session.close();
 405                         }catch(Exception e1){
 406                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 407                         }
 408                 }
 409                 return entityData;
 410         }
 411
 412 }