public List<PlannedNotification> getPlannedNotificationsForCorrespondence() {
    List<PlannedNotification> result;

    SessionFactory sessionFactory = (SessionFactory) applicationContext.getBean("sessionFactory");
    Session session = sessionFactory.openSession(sessionFactory.getCurrentSession().connection());
    session.setFlushMode(FlushMode.MANUAL);
    result = new ArrayList<PlannedNotification>();
    try {
      Query query =
          session
              .createQuery(
                  "from PlannedNotification p left join fetch p.userBasedRecipientInternal where p.eventName = :var")
              .setString(
                  "var",
                  NotificationEventTypeEnum.CORRESPONDENCE_CREATED_OR_UPDATED_EVENT.toString());

      result = query.list().subList(0, 1);
    } catch (DataAccessResourceFailureException e) {
      log.error(e.getMessage());
    } catch (IllegalStateException e) {
      e.printStackTrace();
    } catch (HibernateException e) {
      log.error(e.getMessage());
    } catch (Exception e) {
      log.error(e.getMessage());
    } finally {
      session.close();
    }
    return result;
  }
  protected long getRowCountFromDataBase() {
    long rowCount = 0;
    SessionFactory factory = FLRSessionFactory.getFactory();
    Session session = null;
    try {
      session = factory.openSession();
      session = setFilter(session);

      String queryString =
          "SELECT COUNT(*) FROM FLRLohnartstundenfaktor AS lohnartstundenfaktor"
              + buildWhereClause();

      Query query = session.createQuery(queryString);
      List<?> rowCountResult = query.list();
      if (rowCountResult != null && rowCountResult.size() > 0) {
        rowCount = ((Long) rowCountResult.get(0)).longValue();
      }
    } catch (Exception e) {
      throw new EJBExceptionLP(EJBExceptionLP.FEHLER_FLR, e);
    } finally {
      if (session != null) {
        try {
          session.close();
        } catch (HibernateException he) {
          throw new EJBExceptionLP(EJBExceptionLP.FEHLER, he);
        }
      }
    }
    return rowCount;
  }
  public void insertTarjetaHistorico(PsTarjeta tarjeta, String xml) {

    try {

      SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
      Session newSession = sessionFactory.openSession();

      newSession.beginTransaction();
      ArmResponsePsTarjeta j = new ArmResponsePsTarjeta();
      j.setIdTarjetaArm(tarjeta.getIDTarjetaARM());
      j.setIdTarjetaFrida(tarjeta.getIDTarjetaFrida());
      j.setNombreTarjeta(tarjeta.getNombreTarjeta());
      j.setMeesageId(tarjeta.getMeesageID());
      j.setXmlMessage(xml);
      j.setFechaMensaje(new Date());

      newSession.persist(j);

      newSession.getTransaction().commit();
      newSession.close();

    } catch (HibernateException e) {

    } finally {

    }
  }
  /**
   * Create a single <code>Patient</code> record. The generated id will be available in the
   * patientRecord.
   *
   * @param patientRecord
   * @return boolean
   */
  public boolean create(Patient patientRecord) {
    log.debug("PatientDAO.create() - Begin");
    Session session = null;
    Transaction tx = null;
    boolean result = true;

    if (patientRecord != null) {
      try {
        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        session = sessionFactory.openSession();
        tx = session.beginTransaction();
        log.info("Inserting Record...");

        session.persist(patientRecord);

        log.info("Patient Inserted seccussfully...");
        tx.commit();
      } catch (Exception e) {
        result = false;
        if (tx != null) {
          tx.rollback();
        }
        log.error("Exception during insertion caused by :" + e.getMessage(), e);
      } finally {
        // Actual Patient insertion will happen at this step
        if (session != null) {
          session.close();
        }
      }
    }
    log.debug("PatientDAO.create() - End");
    return result;
  }
  /**
   * Gets Hibernate session.
   *
   * @param tx Cache transaction.
   * @return Session.
   */
  Session session(@Nullable GridCacheTx tx) {
    Session ses;

    if (tx != null) {
      ses = tx.meta(ATTR_SES);

      if (ses == null) {
        ses = sesFactory.openSession();

        ses.beginTransaction();

        // Store session in transaction metadata, so it can be accessed
        // for other operations on the same transaction.
        tx.addMeta(ATTR_SES, ses);

        if (log.isDebugEnabled())
          log.debug("Hibernate session open [ses=" + ses + ", tx=" + tx.xid() + "]");
      }
    } else {
      ses = sesFactory.openSession();

      ses.beginTransaction();
    }

    return ses;
  }
 @BeforeClass
 public void beforeClass() {
   SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
   publicMessageDao = new PublicMessageHibernateDao(sessionFactory);
   session = sessionFactory.getCurrentSession();
   session.beginTransaction();
 }
  @Override
  public void removeRequest(Requests request) {
    if (null != request) {

      org.hibernate.Session sess = sessionFactory.getCurrentSession();
      request = (Requests) sess.get(Requests.class, request.getId());
      List<Contacts> contTemp = request.getContacts();
      List<Products> prodTemp = request.getProducts();

      if (contTemp != null && contTemp.size() != 0) {

        sess.enableFetchProfile("requests-with-products");
        contTemp = contactsDAO.getFromProxy(contTemp);
        for (Contacts contact : contTemp) {
          contact.getConnectedRequests().remove(request);
          sess.update(contact);
        }
      }
      if (prodTemp != null && prodTemp.size() != 0) {
        sess.enableFetchProfile("requests-with-products");
        prodTemp = productsDAO.getFromProxy(prodTemp);
        for (Products product : prodTemp) {
          product.getRequestsForProduct().remove(request);
          sess.update(product);
        }
      }
      sess.update(request);
      sessionFactory.getCurrentSession().delete(request);
    }
  }
  @SuppressWarnings("unchecked")
  public static void main(String[] args) {
    SessionFactory factory = null;
    Session session = null;
    org.hibernate.Transaction tx = null;

    try {
      factory = HibernateUtil.getSessionFactory();
      session = factory.openSession();
      tx = session.beginTransaction();

      List<Transaction> transactions =
          session.createCriteria(Transaction.class).addOrder(Order.desc("title")).list();

      for (Transaction t : transactions) {
        System.out.println(t.getTitle());
      }

      tx.commit();

    } catch (Exception e) {
      e.printStackTrace();
      tx.rollback();
    } finally {
      session.close();
      factory.close();
    }
  }
Exemple #9
0
  public static void main(String[] args) {
    Session session = null;
    Transaction tx = null;
    try {
      session = sessionFactory.openSession();
      tx = session.beginTransaction();

      // retieve all cars
      @SuppressWarnings("unchecked")
      Car car = (Car) session.createQuery("from Car c where id =1").uniqueResult();
      car.setPrice(car.getPrice() + 50);

      tx.commit();
      System.out.println(
          "brand= " + car.getBrand() + ", year= " + car.getYear() + ", price= " + car.getPrice());

    } catch (HibernateException e) {
      if (tx != null) {
        System.err.println("Rolling back: " + e.getMessage());
        tx.rollback();
      }
    } finally {
      if (session != null) {
        session.close();
      }
    }

    // Close the SessionFactory (not mandatory)
    sessionFactory.close();
    System.exit(0);
  }
  public List<DeviceList> getDeviceList(String location) {
    SessionFactory sessionFactory = HibernateSessionFactory.getSessionFactory();
    List<DeviceList> results = new ArrayList<DeviceList>();
    Session session = sessionFactory.openSession();
    if (session != null) {
      SQLQuery query =
          session.createSQLQuery(
              "select d.*,da.*,du.* "
                  + "from device_app.device d, device_app.device_availability da, device_app.device_user du "
                  + "where d.id=da.device_id and "
                  + "da.checked_out_user = du.email_id and "
                  + "d.device_status='active' and "
                  + "du.user_location=:location");
      query.addEntity(Device.class);
      query.addEntity(DeviceAvailability.class);
      query.addEntity(DeviceUser.class);
      query.setString("location", location);

      List<Object[]> resultList = query.list();
      if (resultList != null && resultList.size() > 0) {
        System.out.println("results size is " + resultList.size());
        for (Object[] array : resultList) {
          DeviceList row = new DeviceList();
          for (Object resultObject : array) {
            System.out.println(resultObject.getClass());
            if (resultObject instanceof Device) {
              Device device = (Device) resultObject;

              row.setBarCodeIdentifier(device.getBarCodeId());
              row.setDeviceCapacity(device.getDeviceCapacity());
              row.setDeviceName(device.getDeviceName());
              row.setDeviceNickname(device.getDeviceNickName());
              row.setDeviceOs(device.getDeviceOs());
              row.setDeviceOsVersion(device.getDeviceOsVersion());
              row.setDeviceSerialNumber(device.getDeviceSerialNumber());
              row.setDeviceStatus(device.getDeviceStatus());
              row.setDeviceType(device.getDeviceType());
              row.setId(device.getId());
              row.setOwnedBy(device.getDeviceOwner());

            } else if (resultObject instanceof DeviceAvailability) {
              DeviceAvailability availability = (DeviceAvailability) resultObject;
              //
              //	row.setCheckedOutAt(DateUtils.truncate(availability.getModifiedDate(),Calendar.MINUTE).toString());
              row.setCheckedOutAt(
                  DateFormatUtils.format(availability.getModifiedDate(), "yyyy-MM-dd HH:mm:ss"));
              row.setCurrentlyCheckedOutById(availability.getDeviceUser().getEmailId());
              row.setIsCheckedOut(availability.isIsCheckedOut());
              row.setLocation(location);
            } else {
              DeviceUser user = (DeviceUser) resultObject;
            }
          }
          results.add(row);
        }
      }
    }

    return results;
  }
 @Before
 public void setUp() throws Exception {
   logger.info("初始化Hibernate环境....");
   SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
   session = sessionFactory.openSession();
   session.beginTransaction();
 }
  public static void main(String[] args) {
    Session session = null;

    try {

      SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
      session = sessionFactory.openSession();

      Contact contact;

      String SQL_QUERY = "select c.id, c.firstName from Contact  c where c.id >= 3";

      Query query = session.createQuery(SQL_QUERY);
      Iterator it = query.iterate();
      while (it.hasNext()) {
        Object[] row = (Object[]) it.next();
        System.out.println("------------------------------------------------------");
        System.out.println("ID                : " + row[0]);
        System.out.println("First Name  : " + row[1]);
      }

      System.out.println("Done");
    } catch (Exception e) {
      // tx.rollback();
      System.out.println(e.getMessage());
    } finally {

      // session.flush();
      session.close();
    }
  }
 /*
  * loadStartandEndDates()-->this function is used for load the start and end date
  */
 private void loadStartandEndDates() {
   try {
     SessionFactory sf = serviceAttendanceProcess.getConnection();
     Session session = sf.openSession();
     session.beginTransaction();
     session.doWork(
         new Work() {
           @Override
           public void execute(Connection connection) throws SQLException {
             // TODO Auto-generated method stub
             statement = connection.prepareCall("{ call PROC_DATE_CALC (?,?,?) }");
             statement.setLong(1, payPeriodId);
             statement.registerOutParameter(2, Types.VARCHAR);
             statement.registerOutParameter(3, Types.VARCHAR);
             statement.execute();
             startDate = statement.getString(2);
             endDate = statement.getString(3);
             connection.close();
           }
         });
     tfProcessPeriod.setReadOnly(false);
     tfProcessPeriod.setValue(" " + startDate + " to " + endDate);
     tfProcessPeriod.setReadOnly(true);
   } catch (Exception e) {
     logger.info("Load Start and end Date Using Procedure" + e);
   } finally {
     try {
       statement.close();
     } catch (SQLException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
       logger.info("Load Start and end Date Using Procedure" + e);
     }
   }
 }
  @Test
  public void test() {
    Configuration cfg = new Configuration();
    cfg.addAnnotatedClass(Employee.class);
    cfg.configure("hbm2ddl.xml");

    new SchemaExport(cfg).create(true, true);

    SessionFactory factory = cfg.buildSessionFactory();
    Session session = factory.getCurrentSession();
    session.beginTransaction();

    {
      Employee emp = new Employee();
      emp.setEmpName("seungbeomi");
      emp.setEmpPassword("password");
      emp.setEmpEmailAddress("*****@*****.**");
      emp.setPermanent(true);
      emp.setEmpJoinDate(new GregorianCalendar(2012, 9, 30));
      emp.setEmpLoginTime(new Date());

      session.save(emp);
    }
    session.getTransaction().commit();
  }
  public void AverageRatingByProductName(String prodName) {
    SessionFactory sf = HibernateUtility.getSessionfactory();

    Session session = sf.openSession();

    session.beginTransaction();
    String sql1 = "SELECT * FROM product where productName = :productName";
    SQLQuery query1 = session.createSQLQuery(sql1);
    query1.setParameter("productName", prodName);
    query1.addEntity(Product.class);
    Product product = (Product) query1.uniqueResult();

    String sql2 = "SELECT * FROM ratingdetails where productId = :productId";
    SQLQuery query2 = session.createSQLQuery(sql2);
    query2.setParameter("productId", product.getProductId());
    query2.addEntity(RatingDetails.class);

    List ratings = query2.list();
    session.getTransaction().commit();
    float count = ratings.size();

    int sum = 0;
    for (Object r : ratings) {
      RatingDetails rate = (RatingDetails) r;
      sum = sum + rate.getRating();
    }
    float averageRating = (sum / count);

    System.out.println("pid " + product + " avg " + averageRating);
  }
  public static Profile getProfile(Long id) {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      Profile profile =
          (Profile)
              session
                  .createQuery(
                      "SELECT distinct profile "
                          + "FROM Profile profile "
                          + "left join fetch profile.layoutProfiles laypro "
                          + "left join fetch laypro.layout "
                          + "WHERE profile.id = :pid ")
                  .setParameter("pid", id)
                  .uniqueResult();

      tx.commit();

      return profile;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
  public void insert(ValueObject vo) {
    // TODO Auto-generated method stub
    Session session = null;
    List ls = null;

    try {
      // This step will read hibernate.cfg.xml and prepare Hibernate for use
      SessionFactory sessionFactory =
          new
              // read cgf file.and create an object.
              Configuration()
              .configure()
              .buildSessionFactory();

      session = sessionFactory.openSession();
      // for more then transaction.
      Transaction y = session.beginTransaction();
      // Create new instance of Contact and set
      // values in it by reading them from form object
      session.save(vo); // insert query
      y.commit();

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      session.flush();
      session.close();
    }
  }
  public static void deleteProfile(Profile profile) {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      for (LayoutProfile layoutProfile : profile.getLayoutProfiles()) {
        session.delete(layoutProfile);
      }

      session.delete(profile);

      tx.commit();

    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
    } finally {
      session.clear();
      session.close();
    }
  }
  @Override
  public void addRequest(Requests request) {

    sessionFactory.getCurrentSession().save(request);
    List<Contacts> contTemp = request.getContacts();
    List<Products> prodTemp = request.getProducts();

    if (contTemp != null && contTemp.size() != 0) {
      org.hibernate.Session sess = sessionFactory.getCurrentSession();
      sess.enableFetchProfile("requests-with-products");
      contTemp = contactsDAO.getFromProxy(contTemp);
      for (Contacts contact : contTemp) {
        contact.getConnectedRequests().add(request);
        contactsDAO.changeContact(contact);
      }
    }
    if (prodTemp != null && prodTemp.size() != 0) {
      org.hibernate.Session sess = sessionFactory.getCurrentSession();
      sess.enableFetchProfile("requests-with-products");
      prodTemp = productsDAO.getFromProxy(prodTemp);
      for (Products product : prodTemp) {
        product.getRequestsForProduct().add(request);
        productsDAO.changeProduct(product);
      }
    }
  }
  public static List<Object[]> executeTerminal(String sql) {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      List<Object[]> result = session.createSQLQuery(sql).list();

      tx.commit();

      return result;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
  public void addMansion(Mansion m) {

    Session session = sf.getCurrentSession();

    session.beginTransaction();

    session.save(m);

    session.getTransaction().commit();

    Session session2 = sf.getCurrentSession();

    session2.beginTransaction();

    Query query = session2.createQuery("from Mansion");
    List<Mansion> mlist = query.list();
    for (Mansion onem : mlist) {
      System.out.println(onem.getA().size());
    }

    Query query2 = session2.createQuery("from Aristocrat");
    List<Aristocrat> alist = query2.list();
    for (Aristocrat onea : alist) {
      System.out.println("An aristocrat...");
    }

    session2.close();
  }
  public static Panel savePanel(Panel panel) {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      session.saveOrUpdate(panel);

      tx.commit();

      return panel;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
  public RoleView() {

    SessionFactory sessionFactory = DatabaseUtil.getSessionFactory();
    Session openSession = sessionFactory.openSession();
    openSession.beginTransaction();

    Query query = openSession.createQuery("from Role");

    list = query.list();

    for (Role acconunt : list) {
      addComponent(new Label(acconunt.getRoleName()));
    }

    openSession.getTransaction().commit();
    openSession.flush();

    Button button = new Button("roles");

    button.addClickListener(
        new ClickListener() {

          @Override
          public void buttonClick(ClickEvent event) {

            for (Role account : list) {
              for (Permission role : account.getPermissions()) {
                System.out.println(role.getPermissionName());
              }
            }
          }
        });

    addComponent(button);
  }
  public static List<ClientProfile> getClientProfileList() {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      List<ClientProfile> profiles =
          session.createQuery("SELECT distinct profile " + "FROM ClientProfile profile ").list();

      tx.commit();
      return profiles;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
 protected Session getSession() {
   Session session = sessionFactory.getCurrentSession();
   if (null == session || false == session.isOpen()) {
     session = sessionFactory.openSession();
   }
   return session;
 }
  public static ClientProfile getClientProfileByDisplay(String display) {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      ClientProfile profiles =
          (ClientProfile)
              session
                  .createQuery(
                      "SELECT distinct client "
                          + "FROM ClientProfile client "
                          + "left join fetch client.layout layout "
                          + "left join fetch client.profile profile "
                          + "left join fetch profile.layoutProfiles laypro "
                          + "left join fetch layout.panels panel "
                          + "left join fetch panel.texts "
                          + "left join fetch panel.videos "
                          + "left join fetch panel.images "
                          + "left join fetch panel.webs "
                          + "left join fetch panel.slideShows "
                          + "left join fetch panel.feeds "
                          + "left join fetch laypro.layout lay "
                          + "left join fetch lay.panels pan "
                          + "left join fetch pan.texts "
                          + "left join fetch pan.videos "
                          + "left join fetch pan.images "
                          + "left join fetch pan.webs "
                          + "left join fetch pan.slideShows "
                          + "left join fetch pan.feeds "
                          + "WHERE client.clientName = :pname")
                  .setParameter("pname", display)
                  .uniqueResult();

      tx.commit();

      if (profiles != null && profiles.getProfile() != null) {
        Map<Long, LayoutProfile> map = new LinkedHashMap<Long, LayoutProfile>();
        for (LayoutProfile layoutProfile : profiles.getProfile().getLayoutProfiles()) {
          map.put(layoutProfile.getId(), layoutProfile);
        }
        profiles.getProfile().getLayoutProfiles().clear();
        profiles.getProfile().getLayoutProfiles().addAll(map.values());
      }

      return profiles;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
  public static void main(String[] args) {

    SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
    Session session = sessionFactory.openSession();
    session.beginTransaction();
    // CREATE
    for (int i = 1; i <= 30; i++) {
      UserInfo user = new UserInfo();

      user.setName("User" + i);
      session.save(user);
    }
    session.getTransaction().commit();
    session.close();

    UserInfo user = new UserInfo();
    session = sessionFactory.openSession();
    session.beginTransaction();
    // Retreive
    user = (UserInfo) session.get(UserInfo.class, 6);
    // Update
    user.setName("Updated User Name");
    session.update(user);

    // Delete
    user = (UserInfo) session.get(UserInfo.class, 5);
    session.delete(user);
    session.getTransaction().commit();
    session.close();

    //		System.out.println("User Object retrieved is: " + user);

  }
  @SuppressWarnings("unchecked")
  public static List<Profile> getProfileList() {
    SessionFactory sf = HibernateUtil.getSessionFactory();
    Session session = null;
    Transaction tx = null;

    try {
      session = sf.openSession();
      tx = session.beginTransaction();

      List<Profile> profiles =
          session
              .createQuery(
                  "SELECT distinct profile "
                      + "FROM Profile profile "
                      + "left join fetch profile.layoutProfiles laypro "
                      + "left join fetch laypro.layout "
                      + "ORDER BY profile.name, laypro.ordering ")
              .list();

      tx.commit();
      return profiles;
    } catch (Exception e) {
      e.printStackTrace();
      if (tx != null) {
        tx.rollback();
      }
      return null;
    } finally {
      session.clear();
      session.close();
    }
  }
  public static void reservar(
      Hospede hospede, Apartamento apartamento, Date dt_inicio, Date dt_fim) {
    Session session = null;
    Transaction tx = null;

    try {
      SessionFactory factory = new Configuration().configure().buildSessionFactory();
      session = factory.openSession();

      tx = session.beginTransaction();
      Reserva reserva = new Reserva();
      reserva.setHospede(hospede);
      reserva.setApartamento(apartamento);
      reserva.setDataInicio(dt_inicio);
      reserva.setDataFim(dt_fim);
      session.save(reserva);

      /*Depois de salvar a RESERVA tem que mudar a situação do apartamento para não disponível*/
      // Apartamento apBd = ApartamentoDAO.buscarApartamento(apartamento.getId());
      // apBd.setDisponivel(false);
      session.update(apartamento);
      tx.commit();

    } catch (Exception e) {
      if (tx != null) tx.rollback();
      System.out.println("Erro: " + e.getMessage());
    } finally {
      session.close();
    }
  }
  /**
   * Gets the planned notifications for the list of sites that are passed in. This method access the
   * db using a new session from the hibernate session factory.
   *
   * @param hcsList the hcs list
   * @return the planned notifications
   */
  public List<PlannedNotification> getPlannedNotificationsForUpdateMasterSubject() {
    List<PlannedNotification> result;

    SessionFactory sessionFactory = (SessionFactory) applicationContext.getBean("sessionFactory");
    Session session = sessionFactory.openSession(sessionFactory.getCurrentSession().connection());
    session.setFlushMode(FlushMode.MANUAL);
    result = new ArrayList<PlannedNotification>();
    try {
      Query query =
          session
              .createQuery("from PlannedNotification p where p.eventName = :var")
              .setString("var", NotificationEventTypeEnum.MASTER_SUBJECT_UPDATED_EVENT.toString());

      result = query.list();
    } catch (DataAccessResourceFailureException e) {
      log.error(e.getMessage());
    } catch (IllegalStateException e) {
      e.printStackTrace();
    } catch (HibernateException e) {
      log.error(e.getMessage());
    } catch (Exception e) {
      log.error(e.getMessage());
    } finally {
      session.close();
    }
    return result;
  }