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