ONAP-PAP-REST/src/main/java/org/onap/policy/pap/xacml/rest/daoimpl/CommonClassDaoImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP-PAP-REST
   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.pap.xacml.rest.daoimpl;
  22
  23 import java.util.List;
  24 import java.util.Map;
  25
  26 import javax.script.SimpleBindings;
  27
  28 import org.apache.commons.logging.Log;
  29 import org.apache.commons.logging.LogFactory;
  30 import org.hibernate.Criteria;
  31 import org.hibernate.HibernateException;
  32 import org.hibernate.Query;
  33 import org.hibernate.Session;
  34 import org.hibernate.SessionFactory;
  35 import org.hibernate.Transaction;
  36 import org.hibernate.criterion.Conjunction;
  37 import org.hibernate.criterion.Criterion;
  38 import org.hibernate.criterion.Disjunction;
  39 import org.hibernate.criterion.Projections;
  40 import org.hibernate.criterion.Restrictions;
  41 import org.onap.policy.rest.dao.CommonClassDao;
  42 import org.onap.policy.rest.jpa.ClosedLoops;
  43 import org.onap.policy.rest.jpa.GroupPolicyScopeList;
  44 import org.onap.policy.rest.jpa.PolicyRoles;
  45 import org.onap.policy.xacml.api.XACMLErrorConstants;
  46 import org.springframework.beans.factory.annotation.Autowired;
  47 import org.springframework.stereotype.Service;
  48
  49 @Service("CommonClassDao")
  50 public class CommonClassDaoImpl implements CommonClassDao{
  51
  52         private static final Log LOGGER = LogFactory.getLog(CommonClassDaoImpl.class);
  53
  54
  55         private static SessionFactory sessionFactory;
  56
  57         @Autowired
  58         private CommonClassDaoImpl(SessionFactory sessionFactory){
  59                 CommonClassDaoImpl.sessionFactory = sessionFactory;
  60         }
  61
  62         public CommonClassDaoImpl(){
  63                 //Default Constructor
  64         }
  65
  66         @SuppressWarnings({ "unchecked", "rawtypes" })
  67         @Override
  68         public List<Object> getData(Class className) {
  69                 Session session = sessionFactory.openSession();
  70                 List<Object> data = null;
  71                 try{
  72                         Criteria cr = session.createCriteria(className);
  73                         data = cr.list();
  74                 }catch(Exception e){
  75                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
  76                 }finally{
  77                         try{
  78                                 session.close();
  79                         }catch(Exception e){
  80                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
  81                         }
  82                 }
  83                 return data;
  84         }
  85
  86
  87         @SuppressWarnings({ "rawtypes", "unchecked" })
  88         @Override
  89         public List<Object> getDataById(Class className, String columnName, String key) {
  90                 Session session = sessionFactory.openSession();
  91                 List<Object> data = null;
  92                 try {
  93                         Criteria cr = session.createCriteria(className);
  94                         if(columnName.contains(":") && key.contains(":")){
  95                                 String[] columns = columnName.split(":");
  96                                 String[] keys = key.split(":");
  97                                 for(int i=0; i < columns.length; i++){
  98                                         cr.add(Restrictions.eq(columns[i], keys[i]));
  99                                 }
 100                         }else{
 101                                 cr.add(Restrictions.eq(columnName, key));
 102                         }
 103                         data = cr.list();
 104                 } catch (Exception e) {
 105                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 106                 }finally{
 107                         try{
 108                                 session.close();
 109                         }catch(Exception e1){
 110                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 111                         }
 112                 }
 113                 return data;
 114         }
 115
 116         @SuppressWarnings({ "unchecked", "rawtypes" })
 117         @Override
 118         public List<String> getDataByColumn(Class className, String columnName) {
 119                 Session session = sessionFactory.openSession();
 120                 List<String> data = null;
 121                 try{
 122                         Criteria cr = session.createCriteria(className);
 123                         cr.setProjection(Projections.property(columnName));
 124                         data = cr.list();
 125                 }catch(Exception e){
 126                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Table"+e);
 127                 }finally{
 128                         try{
 129                                 session.close();
 130                         }catch(Exception e){
 131                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e);
 132                         }
 133                 }
 134                 return data;
 135         }
 136
 137         @Override
 138         public void save(Object entity) {
 139                 Session session = sessionFactory.openSession();
 140                 Transaction tx = session.beginTransaction();
 141                 try {
 142                         session.persist(entity);
 143                         tx.commit();
 144                 }catch(Exception e){
 145                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Saving  data to Table"+e);
 146                 }finally{
 147                         try{
 148                                 session.close();
 149                         }catch(Exception e1){
 150                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 151                         }
 152                 }
 153
 154         }
 155
 156         @Override
 157         public void delete(Object entity) {
 158                 Session session = sessionFactory.openSession();
 159                 Transaction tx = session.beginTransaction();
 160                 try {
 161                         session.delete(entity);
 162                         tx.commit();
 163                 }catch(Exception e){
 164                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Deleting data from Table"+e);
 165                 }finally{
 166                         try{
 167                                 session.close();
 168                         }catch(Exception e1){
 169                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 170                         }
 171                 }
 172
 173         }
 174
 175
 176         @Override
 177         public void update(Object entity) {
 178                 Session session = sessionFactory.openSession();
 179                 Transaction tx = session.beginTransaction();
 180                 try {
 181                         session.update(entity);
 182                         tx.commit();
 183                 }catch(Exception e){
 184                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating data to Table"+e);
 185                 }finally{
 186                         try{
 187                                 session.close();
 188                         }catch(Exception e1){
 189                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 190                         }
 191                 }
 192
 193         }
 194
 195
 196         @SuppressWarnings({ "unchecked", "rawtypes" })
 197         @Override
 198         public List<Object> checkDuplicateEntry(String value, String columnName, Class className) {
 199                 Session session = sessionFactory.openSession();
 200                 Transaction tx = session.beginTransaction();
 201                 List<Object> data = null;
 202
 203                 String[] columnNames = null;
 204                 if(columnName != null && columnName.contains(":")){
 205                         columnNames = columnName.split(":");
 206                 }
 207                 String[] values = null;
 208                 if(value != null && value.contains(":")){
 209                         values = value.split(":");
 210                 }
 211                 try {
 212                         Criteria cr = session.createCriteria(className);
 213                         if(columnNames != null && values != null && columnNames.length == values.length){
 214                                 for (int i = 0; i < columnNames.length; i++){
 215                                         cr.add(Restrictions.eq(columnNames[i],values[i]));
 216                                 }
 217                         }else{
 218                                 cr.add(Restrictions.eq(columnName,value));
 219                         }
 220
 221                         data = cr.list();
 222                         tx.commit();
 223                 } catch (Exception e) {
 224                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for Table"+e + className);
 225                 }finally{
 226                         try{
 227                                 session.close();
 228                         }catch(Exception e1){
 229                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 230                         }
 231                 }
 232                 return data;
 233         }
 234
 235
 236         @SuppressWarnings("unchecked")
 237         @Override
 238         public List<Object> getDataByQuery(String query, SimpleBindings params) {
 239                 Session session = sessionFactory.openSession();
 240                 Transaction tx = session.beginTransaction();
 241                 List<Object> data = null;
 242                 try {
 243                         Query hbquery = session.createQuery(query);
 244                         for (Map.Entry<String, Object> paramPair : params.entrySet()) {
 245                                 hbquery.setParameter(paramPair.getKey(), paramPair.getValue());
 246                         }
 247                         data = hbquery.list();
 248                         tx.commit();
 249                 } catch (Exception e) {
 250                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 251                         throw e;
 252                 }finally{
 253                         try{
 254                                 session.close();
 255                         }catch(HibernateException e1){
 256                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement",e1);
 257                         }
 258                 }
 259                 return data;
 260         }
 261
 262
 263         @Override
 264         public void updateQuery(String query) {
 265                 Session session = sessionFactory.openSession();
 266                 Transaction tx = session.beginTransaction();
 267                 try {
 268                         Query hbquery = session.createQuery(query);
 269                         hbquery.executeUpdate();
 270                         tx.commit();
 271                 } catch (Exception e) {
 272                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating Database Table"+e);
 273                 }finally{
 274                         try{
 275                                 session.close();
 276                         }catch(Exception e1){
 277                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 278                         }
 279                 }
 280         }
 281
 282
 283         @SuppressWarnings("rawtypes")
 284         @Override
 285         public Object getEntityItem(Class className, String columnName, String key) {
 286                 Session session = sessionFactory.openSession();
 287                 Transaction tx = session.beginTransaction();
 288                 Object data = null;
 289                 try {
 290                         Criteria cr = session.createCriteria(className);
 291                         if(columnName.contains(":") && key.contains(":")){
 292                                 String[] columns = columnName.split(":");
 293                                 String[] keys = key.split(":");
 294                                 for(int i=0; i < columns.length; i++){
 295                                         cr.add(Restrictions.eq(columns[i], keys[i]));
 296                                 }
 297                         }else{
 298                                 cr.add(Restrictions.eq(columnName, key));
 299                         }
 300                         data = cr.list().get(0);
 301                         tx.commit();
 302                 } catch (Exception e) {
 303                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying Database Table"+e);
 304                 }finally{
 305                         try{
 306                                 session.close();
 307                         }catch(Exception e1){
 308                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 309                         }
 310                 }
 311                 return data;
 312         }
 313
 314
 315         @SuppressWarnings("unchecked")
 316         @Override
 317         public List<PolicyRoles> getUserRoles() {
 318                 Session session = sessionFactory.openSession();
 319                 Transaction tx = session.beginTransaction();
 320                 List<PolicyRoles> rolesData = null;
 321                 try {
 322                         Criteria cr = session.createCriteria(PolicyRoles.class);
 323                         Disjunction disjunction = Restrictions.disjunction();
 324                         Conjunction conjunction1  = Restrictions.conjunction();
 325                         conjunction1.add(Restrictions.eq("role", "admin"));
 326                         Conjunction conjunction2  = Restrictions.conjunction();
 327                         conjunction2.add(Restrictions.eq("role", "editor"));
 328                         Conjunction conjunction3  = Restrictions.conjunction();
 329                         conjunction3.add(Restrictions.eq("role", "guest"));
 330                         disjunction.add(conjunction1);
 331                         disjunction.add(conjunction2);
 332                         disjunction.add(conjunction3);
 333                         rolesData = cr.add(disjunction).list();
 334                         tx.commit();
 335                 } catch (Exception e) {
 336                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying PolicyRoles Table"+e);
 337                 }finally{
 338                         try{
 339                                 session.close();
 340                         }catch(Exception e1){
 341                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 342                         }
 343                 }
 344                 return rolesData;
 345         }
 346
 347
 348         @SuppressWarnings("unchecked")
 349         @Override
 350         public void updateClAlarms(String clName, String alarms) {
 351                 Session session = sessionFactory.openSession();
 352                 List<ClosedLoops> closedloopsdata = null;
 353                 Transaction tx = session.beginTransaction();
 354                 try {
 355                 Criteria cr = session.createCriteria(ClosedLoops.class);
 356                 cr.add(Restrictions.eq("closedLoopControlName",clName));
 357             closedloopsdata = cr.list();
 358                         ClosedLoops closedloop = closedloopsdata.get(0);
 359                         closedloop.setAlarmConditions(alarms);
 360                         session.update(closedloop);
 361                         tx.commit();
 362                 }catch(Exception e){
 363                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table"+e);
 364                 }finally{
 365                         session.close();
 366                 }
 367         }
 368
 369
 370         @SuppressWarnings("unchecked")
 371         @Override
 372         public void updateClYaml(String clName, String yaml) {
 373                 Session session = sessionFactory.openSession();
 374         List<ClosedLoops> closedloopsdata = null;
 375                 Transaction tx = session.beginTransaction();
 376                 try {
 377                 Criteria cr = session.createCriteria(ClosedLoops.class);
 378                 cr.add(Restrictions.eq("closedLoopControlName",clName));
 379             closedloopsdata = cr.list();
 380                         ClosedLoops closedloop = closedloopsdata.get(0);
 381                         closedloop.setYaml(yaml);
 382                         session.update(closedloop);
 383                         tx.commit();
 384                 }catch(Exception e){
 385                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Updating ClosedLoops Table"+e);
 386                 }finally{
 387                         session.close();
 388                 }
 389         }
 390
 391
 392         @SuppressWarnings("unchecked")
 393         @Override
 394         public void deleteAll() {
 395                 Session session = sessionFactory.openSession();
 396                 Transaction tx = session.beginTransaction();
 397                 List<ClosedLoops> closedloopsdata = null;
 398                 try {
 399                         Criteria cr = session.createCriteria(ClosedLoops.class);
 400                         closedloopsdata = cr.list();
 401
 402                         if(closedloopsdata!=null && !closedloopsdata.isEmpty()) {
 403                                 LOGGER.info("ClosedLoops exist in the database, we need to delete them in our first step to buildCache().");
 404                                 for(int i=0; i < closedloopsdata.size(); i++) {
 405                                         ClosedLoops cl = closedloopsdata.get(i);
 406                                         session.delete(cl);
 407                                 }
 408                         } else {
 409                                 LOGGER.info("No ClosedLoops exist in the database, no need to delete.");
 410                         }
 411
 412                         tx.commit();
 413                 }catch(Exception e) {
 414                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error while deleting ClosedLoops from the table"+e);
 415                 }finally{
 416                         session.close();
 417                 }
 418         }
 419
 420         @SuppressWarnings({ "unchecked"})
 421         @Override
 422         public List<Object> checkExistingGroupListforUpdate(String groupListValue, String groupNameValue) {
 423                 Session session = sessionFactory.openSession();
 424                 Transaction tx = session.beginTransaction();
 425                 List<Object> data = null;
 426                 try {
 427                         Criteria cr = session.createCriteria(GroupPolicyScopeList.class);
 428                         cr.add(Restrictions.eq("groupList",groupListValue));
 429                         Criterion expression = Restrictions.eq("name", groupNameValue);
 430                         cr.add(Restrictions.not(expression));
 431                         data = cr.list();
 432                         tx.commit();
 433                 } catch (Exception e) {
 434                         LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Querying for Duplicate Entries for GroupPolicyScopeList Table"+e);
 435                 }finally{
 436                         try{
 437                                 session.close();
 438                         }catch(Exception e1){
 439                                 LOGGER.error(XACMLErrorConstants.ERROR_PROCESS_FLOW + "Error While Closing Connection/Statement"+e1);
 440                         }
 441                 }
 442                 return data;
 443         }
 444
 445
 446         @Override
 447         public List<Object> getMultipleDataOnAddingConjunction(@SuppressWarnings("rawtypes") Class className, String columnName, List<String> data) {
 448                 return null;
 449         }
 450
 451 }