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, Summary
 from cg.apps.tb.models import AnalysesResponse, TrailblazerAnalysis
 from cg.constants import Workflow
 from cg.constants.constants import APIMethods, FileFormat, JobType, WorkflowManager
@@ -168,3 +169,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[str]) -> list[Summary]:
+        orders_param = "order_ids[]=".join([f"{order_id}," for order_id in order_ids]).strip(",")
+        endpoint = f"summaries?{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,14 @@
+from pydantic import BaseModel
+
+
+class Summary(BaseModel):
+    order_id: int
+    total: int
+    delivered: int
+    running: int
+    cancelled: int
+    failed: int
+
+
+class SummariesResponse(BaseModel):
+    summaries: list[Summary]

cg/exc.py

@@ -256,7 +256,3 @@ class ArchiveJobFailedError(CgError):
 
 class XMLError(CgError):
     """Exception raised when something is wrong with the content of an XML file."""
-
-
-class OrderNotFoundError(CgError):
-    """Exception raised when an order is not found."""

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.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_data=order_in, cases=result["records"])
 
     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 | None = Field(default=False, alias="includeSummary")

cg/server/dto/orders/orders_response.py

@@ -3,12 +3,21 @@
 from cg.constants import Workflow
 
 
+class OrderSummary(BaseModel):
+    total: int
+    delivered: int | None = None
+    running: int | None = None
+    cancelled: int | None = None
+    failed: int | None = None
+
+
 class Order(BaseModel):
     customer_id: str
     ticket_id: int
     order_date: str
     order_id: int
     workflow: Workflow
+    summary: OrderSummary | None = None
 
 
 class OrdersResponse(BaseModel):

cg/server/ext.py

@@ -9,6 +9,8 @@
 from cg.apps.osticket import OsTicket
 from cg.store.database import initialize_database
 from cg.store.store import Store
+from cg.apps.tb.api import TrailblazerAPI
+from cg.services.order_service.order_service import OrderService
 
 
 class FlaskLims(LimsAPI):
@@ -45,10 +47,31 @@ 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()
+order_service = OrderService(store=db, analysis_client=analysis_client)

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/order_service/exceptions.py

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

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

@@ -1,16 +1,20 @@
-from cg.exc import OrderNotFoundError
+from cg.apps.tb.api import TrailblazerAPI
+from cg.apps.tb.dto.summary_response import Summary
 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.order_service.exceptions import OrderNotFoundError
+from cg.services.order_service.utils import create_order_response, create_orders_response
+from cg.store.models import Order
 from cg.store.models import Case, Order
 from cg.store.store import Store
 
 
 class OrderService:
-    def __init__(self, store: Store) -> None:
+    def __init__(self, store: Store, analysis_client: TrailblazerAPI) -> None:
         self.store = store
+        self.analysis_client = analysis_client
 
     def get_order(self, order_id: int) -> OrderResponse:
         order: Order | None = self.store.get_order_by_id(order_id)
@@ -19,14 +23,13 @@ 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)
-
-    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(
+        orders: list[Order] = self.store.get_orders(
             workflow=orders_request.workflow, limit=orders_request.limit
         )
+        summaries: list[Summary] = []
+        if orders_request.include_summary:
+            summaries = self.analysis_client.get_summaries(orders)
+        return create_orders_response(database_orders=orders, summaries=summaries)
 
     def create_order(self, order_data: OrderIn, cases: list[Case]) -> OrderResponse:
         """Creates an order and links it to the given cases."""

cg/services/order_service/utils.py

@@ -0,0 +1,41 @@
+from cg.apps.tb.dto.summary_response import Summary
+from cg.server.dto.orders.orders_response import Order, OrderSummary, OrdersResponse
+from cg.store.models import Order as DatabaseOrder
+
+
+def parse_order(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(
+    database_orders: list[DatabaseOrder], summaries: list[Summary]
+) -> OrdersResponse:
+    orders = [parse_order(order) for order in database_orders]
+    if summaries:
+        _add_summaries_to_orders(orders=orders, summaries=summaries)
+    return OrdersResponse(orders=orders)
+
+
+def _add_summaries_to_orders(orders: list[Order], summaries: list[Summary]) -> list[Order]:
+    summary_mapping: dict = {summary.order_id: summary for summary in summaries}
+    for order in orders:
+        summary: Summary = summary_mapping.get(order.order_id)
+        if summary:
+            order.summary = OrderSummary(
+                total=summary.total,
+                delivered=summary.delivered,
+                running=summary.running,
+                cancelled=summary.cancelled,
+                failed=summary.failed,
+            )
+    return orders
+
+
+def create_order_response(order: DatabaseOrder) -> Order:
+    return parse_order(order)

cg/store/crud/read.py

@@ -11,6 +11,7 @@
 from cg.constants import FlowCellStatus, Workflow
 from cg.constants.constants import CaseActions, CustomerId, PrepCategory, SampleType
 from cg.exc import CaseNotFoundError, CgError
+from cg.server.dto.orders.orders_request import OrdersRequest
 from cg.store.base import BaseHandler
 from cg.store.filters.status_analysis_filters import (
     AnalysisFilter,
@@ -1729,23 +1730,24 @@ def get_all_pools_to_deliver(self) -> list[Pool]:
         )
         return records.all()
 
-    def get_orders_by_workflow(
-        self, workflow: str | None = None, limit: int | None = None
-    ) -> list[Order]:
-        """Returns a list of entries in Order. The output is filtered on workflow and limited, if given."""
-        orders: Query = self._get_query(table=Order)
-        order_filter_functions: list[Callable] = [OrderFilter.FILTER_ORDERS_BY_WORKFLOW]
-        orders: Query = apply_order_filters(
-            orders=orders, filter_functions=order_filter_functions, workflow=workflow
-        )
-        return orders.limit(limit).all()
+    def get_orders(self, workflow: Workflow | None = None, limit: int | None = None) -> list[Order]:
+        filters: list[OrderFilter] = [
+            OrderFilter.BY_WORKFLOW,
+            OrderFilter.APPLY_LIMIT,
+        ]
+        return apply_order_filters(
+            orders=self._get_query(Order),
+            filters=filters,
+            workflow=workflow,
+            limit=limit,
+        ).all()
 
     def get_order_by_id(self, order_id: int) -> Order | None:
         """Returns the entry in Order matching the given id."""
         orders: Query = self._get_query(table=Order)
-        order_filter_functions: list[Callable] = [OrderFilter.FILTER_ORDERS_BY_ID]
+        order_filter_functions: list[Callable] = [OrderFilter.BY_ID]
         orders: Query = apply_order_filters(
-            orders=orders, filter_functions=order_filter_functions, id=order_id
+            orders=orders, filters=order_filter_functions, id=order_id
         )
         return orders.first()