Add order status service

Dockerfile

@@ -26,6 +26,10 @@ ENV OSTICKET_TIMEOUT="1"
 ENV GOOGLE_OAUTH_CLIENT_ID="1"
 ENV GOOGLE_OAUTH_CLIENT_SECRET="1"
 
+ENV TRAILBLAZER_HOST="host"
+ENV TRAILBLAZER_SERVICE_ACCOUNT="service_account"
+ENV TRAILBLAZER_SERVICE_ACCOUNT_AUTH_FILE="auth_file"
+
 
 WORKDIR /home/src/app
 COPY pyproject.toml poetry.lock ./ 

cg/apps/tb/api.py

@@ -8,6 +8,7 @@
 from google.auth.crypt import RSASigner
 
 from cg.apps.tb.dto.create_job_request import CreateJobRequest
+from cg.apps.tb.dto.summary_response import SummariesResponse, AnalysisSummary
 from cg.apps.tb.models import AnalysesResponse, TrailblazerAnalysis
 from cg.constants import Workflow
 from cg.constants.constants import APIMethods, FileFormat, JobType, WorkflowManager
@@ -170,3 +171,10 @@ def add_upload_job_to_analysis(self, analysis_id: int, slurm_id: int) -> None:
             request_body=request_body,
             method=APIMethods.POST,
         )
+
+    def get_summaries(self, order_ids: list[int]) -> list[AnalysisSummary]:
+        orders_param = "orderIds=" + ",".join(map(str, order_ids))
+        endpoint = f"summary?{orders_param}"
+        response = self.query_trailblazer(command=endpoint, request_body={}, method=APIMethods.GET)
+        response_data = SummariesResponse.model_validate(response)
+        return response_data.summaries

cg/apps/tb/dto/summary_response.py

@@ -0,0 +1,13 @@
+from pydantic import BaseModel
+
+
+class AnalysisSummary(BaseModel):
+    order_id: int
+    delivered: int | None = None
+    running: int | None = None
+    cancelled: int | None = None
+    failed: int | None = None
+
+
+class SummariesResponse(BaseModel):
+    summaries: list[AnalysisSummary]

cg/server/api.py

@@ -26,7 +26,6 @@
     CaseNotFoundError,
     OrderError,
     OrderFormError,
-    OrderNotFoundError,
     TicketCreationError,
 )
 from cg.io.controller import WriteStream
@@ -36,9 +35,10 @@
 from cg.server.dto.delivery_message_response import DeliveryMessageResponse
 from cg.server.dto.orders.orders_request import OrdersRequest
 from cg.server.dto.orders.orders_response import Order, OrdersResponse
-from cg.server.ext import db, lims, osticket
+from cg.server.ext import db, lims, osticket, order_service
+from cg.server.utils import parse_orders_request
 from cg.services.delivery_message.delivery_message_service import DeliveryMessageService
-from cg.services.orders.order_service import OrderService
+from cg.services.orders.order_service.exceptions import OrderNotFoundError
 from cg.store.models import (
     Analysis,
     Application,
@@ -135,7 +135,6 @@ def submit_order(order_type):
             user_name=g.current_user.name,
             user_mail=g.current_user.email,
         )
-        order_service = OrderService(db)
         order_service.create_order(order_in)
 
     except (  # user misbehaviour
@@ -481,16 +480,14 @@ def get_application_pipeline_limitations(tag: str):
 @BLUEPRINT.route("/orders")
 def get_orders():
     """Return the latest orders."""
-    orders_request: OrdersRequest = OrdersRequest.model_validate(request.args.to_dict())
-    order_service = OrderService(db)
-    response: OrdersResponse = order_service.get_orders(orders_request)
+    data: OrdersRequest = parse_orders_request(request)
+    response: OrdersResponse = order_service.get_orders(data)
     return make_response(response.model_dump())
 
 
 @BLUEPRINT.route("/orders/<order_id>")
 def get_order(order_id: int):
     """Return an order."""
-    order_service = OrderService(db)
     try:
         response: Order = order_service.get_order(order_id)
         response_dict: dict = response.model_dump()

cg/server/app.py

@@ -56,6 +56,7 @@ def _configure_extensions(app: Flask):
     ext.csrf.init_app(app)
     ext.db.init_app(app)
     ext.lims.init_app(app)
+    ext.analysis_client.init_app(app)
     if app.config["OSTICKET_API_KEY"]:
         ext.osticket.init_app(app)
     ext.admin.init_app(app, index_view=AdminIndexView(endpoint="admin"))

cg/server/config.py

@@ -29,3 +29,10 @@
 
 # invoice
 TOTAL_PRICE_THRESHOLD = 750000
+
+# trailblazer
+TRAILBLAZER_SERVICE_ACCOUNT = os.environ["TRAILBLAZER_SERVICE_ACCOUNT"] or "service"
+TRAILBLAZER_SERVICE_ACCOUNT_AUTH_FILE = (
+    os.environ["TRAILBLAZER_SERVICE_ACCOUNT_AUTH_FILE"] or "service_file"
+)
+TRAILBLAZER_HOST = os.environ["TRAILBLAZER_HOST"] or "host"

cg/server/dto/orders/orders_request.py

@@ -1,6 +1,7 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 
 class OrdersRequest(BaseModel):
     limit: int | None = None
     workflow: str | None = None
+    include_summary: bool = Field(default=False, alias="includeSummary")

cg/server/dto/orders/orders_response.py

@@ -1,6 +1,7 @@
 from pydantic import BaseModel
 
 from cg.constants import Workflow
+from cg.services.orders.order_status_service.dto.order_status_summary import OrderSummary
 
 
 class Order(BaseModel):
@@ -9,6 +10,7 @@ class Order(BaseModel):
     order_date: str
     order_id: int
     workflow: Workflow
+    summary: OrderSummary | None = None
 
 
 class OrdersResponse(BaseModel):

cg/server/ext.py

@@ -7,8 +7,11 @@
 
 from cg.apps.lims import LimsAPI
 from cg.apps.osticket import OsTicket
+from cg.services.orders.order_status_service.order_status_service import OrderStatusService
 from cg.store.database import initialize_database
 from cg.store.store import Store
+from cg.apps.tb.api import TrailblazerAPI
+from cg.services.orders.order_service.order_service import OrderService
 
 
 class FlaskLims(LimsAPI):
@@ -45,10 +48,32 @@ def default(self, obj):
         return super().default(obj)
 
 
+class AnalysisClient(TrailblazerAPI):
+    def __init__(self, app=None):
+        if app:
+            self.init_app(app)
+
+    def init_app(self, app):
+        service_account: str = app.config["TRAILBLAZER_SERVICE_ACCOUNT"]
+        service_account_auth_file: str = app.config["TRAILBLAZER_SERVICE_ACCOUNT_AUTH_FILE"]
+        host: str = app.config["TRAILBLAZER_HOST"]
+        config = {
+            "trailblazer": {
+                "service_account": service_account,
+                "service_account_auth_file": service_account_auth_file,
+                "host": host,
+            }
+        }
+        super(AnalysisClient, self).__init__(config)
+
+
 cors = CORS(resources={r"/api/*": {"origins": "*"}}, supports_credentials=True)
 csrf = CSRFProtect()
 db = FlaskStore()
 
 admin = Admin(name="Clinical Genomics")
 lims = FlaskLims()
 osticket = OsTicket()
+analysis_client = AnalysisClient()
+summary_service = OrderStatusService(store=db, analysis_client=analysis_client)
+order_service = OrderService(store=db, status_service=summary_service)

cg/server/utils.py

@@ -0,0 +1,8 @@
+from requests import Request
+
+from cg.server.dto.orders.orders_request import OrdersRequest
+
+
+def parse_orders_request(request: Request) -> OrdersRequest:
+    query_params: dict = request.args.to_dict()
+    return OrdersRequest.model_validate(query_params)

cg/services/fastq_file_service/exceptions.py

@@ -4,7 +4,3 @@ class FastqServiceError(Exception):
 
 class ConcatenationError(FastqServiceError):
     pass
-
-
-class InvalidFastqDirectory(FastqServiceError):
-    pass

cg/services/orders/order_service/exceptions.py

@@ -0,0 +1,6 @@
+class OrderServiceError(Exception):
+    pass
+
+
+class OrderNotFoundError(OrderServiceError):
+    pass

cg/services/orders/order_service.py → cg/services/orders/order_service/order_service.py

@@ -1,16 +1,22 @@
-from cg.exc import OrderNotFoundError
 from cg.models.orders.order import OrderIn
 from cg.server.dto.orders.orders_request import OrdersRequest
 from cg.server.dto.orders.orders_response import Order as OrderResponse
 from cg.server.dto.orders.orders_response import OrdersResponse
-from cg.services.orders.utils import create_order_response, create_orders_response
+from cg.services.orders.order_service.exceptions import OrderNotFoundError
+from cg.services.orders.order_service.utils import (
+    create_order_response,
+    create_orders_response,
+)
+from cg.services.orders.order_status_service import OrderStatusService
+from cg.services.orders.order_status_service.dto.order_status_summary import OrderSummary
 from cg.store.models import Order
 from cg.store.store import Store
 
 
 class OrderService:
-    def __init__(self, store: Store) -> None:
+    def __init__(self, store: Store, status_service: OrderStatusService) -> None:
         self.store = store
+        self.summary_service = status_service
 
     def get_order(self, order_id: int) -> OrderResponse:
         order: Order | None = self.store.get_order_by_id(order_id)
@@ -19,14 +25,14 @@ def get_order(self, order_id: int) -> OrderResponse:
         return create_order_response(order)
 
     def get_orders(self, orders_request: OrdersRequest) -> OrdersResponse:
-        orders: list[Order] = self._get_orders(orders_request)
-        return create_orders_response(orders)
+        orders: list[Order] = self.store.get_orders(orders_request)
 
-    def _get_orders(self, orders_request: OrdersRequest) -> list[Order]:
-        """Returns a list of entries in the table Order."""
-        return self.store.get_orders_by_workflow(
-            workflow=orders_request.workflow, limit=orders_request.limit
-        )
+        summaries: list[OrderSummary] = []
+        if orders_request.include_summary:
+            order_ids: list[int] = [order.id for order in orders]
+            summaries = self.summary_service.get_status_summaries(order_ids)
+
+        return create_orders_response(orders=orders, summaries=summaries)
 
     def create_order(self, order_data: OrderIn) -> OrderResponse:
         """Creates an order and links it to the given cases."""

cg/services/orders/order_service/utils.py

@@ -0,0 +1,28 @@
+from cg.server.dto.orders.orders_response import Order, OrderSummary, OrdersResponse
+from cg.store.models import Order as DatabaseOrder
+
+
+def create_order_response(order: DatabaseOrder) -> Order:
+    return Order(
+        customer_id=order.customer.internal_id,
+        ticket_id=order.ticket_id,
+        order_date=str(order.order_date.date()),
+        order_id=order.id,
+        workflow=order.workflow,
+    )
+
+
+def create_orders_response(
+    orders: list[DatabaseOrder], summaries: list[OrderSummary]
+) -> OrdersResponse:
+    orders: list[Order] = [create_order_response(order) for order in orders]
+    _add_summaries(orders=orders, summaries=summaries)
+    return OrdersResponse(orders=orders)
+
+
+def _add_summaries(orders: list[Order], summaries: list[OrderSummary]) -> list[Order]:
+    order_map = {order.order_id: order for order in orders}
+    for summary in summaries:
+        order = order_map[summary.order_id]
+        order.summary = summary
+    return orders

cg/services/orders/order_status_service/__init__.py

@@ -0,0 +1 @@
+from cg.services.orders.order_status_service.order_status_service import OrderStatusService

cg/services/orders/order_status_service/dto/order_status_summary.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class OrderSummary(BaseModel):
+    order_id: int
+    total: int
+    delivered: int | None = None
+    running: int | None = None
+    cancelled: int | None = None
+    failed: int | None = None
+    in_sequencing: int
+    in_lab_preparation: int

cg/services/orders/order_status_service/order_status_service.py

@@ -0,0 +1,20 @@
+from cg.apps.tb.api import TrailblazerAPI
+from cg.apps.tb.dto.summary_response import AnalysisSummary
+from cg.services.orders.order_status_service.dto.order_status_summary import OrderSummary
+from cg.services.orders.order_status_service.utils import (
+    create_summaries,
+    create_summaries,
+)
+from cg.store.models import Order
+from cg.store.store import Store
+
+
+class OrderStatusService:
+    def __init__(self, analysis_client: TrailblazerAPI, store: Store) -> None:
+        self.analysis_client = analysis_client
+        self.store = store
+
+    def get_status_summaries(self, order_ids: list[int]) -> list[OrderSummary]:
+        orders: list[Order] = self.store.get_orders_by_ids(order_ids)
+        analysis_summaries: list[AnalysisSummary] = self.analysis_client.get_summaries(order_ids)
+        return create_summaries(orders=orders, analysis_summaries=analysis_summaries)

cg/services/orders/order_status_service/utils.py

@@ -0,0 +1,67 @@
+from enum import Enum
+from cg.apps.tb.dto.summary_response import AnalysisSummary
+from cg.services.orders.order_status_service.dto.order_status_summary import OrderSummary
+from cg.store.models import Case, Order
+
+
+def create_summaries(
+    orders: list[Order], analysis_summaries: list[AnalysisSummary]
+) -> list[OrderSummary]:
+    summaries: list[OrderSummary] = []
+    for order in orders:
+        summary: OrderSummary = create_order_summary(order)
+        summaries.append(summary)
+    add_analysis_summaries(order_summaries=summaries, analysis_summaries=analysis_summaries)
+    return summaries
+
+
+def add_analysis_summaries(
+    order_summaries: list[OrderSummary],
+    analysis_summaries: list[AnalysisSummary],
+) -> None:
+    order_summary_map = {summary.order_id: summary for summary in order_summaries}
+    for analysis_summary in analysis_summaries:
+        order_summary = order_summary_map[analysis_summary.order_id]
+        order_summary.delivered = analysis_summary.delivered
+        order_summary.running = analysis_summary.running
+        order_summary.cancelled = analysis_summary.cancelled
+        order_summary.failed = analysis_summary.failed
+
+
+class CaseStatus(Enum):
+    SEQUENCING = 1
+    LAB_PREPARATION = 2
+    OTHER = 3
+
+
+def create_order_summary(order: Order) -> OrderSummary:
+    in_sequencing: int = 0
+    in_preparation: int = 0
+
+    for case in order.cases:
+        status: CaseStatus = get_case_status(case)
+        if status == CaseStatus.SEQUENCING:
+            in_sequencing += 1
+        if status == CaseStatus.LAB_PREPARATION:
+            in_preparation += 1
+
+    return OrderSummary(
+        order_id=order.id,
+        total=len(order.cases),
+        in_sequencing=in_sequencing,
+        in_lab_preparation=in_preparation,
+    )
+
+
+def get_case_status(case: Case):
+    """
+    A case is in lab preparation if at least one sample is not prepared yet.
+    A case is in sequencing if all samples have been prepared and at least one sample is in sequencing.
+    """
+    samples_in_sequencing = False
+    for sample in case.samples:
+        if sample.prepared_at is None:
+            return CaseStatus.LAB_PREPARATION
+        if sample.last_sequenced_at is None:
+            samples_in_sequencing = True
+    return CaseStatus.SEQUENCING if samples_in_sequencing else CaseStatus.OTHER