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.Query;
  31 import org.hibernate.Session;
  32 import org.hibernate.SessionFactory;
  33 import org.hibernate.Transaction;
  34 import org.hibernate.criterion.Conjunction;
  35 import org.hibernate.criterion.Disjunction;
  36 import org.hibernate.criterion.Projections;
  37 import org.hibernate.criterion.Restrictions;
  38 import org.onap.policy.common.logging.flexlogger.FlexLogger;
  39 import org.onap.policy.common.logging.flexlogger.Logger;
  40 import org.onap.policy.rest.dao.CommonClassDao;
  41 import org.onap.policy.rest.jpa.PolicyRoles;
  42 import org.onap.policy.xacml.api.XACMLErrorConstants;
  43 import org.springframework.beans.factory.annotation.Autowired;
  44 import org.springframework.stereotype.Service;
  45
  46 @Service("CommonClassDao")
  47 public class CommonClassDaoImpl implements CommonClassDao{
  48
  49         private static final Logger LOGGER = FlexLogger.getLogger(CommonClassDaoImpl.class);
  50         private static SessionFactory sessionfactory;
  51
  52     public static SessionFactory getSessionfactory() {
  53           return sessionfactory;
  54     }
  55
  56     public static void setSessionfactory(SessionFactory sessionfactory) {
  57           CommonClassDaoImpl.sessionfactory = sessionfactory;
  58     }
  59
  60     @Autowired
  61     private CommonClassDaoImpl(SessionFactory sessionfactory){
  62           CommonClassDaoImpl.sessionfactory = sessionfactory;
  63     }
  64
  65     public CommonClassDaoImpl(){
  66           //Default Constructor
  67     }
  68
  69
  70
  71         @SuppressWarnings({ "unchecked", "rawtypes" })
  72         @Override
  73         public List<Object> getData(Class className) {
  74                 Session session = sessionfactory.openSession();
  75                 List<Object> data = null;
  76                 try{
  77                         Criteria cr = session.createCriteria(className);
  78                         data = cr.list();
  79                 }catch(Exception e){
  80                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
  81                 }finally{
  82                         try{
  83                                 session.close();
  84                         }catch(Exception e){
  85                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
  86                         }
  87                 }
  88                 return data;
  89         }
  90
  91
  92         @SuppressWarnings({ "rawtypes", "unchecked" })
  93         @Override
  94         public List<Object> getDataById(Class className, String columnName, String key) {
  95                 Session session = sessionfactory.openSession();
  96                 List<Object> data = null;
  97                 try {
  98                         Criteria cr = session.createCriteria(className);
  99                         if(columnName.contains(":") && key.contains(":")){
 100                                 String[] columns = columnName.split(":");
 101                                 String[] keys = key.split(":");
 102                                 for(int i=0; i < columns.length; i++){
 103                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 104                                 }
 105                         }else{
 106                                 cr.add(Restrictions.eq(columnName, key));
 107                         }
 108                         data = cr.list();
 109                 } catch (Exception e) {
 110                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 111                 }finally{
 112                         try{
 113                                 session.close();
 114                         }catch(Exception e1){
 115                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 116                         }
 117                 }
 118                 return data;
 119         }
 120
 121         @Override
 122         public void save(Object entity) {
 123                 Session session = sessionfactory.openSession();
 124                 Transaction tx = session.beginTransaction();
 125                 try {
 126                         session.persist(entity);
 127                         tx.commit();
 128                 }catch(Exception e){
 129                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table"+e);
 130                 }finally{
 131                         try{
 132                                 session.close();
 133                         }catch(Exception e1){
 134                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 135                         }
 136                 }
 137
 138         }
 139
 140         @Override
 141         public void delete(Object entity) {
 142                 Session session = sessionfactory.openSession();
 143                 Transaction tx = session.beginTransaction();
 144                 try {
 145                         session.delete(entity);
 146                         tx.commit();
 147                 }catch(Exception e){
 148                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table"+e);
 149                 }finally{
 150                         try{
 151                                 session.close();
 152                         }catch(Exception e1){
 153                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 154                         }
 155                 }
 156
 157         }
 158
 159
 160         @Override
 161         public void update(Object entity) {
 162                 Session session = sessionfactory.openSession();
 163                 Transaction tx = session.beginTransaction();
 164                 try {
 165                         session.update(entity);
 166                         tx.commit();
 167                 }catch(Exception e){
 168                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table"+e);
 169                 }finally{
 170                         try{
 171                                 session.close();
 172                         }catch(Exception e1){
 173                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 174                         }
 175                 }
 176
 177         }
 178
 179
 180         @SuppressWarnings({ "unchecked", "rawtypes" })
 181         @Override
 182         public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 183                 Session session = sessionfactory.openSession();
 184                 Transaction tx = session.beginTransaction();
 185                 List<Object> data = null;
 186                 String[] columnNames = null;
 187                 if(columnName != null && columnName.contains(":")){
 188                         columnNames = columnName.split(":");
 189                 }
 190                 String[] values = null;
 191                 if(value != null && value.contains(":")){
 192                         values = value.split(":");
 193                 }
 194                 try {
 195                         Criteria cr = session.createCriteria(className);
 196                         if(columnNames != null && values != null && columnNames.length == values.length){
 197                                 for (int i = 0; i < columnNames.length; i++){
 198                                         cr.add(Restrictions.eq(columnNames[i],values[i]));
 199                                 }
 200                         }else{
 201                                 cr.add(Restrictions.eq(columnName,value));
 202                         }
 203                         data = cr.list();
 204                         tx.commit();
 205                 } catch (Exception e) {
 206                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"+e + className);
 207                 }finally{
 208                         try{
 209                                 session.close();
 210                         }catch(Exception e1){
 211                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 212                         }
 213                 }
 214                 return data;
 215         }
 216
 217
 218         @SuppressWarnings("unchecked")
 219         @Override
 220         public List<PolicyRoles> getUserRoles() {
 221                 Session session = sessionfactory.openSession();
 222                 Transaction tx = session.beginTransaction();
 223                 List<PolicyRoles> rolesData = null;
 224                 try {
 225                         Criteria cr = session.createCriteria(PolicyRoles.class);
 226                         Disjunction disjunction = Restrictions.disjunction();
 227                         Conjunction conjunction1  = Restrictions.conjunction();
 228                         conjunction1.add(Restrictions.eq("role", "admin"));
 229                         Conjunction conjunction2  = Restrictions.conjunction();
 230                         conjunction2.add(Restrictions.eq("role", "editor"));
 231                         Conjunction conjunction3  = Restrictions.conjunction();
 232                         conjunction3.add(Restrictions.eq("role", "guest"));
 233                         disjunction.add(conjunction1);
 234                         disjunction.add(conjunction2);
 235                         disjunction.add(conjunction3);
 236                         rolesData = cr.add(disjunction).list();
 237                         tx.commit();
 238                 } catch (Exception e) {
 239                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table"+e);
 240                 }finally{
 241                         try{
 242                                 session.close();
 243                         }catch(Exception e1){
 244                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 245                         }
 246                 }
 247                 return rolesData;
 248         }
 249
 250
 251         @Override
 252         public List<Object> checkExistingGroupListforUpdate(String arg0, String arg1) {
 253                 return null;
 254         }
 255
 256
 257         @Override
 258         public void deleteAll() {}
 259
 260
 261         @SuppressWarnings("unchecked")
 262         @Override
 263         public List<Object> getDataByQuery(String query, SimpleBindings params) {
 264                 Session session = sessionfactory.openSession();
 265                 Transaction tx = session.beginTransaction();
 266                 List<Object> data = null;
 267                 try {
 268                         Query hbquery = session.createQuery(query);
 269                         for (Map.Entry<String, Object> paramPair : params.entrySet()) {
 270                                 hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 271                         }
 272                         data = hbquery.list();
 273                         tx.commit();
 274                 } catch (Exception e) {
 275                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 276                         throw e;
 277                 }finally{
 278                         try{
 279                                 session.close();
 280                         }catch(Exception e1){
 281                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 282                                 throw 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 }