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