diff --git 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
index edbfa904c..92c0201ca 100644
--- 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);
+
 }
diff --git 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
index ceae2321c..3cfc33fec 100644
--- 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();
+    }
+
 }
\ No newline at end of file
diff --git 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
index 0f6bb90d3..75eee52e8 100644
--- 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();
diff --git 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
index 7c47ecf29..02aa5d213 100644
--- 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());
+    }
+
 }
diff --git a/libreplan-webapp/src/main/java/org/libreplan/web/reports/ProjectStatusReportModel.java b/libreplan-webapp/src/main/java/org/libreplan/web/reports/ProjectStatusReportModel.java
index 6f989cd46..7a5ee64e2 100644
--- 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));