Example usage for org.hibernate.criterion Restrictions ne

Introduction

In this page you can find the example usage for org.hibernate.criterion Restrictions ne.

Prototype

public static SimpleExpression ne(String propertyName, Object value) 

Source Link

Document

Apply a "not equal" constraint to the named property

Usage

From source file:es.sm2.openppm.core.dao.ProjectDAO.java

License:Open Source License

/**
 * Find investments in process and not disabled
 *
 * @return/*from w  w  w.j av  a2s  .  c om*/
 */
public List<Project> findInvestmentsInProcess() {

    // Create criteria
    Criteria crit = getSession().createCriteria(getPersistentClass());

    // Filter Not disabled projects
    crit.add(Restrictions.disjunction().add(Restrictions.ne(Project.DISABLE, Constants.SELECTED))
            .add(Restrictions.isNull(Project.DISABLE)));

    // Filter investments rejected
    crit.add(Restrictions.eq(Project.INVESTMENTSTATUS, Constants.INVESTMENT_IN_PROCESS));

    // Order
    crit.addOrder(Order.asc(Project.CHARTLABEL));

    return crit.list();
}

---

From source file:es.sm2.openppm.core.dao.ProjectFollowupDAO.java

License:Open Source License

/**
 *
 * @param project//from   w  w  w  .  j  a va2  s.  c o m
 * @param followupdate
 * @param date
 * @return
 */
public Projectfollowup findBydDate(Integer id, Project project, String followupdate, Date date) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setMaxResults(1)
            .add(Restrictions.eq(Projectfollowup.PROJECT, project))
            .add(Restrictions.eq(Projectfollowup.FOLLOWUPDATE, date));

    if (id != null) {
        crit.add(Restrictions.ne(Projectfollowup.IDPROJECTFOLLOWUP, id));
    }

    return (Projectfollowup) crit.uniqueResult();
}

---

From source file:es.sm2.openppm.core.dao.ProjectKpiDAO.java

License:Open Source License

/**
 * Check if metric is assigned in other project KPI
 * @param project/*www. ja  v a 2  s  .c o m*/
 * @param idProjectKPI
 * @param metrickpi
 * @return
 */
public boolean metricExist(Project project, int idProjectKPI, Metrickpi metrickpi) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Projectkpi.PROJECT, project))
            .add(Restrictions.eq(Projectkpi.METRICKPI, metrickpi));

    if (idProjectKPI != -1) {
        crit.add(Restrictions.ne(Projectkpi.IDPROJECTKPI, idProjectKPI));
    }
    Integer count = (Integer) crit.uniqueResult();

    return (count != null && count > 0);
}

---

From source file:es.sm2.openppm.core.dao.SecurityDAO.java

License:Open Source License

/**
 * User name in use//ww w  .j  a v  a2 s. c o  m
 * @param contact
 * @param login
 * @return
 */
public boolean isUserName(Contact contact, String login) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Security.LOGIN, login)).add(Restrictions.ne(Security.CONTACT, contact));

    return ((Integer) crit.uniqueResult() > 0);
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Search Team Members by Project...//from   w  w  w . j a  v  a 2 s.  c om
 * 
 * @param project
 * @param since
 * @param until
 * @param showDisabled
  * @return
 */
public List<Teammember> consStaffinFtes(Project project, Date since, Date until, boolean showDisabled) {

    // Create query and restrictions
    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.or(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED),
                    Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_RELEASED)))
            .add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                    .add(Restrictions.between(Teammember.DATEOUT, since, until))
                    .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                            Restrictions.ge(Teammember.DATEOUT, until))));

    // Restriction project
    crit.createCriteria(Teammember.PROJECTACTIVITY).add(Restrictions.eq(Projectactivity.PROJECT, project));

    if (!showDisabled) {

        // Exclude employees and contacts disabled
        crit.createCriteria(Teammember.EMPLOYEE, "em").add(Restrictions.ne(Employee.DISABLE, true))
                .setFetchMode(Teammember.EMPLOYEE + "." + Employee.RESOURCEPROFILES, FetchMode.JOIN);

        crit.createCriteria("em." + Employee.CONTACT, "contact").add(Restrictions.ne(Contact.DISABLE, true));
    } else {
        crit.setFetchMode(Teammember.EMPLOYEE, FetchMode.JOIN);
        crit.setFetchMode(Teammember.EMPLOYEE + "." + Employee.RESOURCEPROFILES, FetchMode.JOIN);
        crit.setFetchMode(Teammember.EMPLOYEE + "." + Employee.CONTACT, FetchMode.JOIN);

        // Create aliases for order
        crit.createAlias(Teammember.EMPLOYEE, "em").createAlias("em." + Employee.CONTACT, "contact");
    }

    // Data needed
    crit.setFetchMode(Teammember.JOBCATEGORY, FetchMode.JOIN);

    // Order by name
    crit.addOrder(Order.asc("contact.fullName"));

    return crit.list();
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Check if resource is assigned in range of dates in activity 
 * //from  w w w . ja v a  2s  .  c o  m
 * @param member
 * @return
 */
public boolean isAssigned(Teammember member) {

    Date since = member.getDateIn();
    Date until = member.getDateOut();

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, member.getProjectactivity()))
            .add(Restrictions.eq(Teammember.EMPLOYEE, member.getEmployee()))
            .add(Restrictions.ne(Teammember.STATUS, Constants.RESOURCE_RELEASED))
            .add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                    .add(Restrictions.between(Teammember.DATEOUT, since, until))
                    .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                            Restrictions.ge(Teammember.DATEOUT, until))));

    return ((Integer) crit.uniqueResult()) > 0;
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Search Team Members by filter/*from  w  w  w  .jav a  2  s  .  c  o m*/
 * 
 * @param idResourcePools 
 * @param idProjects
 * @param idPMs
 * @param idJobCategories
 * @param statusList
 * @param fullName
 * @param since
 * @param until
 * @param nameOrder 
 * @param order
 * @param idEmployee 
 * @param user 
 * @param idSellers 
 * @param idCategories 
 * @param settings 
 * @return
 */
public List<Teammember> consStaffinFtes(Integer[] idResourcePools, Integer[] idProjects, Integer[] idPMs,
        Integer[] idJobCategories, String[] statusList, String fullName, Date since, Date until,
        String nameOrder, String order, Integer idEmployee, Employee user, Integer[] idSellers,
        Integer[] idCategories, HashMap<String, String> settings) {

    Criteria crit = getSession().createCriteria(getPersistentClass(), "t");

    if (nameOrder == null && ValidateUtil.isNull(idJobCategories)) {

        crit.add(Restrictions.isNull(Teammember.JOBCATEGORY));
    }

    Criteria projActCrit = crit.createCriteria(Teammember.PROJECTACTIVITY);

    // Filter by sellers
    if (ValidateUtil.isNotNull(idSellers)) {

        projActCrit.createCriteria(Projectactivity.ACTIVITYSELLERS).createCriteria(Activityseller.SELLER)
                .add(Restrictions.in(Seller.IDSELLER, idSellers));
    }

    Criteria projCrit = projActCrit.createCriteria(Projectactivity.PROJECT);

    // Filter by category
    if (ValidateUtil.isNotNull(idCategories)) {

        projCrit.createCriteria(Project.CATEGORY).add(Restrictions.in(Category.IDCATEGORY, idCategories));
    }

    // Filter by Project
    if (ValidateUtil.isNotNull(idProjects)) {
        projCrit.add(Restrictions.in(Project.IDPROJECT, idProjects));
    }

    // Remove information if project is closed
    if (!SettingUtil.getBoolean(settings, SettingType.CLOSED_PROJECTS_CAPACITY_PLANNING)) {
        projCrit.add(Restrictions.and(Restrictions.ne(Project.STATUS, Constants.STATUS_CLOSED),
                Restrictions.ne(Project.STATUS, Constants.STATUS_ARCHIVED)));
    }

    // Filter by Project Manager
    if (user.getResourceprofiles().getIdProfile() == Constants.ROLE_PM) {

        projCrit.createCriteria(Project.EMPLOYEEBYPROJECTMANAGER)
                .add(Restrictions.eq(Employee.IDEMPLOYEE, user.getIdEmployee()));
    } else if (user.getResourceprofiles().getIdProfile() != Constants.ROLE_PM
            && ValidateUtil.isNotNull(idPMs)) {

        projCrit.createCriteria(Project.EMPLOYEEBYPROJECTMANAGER)
                .add(Restrictions.in(Employee.IDEMPLOYEE, idPMs));
    }

    // Filter by Status
    if (ValidateUtil.isNotNull(statusList)) {
        crit.add(Restrictions.in(Teammember.STATUS, statusList));
    }

    // Filter by Skill
    Criteria jobCrit = null;
    if (Jobcategory.IDJOBCATEGORY.equals(nameOrder) || ValidateUtil.isNotNull(idJobCategories)) {
        jobCrit = crit.createCriteria(Teammember.JOBCATEGORY);
    }
    if (ValidateUtil.isNotNull(idJobCategories)) {
        jobCrit.add(Restrictions.in(Jobcategory.IDJOBCATEGORY, idJobCategories));
    }

    // Filter by dates (since && until)
    if (since != null && until != null) {

        crit.add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, since, until))
                .add(Restrictions.between(Teammember.DATEOUT, since, until))
                .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                        Restrictions.ge(Teammember.DATEOUT, until))));
    } else if (since != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, since),
                Restrictions.ge(Teammember.DATEOUT, since)));
    } else if (until != null) {
        crit.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, until),
                Restrictions.ge(Teammember.DATEOUT, until)));
    }

    // Filter By Employee
    Criteria employeeCrit = crit.createCriteria(Teammember.EMPLOYEE);

    if (idEmployee != null) {
        employeeCrit.add(Restrictions.idEq(idEmployee));
    }

    // Filter by resource pool
    if (ValidateUtil.isNotNull(idResourcePools)) {

        employeeCrit.createCriteria(Employee.RESOURCEPOOL)
                .add(Restrictions.in(Resourcepool.IDRESOURCEPOOL, idResourcePools));
    }

    // Filter by po
    if (user != null) {
        employeeCrit.add(Restrictions.eq(Employee.PERFORMINGORG, user.getPerformingorg()));
    }

    // Filter by Full Name
    Criteria contactCrit = employeeCrit.createCriteria(Employee.CONTACT);
    if (ValidateUtil.isNotNull(fullName)) {
        contactCrit.add(Restrictions.ilike(Contact.FULLNAME, "%" + fullName + "%"));
    }

    // Apply Order
    Criteria orderCrit = null;
    if (Project.IDPROJECT.equals(nameOrder)) {
        orderCrit = projCrit;
    } else if (Jobcategory.IDJOBCATEGORY.equals(nameOrder)) {
        orderCrit = jobCrit;
    } else {
        orderCrit = contactCrit;
    }

    if (nameOrder != null) {
        if (Constants.DESCENDENT.equals(order)) {
            orderCrit.addOrder(Order.desc(nameOrder));
        } else {
            orderCrit.addOrder(Order.asc(nameOrder));
        }
    }

    contactCrit.addOrder(Order.asc(Contact.IDCONTACT));

    List<String> joins = new ArrayList<String>();
    joins.add(Teammember.PROJECTACTIVITY);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT + "."
            + Project.EMPLOYEEBYPROJECTMANAGER);
    joins.add(Teammember.PROJECTACTIVITY + "." + Projectactivity.PROJECT + "."
            + Project.EMPLOYEEBYPROJECTMANAGER + "." + Employee.CONTACT);

    addJoins(crit, joins);

    return crit.list();
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Find restriction type/*w  w w.  j a v a2s.  com*/
 * 
 * @param propertyRelation
 * @return
 */
private Criterion findRestriction(PropertyRelation propertyRelation) {

    Criterion criterion = null;

    if (propertyRelation.getRestriction() == Constants.EQUAL_RESTRICTION) {
        criterion = Restrictions.eq(propertyRelation.getProperty(), propertyRelation.getRelation());
    } else if (propertyRelation.getRestriction() == Constants.NOT_EQUAL_RESTRICTION) {
        criterion = Restrictions.ne(propertyRelation.getProperty(), propertyRelation.getRelation());
    } else if (propertyRelation.getRestriction() == Constants.GREATER_OR_EQUAL_RESTRICTION) {
        criterion = Restrictions.ge(propertyRelation.getProperty(), propertyRelation.getRelation());
    } else if (propertyRelation.getRestriction() == Constants.LESS_OR_EQUAL_RESTRICTION) {
        criterion = Restrictions.le(propertyRelation.getProperty(), propertyRelation.getRelation());
    } else if (propertyRelation.getRestriction() == Constants.ILIKE_RESTRICTION) {
        criterion = Restrictions.ilike(propertyRelation.getProperty(), propertyRelation.getRelation());
    } else if (propertyRelation.getRestriction() == Constants.DISJUNCTION) {
        ArrayList<PropertyRelation> listDisjunctions = (ArrayList<PropertyRelation>) propertyRelation
                .getRelation();

        Disjunction d = Restrictions.disjunction();

        for (PropertyRelation propertyRelationDis : listDisjunctions) {
            d.add(findRestriction(propertyRelationDis));
        }

        criterion = d;
    }

    return criterion;
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Time sheet not assigned to other team member
 * //from   ww w .j a  v  a  2 s  . co  m
 * @param member
 * @param timesheet
 * @return
 */
public boolean notAssignedToOtherMember(Teammember member, Timesheet timesheet) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .add(Restrictions.eq(Teammember.EMPLOYEE, member.getEmployee()))
            .add(Restrictions.ne(Teammember.IDTEAMMEMBER, member.getIdTeamMember()))
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, member.getProjectactivity()));

    crit.add(Restrictions.disjunction()
            .add(Restrictions.between(Teammember.DATEIN, timesheet.getInitDate(), timesheet.getEndDate()))
            .add(Restrictions.between(Teammember.DATEOUT, timesheet.getInitDate(), timesheet.getEndDate()))
            .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, timesheet.getInitDate()),
                    Restrictions.ge(Teammember.DATEOUT, timesheet.getEndDate()))));

    Integer count = (Integer) crit.uniqueResult();
    return !(count > 0);
}

---

From source file:es.sm2.openppm.core.dao.TeamMemberDAO.java

License:Open Source License

/**
 * Find members assigned of employee and exclude member
 * //from   www  .j  a  v  a 2  s .  c om
 * @param member
 * @return
 */
public List<Teammember> membersForCheckHours(Teammember member) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .add(Restrictions.ne(Teammember.IDTEAMMEMBER, member.getIdTeamMember()))
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, member.getProjectactivity()))
            .add(Restrictions.eq(Teammember.EMPLOYEE, member.getEmployee()))
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED));

    return crit.list();
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »