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.ProjectCalendarExceptionsDAO.java

License:Open Source License

/**
 * /*from w ww. ja v  a2  s  .  c om*/
 * @param calendar
 * @param initDate
 * @param endDate
 * @return
 */
@SuppressWarnings("unchecked")
public List<Projectcalendarexceptions> findByProjectCalendar(Projectcalendar calendar, Date initDate,
        Date endDate) {
    Criteria crit = getSession().createCriteria(getPersistentClass())
            .add(Restrictions.eq(Projectcalendarexceptions.PROJECTCALENDAR, calendar))
            .add(Restrictions.ge(Projectcalendarexceptions.STARTDATE, initDate))
            .add(Restrictions.le(Projectcalendarexceptions.FINISHDATE, endDate));

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find projects where an Employee is team member in range of days
 * @param employee//from   ww w.j  ava 2  s  . c  o m
 * @param sinceDate
 * @param untilDate
 * @return
 */
@SuppressWarnings("unchecked")
public List<Project> findByResourceInProject(Employee employee, Date sinceDate, Date untilDate) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).createCriteria(Project.PROJECTACTIVITIES)
            .createCriteria(Projectactivity.TEAMMEMBERS).add(Restrictions.eq(Teammember.EMPLOYEE, employee))
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .add(Restrictions.disjunction().add(Restrictions.between(Teammember.DATEIN, sinceDate, untilDate))
                    .add(Restrictions.between(Teammember.DATEOUT, sinceDate, untilDate))
                    .add(Restrictions.and(Restrictions.le(Teammember.DATEIN, sinceDate),
                            Restrictions.ge(Teammember.DATEOUT, untilDate))));

    return crit.list();

}

---

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

License:Open Source License

/**
 * //from  ww  w.  j  ava2s .c o m
 * @param employee
 * @param initDate
 * @param endDate
 * @return
 */
@SuppressWarnings("unchecked")
public List<Project> findByEmployee(Employee employee, Date initDate, Date endDate) {

    Criteria crit = getSession().createCriteria(getPersistentClass());
    crit.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY).createCriteria(Project.PROJECTACTIVITIES)
            .createCriteria(Projectactivity.TIMESHEETS).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));

    crit.addOrder(Order.asc(Project.PROJECTNAME));
    crit.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find PMs by employee and dates/*ww  w.  j  a  v a2  s.c  o m*/
 *
 * @param employee
 * @param dates
 * @return
 */
public List<Project> findPMs(Employee employee, List<Date> dates) {

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

    // Filter not null project managers
    crit.add(Restrictions.isNotNull(Project.EMPLOYEEBYPROJECTMANAGER));

    // Filters teammember by assigned and employee
    Criteria teammembers = crit.createCriteria(Project.PROJECTACTIVITIES)
            .createCriteria(Projectactivity.TEAMMEMBERS)
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .add(Restrictions.eq(Teammember.EMPLOYEE, employee));

    // Filter dates
    if (ValidateUtil.isNotNull(dates)) {

        for (Date date : dates) {

            teammembers.add(Restrictions.and(Restrictions.le(Teammember.DATEIN, date),
                    Restrictions.ge(Teammember.DATEOUT, date)));
        }
    }

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find followups before date//from  ww  w .ja  va  2 s .  c o  m
 * @param project
 * @param date
 * @param propertyOrder
 * @param typeOrder
 * @param joins
 * @return
 */
@SuppressWarnings("unchecked")
public List<Projectfollowup> findByProject(Project project, Date date, String propertyOrder, String typeOrder,
        List<String> joins) {

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

    addJoins(crit, joins);

    crit.add(Restrictions.eq(Projectfollowup.PROJECT, project));

    if (date != null) {
        crit.add(Restrictions.le(Projectfollowup.FOLLOWUPDATE, date));
    }

    addOrder(crit, propertyOrder, typeOrder);

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find follow ups for notify//from  w  ww. ja  va 2 s . c  o  m
 * @return
 */
@SuppressWarnings("unchecked")
public List<Projectfollowup> findForNotify() {

    Calendar actualDate = DateUtil.getCalendar();

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .add(Restrictions.le(Projectfollowup.FOLLOWUPDATE, actualDate.getTime()))
            .add(Restrictions.isNull(Projectfollowup.GENERALFLAG))
            .add(Restrictions.isNull(Projectfollowup.RISKFLAG))
            .add(Restrictions.isNull(Projectfollowup.COSTFLAG))
            .add(Restrictions.isNull(Projectfollowup.SCHEDULEFLAG))
            .setFetchMode(Projectfollowup.PROJECT, FetchMode.JOIN)
            .setFetchMode(Projectfollowup.PROJECT + "." + Project.EMPLOYEEBYPROJECTMANAGER, FetchMode.JOIN)
            .setFetchMode(
                    Projectfollowup.PROJECT + "." + Project.EMPLOYEEBYPROJECTMANAGER + "." + Employee.CONTACT,
                    FetchMode.JOIN);

    Criteria crit2 = crit.createCriteria(Projectfollowup.PROJECT);
    crit2.add(Restrictions.eq(Project.STATUS, Constants.STATUS_CONTROL));

    return crit.list();
}

---

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

License:Open Source License

/**
 * Search Team Members by Project...//w  w  w.  j a v a 2s .c  o  m
 * 
 * @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

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

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)
            .add(Restrictions.eq(Teammember.STATUS, Constants.RESOURCE_ASSIGNED))
            .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))));

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

    Criteria timesheetsCrit = crit.createCriteria(Teammember.EMPLOYEE).createCriteria(Employee.TIMESHEETS)
            .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
            .add(Restrictions.disjunction().add(Restrictions.between(Timesheet.INITDATE, since, until))
                    .add(Restrictions.between(Timesheet.ENDDATE, since, until))
                    .add(Restrictions.and(Restrictions.le(Timesheet.INITDATE, since),
                            Restrictions.ge(Timesheet.ENDDATE, until))));

    timesheetsCrit.createCriteria(Timesheet.PROJECTACTIVITY)
            .add(Restrictions.eq(Projectactivity.PROJECT, project));

    crit.setFetchMode(Teammember.JOBCATEGORY, FetchMode.JOIN);
    crit.setFetchMode(Teammember.EMPLOYEE, FetchMode.JOIN);
    crit.setFetchMode(Teammember.EMPLOYEE + "." + Employee.CALENDARBASE, FetchMode.JOIN);

    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  ww w  . ja v a 2s .  co 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

/**
 * Apply filters by table utility/* w  w  w  . j  av a 2s .c  o  m*/
 * 
 * @param crit
 * @param filtrosExtras
 * @param orders
 * @param listResourcepool
 * @throws ParseException
 */
private void applyFilters(Criteria crit, List<DatoColumna> filtrosExtras, List<DatoColumna> orders,
        List<Resourcepool> listResourcepool) throws ParseException {

    employeeCrit = crit.createCriteria(Teammember.EMPLOYEE);

    if (ValidateUtil.isNotNull(listResourcepool)) {
        employeeCrit.add(Restrictions.in(Employee.RESOURCEPOOL, listResourcepool));
    }

    critContact = employeeCrit.createCriteria(Employee.CONTACT);
    critActivity = crit.createCriteria(Teammember.PROJECTACTIVITY);
    critProject = critActivity.createCriteria(Projectactivity.PROJECT);

    for (DatoColumna filtroColumna : filtrosExtras) {

        if (filtroColumna.getTipo() == List.class) {

            // Since Until
            if (filtroColumna.getSubTipo() != null && filtroColumna.getSubTipo() == Date.class) {

                Date sinceDate = (Date) filtroColumna.getObjectList()[0];
                Date untilDate = (Date) filtroColumna.getObjectList()[1];

                String sinceName = (String) filtroColumna.getNombreList()[0];
                String untilName = (String) filtroColumna.getNombreList()[1];

                crit.add(Restrictions.disjunction().add(Restrictions.between(sinceName, sinceDate, untilDate))
                        .add(Restrictions.between(untilName, sinceDate, untilDate)).add(Restrictions.and(
                                Restrictions.le(sinceName, sinceDate), Restrictions.ge(untilName, untilDate))));
            } else {
                // Tiene que estar en la lista
                crit.add(Restrictions.in(filtroColumna.getNombre(), filtroColumna.getValorList()));
            }
        } else if (filtroColumna.getTipo() == String.class) {

            if (filtroColumna.getSubTipo() == List.class) {

                if (!ValidateUtil.isNull(filtroColumna.getValor())) {
                    String[] value = filtroColumna.getValor().split(",");
                    List<Integer> ids = new ArrayList<Integer>();

                    for (String id : value) {
                        ids.add(Integer.parseInt(id));
                    }

                    if (filtroColumna.getNombre().equals(Project.EMPLOYEEBYPROJECTMANAGER)) {

                        critProject.add(Restrictions.in(filtroColumna.getNombre() + ".idEmployee", ids));
                    } else if (filtroColumna.getCriteria() != null) {
                        Criteria crit2 = crit.createCriteria(filtroColumna.getCriteria());
                        crit2.add(Restrictions.in(filtroColumna.getNombre(), ids));
                    } else {
                        crit.add(Restrictions.in(filtroColumna.getNombre(), ids));
                    }

                }
            } else {
                // Add filters for fullname project name or charlabel
                if (filtroColumna.getNombre().equals(Contact.FULLNAME)) {

                    critContact.add(
                            Restrictions.like(filtroColumna.getNombre(), "%" + filtroColumna.getValor() + "%"));
                } else if (filtroColumna.getNombre().equals(Configurations.PROJECT_NAME)) {
                    // Filter employees by project description OR project short name
                    critProject.add(Restrictions.disjunction()
                            .add(Restrictions.like(Project.PROJECTNAME,
                                    StringPool.PERCENT + filtroColumna.getValor() + StringPool.PERCENT))
                            .add(Restrictions.like(Project.CHARTLABEL,
                                    StringPool.PERCENT + filtroColumna.getValor() + StringPool.PERCENT)));

                } else {
                    // Comparando texto
                    crit.add(
                            Restrictions.like(filtroColumna.getNombre(), "%" + filtroColumna.getValor() + "%"));
                }
            }
        } else if (filtroColumna.getTipo() == Integer.class) {
            // Filtrando Objectos

            Integer value = Integer.parseInt(filtroColumna.getValor());
            crit.add(Restrictions.eq(filtroColumna.getNombre(), value));
        } else if (filtroColumna.getTipo() != Date.class) {
            // Filtrando Objectos
            if (filtroColumna.getCriteria() != null) {

                crit.createCriteria(filtroColumna.getCriteria())
                        .add(Restrictions.eq(filtroColumna.getNombre(), filtroColumna.getObject()));
            } else {

                crit.add(Restrictions.eq(filtroColumna.getNombre(), filtroColumna.getObject()));
            }
        }
    }
    if (orders != null && !orders.isEmpty()) {

        appplyOrders(crit, orders);
    }
}

---

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