orchestrator-core 2.9.1rc1__tar.gz → 2.9.2rc2__tar.gz

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 2.9.1rc1
+current_version = 2.9.2rc2
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(rc(?P<build>\d+))?

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/.github/workflows/run-unit-tests.yml

@@ -62,5 +62,5 @@ jobs:
         uses: codecov/codecov-action@v3
         with:
           token: ${{ secrets.CODECOV_TOKEN }}  # gives error 'Could not find a repository associated with upload token'
-          fail_ci_if_error: true
+          fail_ci_if_error: false
           files: ./coverage.xml

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: orchestrator-core
-Version: 2.9.1rc1
+Version: 2.9.2rc2
 Summary: This is the orchestrator workflow engine.
 Requires-Python: >=3.11,<3.14
 Classifier: Intended Audience :: Information Technology

orchestrator_core-2.9.2rc2/docs/architecture/product_modelling/backfilling.md

@@ -0,0 +1,77 @@
+# Backfilling Existing Subscriptions
+When updating a product block that already exists in your orchestrator, it could be the case that new attributes are
+added or removed. When removing resource types from a `ProductBlock`, the `migrate-domain-models` command is able to
+pick up on this change, and generates a migration that removes these resource types from your database completely.
+
+However, when adding a new resource type to a `ProductBlock`, pre-existing product instances in the subscription
+database are not backfilled. For this, another SQL transaction must be added to the generated migration file.
+
+## Generating a Database Migration
+After the new resource type is added to the product block, the generated migration file should already contain at least the following two transactions:
+
+```python
+conn.execute(sa.text("""
+INSERT INTO resource_types (resource_type, description) VALUES ('site_contains_optical_equipment', 'Whether a site contains optical equipment') RETURNING resource_types.resource_type_id
+"""))
+
+conn.execute(sa.text("""
+INSERT INTO product_block_resource_types (product_block_id, resource_type_id) VALUES ((SELECT product_blocks.product_block_id FROM product_blocks WHERE product_blocks.name IN ('SiteBlock')), (SELECT resource_types.resource_type_id FROM resource_types WHERE resource_types.resource_type IN ('site_contains_optical_equipment')))
+"""))
+```
+
+Note that this will correctly add the new resource type to the database, but is missing a backfill for a default value.
+In the case of this example, a new resource type `site_contains_optical_equipment` is added. Assume that all
+subscriptions that already exist in the database already are sites that contain optical equipment. It would therefore
+make sense to backfill the value `True` into all subscriptions that already exist.
+
+## Adapting the Generated Database Migration
+To implement this backfilling mechanism, only one SQL statement needs to be added to the migration, given below.
+
+```python
+conn.execute(sa.text("""
+WITH rt_id AS (SELECT resource_type_id FROM resource_types WHERE resource_type = 'site_contains_optical_equipment') INSERT INTO subscription_instance_values (subscription_instance_id, resource_type_id, value) SELECT subscription_instance_id, rt_id.resource_type_id, 'True' FROM rt_id, subscription_instances WHERE product_block_id = (SELECT product_block_id FROM product_blocks WHERE name = 'SiteBlock');
+"""))
+```
+
+Adding this statement at the end of the `upgrade()` method in the generated migration file, will set the value of
+`site_contains_optical_equipment` in all existing Site subscriptions to `True`. A more formatted version of this SQL
+statement is given here. To adapt this example to your needs, update the resource type name, default value, and name of
+the product block where this resource type is added.
+
+```sql
+WITH rt_id AS (
+    SELECT
+        resource_type_id
+    FROM
+        resource_types
+    WHERE
+        -- The name of your new resource type
+        resource_type = 'site_contains_optical_equipment'
+)
+INSERT INTO
+    subscription_instance_values (
+        subscription_instance_id,
+        resource_type_id,
+        value
+    )
+SELECT
+    subscription_instance_id,
+    rt_id.resource_type_id,
+    'True'  -- The new value that is backfilled
+FROM
+    rt_id,
+    subscription_instances
+WHERE
+    product_block_id = (
+        SELECT
+            product_block_id
+        FROM
+            product_blocks
+        WHERE
+            -- The name of the product block where this value is backfilled
+            name = 'SiteBlock'
+    );
+```
+
+The `downgrade()` method of the generated migration does not need any modification to work. It simply removes the
+resource type from the subscription database altogether.

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/mkdocs.yml

@@ -145,6 +145,7 @@ nav:
                             - IP Static: architecture/product_modelling/ip_static.md
                       - Product Block Graph: architecture/product_modelling/product_block_graph.md
                       - Importing Existing Products: architecture/product_modelling/imports.md
+                      - Backfilling Existing Subscriptions: architecture/product_modelling/backfilling.md
     - Getting Started:
           - Prerequisites: getting-started/versions.md
           - Base Application:

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/__init__.py

@@ -13,7 +13,7 @@
 
 """This is the orchestrator workflow engine."""
 
-__version__ = "2.9.1rc1"
+__version__ = "2.9.2rc2"
 
 from orchestrator.app import OrchestratorCore
 from orchestrator.settings import app_settings

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/api/api_v1/endpoints/processes.py

@@ -133,7 +133,7 @@ def delete(process_id: UUID) -> None:
     status_code=HTTPStatus.CREATED,
     dependencies=[Depends(check_global_lock, use_cache=False)],
 )
-def new_process(
+async def new_process(
     workflow_key: str,
     request: Request,
     json_data: list[dict[str, Any]] | None = Body(...),

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/api/api_v1/endpoints/subscription_customer_descriptions.py

@@ -26,6 +26,8 @@ from orchestrator.domain.customer_description import (
     update_subscription_customer_description,
 )
 from orchestrator.schemas import SubscriptionDescriptionBaseSchema, SubscriptionDescriptionSchema
+from orchestrator.schemas.subscription_descriptions import UpdateSubscriptionDescriptionSchema
+from orchestrator.utils.errors import StaleDataError
 from orchestrator.utils.redis import delete_from_redis
 
 router = APIRouter()
@@ -37,10 +39,15 @@ async def save_subscription_customer_description_endpoint(data: SubscriptionDesc
 
 
 @router.put("/", response_model=None, status_code=HTTPStatus.NO_CONTENT)
-async def update_subscription_customer_description_endpoint(data: SubscriptionDescriptionSchema = Body(...)) -> None:
+async def update_subscription_customer_description_endpoint(
+    data: UpdateSubscriptionDescriptionSchema = Body(...),
+) -> None:
     description = get_customer_description_by_customer_subscription(data.customer_id, data.subscription_id)
     if description:
-        await update_subscription_customer_description(description, data.description, data.created_at)
+        try:
+            await update_subscription_customer_description(description, data.description, data.created_at, data.version)
+        except StaleDataError as error:
+            raise_status(HTTPStatus.BAD_REQUEST, str(error))
 
 
 @router.delete("/{_id}", response_model=None, status_code=HTTPStatus.NO_CONTENT)

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/db/filters/subscription.py

@@ -24,6 +24,7 @@ logger = structlog.get_logger(__name__)
 SUBSCRIPTION_TABLE_COLUMN_CLAUSES = default_inferred_column_clauses(SubscriptionTable) | {
     "product": inferred_filter(ProductTable.name),
     "tag": filter_exact(ProductTable.tag),
+    "type": filter_exact(ProductTable.product_type),
 }
 
 subscription_filter_fields = create_memoized_field_list(SUBSCRIPTION_TABLE_COLUMN_CLAUSES)

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/db/models.py

@@ -554,6 +554,7 @@ class SubscriptionCustomerDescriptionTable(BaseModel):
     customer_id = mapped_column(String, nullable=False, index=True)
     description = mapped_column(Text(), nullable=False)
     created_at = mapped_column(UtcTimestamp, nullable=False, server_default=text("current_timestamp()"))
+    version = mapped_column(Integer, nullable=False, server_default="1")
 
     subscription = relationship("SubscriptionTable", back_populates="customer_descriptions")
 
@@ -572,6 +573,7 @@ class SubscriptionTable(BaseModel):
     start_date = mapped_column(UtcTimestamp, nullable=True)
     end_date = mapped_column(UtcTimestamp)
     note = mapped_column(Text())
+    version = mapped_column(Integer, nullable=False, server_default="1")
 
     product = relationship("ProductTable", foreign_keys=[product_id])
     instances = relationship(

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/devtools/populator.py

@@ -435,16 +435,29 @@ class Populator:
         self.log.info("Providing user input.")
 
         user_inputs: list[State] = [self.get_form_data(form)] if form else []
+        # Keep submitting the form until it has been successfully submitted
         while True:
             self.log.info("Submitting user input", data=user_inputs)
             response = self.session.request(method, url, json=user_inputs)
-            if not response.ok and "MigrationSummary" in response.text:
-                user_inputs[-1] = {}
-                continue
+            self.log.debug("Response", response=response.content)
+
+            # Return the response if the form has been successfully submitted
             if response.status_code != HTTPStatus.NOT_EXTENDED:
                 return response
-            input_fields = response.json()["form"]
-            user_inputs.append(self.get_form_data(input_fields))
+
+            response_json = response.json()
+            meta = response_json.get("meta", {}) or {}
+            no_next = meta.get("hasNext") is False
+            is_summary_form = response_json.get("form", {}).get("title", "").endswith("Summary")
+
+            # If there are no next pages and a summary form is expected then append an empty form/dict
+            if no_next and is_summary_form:
+                self.log.info("Append empty form", response=response_json)
+                user_inputs.append({})
+            # Otherwise resolve the values for the input fields on the form
+            else:
+                input_fields = response_json["form"]
+                user_inputs.append(self.get_form_data(input_fields))
 
     def reset(self) -> None:
         """Reset internal state."""

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/domain/base.py

@@ -1017,6 +1017,7 @@ class SubscriptionModel(DomainModel):
     start_date: datetime | None = None  # pragma: no mutate
     end_date: datetime | None = None  # pragma: no mutate
     note: str | None = None  # pragma: no mutate
+    version: int = 1  # pragma: no mutate
 
     def __new__(cls, *args: Any, status: SubscriptionLifecycle | None = None, **kwargs: Any) -> "SubscriptionModel":
         # status can be none if created during change_lifecycle
@@ -1108,6 +1109,7 @@ class SubscriptionModel(DomainModel):
         start_date: datetime | None = None,
         end_date: datetime | None = None,
         note: str | None = None,
+        version: int = 1,
     ) -> S:
         """Use product_id (and customer_id) to return required fields of a new empty subscription."""
         # Caller wants a new instance and provided a product_id and customer_id
@@ -1140,6 +1142,7 @@ class SubscriptionModel(DomainModel):
             start_date=start_date,
             end_date=end_date,
             note=note,
+            version=version,
         )
         db.session.add(subscription)
 
@@ -1156,6 +1159,7 @@ class SubscriptionModel(DomainModel):
             start_date=start_date,
             end_date=end_date,
             note=note,
+            version=version,
             **fixed_inputs,
             **instances,
         )
@@ -1270,6 +1274,7 @@ class SubscriptionModel(DomainModel):
                 start_date=subscription.start_date,
                 end_date=subscription.end_date,
                 note=subscription.note,
+                version=subscription.version,
                 **fixed_inputs,
                 **instances,
             )
@@ -1320,6 +1325,7 @@ class SubscriptionModel(DomainModel):
                 start_date=subscription.start_date,
                 end_date=subscription.end_date,
                 note=subscription.note,
+                version=subscription.version,
                 **fixed_inputs,
                 **instances,
             )

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/domain/customer_description.py

@@ -20,7 +20,9 @@ from sqlalchemy import select
 
 from orchestrator.api.models import delete
 from orchestrator.db import SubscriptionCustomerDescriptionTable, db
+from orchestrator.utils.errors import StaleDataError
 from orchestrator.utils.redis import delete_subscription_from_redis
+from orchestrator.utils.validate_data_version import validate_data_version
 from orchestrator.websocket import invalidate_subscription_cache
 
 router = APIRouter()
@@ -53,8 +55,14 @@ async def create_subscription_customer_description(
 
 @delete_subscription_from_redis()
 async def update_subscription_customer_description(
-    customer_description: SubscriptionCustomerDescriptionTable, description: str, created_at: datetime | None = None
+    customer_description: SubscriptionCustomerDescriptionTable,
+    description: str,
+    created_at: datetime | None = None,
+    version: int | None = None,
 ) -> SubscriptionCustomerDescriptionTable:
+    if not validate_data_version(customer_description.version, version):
+        raise StaleDataError(customer_description.version, version)
+
     customer_description.description = description
     customer_description.created_at = created_at if created_at else datetime.now(tz=timezone("UTC"))
     db.session.commit()

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/graphql/mutations/customer_description.py

@@ -25,25 +25,28 @@ from orchestrator.domain.customer_description import (
 )
 from orchestrator.graphql.schemas.customer_description import CustomerDescription
 from orchestrator.graphql.types import MutationError, NotFoundError
+from orchestrator.utils.errors import StaleDataError
 
 logger = structlog.get_logger(__name__)
 
 
 async def upsert_customer_description(
-    customer_id: str, subscription_id: UUID, description: str
+    customer_id: str, subscription_id: UUID, description: str, version: int | None
 ) -> SubscriptionCustomerDescriptionTable | NotFoundError:
     current_description = get_customer_description_by_customer_subscription(customer_id, subscription_id)
 
     if current_description:
-        return await update_subscription_customer_description(current_description, description)
+        return await update_subscription_customer_description(current_description, description, version=version)
     return await create_subscription_customer_description(customer_id, subscription_id, description)
 
 
 async def resolve_upsert_customer_description(
-    customer_id: str, subscription_id: UUID, description: str
+    customer_id: str, subscription_id: UUID, description: str, version: int | None = None
 ) -> CustomerDescription | NotFoundError | MutationError:
     try:
-        customer_description = await upsert_customer_description(customer_id, subscription_id, description)
+        customer_description = await upsert_customer_description(customer_id, subscription_id, description, version)
+    except StaleDataError as error:
+        return MutationError(message=str(error))
     except Exception:
         return NotFoundError(message="Subscription not found")
     return CustomerDescription.from_pydantic(customer_description)  # type: ignore

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/graphql/schemas/subscription.py

@@ -77,6 +77,7 @@ class SubscriptionInterface:
     status: SubscriptionLifecycle
     insync: bool
     note: str | None
+    version: int
 
     @strawberry.field(description="Product information")  # type: ignore
     async def product(self) -> ProductModelGraphql:

orchestrator_core-2.9.2rc2/orchestrator/migrations/versions/schema/2025-01-08_4c5859620539_add_version_column_to_subscription.py

@@ -0,0 +1,64 @@
+"""Add version column to subscription and subscription customer descriptions.
+
+Revision ID: 4c5859620539
+Revises: 460ec6748e37
+Create Date: 2025-01-08 15:07:41.957937
+
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4c5859620539"
+down_revision = "460ec6748e37"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    op.add_column(
+        "subscription_customer_descriptions", sa.Column("version", sa.Integer(), server_default="1", nullable=False)
+    )
+    op.add_column("subscriptions", sa.Column("version", sa.Integer(), server_default="1", nullable=False))
+
+    conn.execute(
+        sa.text(
+            """
+CREATE OR REPLACE FUNCTION increment_version()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.version := OLD.version + 1;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER subscriptions_increment_version_trigger
+BEFORE UPDATE ON subscriptions
+FOR EACH ROW
+EXECUTE FUNCTION increment_version();
+
+CREATE TRIGGER subscription_customer_descriptions_increment_version_trigger
+BEFORE UPDATE ON subscription_customer_descriptions
+FOR EACH ROW
+EXECUTE FUNCTION increment_version();
+    """
+        )
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    op.drop_column("subscriptions", "version")
+    op.drop_column("subscription_customer_descriptions", "version")
+
+    conn.execute(
+        sa.text(
+            """
+DROP TRIGGER IF EXISTS subscriptions_increment_version_trigger on subscriptions;
+DROP TRIGGER IF EXISTS subscription_customer_descriptions_increment_version_trigger on subscription_customer_descriptions;
+DROP FUNCTION IF EXISTS increment_version;
+"""
+        )
+    )

orchestrator_core-2.9.2rc2/orchestrator/migrations/versions/schema/2025-10-19_4fjdn13f83ga_add_validate_product_type_task.py

@@ -0,0 +1,41 @@
+"""Validate Product Type.
+
+Revision ID: 4fjdn13f83ga
+Revises: 2c7e8a43d4f9
+Create Date: 2025-10-13 16:21:43.956814
+
+"""
+
+from uuid import uuid4
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "4fjdn13f83ga"
+down_revision = "4c5859620539"
+branch_labels = None
+depends_on = None
+
+
+workflow = {
+    "name": "task_validate_product_type",
+    "target": "SYSTEM",
+    "description": "Validate all subscriptions of Product Type",
+    "workflow_id": uuid4(),
+}
+
+
+def upgrade() -> None:
+    conn = op.get_bind()
+    conn.execute(
+        sa.text(
+            "INSERT INTO workflows VALUES (:workflow_id, :name, :target, :description, now()) ON CONFLICT DO NOTHING"
+        ),
+        workflow,
+    )
+
+
+def downgrade() -> None:
+    conn = op.get_bind()
+    conn.execute(sa.text("DELETE FROM workflows WHERE name = :name"), {"name": workflow["name"]})

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/schedules/validate_subscriptions.py

@@ -15,14 +15,17 @@
 from threading import BoundedSemaphore
 
 import structlog
-from sqlalchemy import select
 
-from orchestrator.db import ProductTable, SubscriptionTable, db
 from orchestrator.schedules.scheduling import scheduler
-from orchestrator.services.processes import get_execution_context
-from orchestrator.services.subscriptions import TARGET_DEFAULT_USABLE_MAP, WF_USABLE_MAP
+from orchestrator.services.subscriptions import (
+    get_subscriptions_on_product_table,
+    get_subscriptions_on_product_table_in_sync,
+)
+from orchestrator.services.workflows import (
+    get_system_product_workflows_for_subscription,
+    start_validation_workflow_for_workflows,
+)
 from orchestrator.settings import app_settings
-from orchestrator.targets import Target
 
 logger = structlog.get_logger(__name__)
 
@@ -34,29 +37,19 @@ task_semaphore = BoundedSemaphore(value=2)
 def validate_subscriptions() -> None:
     if app_settings.VALIDATE_OUT_OF_SYNC_SUBSCRIPTIONS:
         # Automatically re-validate out-of-sync subscriptions. This is not recommended for production.
-        select_query = select(SubscriptionTable).join(ProductTable)
+        subscriptions = get_subscriptions_on_product_table()
     else:
-        select_query = select(SubscriptionTable).join(ProductTable).filter(SubscriptionTable.insync.is_(True))
-    subscriptions = db.session.scalars(select_query)
-    for subscription in subscriptions:
-        validation_workflow = None
-
-        for workflow in subscription.product.workflows:
-            if workflow.target == Target.SYSTEM:
-                validation_workflow = workflow.name
-
-        if validation_workflow:
-            default = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
-            usable_when = WF_USABLE_MAP.get(validation_workflow, default)
+        subscriptions = get_subscriptions_on_product_table_in_sync()
 
-            if subscription.status in usable_when:
-                json = [{"subscription_id": str(subscription.subscription_id)}]
+    for subscription in subscriptions:
+        system_product_workflows = get_system_product_workflows_for_subscription(subscription)
 
-                validate_func = get_execution_context()["validate"]
-                validate_func(validation_workflow, json=json)
-        else:
+        if not system_product_workflows:
             logger.warning(
                 "SubscriptionTable has no validation workflow",
                 subscription=subscription,
                 product=subscription.product.name,
             )
+            break
+
+        start_validation_workflow_for_workflows(subscription=subscription, workflows=system_product_workflows)

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/schemas/subscription.py

@@ -84,6 +84,7 @@ class SubscriptionSchema(SubscriptionBaseSchema):
     product: ProductBaseSchema | None = None
     customer_descriptions: list[SubscriptionDescriptionSchema] | None = None
     tag: str | None = None
+    version: int
     model_config = ConfigDict(from_attributes=True)
 
 

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/schemas/subscription_descriptions.py

@@ -28,4 +28,12 @@ class SubscriptionDescriptionBaseSchema(OrchestratorBaseModel):
 class SubscriptionDescriptionSchema(SubscriptionDescriptionBaseSchema):
     id: UUID
     created_at: datetime | None = None
+    version: int
+    model_config = ConfigDict(from_attributes=True)
+
+
+class UpdateSubscriptionDescriptionSchema(SubscriptionDescriptionBaseSchema):
+    id: UUID
+    created_at: datetime | None = None
+    version: int | None = None
     model_config = ConfigDict(from_attributes=True)

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/services/subscriptions.py

@@ -670,3 +670,13 @@ def format_extended_domain_model(subscription: dict, filter_owner_relations: boo
         filter_instance_ids_on_subscription()
 
     return subscription
+
+
+def get_subscriptions_on_product_table() -> list[SubscriptionTable]:
+    select_query = select(SubscriptionTable).join(ProductTable)
+    return list(db.session.scalars(select_query))
+
+
+def get_subscriptions_on_product_table_in_sync(in_sync: bool = True) -> list[SubscriptionTable]:
+    select_query = select(SubscriptionTable).join(ProductTable).filter(SubscriptionTable.insync.is_(in_sync))
+    return list(db.session.scalars(select_query))

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/services/workflows.py

@@ -2,8 +2,14 @@ from collections.abc import Iterable
 
 from sqlalchemy import Select, select
 
-from orchestrator.db import WorkflowTable, db
+from orchestrator.db import (
+    SubscriptionTable,
+    WorkflowTable,
+    db,
+)
 from orchestrator.schemas import StepSchema, WorkflowSchema
+from orchestrator.services.subscriptions import TARGET_DEFAULT_USABLE_MAP, WF_USABLE_MAP
+from orchestrator.targets import Target
 from orchestrator.workflows import get_workflow
 
 
@@ -42,3 +48,43 @@ def get_workflows(
 
 def get_workflow_by_name(workflow_name: str) -> WorkflowTable | None:
     return db.session.scalar(select(WorkflowTable).where(WorkflowTable.name == workflow_name))
+
+
+def get_system_product_workflows_for_subscription(
+    subscription: SubscriptionTable,
+) -> list:
+    return [workflow.name for workflow in subscription.product.workflows if workflow.target == Target.SYSTEM]
+
+
+def start_validation_workflow_for_workflows(
+    subscription: SubscriptionTable,
+    workflows: list,
+    product_type_filter: str | None = None,
+) -> list:
+    """Start validation workflows for a subscription."""
+    result = []
+
+    for workflow_name in workflows:
+        default = TARGET_DEFAULT_USABLE_MAP[Target.SYSTEM]
+        usable_when = WF_USABLE_MAP.get(workflow_name, default)
+
+        if subscription.status in usable_when and (
+            product_type_filter is None or subscription.product.product_type == product_type_filter
+        ):
+            json = [{"subscription_id": str(subscription.subscription_id)}]
+
+            # against circular import
+            from orchestrator.services.processes import get_execution_context
+
+            validate_func = get_execution_context()["validate"]
+            validate_func(workflow_name, json=json)
+
+            result.append(
+                {
+                    "workflow_name": workflow_name,
+                    "subscription_id": subscription.subscription_id,
+                    "product_type": subscription.product.product_type,
+                }
+            )
+
+    return result

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/utils/enrich_process.py

@@ -33,6 +33,7 @@ def format_subscription(subscription: SubscriptionTable) -> dict:
         "note": subscription.note,
         "start_date": subscription.start_date if subscription.start_date else None,
         "end_date": subscription.end_date if subscription.end_date else None,
+        "version": subscription.version,
         "product": {
             "product_id": prod.product_id,
             "description": prod.description,

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/utils/errors.py

@@ -74,6 +74,14 @@ class InconsistentDataError(ProcessFailureError):
     pass
 
 
+class StaleDataError(ValueError):
+    """The version of the update payload does not match the version in the database."""
+
+    def __init__(self, current_version: int, new_version: int | None = None) -> None:
+        message = f"Stale data: given version ({new_version}) does not match the current version ({current_version})"
+        super().__init__(message)
+
+
 def is_api_exception(ex: Exception) -> bool:
     """Test for swagger-codegen ApiException.
 

orchestrator_core-2.9.2rc2/orchestrator/utils/validate_data_version.py

@@ -0,0 +1,2 @@
+def validate_data_version(current_version: int, new_version: int | None = None) -> bool:
+    return (new_version is not None and new_version == current_version) or new_version is None

{orchestrator_core-2.9.1rc1 → orchestrator_core-2.9.2rc2}/orchestrator/workflows/__init__.py

@@ -110,5 +110,6 @@ LazyWorkflowInstance(".modify_note", "modify_note")
 LazyWorkflowInstance(".tasks.cleanup_tasks_log", "task_clean_up_tasks")
 LazyWorkflowInstance(".tasks.resume_workflows", "task_resume_workflows")
 LazyWorkflowInstance(".tasks.validate_products", "task_validate_products")
+LazyWorkflowInstance(".tasks.validate_product_type", "task_validate_product_type")
 
 __doc__ = make_workflow_index_doc(ALL_WORKFLOWS)