@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateRefreshTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2RefreshTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate refresh tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2RefreshTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2RefreshTokenEntity.class); Root<OAuth2RefreshTokenEntity> root = criteriaDelete.from(OAuth2RefreshTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate refresh tokens", result); } }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateAccessTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2AccessTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate access tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2AccessTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2AccessTokenEntity.class); Root<OAuth2AccessTokenEntity> root = criteriaDelete.from(OAuth2AccessTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate access tokens", result); } }
protected <E extends Identifiable, T> void _deleteGlobalRecordsForType(E entity, EntityManager em, Class<T> clazz) { if(JPAEntity.class.isAssignableFrom(entity.getClass())) { JPAEntity jpaEntity = JPAEntity.class.cast(entity); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaDelete<T> update = cb.createCriteriaDelete(clazz); Root<T> from = update.from(clazz); update.where(cb.equal(from.get("entity"), jpaEntity)); em.createQuery(update).executeUpdate(); }else { throw new IllegalArgumentException("Entity - " + entity.getClass() + " is not of type JPAEntity"); } }
protected <E extends Identifiable, T> void _deleteGlobalRecordsForType(E entity, EntityManager em, Class<T> clazz) { if(JPAEntity.class.isAssignableFrom(entity.getClass())) { JPAEntity jpaEntity = JPAEntity.class.cast(entity); CriteriaBuilder cb = em.getCriteriaBuilder(); CriteriaDelete<T> update = cb.createCriteriaDelete(clazz); Root<T> from = update.from(clazz); update.where(cb.equal(from.get("entity"), jpaEntity)); em.createQuery(update).executeUpdate(); }else { throw new IllegalArgumentException("Entity - " + entity.getClass() + " is not of type JPAEntity"); } }
/** * Constructs the delete criteria query * * @param builder * @param query * @param root */ public <T extends Model> void constructQuery(CriteriaBuilder builder, CriteriaDelete<?> query, Root<T> root) { if (conditions != null || !conditions.isEmpty()) { List<Predicate> predicates = new ArrayList<Predicate>(); for (Condition condition : conditions) { predicates.add(condition.constructQuery(builder, root)); } query.where(predicates.toArray(new Predicate[0])); } }
/** * {@inheritDoc} */ @Override public Query createDeletionQuery(Class queryClazz, TranslationContext criteria) { CriteriaDelete jpaQuery = entityManager.getCriteriaBuilder().createCriteriaDelete(queryClazz); if (!criteria.predicates.isEmpty()) { jpaQuery = jpaQuery.where(criteria.getCriteriaPredicate()); } return entityManager.createQuery(jpaQuery); }
@Override public void delete(Long primaryKey) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<PersonEntity> query = builder.createCriteriaDelete(PersonEntity.class); Root<PersonEntity> from = query.from(PersonEntity.class); query.where(builder.equal(from.get("personId"), primaryKey)); em.createQuery(query).executeUpdate(); logger.info("Deleted Person with ID : {}", primaryKey); return null; }); }
@Override public void delete(Long primaryKey) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<PersonEntity> query = builder.createCriteriaDelete(PersonEntity.class); Root<PersonEntity> from = query.from(PersonEntity.class); query.where(builder.equal(from.get("personId"), primaryKey)); em.createQuery(query).executeUpdate(); logger.info("Deleted Person with ID : {}", primaryKey); return null; }); }
@Override public void delete(Long personId) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<AddressEntity> query = builder.createCriteriaDelete(AddressEntity.class); Root<AddressEntity> from = query.from(AddressEntity.class); query.where(builder.equal(from.get("person").get("personId"), personId)); em.createQuery(query).executeUpdate(); return null; }); } }
@Override public void delete(Long personId) { transactionControl.required(() -> { CriteriaBuilder builder = em.getCriteriaBuilder(); CriteriaDelete<AddressEntity> query = builder.createCriteriaDelete(AddressEntity.class); Root<AddressEntity> from = query.from(AddressEntity.class); query.where(builder.equal(from.get("person").get("personId"), personId)); em.createQuery(query).executeUpdate(); return null; }); } }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateAccessTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2AccessTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate access tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2AccessTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2AccessTokenEntity.class); Root<OAuth2AccessTokenEntity> root = criteriaDelete.from(OAuth2AccessTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate access tokens", result); } }
@Override @Transactional(value="defaultTransactionManager") public void clearDuplicateRefreshTokens() { Query query = manager.createQuery("select a.jwt, count(1) as c from OAuth2RefreshTokenEntity a GROUP BY a.jwt HAVING count(1) > 1"); @SuppressWarnings("unchecked") List<Object[]> resultList = query.getResultList(); List<JWT> values = new ArrayList<>(); for (Object[] r : resultList) { logger.warn("Found duplicate refresh tokens: {}, {}", ((JWT)r[0]).serialize(), r[1]); values.add((JWT) r[0]); } if (values.size() > 0) { CriteriaBuilder cb = manager.getCriteriaBuilder(); CriteriaDelete<OAuth2RefreshTokenEntity> criteriaDelete = cb.createCriteriaDelete(OAuth2RefreshTokenEntity.class); Root<OAuth2RefreshTokenEntity> root = criteriaDelete.from(OAuth2RefreshTokenEntity.class); criteriaDelete.where(root.get("jwt").in(values)); int result = manager.createQuery(criteriaDelete).executeUpdate(); logger.warn("Deleted {} duplicate refresh tokens", result); } }
public void delete(Map<String, Object> params, AppDaoEnumConnector connector) { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaDelete<E> criteriaDelete = new CriteriaDeleteDefaultImpl<>((CriteriaBuilderImpl) builder); Root<E> root = criteriaDelete.from(getDomainClass()); List<Predicate> predicateList = Lists.newArrayList(); params.forEach((k, v) -> predicateList.add(builder.equal(root.get(k), v))); Predicate[] predicates = new Predicate[predicateList.size()]; predicates = predicateList.toArray(predicates); Predicate predicate = null; if (connector == AppDaoEnumConnector.AND) { predicate = builder.and(predicates); } else if (connector == AppDaoEnumConnector.OR) { predicate = builder.or(predicates); } criteriaDelete.where(predicate); entityManager.createQuery(criteriaDelete).executeUpdate(); }
/** * @param id */ @Override public void delete(ID id) throws GPDAOException { checkArgument(id != null, "The Parameter ID must not be null."); try { CriteriaDelete<T> criteriaDelete = this.createCriteriaDelete(); Root<T> root = criteriaDelete.from(super.getPersistentClass()); criteriaDelete.where(this.criteriaBuilder().equal(root.get("id"), id)); this.entityManager.createQuery(criteriaDelete).executeUpdate(); } catch (Exception ex) { ex.printStackTrace(); throw new GPDAOException(ex); } }
@Override public long remove(Specification<A> specification) { CriteriaBuilder cb = entityManager.getCriteriaBuilder(); Class<A> entityClass = getAggregateRootClass(); CriteriaDelete<A> cd = cb.createCriteriaDelete(entityClass); cd.where(specificationTranslator .translate(specification, new JpaTranslationContext<>(cb, cd.from(entityClass)))); return entityManager.createQuery(cd).executeUpdate(); }
/** * @param id * @return {@link Integer} * @throws GPDAOException */ @Override public Integer deleteByID(ID id) throws GPDAOException { checkArgument(id != null, "The Parameter ID must not be null."); try { CriteriaDelete<T> criteriaDelete = this.createCriteriaDelete(); Root<T> root = criteriaDelete.from(super.getPersistentClass()); criteriaDelete.where(this.criteriaBuilder().equal(root.get("id"), id)); return entityManager.createQuery(criteriaDelete).executeUpdate(); } catch (HibernateException ex) { logger.error("HibernateException : " + ex); throw new GPDAOException(ex); } }
/** * @param id */ @Override public void delete(ID id) throws GPDAOException { checkArgument(id != null, "The Parameter ID must not be null."); try { CriteriaBuilder criteriaBuilder = super.criteriaBuilder(); CriteriaDelete<T> criteriaDelete = super.createCriteriaDelete(); Root<T> root = criteriaDelete.from(this.persistentClass); criteriaDelete.where(criteriaBuilder.equal(root.get("id"), id)); this.currentSession().createQuery(criteriaDelete).executeUpdate(); } catch (Exception ex) { ex.printStackTrace(); throw new GPDAOException(ex); } }
/** * @param id * @return {@link Integer} * @throws GPDAOException */ @Override public Integer deleteByID(ID id) throws GPDAOException { checkArgument(id != null, "The Parameter ID must not be null."); try { CriteriaDelete<T> criteriaDelete = this.createCriteriaDelete(); Root<T> root = criteriaDelete.from(super.getPersistentClass()); criteriaDelete.where(this.criteriaBuilder().equal(root.get("id"), id)); return currentSession().createQuery(criteriaDelete).executeUpdate(); } catch (HibernateException ex) { logger.error("HibernateException : " + ex); throw new GPDAOException(ex); } }
/** * Removes entities by GUIDs. Check on existence is made. * * @param guids the set of GUIDs. * @return the number of deleted entities. * @throws org.lorislab.jee.exception.ServiceException if the method fails. */ @TransactionAttribute(TransactionAttributeType.REQUIRED) public int deleteQueryByGuids(List<K> guids) throws ServiceException { try { if (guids != null && !guids.isEmpty()) { CriteriaBuilder cb = getEntityManager().getCriteriaBuilder(); CriteriaDelete<T> cq = cb.createCriteriaDelete(entityClass); Root<T> root = cq.from(entityClass); cq.where(root.get(AbstractPersistent_.guid).in(guids)); return getEntityManager().createQuery(cq).executeUpdate(); } } catch (Exception e) { throw new ServiceException(EntityServiceErrors.FAILED_TO_DELETE_ALL_BY_GUIDS_QUERY, e, entityName); } return 0; }
public <T extends PostModerate> int deleteSpam(EntityManager entityManager, Class<T> postModerateClass) { CriteriaBuilder builder = entityManager.getCriteriaBuilder(); CriteriaDelete<T> delete = builder.createCriteriaDelete(postModerateClass); Root<T> root = delete.from(postModerateClass); int daysValidityThreshold = (Post.class.isAssignableFrom(postModerateClass)) ? 7 : 3; delete .where( builder.and( builder.equal(root.get("status"), PostStatus.SPAM), builder.lessThanOrEqualTo(root.get("updatedOn"), Timestamp.valueOf(LocalDateTime.now().minusDays(daysValidityThreshold))) ) ); return entityManager.createQuery(delete).executeUpdate(); }