fix(be): change join query filters to be subqueries

After c16369d0, filtering when paginating needs to be done on fields of
the model being listed. This change address that for a couple of
entities.

Author: luis-dk

common/entity_services/company_service.py

@@ -26,7 +26,7 @@ def get_organizations_with_rules(company_id: str, rules: ListRules) -> Page[Orga
 
     @staticmethod
     def get_users_with_rules(company_id: str, rules: ListRules) -> Page[User]:
-        query = User.select().join(Company).where(Company.id == company_id)
+        query = User.select().join(Company).where(User.primary_company == company_id)
         return Page[User].get_paginated_results(query, User.name, rules)
 
     @staticmethod

common/entity_services/journey_service.py

@@ -52,16 +52,18 @@ def get_action_by_implementation(journey_id: UUID, action_impl: str) -> Optional
 
     @staticmethod
     def get_components_with_rules(journey_id: str, rules: ListRules, filters: ComponentFilters) -> Page[Component]:
-        query = JourneyDagEdge.journey_id == journey_id
+        join_on = (JourneyDagEdge.journey_id == journey_id) & (
+            (JourneyDagEdge.left == Component.id) | (JourneyDagEdge.right == Component.id)
+        )
+        query = Component.select(Component).join(JourneyDagEdge, on=join_on)
         if rules.search is not None:
-            query &= Component.key ** f"%{rules.search}%"
+            query = query.where(Component.key ** f"%{rules.search}%")
         if filters.component_types:
-            query &= Component.type.in_(filters.component_types)
+            query = query.where(Component.type.in_(filters.component_types))
         if filters.tools:
-            query &= Component.tool.in_(filters.tools)
-        join_on = (JourneyDagEdge.left == Component.id) | (JourneyDagEdge.right == Component.id)
-        query = Component.select(Component).join(JourneyDagEdge, on=join_on).where(query).distinct()
-        return Page[Component].get_paginated_results(query, Component.key, rules)
+            query = query.where(Component.tool.in_(filters.tools))
+
+        return Page[Component].get_paginated_results(query.distinct(), Component.key, rules)
 
     @staticmethod
     def get_upstream_nodes(journey: Journey, component_id: UUID) -> set:

common/entity_services/project_service.py

@@ -55,36 +55,37 @@ class ProjectService:
     def get_test_outcomes_with_rules(
         project: Project, rules: ListRules, filters: TestOutcomeItemFilters
     ) -> Page[TestOutcome]:
-        clauses = [TestOutcome.component.in_(project.components)]
+        query = TestOutcome.select(TestOutcome).where(TestOutcome.component.in_(project.components))
         if rules.search is not None:
-            clauses.append(
+            query = query.where(
                 ((TestOutcome.name ** f"%{rules.search}%") | (TestOutcome.description ** f"%{rules.search}%"))
             )
+
         if filters:
             if statuses := filters.statuses:
-                clauses.append(TestOutcome.status.in_(statuses))
+                query = query.where(TestOutcome.status.in_(statuses))
             if component_ids := filters.component_ids:
-                clauses.append(TestOutcome.component << component_ids)
+                query = query.where(TestOutcome.component << component_ids)
             if start_range_begin := filters.start_range_begin:
-                clauses.append(TestOutcome.start_time >= start_range_begin)
+                query = query.where(TestOutcome.start_time >= start_range_begin)
             if start_range_end := filters.start_range_end:
-                clauses.append(TestOutcome.start_time < start_range_end)
+                query = query.where(TestOutcome.start_time < start_range_end)
             if end_range_begin := filters.end_range_begin:
-                clauses.append(TestOutcome.end_time >= end_range_begin)
+                query = query.where(TestOutcome.end_time >= end_range_begin)
             if end_range_end := filters.end_range_end:
-                clauses.append(TestOutcome.end_time < end_range_end)
+                query = query.where(TestOutcome.end_time < end_range_end)
             if run_ids := filters.run_ids:
-                clauses.append(TestOutcome.run.in_(run_ids))
+                query = query.where(TestOutcome.run.in_(run_ids))
             if instance_ids := filters.instance_ids:
-                clauses.append(InstancesInstanceSets.instance.in_(instance_ids))
+                instance_set_subquery = (
+                    InstanceSet.select(InstanceSet.id)
+                    .join(InstancesInstanceSets)
+                    .where(InstancesInstanceSets.instance.in_(instance_ids))
+                )
+                query = query.where(TestOutcome.instance_set.in_(instance_set_subquery))
             if key := filters.key:
-                clauses.append(TestOutcome.key == key)
+                query = query.where(TestOutcome.key == key)
 
-        # If filtering on instance_ids we need to join the InstanceSet tables
-        if filters and filters.instance_ids:
-            query = TestOutcome.select(TestOutcome).join(InstanceSet).join(InstancesInstanceSets).where(*clauses)
-        else:
-            query = TestOutcome.select(TestOutcome).where(*clauses)
         return Page[TestOutcome].get_paginated_results(query, TestOutcome.start_time, rules)
 
     @staticmethod