POLICY-SDK-APP/src/main/java/org/openecomp/policy/daoImp/CommonClassDaoImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ECOMP 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.openecomp.policy.daoImp;
  22
  23 import java.util.ArrayList;
  24 import java.util.List;
  25
  26 import org.hibernate.Criteria;
  27 import org.hibernate.Query;
  28 import org.hibernate.Session;
  29 import org.hibernate.SessionFactory;
  30 import org.hibernate.Transaction;
  31 import org.hibernate.criterion.Conjunction;
  32 import org.hibernate.criterion.Disjunction;
  33 import org.hibernate.criterion.Projections;
  34 import org.hibernate.criterion.Restrictions;
  35 import org.openecomp.policy.common.logging.flexlogger.FlexLogger;
  36 import org.openecomp.policy.common.logging.flexlogger.Logger;
  37 import org.openecomp.policy.rest.dao.CommonClassDao;
  38 import org.openecomp.policy.rest.jpa.PolicyRoles;
  39 import org.openecomp.policy.xacml.api.XACMLErrorConstants;
  40 import org.springframework.beans.factory.annotation.Autowired;
  41 import org.springframework.stereotype.Service;
  42
  43 @Service("CommonClassDao")
  44 public class CommonClassDaoImpl implements CommonClassDao{
  45
  46         private static final Logger LOGGER = FlexLogger.getLogger(CommonClassDaoImpl.class);
  47
  48         @Autowired
  49         SessionFactory sessionfactory;
  50
  51         @SuppressWarnings({ "unchecked", "rawtypes" })
  52         @Override
  53         public List<Object> getData(Class className) {
  54                 Session session = sessionfactory.openSession();
  55                 List<Object> data = null;
  56                 try{
  57                         Criteria cr = session.createCriteria(className);
  58                         data = cr.list();
  59                 }catch(Exception e){
  60                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
  61                 }finally{
  62                         try{
  63                                 session.close();
  64                         }catch(Exception e){
  65                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
  66                         }
  67                 }
  68                 return data;
  69         }
  70
  71
  72         @SuppressWarnings({ "rawtypes", "unchecked" })
  73         @Override
  74         public List<Object> getDataById(Class className, String columnName, String key) {
  75                 Session session = sessionfactory.openSession();
  76                 List<Object> data = null;
  77                 try {
  78                         Criteria cr = session.createCriteria(className);
  79                         if(columnName.contains(":") && key.contains(":")){
  80                                 String[] columns = columnName.split(":");
  81                                 String[] keys = key.split(":");
  82                                 for(int i=0; i < columns.length; i++){
  83                                         cr.add(Restrictions.eq(columns[i], keys[i]));
  84                                 }
  85                         }else{
  86                                 cr.add(Restrictions.eq(columnName, key));
  87                         }
  88                         data = cr.list();
  89                 } catch (Exception e) {
  90                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
  91                 }finally{
  92                         try{
  93                                 session.close();
  94                         }catch(Exception e1){
  95                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
  96                         }
  97                 }
  98                 return data;
  99         }
 100
 101         @Override
 102         public void save(Object entity) {
 103                 Session session = sessionfactory.openSession();
 104                 Transaction tx = session.beginTransaction();
 105                 try {
 106                         session.persist(entity);
 107                         tx.commit();
 108                 }catch(Exception e){
 109                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table"+e);
 110                 }finally{
 111                         try{
 112                                 session.close();
 113                         }catch(Exception e1){
 114                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 115                         }
 116                 }
 117
 118         }
 119
 120         @Override
 121         public void delete(Object entity) {
 122                 Session session = sessionfactory.openSession();
 123                 Transaction tx = session.beginTransaction();
 124                 try {
 125                         session.delete(entity);
 126                         tx.commit();
 127                 }catch(Exception e){
 128                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table"+e);
 129                 }finally{
 130                         try{
 131                                 session.close();
 132                         }catch(Exception e1){
 133                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 134                         }
 135                 }
 136
 137         }
 138
 139
 140         @Override
 141         public void update(Object entity) {
 142                 Session session = sessionfactory.openSession();
 143                 Transaction tx = session.beginTransaction();
 144                 try {
 145                         session.update(entity);
 146                         tx.commit();
 147                 }catch(Exception e){
 148                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to 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         @SuppressWarnings({ "unchecked", "rawtypes" })
 161         @Override
 162         public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 163                 Session session = sessionfactory.openSession();
 164                 Transaction tx = session.beginTransaction();
 165                 List<Object> data = null;
 166                 String[] columnNames = null;
 167                 if(columnName != null && columnName.contains(":")){
 168                         columnNames = columnName.split(":");
 169                 }
 170                 String[] values = null;
 171                 if(value != null && value.contains(":")){
 172                         values = value.split(":");
 173                 }
 174                 try {
 175                         Criteria cr = session.createCriteria(className);
 176                         if(columnNames != null && values != null && columnNames.length == values.length){
 177                                 for (int i = 0; i < columnNames.length; i++){
 178                                         cr.add(Restrictions.eq(columnNames[i],values[i]));
 179                                 }
 180                         }else{
 181                                 cr.add(Restrictions.eq(columnName,value));
 182                         }
 183                         data = cr.list();
 184                         tx.commit();
 185                 } catch (Exception e) {
 186                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"+e + className);
 187                 }finally{
 188                         try{
 189                                 session.close();
 190                         }catch(Exception e1){
 191                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 192                         }
 193                 }
 194                 return data;
 195         }
 196
 197
 198         @SuppressWarnings("unchecked")
 199         @Override
 200         public List<PolicyRoles> getUserRoles() {
 201                 Session session = sessionfactory.openSession();
 202                 Transaction tx = session.beginTransaction();
 203                 List<PolicyRoles> rolesData = null;
 204                 try {
 205                         Criteria cr = session.createCriteria(PolicyRoles.class);
 206                         Disjunction disjunction = Restrictions.disjunction();
 207                         Conjunction conjunction1  = Restrictions.conjunction();
 208                         conjunction1.add(Restrictions.eq("role", "admin"));
 209                         Conjunction conjunction2  = Restrictions.conjunction();
 210                         conjunction2.add(Restrictions.eq("role", "editor"));
 211                         Conjunction conjunction3  = Restrictions.conjunction();
 212                         conjunction3.add(Restrictions.eq("role", "guest"));
 213                         disjunction.add(conjunction1);
 214                         disjunction.add(conjunction2);
 215                         disjunction.add(conjunction3);
 216                         rolesData = cr.add(disjunction).list();
 217                         tx.commit();
 218                 } catch (Exception e) {
 219                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table"+e);
 220                 }finally{
 221                         try{
 222                                 session.close();
 223                         }catch(Exception e1){
 224                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 225                         }
 226                 }
 227                 return rolesData;
 228         }
 229
 230
 231         @Override
 232         public List<Object> checkExistingGroupListforUpdate(String arg0, String arg1) {
 233                 return null;
 234         }
 235
 236
 237         @Override
 238         public void deleteAll() {}
 239
 240
 241         @SuppressWarnings("unchecked")
 242         @Override
 243         public List<Object> getDataByQuery(String query) {
 244                 Session session = sessionfactory.openSession();
 245                 Transaction tx = session.beginTransaction();
 246                 List<Object> data = null;
 247                 try {
 248                         Query hbquery = session.createQuery(query);
 249                         data = hbquery.list();
 250                         tx.commit();
 251                 } catch (Exception e) {
 252                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 253                 }finally{
 254                         try{
 255                                 session.close();
 256                         }catch(Exception e1){
 257                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 258                         }
 259                 }
 260                 return data;
 261         }
 262
 263
 264         @SuppressWarnings("rawtypes")
 265         @Override
 266         public Object getEntityItem(Class className, String columnName, String key) {
 267                 Session session = sessionfactory.openSession();
 268                 Transaction tx = session.beginTransaction();
 269                 Object data = null;
 270                 try {
 271                         Criteria cr = session.createCriteria(className);
 272                         if(columnName.contains(":") && key.contains(":")){
 273                                 String[] columns = columnName.split(":");
 274                                 String[] keys = key.split(":");
 275                                 for(int i=0; i < columns.length; i++){
 276                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 277                                 }
 278                         }else{
 279                                 cr.add(Restrictions.eq(columnName, key));
 280                         }
 281                         data = cr.list().get(0);
 282                         tx.commit();
 283                 } catch (Exception e) {
 284                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 285                 }finally{
 286                         try{
 287                                 session.close();
 288                         }catch(Exception e1){
 289                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 290                         }
 291                 }
 292                 return data;
 293         }
 294
 295
 296         @Override
 297         public void updateClAlarms(String arg0, String arg1) {}
 298
 299
 300         @Override
 301         public void updateClYaml(String arg0, String arg1) {}
 302
 303
 304         @Override
 305         public void updateQuery(String query) {
 306                 Session session = sessionfactory.openSession();
 307                 Transaction tx = session.beginTransaction();
 308                 try {
 309                         Query hbquery = session.createQuery(query);
 310                         hbquery.executeUpdate();
 311                         tx.commit();
 312                 } catch (Exception e) {
 313                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e);
 314                 }finally{
 315                         try{
 316                                 session.close();
 317                         }catch(Exception e1){
 318                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 319                         }
 320                 }
 321
 322         }
 323
 324
 325         @SuppressWarnings({ "rawtypes", "unchecked" })
 326         @Override
 327         public List<String> getDataByColumn(Class className, String columnName) {
 328                 Session session = sessionfactory.openSession();
 329                 List<String> data = null;
 330                 try{
 331                         Criteria cr = session.createCriteria(className);
 332                         cr.setProjection(Projections.property(columnName));
 333                         data = cr.list();
 334                 }catch(Exception e){
 335                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 336                 }finally{
 337                         try{
 338                                 session.close();
 339                         }catch(Exception e){
 340                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
 341                         }
 342                 }
 343                 return data;
 344         }
 345
 346
 347         @SuppressWarnings({ "rawtypes", "unchecked" })
 348         @Override
 349         public List<Object> getMultipleDataOnAddingConjunction(Class className, String columnName, List<String> data) {
 350                 Session session = sessionfactory.openSession();
 351                 Transaction tx = session.beginTransaction();
 352                 List<Object> entityData = null;
 353                 try {
 354                         Criteria cr = session.createCriteria(className);
 355                         Disjunction disjunction = Restrictions.disjunction();
 356                         List<Conjunction> conjunctionList = new ArrayList<>();
 357                         String[] columNames = columnName.split(":");
 358                         for(int i =0; i < data.size(); i++){
 359                                 String[] entiySplit = data.get(i).split(":");
 360                                 Conjunction conjunction = Restrictions.conjunction();
 361                                 conjunction.add(Restrictions.eq(columNames[0], entiySplit[0]));
 362                                 conjunction.add(Restrictions.eq(columNames[1], entiySplit[1]));
 363                                 conjunctionList.add(conjunction);
 364                         }
 365                         for(int j =0 ; j < conjunctionList.size(); j++){
 366                                 disjunction.add(conjunctionList.get(j));
 367                         }
 368                         entityData = cr.add(disjunction).list();
 369                         tx.commit();
 370                 } catch (Exception e) {
 371                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table" +className +e);
 372                 }finally{
 373                         try{
 374                                 session.close();
 375                         }catch(Exception e1){
 376                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 377                         }
 378                 }
 379                 return entityData;
 380         }
 381
 382 }