Example usage for org.hibernate.criterion Restrictions disjunction

Introduction

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

Prototype

public static Disjunction disjunction() 

Source Link

Document

Group expressions together in a single disjunction (A or B or C...).

Usage

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

License:Open Source License

/**
 * Find milestones filter by project and activity and dates
 * /*from  w w  w  . j av  a  2s.co  m*/
 * @param project
 * @param projectactivity
 * @param since
 * @param until
 * @param hasCategory
 * @param property
 * @param order
 * @param joins
 * @return
 */
@SuppressWarnings("unchecked")
public List<Milestones> filter(Project project, Projectactivity projectactivity, Date since, Date until,
        boolean hasCategory, String property, String order, List<String> joins) {

    List<Milestones> list = new ArrayList<Milestones>();

    if (project != null) {

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

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

            crit.add(Restrictions.disjunction()
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ACHIEVED))
                            .add(Restrictions.between(Milestones.ACHIEVED, since, until)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ESTIMATEDDATE))
                            .add(Restrictions.between(Milestones.ESTIMATEDDATE, since, until)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.PLANNED))
                            .add(Restrictions.between(Milestones.PLANNED, since, until))));
        } else if (since != null) {

            crit.add(Restrictions.disjunction()
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ACHIEVED))
                            .add(Restrictions.ge(Milestones.ACHIEVED, since)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ESTIMATEDDATE))
                            .add(Restrictions.ge(Milestones.ESTIMATEDDATE, since)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.PLANNED))
                            .add(Restrictions.ge(Milestones.PLANNED, since))));
        } else if (until != null) {

            crit.add(Restrictions.disjunction()
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ACHIEVED))
                            .add(Restrictions.le(Milestones.ACHIEVED, until)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.ESTIMATEDDATE))
                            .add(Restrictions.le(Milestones.ESTIMATEDDATE, until)))
                    .add(Restrictions.conjunction().add(Restrictions.isNotNull(Milestones.PLANNED))
                            .add(Restrictions.le(Milestones.PLANNED, until))));
        }

        // Filter by project
        //
        if (project != null) {
            crit.add(Restrictions.eq(Milestones.PROJECT, project));
        }

        // Filter by activity 
        //
        if (projectactivity != null) {
            crit.add(Restrictions.eq(Milestones.PROJECTACTIVITY, projectactivity));
        }

        // Filter by has category 
        //
        if (hasCategory) {
            crit.add(Restrictions.isNotNull(Milestones.MILESTONECATEGORY));
        }

        // Joins
        addJoins(crit, joins);

        // Orders
        addOrder(crit, property, order);

        list = crit.list();
    }

    return list;
}

---

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

License:Open Source License

/**
 * Find operations by employees and dates and status app3
 * //  w  w w  .j a v a  2s .  c o  m
 * @param employees
 * @param since
 * @param until
 * @return
 */
@SuppressWarnings("unchecked")
public List<Operation> findByEmployeesAndDatesAndApproved(List<Employee> employees, Date since, Date until,
        Company company) {

    List<Operation> operations = null;

    if (ValidateUtil.isNotNull(employees)) {

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

        // Operation 
        //
        crit.addOrder(Order.asc(Operation.OPERATIONNAME)).createCriteria(Operation.OPERATIONACCOUNT)
                .add(Restrictions.eq(Operationaccount.COMPANY, company));

        // Timesheet 
        //
        Criteria sheets = crit.createCriteria(Employee.TIMESHEETS)
                .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3))
                .add(Restrictions.isNotNull(Timesheet.OPERATION));

        if (!employees.isEmpty()) {
            sheets.add(Restrictions.in(Timesheet.EMPLOYEE, employees));
        }

        if (since != null && until != null) {
            sheets.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))));
        }

        operations = crit.list();
    }

    return operations;
}

---

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

License:Open Source License

/**
 * Search by PerfOrg/*from   w  w w.j  ava  2 s.c o m*/
 * @param budgetYear 
 * @param user
 * @return
 */
@SuppressWarnings("unchecked")
public List<Program> searchByPerfOrg(Performingorg perfOrg, Integer budgetYear) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).addOrder(Order.asc(Program.PROGRAMNAME));

    if (budgetYear != null) {
        crit.add(Restrictions.disjunction().add(Restrictions.eq(Program.INITBUDGETYEAR, budgetYear + ""))
                .add(Restrictions.isNull(Program.INITBUDGETYEAR))
                .add(Restrictions.eq(Program.INITBUDGETYEAR, "")));
    }

    crit.createCriteria("employee").add(Restrictions.eq("performingorg", perfOrg));

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find restriction type// w w w. j a v a2  s .c  o m
 * @param propertyRelation
 * @return
 */
@SuppressWarnings("unchecked")
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.ProjectActivityDAO.java

License:Open Source License

/**
 * Checks whether an activity with a start date is imputed hours than
 * /*  ww w .j  a v  a2 s  .  co m*/
 * @param activity
 * @return
 */
public boolean checkAfterActivityInputed(Projectactivity activity) {

    Criteria crit = getSession().createCriteria(getPersistentClass()).setProjection(Projections.rowCount())
            .add(Restrictions.idEq(activity.getIdActivity())).createCriteria(Projectactivity.TIMESHEETS)
            .add(Restrictions.disjunction().add(Restrictions.ne(Timesheet.HOURSDAY1, 0D))
                    .add(Restrictions.ne(Timesheet.HOURSDAY2, 0D)).add(Restrictions.ne(Timesheet.HOURSDAY3, 0D))
                    .add(Restrictions.ne(Timesheet.HOURSDAY4, 0D)).add(Restrictions.ne(Timesheet.HOURSDAY5, 0D))
                    .add(Restrictions.ne(Timesheet.HOURSDAY6, 0D))
                    .add(Restrictions.ne(Timesheet.HOURSDAY7, 0D)))
            .add(Restrictions.le(Timesheet.ENDDATE, activity.getPlanInitDate()));

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

---

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

License:Open Source License

/**
 * Filter by project and since until over planned dates
 * //from  w w w .  j a v a 2s. c o  m
 * @param project
 * @param since
 * @param until
 * @param typeOrder 
 * @param propertyOrder 
 * @return
 */
@SuppressWarnings("unchecked")
public List<Projectactivity> findByProject(Project project, Date since, Date until, String propertyOrder,
        String typeOrder) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .add(Restrictions.disjunction()
                    .add(Restrictions.between(Projectactivity.PLANINITDATE, since, until))
                    .add(Restrictions.between(Projectactivity.PLANENDDATE, since, until))
                    .add(Restrictions.and(Restrictions.le(Projectactivity.PLANINITDATE, since),
                            Restrictions.ge(Projectactivity.PLANENDDATE, until))))
            .add(Restrictions.eq(Projectactivity.PROJECT, project));

    addOrder(crit, propertyOrder, typeOrder);

    return crit.list();
}

---

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

License:Open Source License

/**
 * Find activities inputed//from www .j  a v  a 2  s. c  om
 *
 * @param ids
 * @param since
 * @param until
 * @param idResourcePool
 * @return
 */
@SuppressWarnings("unchecked")
public List<Projectactivity> findActivitiesInputedByProjectsAndEmployees(Integer[] ids, Date since, Date until,
        Integer idResourcePool) {

    List<Projectactivity> activities = null;

    if (ValidateUtil.isNotNull(ids)) {

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

        // All activities by projects
        //
        crit.createCriteria(Projectactivity.PROJECT).add(Restrictions.in(Project.IDPROJECT, ids))
                .addOrder(Order.asc(Project.ACCOUNTINGCODE));

        crit.createCriteria(Projectactivity.WBSNODE).add(Restrictions.eq(Wbsnode.ISCONTROLACCOUNT, true));

        crit.addOrder(Order.asc(Projectactivity.IDACTIVITY));

        // Teammmembers
        //
        Criteria members = crit.createCriteria(Projectactivity.TEAMMEMBERS);

        if (since != null && until != null) {

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

        // Employees 
        //
        Criteria employees = members.createCriteria(Teammember.EMPLOYEE);

        if (idResourcePool != null) {
            employees.add(Restrictions.eq(Employee.RESOURCEPOOL, new Resourcepool(idResourcePool)));
        }

        Criteria sheets = employees.createCriteria(Employee.TIMESHEETS)
                .add(Restrictions.eq(Timesheet.STATUS, Constants.TIMESTATUS_APP3));

        if (since != null && until != null) {
            sheets.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))));
        }

        activities = crit.list();
    } else {
        activities = new ArrayList<Projectactivity>();
    }

    return activities;
}

---

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/*  w  w w . j  a v  a2s  .c om*/
 * @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

@SuppressWarnings("unchecked")
public List<Project> find(String search, Performingorg performingorg, Company company) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .add(Restrictions.disjunction().add(Restrictions.ilike(Project.PROJECTNAME, "%" + search + "%"))
                    .add(Restrictions.ilike(Project.CHARTLABEL, "%" + search + "%"))
                    .add(Restrictions.ilike(Project.ACCOUNTINGCODE, "%" + search + "%")));

    Criteria poCrit = crit.createCriteria(Project.PERFORMINGORG)
            .add(Restrictions.eq(Performingorg.COMPANY, company));

    if (performingorg != null) {
        poCrit.add(Restrictions.eq(Performingorg.IDPERFORG, performingorg.getIdPerfOrg()));
    }// www. ja va  2  s. c om

    return crit.list();
}

---

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

License:Open Source License

/**
 * /*from  w  w  w  .  j ava  2s.c o  m*/
 * @param program
 * @return
 */
public Double getBudgetBottomUp(Program program, boolean projectsDisabled) {

    Criteria crit = getSession().createCriteria(getPersistentClass())
            .setProjection(Projections.sum(Project.TCV)).add(Restrictions.eq(Project.PROGRAM, program));

    // Projects disabled
    if (projectsDisabled) {

        crit.add(Restrictions.disjunction().add(Restrictions.ne(Project.DISABLE, Constants.SELECTED))
                .add(Restrictions.isNull(Project.DISABLE)));
    }

    Double budget = (Double) crit.uniqueResult();

    return (budget == null ? 0 : budget);
}

---

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