python-ddd-framework 0.6.0__py3-none-any.whl → 0.7.1__py3-none-any.whl

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/background_workers/order_statistics_worker.py.jinja

@@ -1,26 +0,0 @@
-import logging
-from datetime import timedelta
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.integration_services.order_reporting_service import (
-    OrderReportingService,
-)
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework import BackgroundWorker, BackgroundWorkerContext
-
-logger = logging.getLogger(__name__)
-
-
-class OrderStatisticsWorker(BackgroundWorker):
-    name = f"{MODULE_NAME}.statistics"
-    enabled = False
-    interval = timedelta(minutes=5)
-    iteration_timeout = timedelta(seconds=10)
-
-    def __init__(self, reporting: OrderReportingService) -> None:
-        self._reporting = reporting
-
-    async def run_iteration(self, context: BackgroundWorkerContext) -> None:
-        # 业务扩展：这里是一轮周期统计的处理体；替换统计/汇总逻辑，不自行启动 while 循环或线程。
-        # 启用这个默认关闭的示例 Worker 前，先确定自己的执行周期和失败处理要求。
-        logger.info("Order count: %s", await self._reporting.get_count())

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/caching/order_cache.py.jinja

@@ -1,9 +0,0 @@
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework.caching import cache_name
-
-
-@cache_name(f"{MODULE_NAME}.view")
-class OrderCacheItem(OrderView):
-    pass

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/caching/statistics_cache.py.jinja

@@ -1,9 +0,0 @@
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_statistics_snapshot import OrderStatisticsSnapshot
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework.caching import cache_name
-
-
-@cache_name(f"{MODULE_NAME}.statistics")
-class OrderStatisticsCacheItem(OrderStatisticsSnapshot):
-    pass

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/event_handlers/order_changed_handler.py.jinja

@@ -1,23 +0,0 @@
-from modules.{{ cookiecutter.module_name }}.application.caching.order_cache import OrderCacheItem
-from modules.{{ cookiecutter.module_name }}.domain.events.order_changed import OrderChanged
-from modules.{{ cookiecutter.module_name }}.domain_shared.messages.order_messages import OrderChangedMessage
-
-from python_ddd_framework import LocalEventPhase, local_event_handler
-from python_ddd_framework.caching import DistributedCache
-from python_ddd_framework.realtime import RealtimePublisher
-
-
-@local_event_handler(phase=LocalEventPhase.AFTER_COMMIT)
-class OrderChangedHandler:
-    def __init__(self, cache: DistributedCache[OrderCacheItem], realtime: RealtimePublisher) -> None:
-        self._cache, self._realtime = cache, realtime
-
-    async def handle(self, event: OrderChanged) -> None:
-        # 业务扩展：这里处理提交后的缓存失效/在线通知，替换自己的事件、缓存定义和消息载荷。
-        # 必须随业务一起回滚的规则应放在聚合或 DOMAIN 阶段；这里失败不会撤销已经提交的数据。
-        await self._cache.remove(str(event.order_id))
-        if event.user_id is not None:
-            await self._realtime.send_to_user(
-                event.user_id,
-                OrderChangedMessage(id=event.order_id, status=event.status),
-            )

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/hosted_services/order_integration_service.py.jinja

@@ -1,71 +0,0 @@
-"""可选外部线程集成示例；替换线程生产逻辑即可接入 SDK，不另建容器或任务执行器。"""
-
-import asyncio
-import logging
-from threading import Event, Thread
-
-from python_ddd_framework import (
-    HostedService,
-    HostedServiceContext,
-    HostedServiceInvocationRejectedError,
-    ShutdownReason,
-)
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.integration_services.order_reporting_service import (
-    OrderReportingService,
-)
-
-
-async def observe_integration(reporting: OrderReportingService) -> None:
-    count = await reporting.get_count()
-    logging.getLogger(__name__).info("External integration callback observed %s orders", count)
-
-
-class OrderIntegrationService(HostedService):
-    def __init__(self) -> None:
-        self._stop = Event()
-        self._prepare = Event()
-        self._callback_done = Event()
-        self._stopping_context: HostedServiceContext | None = None
-        self._callback_error: BaseException | None = None
-        self._thread: Thread | None = None
-
-    async def start(self, context: HostedServiceContext) -> None:
-        await context.call(observe_integration)
-        self._thread = Thread(target=self._receive, args=(context,), name=__name__)
-        self._thread.start()
-
-    def _receive(self, context: HostedServiceContext) -> None:
-        # submit_call 只能来自外部线程；Future.result 等待同一正式 invocation 完成。
-        try:
-            try:
-                context.submit_call(observe_integration).result()
-            except HostedServiceInvocationRejectedError:
-                pass  # 普通准入可能已经关闭；收尾只使用 stopping 新提供的 context。
-            self._prepare.wait()
-            stopping = self._stopping_context
-            if stopping is not None:
-                stopping.submit_call(observe_integration).result()
-        except BaseException as error:  # noqa: BLE001 -- 线程故障转交 stopping 重新抛出。
-            self._callback_error = error
-        finally:
-            self._callback_done.set()
-        self._stop.wait()
-
-    async def stopping(self, context: HostedServiceContext, reason: ShutdownReason) -> None:
-        # 独立业务调用完成后再等 SDK 回调，不跨线程传 scope，也不跨等待持有事务。
-        await context.call(observe_integration)
-        self._stopping_context = context
-        self._prepare.set()
-        await asyncio.to_thread(self._callback_done.wait)
-        if self._callback_error is not None:
-            raise RuntimeError("External integration callback failed") from self._callback_error
-
-    async def stop(self, reason: ShutdownReason) -> None:
-        # start 部分失败时 stopping 不会执行；仍须唤醒并等待实际线程退出。
-        self._stop.set()
-        self._prepare.set()
-        if self._thread is not None:
-            await asyncio.to_thread(self._thread.join)
-            self._thread = None
-        logging.getLogger(__name__).info("External integration thread stopped")

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/hosted_services/order_observation_handler.py.jinja

@@ -1,16 +0,0 @@
-"""可选线程集成的快照消费者；通过消息能力进入一次受管理调用。"""
-
-import logging
-
-from python_ddd_framework import MessageHandler, unit_of_work
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.messages.order_observation import (
-    OrderObservation,
-)
-
-
-class OrderObservationHandler(MessageHandler[OrderObservation]):
-    @unit_of_work(disabled=True)
-    async def handle(self, message: OrderObservation) -> None:
-        # 替换为快照应用逻辑；若需要保存数据，显式选择事务而非把接收等待放入 UoW。
-        logging.getLogger(__name__).info("Observed order count: %s", message.count)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/integration_services/order_reporting_service.py.jinja

@@ -1,16 +0,0 @@
-"""内部统计使用正式 IntegrationService 调用链，不开放 HTTP。"""
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.integration_services.order_reporting_service import (
-    OrderReportingService,
-)
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-
-from python_ddd_framework import IntegrationService
-
-
-class _OrderReportingService(IntegrationService, OrderReportingService):
-    def __init__(self, repository: OrderRepository) -> None:
-        self._repository = repository
-
-    async def get_count(self) -> int:
-        return await self._repository.get_count()

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/interceptors/order_timing_interceptor.py.jinja

@@ -1,17 +0,0 @@
-"""Record invocation timing through the framework's interceptor extension."""
-
-import logging
-from time import monotonic
-
-from python_ddd_framework import Interceptor, MethodInvocation
-
-
-class OrderTimingInterceptor(Interceptor):
-    async def intercept(self, invocation: MethodInvocation) -> object:
-        started = monotonic()
-        try:
-            return await invocation.proceed()
-        finally:
-            logging.getLogger(__name__).info(
-                "Order invocation completed in %.4fs", monotonic() - started
-            )

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/options/order_options.py.jinja

@@ -1,7 +0,0 @@
-"""Typed startup options bound to the module's configuration section."""
-
-from python_ddd_framework import BaseOptions
-
-
-class {{ cookiecutter.class_prefix }}Options(BaseOptions):
-    allow_background_approval: bool = True

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/services/order_approval_service.py.jinja

@@ -1,65 +0,0 @@
-import logging
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.application.background_jobs.order_approval.handler import (
-    ApprovalJob,
-)
-from modules.{{ cookiecutter.module_name }}.application.background_jobs.order_approval.payload import (
-    ApprovalPayload,
-)
-from modules.{{ cookiecutter.module_name }}.application_contracts.inputs.approve_order import ApproveOrder
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_approval_service import (
-    {{ cookiecutter.class_prefix }}ApprovalApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-from modules.{{ cookiecutter.module_name }}.domain.services.order_approval_service import OrderApprovalService
-from modules.{{ cookiecutter.module_name }}.domain_shared.permissions.order_permissions import ORDERS_WRITE
-
-from python_ddd_framework import ApplicationService, CurrentUser
-from python_ddd_framework.authorization import authorize
-from python_ddd_framework.background_jobs import BackgroundJobEnqueuer
-from python_ddd_framework.errors.base import ResourceConflictError, ResourceNotFoundError
-from python_ddd_framework.fastapi import http
-
-logger = logging.getLogger(__name__)
-
-
-class _{{ cookiecutter.class_prefix }}ApprovalApplicationService(
-    ApplicationService, {{ cookiecutter.class_prefix }}ApprovalApplicationService
-):
-    def __init__(
-        self,
-        repository: OrderRepository,
-        user: CurrentUser,
-        jobs: BackgroundJobEnqueuer,
-        approval: OrderApprovalService,
-    ) -> None:
-        self._repository = repository
-        self._user = user
-        self._jobs = jobs
-        self._approval = approval
-
-    @authorize(ORDERS_WRITE)
-    async def approve(self, id: UUID, command: ApproveOrder) -> OrderView:
-        # 业务扩展：这里编排“读取聚合 → 核对版本 → 领域服务检查策略并执行动作 → 保存”。
-        # 审批只是动作示例；替换为入库等用例时保留权限/并发边界，把状态规则放进领域方法。
-        order = await self._repository.find(id)
-        if order is None:
-            raise ResourceNotFoundError("Order not found")
-        if order.version != command.expected_version:
-            raise ResourceConflictError("Order version changed")
-        await self._approval.approve(order, user_id=self._user.user_id)
-        await self._repository.save(order)
-        logger.info("Order approved")
-        return OrderView.model_validate(order)
-
-    @authorize(ORDERS_WRITE)
-    @http.post(status_code=202)
-    async def queue_approval(self, id: UUID) -> str:
-        # 业务扩展：这里校验入队条件并构造自己的任务载荷；实际后台业务写在对应 Job.execute。
-        # Job 和载荷类型一起替换，通过注入的入队服务调用，不自行创建消费者或数据库连接。
-        if await self._repository.find(id) is None:
-            raise ResourceNotFoundError("Order not found")
-        # 入队参与本方法原生事务；失败时订单业务与队列写入一起回滚。
-        return await self._jobs.enqueue(ApprovalJob, ApprovalPayload(order_id=id))

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/services/order_management_service.py.jinja

@@ -1,35 +0,0 @@
-import logging
-from uuid import uuid4
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.inputs.create_order import CreateOrder
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_management_service import (
-    {{ cookiecutter.class_prefix }}ManagementApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-from modules.{{ cookiecutter.module_name }}.domain.value_objects.order_title import OrderTitle
-from modules.{{ cookiecutter.module_name }}.domain_shared.permissions.order_permissions import ORDERS_WRITE
-
-from python_ddd_framework import ApplicationService
-from python_ddd_framework.authorization import authorize
-from python_ddd_framework.fastapi import http
-
-logger = logging.getLogger(__name__)
-
-
-class _{{ cookiecutter.class_prefix }}ManagementApplicationService(
-    ApplicationService, {{ cookiecutter.class_prefix }}ManagementApplicationService
-):
-    def __init__(self, repository: OrderRepository) -> None:
-        self._repository = repository
-
-    @authorize(ORDERS_WRITE)
-    @http.post(status_code=201)
-    async def create(self, command: CreateOrder) -> OrderView:
-        # 业务扩展：这里编排创建用例，把输入 DTO 转成领域对象，调用领域方法，再交给仓储保存。
-        # 将 Order/OrderTitle 换成自己的聚合和值对象；领域规则写进聚合，事务由正式调用管线完成。
-        order = Order.create(uuid4(), OrderTitle(value=command.title))
-        await self._repository.save(order)
-        logger.info("Order created")
-        return OrderView.model_validate(order)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/services/order_query_service.py.jinja

@@ -1,41 +0,0 @@
-import logging
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.application.caching.order_cache import OrderCacheItem
-from modules.{{ cookiecutter.module_name }}.application_contracts.services.order_query_service import (
-    {{ cookiecutter.class_prefix }}QueryApplicationService,
-)
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-from modules.{{ cookiecutter.module_name }}.domain_shared.permissions.order_permissions import ORDERS_READ
-
-from python_ddd_framework import ApplicationService
-from python_ddd_framework.authorization import authorize
-from python_ddd_framework.caching import DistributedCache
-from python_ddd_framework.errors.base import ResourceNotFoundError
-
-logger = logging.getLogger(__name__)
-
-
-class _{{ cookiecutter.class_prefix }}QueryApplicationService(ApplicationService, {{ cookiecutter.class_prefix }}QueryApplicationService):
-    def __init__(self, repository: OrderRepository, cache: DistributedCache[OrderCacheItem]) -> None:
-        self._repository = repository
-        self._cache = cache
-
-    @authorize(ORDERS_READ)
-    async def get(self, id: UUID) -> OrderView:
-        # 业务扩展：这里组织单条查询及 DTO 返回；保留缓存时，定义和变更后的失效逻辑要一起调整。
-        cached = await self._cache.get(str(id))
-        if cached is not None:
-            return cached
-        order = await self._repository.find(id)
-        if order is None:
-            raise ResourceNotFoundError("Order not found")
-        view = OrderCacheItem.model_validate(order)
-        await self._cache.set(str(id), view)
-        return view
-
-    @authorize(ORDERS_READ)
-    async def get_list(self) -> tuple[OrderView, ...]:
-        # 业务扩展：这里接收实际业务的查询条件；需要筛选/分页时同步扩展 DTO 和仓储查询契约。
-        return tuple(OrderView.model_validate(order) for order in await self._repository.get_list())

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application/setting_handlers/approval_setting_observer.py.jinja

@@ -1,17 +0,0 @@
-"""Application-owned setting snapshot refreshed by the framework."""
-
-import logging
-import os
-
-from python_ddd_framework.settings import SettingSnapshot
-
-
-class ApprovalSettingObserver:
-    def __init__(self) -> None:
-        self.snapshot: SettingSnapshot[bool] | None = None
-
-    async def apply(self, snapshot: SettingSnapshot[bool]) -> None:
-        self.snapshot = snapshot
-        logging.getLogger(__name__).info(
-            "Approval setting applied: %s pid=%s", snapshot.value, os.getpid()
-        )

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/inputs/approve_order.py.jinja

@@ -1,6 +0,0 @@
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class ApproveOrder(BaseModel):
-    model_config = ConfigDict(frozen=True, extra="forbid")
-    expected_version: int = Field(ge=1)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/inputs/create_order.py.jinja

@@ -1,7 +0,0 @@
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import TITLE_MAX_LENGTH
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class CreateOrder(BaseModel):
-    model_config = ConfigDict(frozen=True, extra="forbid")
-    title: str = Field(min_length=1, max_length=TITLE_MAX_LENGTH)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/integration_services/order_reporting_service.py.jinja

@@ -1,7 +0,0 @@
-from typing import Protocol
-
-from python_ddd_framework import ApplicationServiceContract
-
-
-class OrderReportingService(ApplicationServiceContract, Protocol):
-    async def get_count(self) -> int: ...

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/services/order_approval_service.py.jinja

@@ -1,13 +0,0 @@
-from typing import Protocol
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.inputs.approve_order import ApproveOrder
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-
-from python_ddd_framework import ApplicationServiceContract
-
-
-class {{ cookiecutter.class_prefix }}ApprovalApplicationService(ApplicationServiceContract, Protocol):
-    async def approve(self, id: UUID, command: ApproveOrder) -> OrderView: ...
-
-    async def queue_approval(self, id: UUID) -> str: ...

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/services/order_management_service.py.jinja

@@ -1,10 +0,0 @@
-from typing import Protocol
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.inputs.create_order import CreateOrder
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-
-from python_ddd_framework import ApplicationServiceContract
-
-
-class {{ cookiecutter.class_prefix }}ManagementApplicationService(ApplicationServiceContract, Protocol):
-    async def create(self, command: CreateOrder) -> OrderView: ...

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/services/order_query_service.py.jinja

@@ -1,12 +0,0 @@
-from typing import Protocol
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.application_contracts.views.order_view import OrderView
-
-from python_ddd_framework import ApplicationServiceContract
-
-
-class {{ cookiecutter.class_prefix }}QueryApplicationService(ApplicationServiceContract, Protocol):
-    async def get(self, id: UUID) -> OrderView: ...
-
-    async def get_list(self) -> tuple[OrderView, ...]: ...

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/views/order_statistics_snapshot.py.jinja

@@ -1,9 +0,0 @@
-from datetime import datetime
-
-from pydantic import BaseModel, ConfigDict, Field
-
-
-class OrderStatisticsSnapshot(BaseModel):
-    model_config = ConfigDict(frozen=True)
-    count: int = Field(ge=0)
-    captured_at: datetime

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/application_contracts/views/order_view.py.jinja

@@ -1,12 +0,0 @@
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-from pydantic import BaseModel, ConfigDict
-
-
-class OrderView(BaseModel):
-    model_config = ConfigDict(frozen=True, from_attributes=True)
-    id: UUID
-    title: str
-    status: OrderStatus
-    version: int

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/entities/order.py.jinja

@@ -1,48 +0,0 @@
-from __future__ import annotations
-
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain.events.order_changed import OrderChanged
-from modules.{{ cookiecutter.module_name }}.domain.value_objects.order_title import OrderTitle
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-from modules.{{ cookiecutter.module_name }}.domain_shared.errors.order_errors import ALREADY_APPROVED
-
-from python_ddd_framework import AggregateRoot
-from python_ddd_framework.errors import BusinessError
-
-
-class Order(AggregateRoot[UUID]):
-    def __init__(
-        self,
-        id: UUID,
-        title: OrderTitle,
-        *,
-        status: OrderStatus = OrderStatus.PENDING,
-        version: int = 0,
-    ) -> None:
-        super().__init__(id, version=version)
-        self._title, self._status = title, status
-
-    @property
-    def title(self) -> str:
-        return self._title.value
-
-    @property
-    def status(self) -> OrderStatus:
-        return self._status
-
-    @classmethod
-    def create(cls, id: UUID, title: OrderTitle) -> Order:
-        # 业务扩展：在这里校验新聚合的创建条件、初始化实体和值对象；替换订单示例时一起调整参数。
-        # 领域方法只维护业务状态和事件，持久化由应用服务调用仓储完成。
-        order = cls(id, title)
-        order.raise_local_event(OrderChanged(id, order.status))
-        return order
-
-    def approve(self, *, user_id: UUID | None = None) -> None:
-        # 业务扩展：在这里实现自己的状态转换条件，例如库存是否足够、单据是否允许提交。
-        # 校验通过后再修改状态并记录对应事件；HTTP 参数绑定和调用者授权留在外层。
-        if self.status is OrderStatus.APPROVED:
-            raise BusinessError(ALREADY_APPROVED)
-        self._status = OrderStatus.APPROVED
-        self.raise_local_event(OrderChanged(self.id, self.status, user_id))

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/events/order_changed.py.jinja

@@ -1,13 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.enums.order_status import OrderStatus
-
-
-@dataclass(frozen=True)
-class OrderChanged:
-    order_id: UUID
-    status: OrderStatus
-    user_id: UUID | None = None

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/repositories/order_repository.py.jinja

@@ -1,17 +0,0 @@
-"""领域需要的业务仓储边界；不暴露 Session 或容器。"""
-
-from typing import Protocol
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-
-from python_ddd_framework import RepositoryContract
-
-
-class OrderRepository(RepositoryContract, Protocol):
-    async def find(self, id: UUID, include_details: bool = True) -> Order | None: ...
-    async def get(self, id: UUID, include_details: bool = True) -> Order: ...
-    async def get_count(self) -> int: ...
-    async def get_paged_list(self, skip_count: int, max_result_count: int, sorting: str | None = None, include_details: bool = False) -> list[Order]: ...
-    async def get_list(self, include_details: bool = False) -> list[Order]: ...
-    async def save(self, order: Order) -> None: ...

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/seeding/order_seed_contributor.py.jinja

@@ -1,22 +0,0 @@
-"""仅 pddd db seed 显式调用；确定性业务 ID 保证重复初始化不产生新订单。"""
-
-from uuid import NAMESPACE_URL, uuid5
-
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-from modules.{{ cookiecutter.module_name }}.domain.repositories.order_repository import OrderRepository
-from modules.{{ cookiecutter.module_name }}.domain.value_objects.order_title import OrderTitle
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework import DataSeedContributor
-
-
-class {{ cookiecutter.class_prefix }}SeedContributor(DataSeedContributor):
-    def __init__(self, repository: OrderRepository) -> None:
-        self._repository = repository
-
-    async def seed(self) -> None:
-        # 业务扩展：把演示订单换成业务需要的初始数据；使用稳定标识并先查再写，保证重复 seed 安全。
-        # 真实业务不需要这条示例数据时可移除它；不要在这里执行迁移或启动后台任务。
-        id = uuid5(NAMESPACE_URL, f"{MODULE_NAME}:sample-order")
-        if await self._repository.find(id) is None:
-            await self._repository.save(Order.create(id, OrderTitle(value="Sample order")))

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/services/order_approval_service.py.jinja

@@ -1,23 +0,0 @@
-"""审批设置属于跨对象的领域策略；订单自身仍拥有状态转换规则。"""
-
-from uuid import UUID
-
-from modules.{{ cookiecutter.module_name }}.domain.entities.order import Order
-from modules.{{ cookiecutter.module_name }}.domain.settings.approval_settings import APPROVAL_ENABLED
-from modules.{{ cookiecutter.module_name }}.domain_shared.errors.order_errors import APPROVAL_DISABLED
-
-from python_ddd_framework import DomainService, ValidationEnabled
-from python_ddd_framework.errors import BusinessError
-from python_ddd_framework.settings import SettingProvider
-
-
-class OrderApprovalService(DomainService, ValidationEnabled):
-    def __init__(self, settings: SettingProvider) -> None:
-        self._settings = settings
-
-    async def approve(self, order: Order, *, user_id: UUID | None = None) -> None:
-        # 业务扩展：依赖设置、仓储或多个聚合的规则写在领域服务；不接收 HTTP DTO。
-        # 聚合仍保证不能重复审批；保存和提交由调用方完成，失败才能整体回滚。
-        if not await self._settings.get(APPROVAL_ENABLED):
-            raise BusinessError(APPROVAL_DISABLED)
-        order.approve(user_id=user_id)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/settings/approval_settings.py.jinja

@@ -1,17 +0,0 @@
-"""设置默认值属于领域，业务通过 SettingProvider 获取冻结读取视图。"""
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework.settings import (
-    SettingDefinition,
-    SettingDefinitionContext,
-    SettingDefinitionProvider,
-)
-
-APPROVAL_ENABLED = SettingDefinition(f"{MODULE_NAME}.approval_enabled", bool, default=True)
-
-
-class {{ cookiecutter.class_prefix }}SettingDefinitionProvider(SettingDefinitionProvider):
-    def define(self, context: SettingDefinitionContext) -> None:
-        # 定义扩展：在这里发布本模块的动态业务设置；类型/默认值归 SettingDefinition，读取走 SettingProvider。
-        context.add(APPROVAL_ENABLED)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain/value_objects/order_title.py.jinja

@@ -1,10 +0,0 @@
-from __future__ import annotations
-
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import TITLE_MAX_LENGTH
-from pydantic import Field
-
-from python_ddd_framework import ValueObject
-
-
-class OrderTitle(ValueObject):
-    value: str = Field(min_length=1, max_length=TITLE_MAX_LENGTH)

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain_shared/constants/order_constants.py.jinja

@@ -1,3 +0,0 @@
-MODULE_NAME = "{{ cookiecutter.module_name }}"
-
-TITLE_MAX_LENGTH = 120

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain_shared/enums/order_status.py.jinja

@@ -1,6 +0,0 @@
-from enum import Enum
-
-
-class OrderStatus(str, Enum):
-    PENDING = "pending"
-    APPROVED = "approved"

python_ddd_framework/developer_kit/templates/module/{{cookiecutter.module_name}}/domain_shared/errors/order_errors.py.jinja

@@ -1,11 +0,0 @@
-from modules.{{ cookiecutter.module_name }}.domain_shared.constants.order_constants import MODULE_NAME
-
-from python_ddd_framework.errors import BusinessErrorDefinition
-
-ALREADY_APPROVED = BusinessErrorDefinition(
-    f"{MODULE_NAME}.already_approved", "Order is already approved"
-)
-
-APPROVAL_DISABLED = BusinessErrorDefinition(
-    f"{MODULE_NAME}.approval_disabled", "Order approval is disabled"
-)