Example usage for org.hibernate.criterion Restrictions le

Introduction

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

Prototype

public static SimpleExpression le(String propertyName, Object value) 

Source Link

Document

Apply a "less than or equal" constraint to the named property

Usage

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

License:Open Source License

/**
 * Check if employee is assigned in these day on the project activity
 * //w w w .  j  a va 2 s . c o m
 * @param day
 * @param projectactivity
 * @param employee
 * @return
 */
public boolean isWorkDay(Date day, Projectactivity projectactivity, Employee employee) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, projectactivity))
            .add(Restrictions.eq(Teammember.EMPLOYEE, employee)).add(Restrictions.le(Teammember.DATEIN, day))
            .add(Restrictions.ge(Teammember.DATEOUT, day));

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

---

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

License:Open Source License

/**
 * Find members assigned by project in dates 
 * /*from w w  w.j av a2 s  .c  om*/
 * @param employee
 * @param joins
 * @return
 * @throws Exception
 */
public List<Teammember> findByEmployeeOrderByProject(Employee employee, Date since, Date until,
        List<String> joins) throws Exception {

    Criteria crit = getSession().createCriteria(getPersistentClass());

    addJoins(crit, joins);
    crit.add(Restrictions.eq(Teammember.EMPLOYEE, employee))
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED));

    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)));
    }

    crit.createCriteria(Teammember.PROJECTACTIVITY).createCriteria(Projectactivity.PROJECT)
            .addOrder(Order.desc(Project.IDPROJECT));

    return crit.list();
}

---

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

License:Open Source License

/**
 * Search Team Members by filter//www  .j a  v 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 team members filter by activity, employee and dates
 * //from   w w w  . j  a  v a 2  s  .com
 * @param employee
 * @param projectactivity
 * @param dateIn
 * @param dateOut
 * @param joins
 * @return
 */
public List<Teammember> findByActivityAndDates(Employee employee, Projectactivity projectactivity, Date dateIn,
        Date dateOut, List<String> joins) {

    Criteria crit = getSession().createCriteria(getPersistentClass());

    if (joins != null) {
        for (String join : joins) {
            crit.setFetchMode(join, FetchMode.JOIN);
        }
    }

    crit.add(Restrictions.eq(Teammember.EMPLOYEE, employee))
            .add(Restrictions.eq(Teammember.PROJECTACTIVITY, projectactivity));

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

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

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find restriction type//from   ww  w .j av a  2  s.  c om
 * 
 * @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 w  w  w.j  ava  2s .c  o 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 teammembers of project in date/*w  ww .  j  a  v  a2s . c  om*/
 * 
 * @param project
 * @param closeDate
 * @return
 */
public List<Teammember> findByProjectInDate(Project project, Date closeDate) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, closeDate),
                    Restrictions.ge(Teammember.DATEOUT, closeDate)));

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

    return crit.list();
}

---

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

License:Open Source License

/**
 * Capacity planning resource //from w  w  w. ja va 2  s.c om
 * 
 * @param idEmployee
 * @param since
 * @param until
 * @param statusList
 * @param joins
 * @param settings
 * @param user
  * @return
 */
public List<Teammember> capacityPlanningResource(Integer idEmployee, Date since, Date until,
        String[] statusList, List<String> joins, HashMap<String, String> settings, Employee user) {

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

    // 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)));
    }

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

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

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

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

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

    // 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)));
    }

    addJoins(crit, joins);

    // PM Projects
    if (!SettingUtil.getBoolean(settings, GeneralSetting.PM_VIEW_OTHER_PROJECTS)
            && user.getResourceprofiles().getIdProfile() == Constants.ROLE_PM) {

        projCrit.add(Restrictions.eq(Project.EMPLOYEEBYPROJECTMANAGER, user));
    }

    // Orders
    //
    employeeCrit.createCriteria(Employee.CONTACT).addOrder(Order.asc(Contact.FULLNAME));

    projCrit.addOrder(Order.asc(Project.PROJECTNAME));

    projActCrit.addOrder(Order.asc(Projectactivity.ACTIVITYNAME));

    return crit.list();
}

---

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

License:Open Source License

/**
 * //w ww  .  j a  va 2 s.c  o m
 * @param employee
 * @param initDate
 * @param endDate
 * @param joins
 * @return
 */
@SuppressWarnings("unchecked")
public List<Timesheet> findWithActivityByResource(Employee employee, Date initDate, Date endDate,
        List<String> joins) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.eq(Timesheet.EMPLOYEE, employee))
            .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
            .add(Restrictions.ge(Timesheet.INITDATE, initDate)).add(Restrictions.le(Timesheet.ENDDATE, endDate))
            .createAlias(Timesheet.PROJECTACTIVITY, "pActivity")
            .addOrder(Order.asc("pActivity." + Projectactivity.PROJECT))
            .addOrder(Order.asc(Timesheet.INITDATE));

    addJoins(crit, joins);

    return crit.list();
}

---

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

License:Open Source License

/**
 * //ww w . ja  va  2 s.  c o  m
 * @param employee
 * @param initDate
 * @param endDate
 * @param joins
 * @return
 */
@SuppressWarnings("unchecked")
public List<Timesheet> findWithOperationByResource(Employee employee, Date initDate, Date endDate,
        List<String> joins) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.isNull(Timesheet.PROJECTACTIVITY))
            .add(Restrictions.eq(Timesheet.EMPLOYEE, employee))
            .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
            .add(Restrictions.ge(Timesheet.INITDATE, initDate)).add(Restrictions.le(Timesheet.ENDDATE, endDate))
            .addOrder(Order.asc(Timesheet.OPERATION)).addOrder(Order.asc(Timesheet.INITDATE));

    addJoins(crit, joins);

    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
• »