@Sessional
@Override
public SshKey findByDigest(String digest) {
    SimpleExpression eq = Restrictions.eq("digest", digest);
    EntityCriteria<SshKey> entityCriteria = EntityCriteria.of(SshKey.class).add(eq);
    entityCriteria.setCacheable(true);
    return find(entityCriteria);
}
 

/**
 * Get value of failed login attemtpts counter from DB.
 *
 * @author Marco Libanori
 */
@Override
public int getFailedLoginAttempts(String userId) {
	logger.debug("IN");

	Session aSession = null;
	Transaction tx = null;
	try {

		Integer result = 0;

		if (isUserIdAlreadyInUse(userId) != null) {

			aSession = getSession();
			tx = aSession.beginTransaction();

			ProjectionList projList = Projections.projectionList().add(Projections.property("failedLoginAttempts"), "failedLoginAttempts");

			SimpleExpression eq = Restrictions.eq("userId", userId);

			result = (Integer) aSession.createCriteria(SbiUser.class).add(eq).setProjection(projList).uniqueResult();

			tx.commit();
		}

		return result;
	} catch (HibernateException he) {
		if (tx != null)
			tx.rollback();
		throw new SpagoBIDAOException("Error while reading failed login attempts counter for user " + userId, he);
	} finally {
		logger.debug("OUT");
		if (aSession != null) {
			if (aSession.isOpen())
				aSession.close();
		}
	}
}
 

public static List query(Class clazz, SimpleExpression... simpleExpressions) {
	Criteria criteria = getSession().createCriteria(clazz);
	for (SimpleExpression simpleExpression : simpleExpressions) {
		criteria.add(simpleExpression);
	}
	List result = criteria.list();
	return result;
}
 

@SuppressWarnings(SUPPRESS_UNCHECKED)
private List<Repository> getAllRepositories(String projectName, ContentType type) {
    final Criteria crit = sessionService.getSession().createCriteria(Repository.class);
    SimpleExpression restriction = Restrictions.eq("contentType", type);
    SimpleExpression bothRestriction = Restrictions.eq("contentType", ContentType.BOTH);
    crit.add(Restrictions.or(restriction, bothRestriction));
    if (projectName != null) {
        crit.createAlias("project", "p");
        crit.add(Restrictions.eq("p.name", projectName));
    }
    List<Repository> list = crit.list();
    HibernateLazyInitializer.initCollection(list);
    return list;
}
 

@SuppressWarnings("unchecked")
public static List<BasicRule> getAllOtherPublishedBasicRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(BasicRule.class);
    Criterion isOwner = Restrictions.not(Restrictions.eq(OWNER_ID, valueOf(userID)));
    SimpleExpression isPublished = Restrictions.eq(PUBLISHED, true);
    List<BasicRule> rules = crit.add(Restrictions.and(isOwner, isPublished)).list();
    session.getTransaction().commit();
    return rules;
}
 

@Deprecated
@SuppressWarnings("unchecked")
public static List<ComplexRule> getAllOtherPublishedComplexRules(String userID) {
    Session session = getSessionFactory().getCurrentSession();
    session.beginTransaction();
    Criteria crit = session.createCriteria(ComplexRule.class);
    Criterion isOwner = Restrictions.not(Restrictions.eq(OWNER_ID, valueOf(userID)));
    SimpleExpression isPublished = Restrictions.eq(PUBLISHED, true);
    List<ComplexRule> rules = crit.add(Restrictions.and(isOwner, isPublished)).list();
    session.getTransaction().commit();
    return rules;
}
 

private SimpleExpression isAuthor(String modelAlias) {
	return eq(modelAlias+".author.id", currentUser.getCurrent().getId());
}
 

private SimpleExpression isVisible(String modelAlias) {
	return eq(modelAlias+".moderationOptions.invisible", false);
}
 

private SimpleExpression moderationOptionsVisible(String modelAlias) {
	return eq(modelAlias+".moderationOptions.invisible", false);
}