Add query to get OrderElements filtered by labels and criteria

FEA: ItEr77S09WBSReport
2012-10-24 10:35:35 +02:00 · 2012-10-24 10:35:35 +02:00 · d9575754a4
commit d9575754a4
parent 1ca57a5a00
5 changed files with 379 additions and 12 deletions
--- a/libreplan-business/src/main/java/org/libreplan/business/orders/daos/IOrderElementDAO.java
+++ b/libreplan-business/src/main/java/org/libreplan/business/orders/daos/IOrderElementDAO.java
@ -27,7 +27,9 @@ import java.util.Set;

 import org.libreplan.business.common.daos.IIntegrationEntityDAO;
 import org.libreplan.business.common.exceptions.InstanceNotFoundException;
+import org.libreplan.business.labels.entities.Label;
 import org.libreplan.business.orders.entities.OrderElement;
+import org.libreplan.business.resources.entities.Criterion;
 import org.libreplan.business.templates.entities.OrderElementTemplate;
 import org.libreplan.business.workingday.EffortDuration;

@ -130,4 +132,7 @@ public interface IOrderElementDAO extends IIntegrationEntityDAO<OrderElement> {

    OrderElement findByExternalCode(String code) throws InstanceNotFoundException;

+    public List<OrderElement> findByLabelsAndCriteria(Set<Label> labels,
+            Set<Criterion> criteria);
+
 }
--- a/libreplan-business/src/main/java/org/libreplan/business/orders/daos/OrderElementDAO.java
+++ b/libreplan-business/src/main/java/org/libreplan/business/orders/daos/OrderElementDAO.java
@ -25,6 +25,7 @@ import java.math.BigDecimal;
 import java.math.MathContext;
 import java.math.RoundingMode;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
@ -41,10 +42,12 @@ import org.libreplan.business.common.IAdHocTransactionService;
 import org.libreplan.business.common.daos.IntegrationEntityDAO;
 import org.libreplan.business.common.exceptions.InstanceNotFoundException;
 import org.libreplan.business.expensesheet.daos.IExpenseSheetLineDAO;
+import org.libreplan.business.labels.entities.Label;
 import org.libreplan.business.orders.entities.OrderElement;
 import org.libreplan.business.orders.entities.SchedulingDataForVersion;
 import org.libreplan.business.orders.entities.TaskSource;
 import org.libreplan.business.planner.daos.ITaskSourceDAO;
+import org.libreplan.business.resources.entities.Criterion;
 import org.libreplan.business.templates.entities.OrderElementTemplate;
 import org.libreplan.business.workingday.EffortDuration;
 import org.libreplan.business.workreports.daos.IWorkReportDAO;
@ -519,4 +522,63 @@ public class OrderElementDAO extends IntegrationEntityDAO<OrderElement>
        OrderElement orderElement = find(id);
        return (!expenseSheetLineDAO.findByOrderElementAndChildren(orderElement).isEmpty());
    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public List<OrderElement> findByLabelsAndCriteria(Set<Label> labels,
+            Set<Criterion> criteria) {
+
+        String strQuery = "SELECT oe.id ";
+        strQuery += "FROM OrderElement oe ";
+
+        String where = "";
+        if (labels != null && !labels.isEmpty()) {
+            for (int i = 0; i < labels.size(); i++) {
+                if (where.isEmpty()) {
+                    where += "WHERE ";
+                } else {
+                    where += "AND ";
+                }
+                where += ":label" + i + " IN elements(oe.labels) ";
+            }
+        }
+
+        if (criteria != null && !criteria.isEmpty()) {
+            strQuery += "JOIN oe.criterionRequirements cr ";
+            if (where.isEmpty()) {
+                where += "WHERE ";
+            } else {
+                where += "AND ";
+            }
+            where += "cr.criterion IN (:criteria) ";
+            where += "AND cr.class = DirectCriterionRequirement ";
+            where += "GROUP BY oe.id ";
+            where += "HAVING count(oe.id) = :criteriaSize ";
+        }
+
+        strQuery += where;
+
+        Query query = getSession().createQuery(strQuery);
+        if (labels != null && !labels.isEmpty()) {
+            int i = 0;
+            for (Label label : labels) {
+                query.setParameter("label" + i, label);
+                i++;
+            }
+        }
+        if (criteria != null && !criteria.isEmpty()) {
+            query.setParameterList("criteria", criteria);
+            query.setParameter("criteriaSize", (long) criteria.size());
+        }
+
+        List<Long> orderElementsIds = query.list();
+        if (orderElementsIds.isEmpty()) {
+            return Collections.emptyList();
+        }
+
+        return getSession()
+                .createQuery("FROM OrderElement oe WHERE oe.id IN (:ids)")
+                .setParameterList("ids", orderElementsIds).list();
+    }
+
 }
--- a/libreplan-business/src/main/java/org/libreplan/business/reports/dtos/ProjectStatusReportDTO.java
+++ b/libreplan-business/src/main/java/org/libreplan/business/reports/dtos/ProjectStatusReportDTO.java
@ -21,6 +21,7 @@ package org.libreplan.business.reports.dtos;

 import java.math.BigDecimal;

+import org.libreplan.business.orders.entities.Order;
 import org.libreplan.business.orders.entities.OrderElement;
 import org.libreplan.business.orders.entities.SumChargedEffort;
 import org.libreplan.business.orders.entities.TaskSource;
@ -81,12 +82,12 @@ public class ProjectStatusReportDTO {
    }

    public ProjectStatusReportDTO(OrderElement orderElement,
-            boolean appendProjectInName) {
+            Order orderToAppendName) {
        code = orderElement.getCode();

-        if (appendProjectInName) {
-            name = orderElement.getName() + " ("
-                    + orderElement.getOrder().getName() + ")";
+        if (orderToAppendName != null) {
+            name = orderElement.getName() + " (" + orderToAppendName.getName()
+                    + ")";
        } else {
            name = Util.getPrefixSpacesDependingOnDepth(orderElement)
                    + orderElement.getName();
--- a/libreplan-business/src/test/java/org/libreplan/business/test/orders/daos/OrderElementDAOTest.java
+++ b/libreplan-business/src/test/java/org/libreplan/business/test/orders/daos/OrderElementDAOTest.java
@ -32,7 +32,10 @@ import static org.libreplan.business.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_
 import static org.libreplan.business.test.BusinessGlobalNames.BUSINESS_SPRING_CONFIG_TEST_FILE;

 import java.math.BigDecimal;
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.Date;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.SortedSet;
@ -54,6 +57,10 @@ import org.libreplan.business.calendars.daos.IBaseCalendarDAO;
 import org.libreplan.business.calendars.entities.BaseCalendar;
 import org.libreplan.business.common.exceptions.InstanceNotFoundException;
 import org.libreplan.business.common.exceptions.ValidationException;
+import org.libreplan.business.labels.daos.ILabelDAO;
+import org.libreplan.business.labels.daos.ILabelTypeDAO;
+import org.libreplan.business.labels.entities.Label;
+import org.libreplan.business.labels.entities.LabelType;
 import org.libreplan.business.orders.daos.IOrderElementDAO;
 import org.libreplan.business.orders.entities.Order;
 import org.libreplan.business.orders.entities.OrderElement;
@ -63,6 +70,11 @@ import org.libreplan.business.orders.entities.SumChargedEffort;
 import org.libreplan.business.qualityforms.daos.IQualityFormDAO;
 import org.libreplan.business.qualityforms.entities.QualityForm;
 import org.libreplan.business.qualityforms.entities.TaskQualityForm;
+import org.libreplan.business.requirements.entities.DirectCriterionRequirement;
+import org.libreplan.business.resources.daos.ICriterionDAO;
+import org.libreplan.business.resources.daos.ICriterionTypeDAO;
+import org.libreplan.business.resources.entities.Criterion;
+import org.libreplan.business.resources.entities.CriterionType;
 import org.libreplan.business.scenarios.IScenarioManager;
 import org.libreplan.business.scenarios.bootstrap.IScenariosBootstrap;
 import org.libreplan.business.scenarios.entities.OrderVersion;
@ -107,6 +119,18 @@ public class OrderElementDAOTest {
    @Autowired
    private IScenarioManager scenarioManager;

+    @Autowired
+    private ILabelDAO labelDAO;
+
+    @Autowired
+    private ILabelTypeDAO labelTypeDAO;
+
+    @Autowired
+    private ICriterionDAO criterionDAO;
+
+    @Autowired
+    private ICriterionTypeDAO criterionTypeDAO;
+
    @Before
    public void loadRequiredData() {
        scenariosBootstrap.loadRequiredData();
@ -438,4 +462,275 @@ public class OrderElementDAOTest {
        assertEquals(orderLineCopy.getSumChargedEffort()
                .getTotalChargedEffort(), EffortDuration.hours(18));
    }
+
+    private Label givenStoredLabel() {
+        LabelType labelType = LabelType.create(UUID.randomUUID().toString());
+        labelTypeDAO.save(labelType);
+
+        Label label = Label.create(UUID.randomUUID().toString());
+        label.setType(labelType);
+        labelDAO.save(label);
+
+        return label;
+    }
+
+    @Test
+    public void testFindByLabels1() throws InstanceNotFoundException {
+        Label label = givenStoredLabel();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addLabel(label);
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label), null);
+
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+    }
+
+    @Test
+    public void testFindByLabels2() throws InstanceNotFoundException {
+        Label label1 = givenStoredLabel();
+        Label label2 = givenStoredLabel();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addLabel(label1);
+        orderLine1.addLabel(label2);
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderLine3.addLabel(label2);
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label1), null);
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(
+                Collections.singleton(label2), null);
+        assertEquals(2, orderELements.size());
+        for (OrderElement each : orderELements) {
+            assertTrue(each.getId().equals(orderLine1.getId())
+                    || each.getId().equals(orderLine3.getId()));
+        }
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(
+                new HashSet<Label>(Arrays.asList(label1, label2)), null);
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+    }
+
+    @Test
+    public void testFindByLabelsOnTree() throws InstanceNotFoundException {
+        Label label1 = givenStoredLabel();
+        Label label2 = givenStoredLabel();
+
+        OrderLineGroup orderLineGroup = createValidOrderLineGroup();
+        orderLineGroup.addLabel(label1);
+        OrderElement child = orderLineGroup.getChildren().get(0);
+        child.addLabel(label2);
+        orderElementDAO.save(orderLineGroup);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label1), null);
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLineGroup.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(
+                Collections.singleton(label2), null);
+        assertEquals(1, orderELements.size());
+        assertEquals(child.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(
+                new HashSet<Label>(Arrays.asList(label1, label2)), null);
+        assertEquals(0, orderELements.size());
+    }
+
+    private Criterion givenStoredCriterion() {
+        String criterionTypeCode = UUID.randomUUID().toString();
+        CriterionType criterionType = CriterionType.create(criterionTypeCode);
+        criterionType.setName(criterionTypeCode);
+        criterionTypeDAO.save(criterionType);
+
+        String criterionCode = UUID.randomUUID().toString();
+        Criterion criterion = Criterion.create(criterionCode, criterionType);
+        criterion.setCode(criterionCode);
+        criterionDAO.save(criterion);
+
+        return criterion;
+    }
+
+    @Test
+    public void testFindByCriteria1() throws InstanceNotFoundException {
+        Criterion criterion = givenStoredCriterion();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion));
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(null, Collections.singleton(criterion));
+
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+    }
+
+    @Test
+    public void testFindByCriteria2() throws InstanceNotFoundException {
+        Criterion criterion1 = givenStoredCriterion();
+        Criterion criterion2 = givenStoredCriterion();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion1));
+        orderLine1.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion2));
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderLine3.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion2));
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(null, Collections.singleton(criterion1));
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(null,
+                Collections.singleton(criterion2));
+        assertEquals(2, orderELements.size());
+        for (OrderElement each : orderELements) {
+            assertTrue(each.getId().equals(orderLine1.getId())
+                    || each.getId().equals(orderLine3.getId()));
+        }
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(null,
+                new HashSet<Criterion>(Arrays.asList(criterion1, criterion2)));
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine1.getId(), orderELements.get(0).getId());
+
+    }
+
+    @Test
+    public void testFindByCriteriaOnTree() throws InstanceNotFoundException {
+        Criterion criterion1 = givenStoredCriterion();
+        Criterion criterion2 = givenStoredCriterion();
+
+        OrderLineGroup orderLineGroup = createValidOrderLineGroup();
+        orderLineGroup.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion1));
+        OrderElement child = orderLineGroup.getChildren().get(0);
+        child.addCriterionRequirement(new DirectCriterionRequirement(criterion2));
+        orderElementDAO.save(orderLineGroup);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(null,
+                        Collections.singleton(criterion1));
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLineGroup.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(null,
+                Collections.singleton(criterion2));
+        assertEquals(1, orderELements.size());
+        assertEquals(child.getId(), orderELements.get(0).getId());
+
+        orderELements = orderElementDAO.findByLabelsAndCriteria(null,
+                new HashSet<Criterion>(Arrays.asList(criterion1, criterion2)));
+        assertEquals(0, orderELements.size());
+    }
+
+    @Test
+    public void testFindByLabelsAndCriteria1() throws InstanceNotFoundException {
+        Label label = givenStoredLabel();
+        Criterion criterion = givenStoredCriterion();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addLabel(label);
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderLine2.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion));
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderLine3.addLabel(label);
+        orderLine3.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion));
+
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label),
+                        Collections.singleton(criterion));
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine3.getId(), orderELements.get(0).getId());
+    }
+
+    @Test
+    public void testFindByLabelsAndCriteria2() throws InstanceNotFoundException {
+        Label label1 = givenStoredLabel();
+        Label label2 = givenStoredLabel();
+        Criterion criterion1 = givenStoredCriterion();
+        Criterion criterion2 = givenStoredCriterion();
+
+        OrderLine orderLine1 = createValidOrderLine();
+        orderLine1.addLabel(label1);
+        orderLine1.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion2));
+        orderElementDAO.save(orderLine1);
+        OrderLine orderLine2 = createValidOrderLine();
+        orderLine2.addLabel(label2);
+        orderLine2.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion1));
+        orderElementDAO.save(orderLine2);
+        OrderLine orderLine3 = createValidOrderLine();
+        orderLine3.addLabel(label1);
+        orderLine3.addLabel(label2);
+        orderLine3.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion1));
+        orderLine3.addCriterionRequirement(new DirectCriterionRequirement(
+                criterion2));
+
+        orderElementDAO.save(orderLine3);
+
+        List<OrderElement> orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label2),
+                        Collections.singleton(criterion1));
+        assertEquals(2, orderELements.size());
+        for (OrderElement each : orderELements) {
+            assertTrue(each.getId().equals(orderLine2.getId())
+                    || each.getId().equals(orderLine3.getId()));
+        }
+
+        orderELements = orderElementDAO
+                .findByLabelsAndCriteria(Collections.singleton(label1),
+                        Collections.singleton(criterion2));
+        assertEquals(2, orderELements.size());
+        for (OrderElement each : orderELements) {
+            assertTrue(each.getId().equals(orderLine1.getId())
+                    || each.getId().equals(orderLine3.getId()));
+        }
+
+        orderELements = orderElementDAO
+                .findByLabelsAndCriteria(
+                        new HashSet<Label>(Arrays.asList(label1, label2)),
+                        new HashSet<Criterion>(Arrays.asList(criterion1,
+                                criterion2)));
+        assertEquals(1, orderELements.size());
+        assertEquals(orderLine3.getId(), orderELements.get(0).getId());
+    }
+
 }
--- a/libreplan-webapp/src/main/java/org/libreplan/web/reports/ProjectStatusReportModel.java
+++ b/libreplan-webapp/src/main/java/org/libreplan/web/reports/ProjectStatusReportModel.java
@ -99,17 +99,19 @@ public class ProjectStatusReportModel implements IProjectStatusReportModel {
            orderDAO.reattach(order);
            order.useSchedulingDataFor(scenarioManager.getCurrent());
            orderElements = order.getAllChildren();
+
+            orderElements = filterBySelectedLabels(orderElements);
+            orderElements = filterBySelectedCriteria(orderElements);
        } else {
-            orderElements = new ArrayList<OrderElement>();
-            for (Order each : orderDAO.findAll()) {
-                each.useSchedulingDataFor(scenarioManager.getCurrent());
-                orderElements.addAll(each.getAllChildren());
+            orderElements = orderElementDAO.findByLabelsAndCriteria(
+                    selectedLabels, selectedCriteria);
+            for (OrderElement each : orderElements) {
+                each.useSchedulingDataFor(orderDAO.loadOrderAvoidingProxyFor(
+                        each).getOrderVersionFor(
+                        scenarioManager.getCurrent()));
            }
        }

-        orderElements = filterBySelectedLabels(orderElements);
-        orderElements = filterBySelectedCriteria(orderElements);
-
        List<ProjectStatusReportDTO> dtos = new ArrayList<ProjectStatusReportDTO>();
        for (OrderElement child : orderElements) {
            dtos.add(calculateDTO(child, order == null));
@ -121,7 +123,9 @@ public class ProjectStatusReportModel implements IProjectStatusReportModel {
    }

    private ProjectStatusReportDTO calculateDTO(OrderElement orderElement, boolean appendProjectInName) {
-        ProjectStatusReportDTO dto = new ProjectStatusReportDTO(orderElement, appendProjectInName);
+        ProjectStatusReportDTO dto = new ProjectStatusReportDTO(orderElement,
+                appendProjectInName ? orderDAO
+                        .loadOrderAvoidingProxyFor(orderElement) : null);
        dto.setHoursCost(moneyCostCalculator.getHoursMoneyCost(orderElement));
        dto.setExpensesCost(moneyCostCalculator
                .getExpensesMoneyCost(orderElement));