chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动

演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
wuzilongandCursor committed 2026-11-18 13:59:25 +08:00
1 parent 60158935f4
commit 6519682885
15831 files changed
+3063428

No files matched your search

@@ -0,0 +1 @@
"""Workspace domain modules."""
@@ -0,0 +1,213 @@
"""Shared workspace data, independent of service implementations."""
from collections.abc import Mapping
from dataclasses import dataclass, field
from datetime import datetime
from typing import Literal, NamedTuple
from enums import CloudPlan
@dataclass(frozen=True)
class WorkspaceCustomConfig:
remove_webapp_brand: bool = False
replace_webapp_logo: str | None = None
@dataclass(frozen=True)
class WorkspaceCustomConfigChanges:
remove_webapp_brand: bool | None = None
replace_webapp_logo: str | None = None
@dataclass(frozen=True)
class WorkspaceSnapshot:
id: str
name: str
status: str
created_at: datetime
role: str | None = None
custom_config: WorkspaceCustomConfig = field(default_factory=WorkspaceCustomConfig)
has_privileged_member: bool = False
current: bool = False
@dataclass(frozen=True, slots=True)
class WorkspaceMemberWrite:
workspace_id: str
account_id: str
role: str
account_status: str
created: bool
@dataclass(frozen=True, slots=True)
class WorkspaceMemberRemoval:
account_id: str
email: str
account_deleted: bool
@dataclass(frozen=True)
class WorkspacePage:
data: tuple[WorkspaceSnapshot, ...]
total: int
page: int
limit: int
has_more: bool
@dataclass(frozen=True)
class WorkspaceFeatures:
can_replace_logo: bool
credits: "EffectiveCreditPool"
@dataclass(frozen=True)
class WorkspacePermission:
workspace_id: str
allow_member_invite: bool
allow_owner_transfer: bool
@dataclass(frozen=True)
class CreatedWorkspace:
id: str
name: str
plan: str
status: str
created_at: datetime | None
updated_at: datetime | None
encrypt_public_key: str | None
custom_config: dict[str, object]
@dataclass(frozen=True)
class WorkspaceMembership:
workspace_id: str
account_id: str
role: str
@dataclass(frozen=True, slots=True)
class OwnerTransferToken:
email: str
code: str
account_id: str | None = None
@dataclass(frozen=True, slots=True)
class WorkspaceInvitationResult:
email: str
status: Literal["success", "already_member", "failed"]
token: str | None = None
message: str | None = None
@dataclass(frozen=True, slots=True)
class WorkspaceInvitation:
workspace_id: str
account_id: str
email: str
role: str
token: str
@dataclass(frozen=True)
class EffectiveCreditPool:
plan: CloudPlan | None = None
pool_type: Literal["paid", "trial"] | None = None
quota_limit: int | None = None
quota_used: int | None = None
exhausted_at: int | None = None
next_credit_reset_date: int | None = None
@property
def remaining_credits(self) -> int | None:
if self.quota_limit is None or self.quota_used is None:
return None
if self.is_unlimited:
return -1
return max(0, self.quota_limit - self.quota_used)
@property
def is_unlimited(self) -> bool:
return self.quota_limit == -1
@property
def is_exhausted(self) -> bool:
remaining_credits = self.remaining_credits
return not self.is_unlimited and (remaining_credits is None or remaining_credits <= 0)
class WorkspaceRecord(NamedTuple):
id: str
name: str | None
status: str
created_at: datetime
last_opened_at: datetime | None
class WorkspaceSummary(NamedTuple):
id: str
name: str | None
plan: str
status: str
created_at: datetime
last_opened_at: datetime | None
current: bool
class WorkspaceMemberRole(NamedTuple):
id: str
name: str
class WorkspaceMemberRecord(NamedTuple):
id: str
name: str
email: str
avatar: str | None
last_login_at: datetime | None
last_active_at: datetime
created_at: datetime
status: str
legacy_role: str
@property
def role(self) -> str:
return self.legacy_role
@dataclass(frozen=True, slots=True)
class WorkspaceMemberPage:
members: tuple[WorkspaceMemberRecord, ...]
total: int
class WorkspaceMemberRoleSubject(NamedTuple):
account_id: str
legacy_role: str
class WorkspaceMemberSummary(NamedTuple):
id: str
name: str
email: str
avatar: str | None
last_login_at: datetime | None
last_active_at: datetime
created_at: datetime
role: str
roles: tuple[WorkspaceMemberRole, ...]
status: str
@dataclass(frozen=True, slots=True)
class WorkspaceCreation:
id: str
name: str
encrypt_public_key: str
trial_credits: int
plugin_upgrade_time: int
plugin_upgrade_settings: Mapping[str, str]
@@ -0,0 +1,492 @@
"""Adapters for workspace plans, features, files, member roles, and provisioning."""
import logging
import secrets
from collections.abc import Mapping, Sequence
from contextlib import AbstractContextManager
from typing import Literal, override
from uuid import uuid4
from werkzeug.exceptions import Forbidden
from configs import dify_config
from enums import CloudPlan, DeploymentEdition
from events.tenant_event import tenant_was_created
from extensions.ext_redis import RedisClientWrapper
from libs.helper import RateLimiter, TokenManager
from libs.key_providers import generate_key_pair
from libs.workspace_permission import check_workspace_member_invite_permission
from machinery.context import RequestContext
from models.account import (
Account,
AccountStatus,
Tenant,
TenantAccountRole,
TenantPluginAutoUpgradeCategory,
)
from repositories.workspace.workspace_repository import WorkspaceRepository
from services.account.adapters import RedisInvitationTokenStore
from services.account_security_gateway import RedisAccountEmailSecurityGateway
from services.billing_service import BillingService
from services.credit_pool_service import CreditPoolBalance, CreditPoolService
from services.enterprise import rbac_service as enterprise_rbac_service
from services.enterprise.enterprise_service import EnterpriseService
from services.enterprise.rbac_service import RBACService
from services.entities.account_activation_entities import InvitationToken
from services.entities.account_entities import AccountSnapshot
from services.errors.base import NoPermissionError
from services.errors.workspace import (
InvalidWorkspaceMemberRoleError,
OwnerTransferSendRateLimitError,
WorkspaceInvitationQuotaError,
WorkspaceMemberLicenseQuotaError,
)
from services.feature_service import FeatureService
from services.file_service import FileService
from services.plugin.plugin_auto_upgrade_service import PluginAutoUpgradeService
from services.rbac.contracts import ListOption
from services.system_feature_service import SystemFeatureService
from services.workspace.contracts import (
CreatedWorkspace,
EffectiveCreditPool,
OwnerTransferToken,
WorkspaceCreation,
WorkspaceFeatures,
WorkspaceMemberRemoval,
WorkspaceMemberRole,
WorkspaceMemberRoleSubject,
WorkspaceMemberWrite,
WorkspacePermission,
)
from services.workspace.member_service import WorkspaceMemberRoleResolver
from services.workspace.service import WorkspaceFeatureGateway, WorkspaceLogoGateway, WorkspacePlanGateway
from tasks.mail_invite_member_task import send_invite_member_mail_task
from tasks.mail_owner_transfer_task import (
send_new_owner_transfer_notify_email_task,
send_old_owner_transfer_notify_email_task,
send_owner_transfer_confirm_task,
)
logger = logging.getLogger(__name__)
class WorkspaceIdentityGateway:
"""Materialize workspace identities for adapters that require the ORM model."""
def __init__(self, *, workspaces: WorkspaceRepository) -> None:
self._workspaces = workspaces
def get_workspace(self, workspace_id: str) -> Tenant | None:
return self._workspaces.get_model(workspace_id)
class WorkspaceOwnerTransferGateway(RedisAccountEmailSecurityGateway):
def __init__(self, *, redis: RedisClientWrapper) -> None:
super().__init__(
redis=redis,
email_send_ip_limit_per_minute=dify_config.EMAIL_SEND_IP_LIMIT_PER_MINUTE,
verification_failure_limit=5,
verification_lockout_duration=dify_config.OWNER_TRANSFER_LOCKOUT_DURATION,
verification_key_prefix="owner_transfer_error_rate_limit",
)
self._send_limits = RateLimiter(
prefix="owner_transfer_rate_limit", max_attempts=1, time_window=60, redis_client=redis
)
def send_confirmation(self, account: AccountSnapshot, workspace_name: str, language: str) -> str:
if self._send_limits.is_rate_limited(account.email):
raise OwnerTransferSendRateLimitError(int(self._send_limits.time_window / 60))
code = "".join(str(secrets.randbelow(10)) for _ in range(6))
token = self.issue_token(OwnerTransferToken(account.email, code, account.id))
send_owner_transfer_confirm_task.delay(language=language, to=account.email, code=code, workspace=workspace_name)
self._send_limits.increment_rate_limit(account.email)
return token
def read_token(self, token: str) -> OwnerTransferToken | None:
data = TokenManager.get_token_data(token, "owner_transfer")
if data is None or not isinstance(data.get("email"), str) or not isinstance(data.get("code"), str):
return None
return OwnerTransferToken(data["email"], data["code"], data.get("account_id"))
def issue_token(self, token: OwnerTransferToken) -> str:
return TokenManager.generate_token(
account_id=token.account_id,
email=token.email,
token_type="owner_transfer",
additional_data={"code": token.code},
)
def revoke_token(self, token: str) -> None:
TokenManager.revoke_token(token, "owner_transfer")
def notify(self, *, old_owner: AccountSnapshot, new_owner: AccountSnapshot, workspace_name: str) -> None:
send_new_owner_transfer_notify_email_task.delay(language="en-US", to=new_owner.email, workspace=workspace_name)
send_old_owner_transfer_notify_email_task.delay(
language="en-US", to=old_owner.email, workspace=workspace_name, new_owner_email=new_owner.email
)
class DeploymentWorkspaceCreationPolicy:
def is_workspace_creation_allowed(self) -> bool:
return SystemFeatureService.is_workspace_creation_allowed()
def has_workspace_capacity(self) -> bool:
return SystemFeatureService.get_license().workspaces.is_available()
def _ensure_role_enabled(role: str) -> None:
if role == "dataset_operator" and not dify_config.DATASET_OPERATOR_ENABLED:
raise InvalidWorkspaceMemberRoleError()
class WorkspaceInvitationGateway:
def __init__(self, *, tokens: RedisInvitationTokenStore, redis: RedisClientWrapper) -> None:
self._tokens = tokens
self._redis = redis
@property
def requires_capacity_check(self) -> bool:
return dify_config.DEPLOYMENT_EDITION in {DeploymentEdition.CLOUD, DeploymentEdition.ENTERPRISE}
def acquire(self, workspace_id: str) -> AbstractContextManager[object]:
return self._redis.lock(f"workspace_member_invite:{workspace_id}", timeout=60)
def ensure_role_enabled(self, role: str) -> None:
_ensure_role_enabled(role)
def check_invitation_quota(self, workspace_id: str) -> None:
"""Admit a single invitation using the advertised plan and license limits.
Unlike batch capacity checks, this gate also applies to reinvitations
and uses the billing-reported member count.
"""
features = FeatureService.get_features(tenant_id=workspace_id, exclude_vector_space=True)
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:
if 0 < features.members.limit <= features.members.size:
raise WorkspaceInvitationQuotaError()
if features.workspace_members.enabled and not features.workspace_members.is_available(1):
raise WorkspaceMemberLicenseQuotaError()
def check_capacity(self, workspace_id: str, *, current_members: int, new_members: int, new_accounts: int) -> None:
if dify_config.DEPLOYMENT_EDITION not in {DeploymentEdition.CLOUD, DeploymentEdition.ENTERPRISE}:
return
features = FeatureService.get_features(tenant_id=workspace_id, exclude_vector_space=True)
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE:
quota = features.workspace_members
if quota.enabled and not quota.is_available(new_members):
raise WorkspaceMemberLicenseQuotaError()
if new_accounts and not SystemFeatureService.get_license().seats.is_available(new_accounts):
raise WorkspaceInvitationQuotaError(seats=True)
elif 0 < features.members.limit < current_members + new_members:
raise WorkspaceInvitationQuotaError()
def ensure_allowed(self, workspace_id: str) -> None:
try:
check_workspace_member_invite_permission(workspace_id)
except Forbidden as error:
raise NoPermissionError(error.description) from error
def create(self, invitation: InvitationToken) -> str:
return self._tokens.create(invitation)
def send(self, *, language: str, email: str, token: str, inviter_name: str, workspace_name: str) -> None:
send_invite_member_mail_task.delay(
language=language,
to=email,
token=token,
inviter_name=inviter_name,
workspace_name=workspace_name,
)
class DeploymentWorkspaceMemberAccessGateway:
def ensure_role_enabled(self, role: str) -> None:
_ensure_role_enabled(role)
@property
def rbac_enabled(self) -> bool:
return dify_config.RBAC_ENABLED
def permission_keys(self, workspace_id: str, actor_id: str) -> set[str]:
permissions = RBACService.MyPermissions.get(workspace_id, actor_id)
return set(permissions.workspace.permission_keys)
def is_owner(self, workspace_id: str, actor_id: str, member_id: str) -> bool:
roles = RBACService.MemberRoles.get(workspace_id, actor_id, member_id).roles
return any(
role.is_builtin and role.category == "global_system_default" and role.role_tag == "owner" for role in roles
)
@staticmethod
def _role_id(workspace_id: str, actor_id: str, tag: str) -> str:
roles = RBACService.Roles.list(
workspace_id, actor_id, options=ListOption(page_number=1, results_per_page=100)
).data
for role in roles:
if role.is_builtin and role.category == "global_system_default" and role.role_tag == tag:
return str(role.id)
raise ValueError(f"Builtin RBAC role not found for tag {tag!r} in tenant {workspace_id}")
def owner_id(self, workspace_id: str, actor_id: str) -> str:
members = RBACService.Roles.members(
tenant_id=workspace_id,
account_id=actor_id,
role_id=self._role_id(workspace_id, actor_id, "owner"),
options=ListOption(page_number=1, results_per_page=1),
).data
if not members:
raise ValueError(f"Workspace RBAC owner not found for tenant {workspace_id}.")
return members[0].account_id
def assign_role(self, workspace_id: str, actor_id: str, member_id: str, role_id: str) -> None:
RBACService.MemberRoles.replace(
tenant_id=workspace_id,
account_id=actor_id,
member_account_id=member_id,
role_ids=[role_id],
)
def change_role(self, workspace_id: str, actor_id: str, member_id: str, role: TenantAccountRole) -> None:
if not TenantAccountRole.is_non_owner_role(role):
raise InvalidWorkspaceMemberRoleError("Owner changes require ownership transfer.")
self.assign_role(workspace_id, actor_id, member_id, self._role_id(workspace_id, actor_id, role.value))
def transfer_owner(self, workspace_id: str, actor_id: str, member_id: str) -> None:
owner_role_id = self._role_id(workspace_id, actor_id, "owner")
old_owner_id = self.owner_id(workspace_id, actor_id)
no_access_id = self._role_id(workspace_id, actor_id, "no_access")
# Complete the remote role changes before the repository commits local ownership.
current = RBACService.MemberRoles.get(workspace_id, actor_id, old_owner_id).roles
remaining = [str(item.id) for item in current if str(item.id) != owner_role_id]
RBACService.MemberRoles.replace(
tenant_id=workspace_id,
account_id=actor_id,
member_account_id=old_owner_id,
role_ids=remaining or [no_access_id],
)
RBACService.MemberRoles.replace(
tenant_id=workspace_id,
account_id=actor_id,
member_account_id=member_id,
role_ids=[owner_role_id],
)
def membership_changed(self, membership: WorkspaceMemberWrite, operator_account_id: str | None) -> None:
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:
BillingService.clean_billing_info_cache(membership.workspace_id)
if (
membership.created
and self.rbac_enabled
and membership.role != TenantAccountRole.OWNER
and membership.account_status != AccountStatus.PENDING
):
from tasks.initialize_created_app_rbac_access_task import sync_joined_workspace_member_rbac_access_task
sync_joined_workspace_member_rbac_access_task.delay(
membership.workspace_id,
membership.account_id,
operator_account_id=operator_account_id,
)
def member_removed(self, workspace_id: str, removal: WorkspaceMemberRemoval) -> None:
if removal.account_deleted:
logger.info("Deleted orphaned pending account: account_id=%s, email=%s", removal.account_id, removal.email)
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:
BillingService.clean_billing_info_cache(workspace_id)
from services.enterprise.account_deletion_sync import sync_workspace_member_removal
if not sync_workspace_member_removal(
workspace_id=workspace_id, member_id=removal.account_id, source="workspace_member_removed"
):
logger.warning(
"Enterprise workspace member removal sync failed: workspace_id=%s, member_id=%s",
workspace_id,
removal.account_id,
)
if self.rbac_enabled:
RBACService.MemberRoles.delete_rbac_bindings(tenant_id=workspace_id, account_id=removal.account_id)
class DeploymentWorkspacePlanGateway(WorkspacePlanGateway):
"""Resolve workspace plans using deployment-specific Billing and Feature sources."""
@override
def resolve_many(self, workspace_ids: Sequence[str]) -> Mapping[str, str]:
ids = tuple(workspace_ids)
if not ids:
return {}
is_enterprise_only = dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE
if is_enterprise_only:
return dict.fromkeys(ids, str(CloudPlan.SANDBOX))
is_saas = dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD
bulk_plans = BillingService.get_plan_bulk(ids) if is_saas else {}
if is_saas and not bulk_plans:
logger.warning("get_plan_bulk returned empty result, falling back to FeatureService")
resolved: dict[str, str] = {}
for workspace_id in ids:
tenant_plan = bulk_plans.get(workspace_id)
if tenant_plan:
resolved[workspace_id] = tenant_plan.plan or CloudPlan.SANDBOX
continue
features = FeatureService.get_features(workspace_id, exclude_vector_space=True)
resolved[workspace_id] = features.billing.subscription.plan or CloudPlan.SANDBOX
return resolved
class DeploymentWorkspaceFeatureGateway(WorkspaceFeatureGateway):
@override
def get_features(self, workspace_id: str) -> WorkspaceFeatures:
features = FeatureService.get_features(workspace_id, exclude_vector_space=True)
credits = EffectiveCreditPool()
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:
credits = self._credit_pool(
workspace_id, CloudPlan(features.billing.subscription.plan), features.next_credit_reset_date
)
return WorkspaceFeatures(can_replace_logo=features.can_replace_logo, credits=credits)
@override
def get_effective_credit_pool(self, workspace_id: str) -> EffectiveCreditPool:
if dify_config.DEPLOYMENT_EDITION != DeploymentEdition.CLOUD:
return EffectiveCreditPool()
billing = BillingService.get_info(workspace_id, exclude_vector_space=True)
return self._credit_pool(workspace_id, CloudPlan(billing.subscription.plan), billing.next_credit_reset_date)
@staticmethod
def _credit_pool(workspace_id: str, plan: CloudPlan, reset_date: int | None) -> EffectiveCreditPool:
# In Cloud, CreditPoolService reads the billing quota API, without an ORM Session.
pool = None
pool_type: Literal["paid", "trial"] = "trial"
if plan != CloudPlan.SANDBOX:
paid = CreditPoolService.get_pool(tenant_id=workspace_id, pool_type="paid")
if paid is not None and (paid.quota_limit == -1 or paid.quota_limit > paid.quota_used):
pool, pool_type = paid, "paid"
if pool is None:
pool = CreditPoolService.get_pool(tenant_id=workspace_id, pool_type="trial")
if pool is None:
return EffectiveCreditPool(plan=plan, next_credit_reset_date=reset_date)
exhausted_at = pool.exhausted_at if isinstance(pool, CreditPoolBalance) else None
if not (
isinstance(exhausted_at, int)
and exhausted_at > 0
and pool.quota_limit > 0
and pool.quota_used >= pool.quota_limit
):
exhausted_at = None
return EffectiveCreditPool(
plan=plan,
pool_type=pool_type,
quota_limit=pool.quota_limit,
quota_used=pool.quota_used,
exhausted_at=exhausted_at,
next_credit_reset_date=reset_date,
)
@override
def logo_url(self, workspace_id: str) -> str:
return f"{dify_config.FILES_URL}/files/workspaces/{workspace_id}/webapp-logo"
@override
def get_permission(self, workspace_id: str) -> WorkspacePermission:
permission = EnterpriseService.WorkspacePermissionService.get_permission(workspace_id)
return WorkspacePermission(
workspace_id=permission.workspace_id,
allow_member_invite=permission.allow_member_invite,
allow_owner_transfer=permission.allow_owner_transfer,
)
class WorkspaceFileGateway(WorkspaceLogoGateway):
def __init__(self, *, files: FileService) -> None:
self._files = files
@override
def upload(self, context: RequestContext, *, filename: str, content: bytes, mimetype: str) -> str:
# FileService only needs the admitted account ID and its explicit tenant ID.
owner = Account(name="", email="")
owner.id = context.account_id
return self._files.upload_file(
filename=filename,
content=content,
mimetype=mimetype,
user=owner,
tenant_id=context.active_workspace_id,
).id
class DeploymentWorkspaceMemberRoleResolver(WorkspaceMemberRoleResolver):
"""Preserve deployment-specific legacy and enterprise role behavior."""
@override
def resolve_many(
self,
workspace_id: str,
actor_account_id: str,
subjects: Sequence[WorkspaceMemberRoleSubject],
*,
language: str | None = None,
) -> Mapping[str, Sequence[WorkspaceMemberRole]]:
role_subjects = tuple(subjects)
if not role_subjects:
return {}
if not dify_config.RBAC_ENABLED:
return {
subject.account_id: (WorkspaceMemberRole(id=subject.legacy_role, name=subject.legacy_role),)
for subject in role_subjects
}
member_roles = enterprise_rbac_service.RBACService.MemberRoles.batch_get(
workspace_id,
actor_account_id,
[subject.account_id for subject in role_subjects],
language=language,
)
return {
item.account_id: tuple(WorkspaceMemberRole(id=role.id, name=role.name) for role in item.roles)
for item in member_roles
}
class WorkspaceProvisioningEffectsGateway:
"""Prepare external resources and publish committed workspace creation."""
def prepare(self, name: str) -> WorkspaceCreation:
workspace_id = str(uuid4())
return WorkspaceCreation(
id=workspace_id,
name=name,
encrypt_public_key=generate_key_pair(workspace_id),
trial_credits=dify_config.HOSTED_POOL_CREDITS,
plugin_upgrade_time=PluginAutoUpgradeService.default_upgrade_time_of_day(workspace_id),
plugin_upgrade_settings={
category.value: PluginAutoUpgradeService.default_strategy_setting_for_category(category).value
for category in TenantPluginAutoUpgradeCategory
},
)
def bind_owner(self, workspace_id: str, account_id: str) -> None:
if not dify_config.RBAC_ENABLED:
return
role_id = DeploymentWorkspaceMemberAccessGateway._role_id(workspace_id, account_id, "owner")
RBACService.MemberRoles.replace(
tenant_id=workspace_id,
account_id=account_id,
member_account_id=account_id,
role_ids=[role_id],
)
def created(self, workspace: CreatedWorkspace, *, owner_id: str | None) -> None:
if owner_id is not None and dify_config.DEPLOYMENT_EDITION == DeploymentEdition.CLOUD:
BillingService.clean_billing_info_cache(workspace.id)
tenant_was_created.send(workspace)
def join_default_workspace(self, account_id: str) -> None:
if dify_config.DEPLOYMENT_EDITION == DeploymentEdition.ENTERPRISE:
from services.enterprise.enterprise_service import try_join_default_workspace
try_join_default_workspace(account_id)
@@ -0,0 +1,571 @@
"""Workspace membership, invitation and ownership use cases with application-owned ports."""
from collections.abc import Mapping, Sequence
from contextlib import AbstractContextManager
from typing import Protocol
from enums.account import TenantAccountRole
from machinery.context import RequestContext
from services.account_errors import AccountNotFoundError
from services.account_ports import AccountSnapshotQuery
from services.entities.account_activation_entities import InvitationToken
from services.entities.account_entities import AccountSnapshot
from services.errors.base import NoPermissionError
from services.errors.workspace import (
AccountAlreadyInTenantError,
CannotOperateSelfError,
InvalidActionError,
InvalidOwnerTransferCodeError,
InvalidOwnerTransferEmailError,
InvalidOwnerTransferTokenError,
InvalidWorkspaceMemberRoleError,
MemberNotInTenantError,
OwnerTransferSendIPLimitedError,
OwnerTransferVerificationLimitError,
RoleAlreadyAssignedError,
WorkspaceAlreadyHasOwnerError,
WorkspaceNotFoundError,
)
from services.workspace.contracts import (
OwnerTransferToken,
WorkspaceInvitation,
WorkspaceInvitationResult,
WorkspaceMemberPage,
WorkspaceMemberRecord,
WorkspaceMemberRemoval,
WorkspaceMemberRole,
WorkspaceMemberRoleSubject,
WorkspaceMembership,
WorkspaceMemberSummary,
WorkspaceMemberWrite,
WorkspaceSnapshot,
)
class WorkspaceMemberQuery(Protocol):
def list_for_workspace(
self, workspace_id: str, *, role: TenantAccountRole | None = None
) -> Sequence[WorkspaceMemberRecord]: ...
class WorkspaceMemberRoleResolver(Protocol):
def resolve_many(
self,
workspace_id: str,
actor_account_id: str,
subjects: Sequence[WorkspaceMemberRoleSubject],
*,
language: str | None = None,
) -> Mapping[str, Sequence[WorkspaceMemberRole]]: ...
class WorkspaceMemberQueryService:
def __init__(
self,
*,
members: WorkspaceMemberQuery,
roles: WorkspaceMemberRoleResolver,
) -> None:
self._members = members
self._roles = roles
def list_members(
self, workspace_id: str, *, dataset_operators_only: bool = False
) -> tuple[WorkspaceMemberRecord, ...]:
role = TenantAccountRole.DATASET_OPERATOR if dataset_operators_only else None
return tuple(self._members.list_for_workspace(workspace_id, role=role))
def list_page(self, context: RequestContext, *, page: int, limit: int) -> WorkspaceMemberPage:
records = self.list_members(context.active_workspace_id)
start = (page - 1) * limit
return WorkspaceMemberPage(members=records[start : start + limit], total=len(records))
def list_current(
self, context: RequestContext, *, language: str | None = None
) -> tuple[WorkspaceMemberSummary, ...]:
workspace_id = context.active_workspace_id
records = tuple(self._members.list_for_workspace(workspace_id))
role_subjects = tuple(
WorkspaceMemberRoleSubject(account_id=record.id, legacy_role=record.legacy_role) for record in records
)
# The repository closes its read Session before role resolution
# performs enterprise I/O.
roles_by_member = self._roles.resolve_many(workspace_id, context.account_id, role_subjects, language=language)
return tuple(
WorkspaceMemberSummary(
id=record.id,
name=record.name,
email=record.email,
avatar=record.avatar,
last_login_at=record.last_login_at,
last_active_at=record.last_active_at,
created_at=record.created_at,
role=record.legacy_role,
roles=tuple(roles_by_member.get(record.id, ())),
status=record.status,
)
for record in records
)
class WorkspaceMemberStore(Protocol):
def get(self, workspace_id: str) -> WorkspaceSnapshot | None: ...
def member_role(self, workspace_id: str, account_id: str | None) -> TenantAccountRole | None: ...
def owner_id(self, workspace_id: str) -> str | None: ...
def upsert_member(
self,
*,
workspace_id: str,
account_id: str,
role: TenantAccountRole,
actor_account_id: str | None = None,
) -> WorkspaceMemberWrite: ...
def remove_member(
self, *, workspace_id: str, account_id: str, owner_id: str, actor_account_id: str
) -> WorkspaceMemberRemoval: ...
def update_member_role(
self,
*,
workspace_id: str,
account_id: str,
role: TenantAccountRole,
actor_account_id: str,
previous_owner_account_ids: Sequence[str] = (),
) -> None: ...
class WorkspaceMemberAccessGateway(Protocol):
@property
def rbac_enabled(self) -> bool: ...
def ensure_role_enabled(self, role: str) -> None: ...
def permission_keys(self, workspace_id: str, actor_id: str) -> set[str]: ...
def is_owner(self, workspace_id: str, actor_id: str, member_id: str) -> bool: ...
def owner_id(self, workspace_id: str, actor_id: str) -> str: ...
def assign_role(self, workspace_id: str, actor_id: str, member_id: str, role_id: str) -> None: ...
def change_role(self, workspace_id: str, actor_id: str, member_id: str, role: TenantAccountRole) -> None: ...
def transfer_owner(self, workspace_id: str, actor_id: str, member_id: str) -> None: ...
def membership_changed(self, membership: WorkspaceMemberWrite, operator_account_id: str | None) -> None: ...
def member_removed(self, workspace_id: str, removal: WorkspaceMemberRemoval) -> None: ...
class WorkspaceMemberService:
def __init__(
self, *, workspaces: WorkspaceMemberStore, accounts: AccountSnapshotQuery, access: WorkspaceMemberAccessGateway
) -> None:
self._workspaces = workspaces
self._accounts = accounts
self._access = access
@property
def rbac_enabled(self) -> bool:
return self._access.rbac_enabled
def get_role(self, workspace_id: str, account_id: str | None) -> TenantAccountRole | None:
return self._workspaces.member_role(workspace_id, account_id)
def check_permission(self, workspace_id: str, operator_id: str, member_id: str | None, action: str) -> None:
if action not in {"add", "remove", "update"}:
raise InvalidActionError("Invalid action.")
if member_id == operator_id:
raise CannotOperateSelfError("Cannot operate self.")
if self._access.rbac_enabled:
permission = "workspace.member.manage" if action in {"add", "remove"} else "workspace.role.manage"
if permission not in self._access.permission_keys(workspace_id, operator_id):
raise NoPermissionError(f"No permission to {action} member.")
if action == "remove" and member_id and self._access.is_owner(workspace_id, operator_id, member_id):
raise NoPermissionError(f"No permission to {action} member.")
return
role = self.get_role(workspace_id, operator_id)
if role not in {TenantAccountRole.OWNER, TenantAccountRole.ADMIN}:
raise NoPermissionError(f"No permission to {action} member.")
if (
action == "remove"
and role == TenantAccountRole.ADMIN
and member_id
and self.get_role(workspace_id, member_id) == TenantAccountRole.OWNER
):
raise NoPermissionError(f"No permission to {action} member.")
def join_member(
self,
*,
workspace_id: str,
account_id: str,
email: str,
role: TenantAccountRole,
operator_account_id: str | None,
) -> WorkspaceMembership:
"""Add or update a member and synchronize their workspace access.
Raises:
WorkspaceNotFoundError: The workspace is missing or is not active.
AccountNotFoundError: The account is missing or its email does not match.
WorkspaceAlreadyHasOwnerError: An owner is requested but the workspace
already has one.
"""
workspace = self._workspaces.get(workspace_id)
if workspace is None or workspace.status != "normal":
raise WorkspaceNotFoundError()
account = self._accounts.get(account_id)
if account is None or account.email != email:
raise AccountNotFoundError()
if role == TenantAccountRole.OWNER and self._workspaces.owner_id(workspace_id) is not None:
raise WorkspaceAlreadyHasOwnerError("Tenant already has an owner.")
membership = self._workspaces.upsert_member(
workspace_id=workspace_id,
account_id=account_id,
role=role,
actor_account_id=operator_account_id,
)
self._access.membership_changed(membership, operator_account_id)
return WorkspaceMembership(workspace_id, account_id, role.value)
def assign_role(self, workspace_id: str, operator_id: str, member_id: str, role_id: str) -> None:
self._access.assign_role(workspace_id, operator_id, member_id, role_id)
def remove(self, workspace_id: str, account_id: str, operator_id: str) -> None:
"""Remove a member and transfer their resources to the workspace owner.
Raises:
AccountNotFoundError: The member account does not exist.
CannotOperateSelfError: The operator tries to remove themselves.
NoPermissionError: The operator cannot remove the member.
MemberNotInTenantError: The account is not a member of the workspace.
ValueError: The workspace has no owner to receive the member's resources.
"""
if self._accounts.get(account_id) is None:
raise AccountNotFoundError()
self.check_permission(workspace_id, operator_id, account_id, "remove")
if self.get_role(workspace_id, account_id) is None:
raise MemberNotInTenantError("Member not in tenant.")
owner_id = (
self._access.owner_id(workspace_id, operator_id)
if self._access.rbac_enabled
else self._workspaces.owner_id(workspace_id)
)
if owner_id is None:
raise ValueError(f"Workspace owner not found for tenant {workspace_id}.")
removal = self._workspaces.remove_member(
workspace_id=workspace_id,
account_id=account_id,
owner_id=owner_id,
actor_account_id=operator_id,
)
self._access.member_removed(workspace_id, removal)
def update_role(self, workspace_id: str, member_id: str, new_role: str, operator_id: str) -> None:
if not TenantAccountRole.is_valid_role(new_role):
raise InvalidWorkspaceMemberRoleError()
self._access.ensure_role_enabled(new_role)
if self._accounts.get(member_id) is None:
raise AccountNotFoundError()
self.check_permission(workspace_id, operator_id, member_id, "update")
role = TenantAccountRole(new_role)
previous = self.get_role(workspace_id, member_id)
if previous is None:
raise MemberNotInTenantError("Member not in tenant.")
# RBAC ownership can be ahead of local membership after a failed local commit.
if previous == TenantAccountRole.OWNER or (
self._access.rbac_enabled and self._access.is_owner(workspace_id, operator_id, member_id)
):
raise NoPermissionError("No permission to update member.")
if role == TenantAccountRole.OWNER and (
self.get_role(workspace_id, operator_id) != TenantAccountRole.OWNER
or (self._access.rbac_enabled and not self._access.is_owner(workspace_id, operator_id, operator_id))
):
raise NoPermissionError("No permission to update member.")
if previous == role:
raise RoleAlreadyAssignedError("The provided role is already assigned to the member.")
previous_owner_account_ids: tuple[str, ...] = ()
if self._access.rbac_enabled:
if role == TenantAccountRole.OWNER:
previous_owner_account_ids = (self._access.owner_id(workspace_id, operator_id),)
self._access.transfer_owner(workspace_id, operator_id, member_id)
else:
self._access.change_role(workspace_id, operator_id, member_id, role)
self._workspaces.update_member_role(
workspace_id=workspace_id,
account_id=member_id,
role=role,
actor_account_id=operator_id,
previous_owner_account_ids=previous_owner_account_ids,
)
class InvitedAccountRegistration(Protocol):
def get_account_by_id(self, account_id: str) -> AccountSnapshot | None: ...
def get_account_by_email_with_case_fallback(self, email: str) -> AccountSnapshot | None: ...
def register(
self,
email: str,
name: str,
*,
language: str | None,
status: str,
is_setup: bool,
check_normalized_email: bool,
) -> AccountSnapshot: ...
class InvitationWorkspaceStore(Protocol):
def get(self, workspace_id: str) -> WorkspaceSnapshot | None: ...
def switch(self, *, account_id: str, workspace_id: str) -> WorkspaceSnapshot: ...
def count_members(self, workspace_id: str) -> int: ...
class WorkspaceInvitationDelivery(Protocol):
@property
def requires_capacity_check(self) -> bool: ...
def acquire(self, workspace_id: str) -> AbstractContextManager[object]: ...
def ensure_role_enabled(self, role: str) -> None: ...
def check_capacity(
self, workspace_id: str, *, current_members: int, new_members: int, new_accounts: int
) -> None: ...
def ensure_allowed(self, workspace_id: str) -> None: ...
def check_invitation_quota(self, workspace_id: str) -> None: ...
def create(self, invitation: InvitationToken) -> str: ...
def send(self, *, language: str, email: str, token: str, inviter_name: str, workspace_name: str) -> None: ...
class WorkspaceInvitationService:
def __init__(
self,
*,
accounts: InvitedAccountRegistration,
workspaces: InvitationWorkspaceStore,
members: WorkspaceMemberService,
invitations: WorkspaceInvitationDelivery,
) -> None:
self._accounts = accounts
self._workspaces = workspaces
self._members = members
self._invitations = invitations
def check_invitation_quota(self, context: RequestContext) -> None:
self._invitations.check_invitation_quota(context.active_workspace_id)
def invite_many(
self, context: RequestContext, *, emails: Sequence[str], language: str | None, role: str
) -> tuple[WorkspaceInvitationResult, ...]:
if not self._members.rbac_enabled and (not TenantAccountRole.is_valid_role(role) or role == "owner"):
raise InvalidWorkspaceMemberRoleError()
self._invitations.ensure_role_enabled(role)
workspace_id = context.active_workspace_id
self._invitations.ensure_allowed(workspace_id)
results: list[WorkspaceInvitationResult] = []
with self._invitations.acquire(workspace_id):
if self._invitations.requires_capacity_check:
new_members, new_accounts = 0, 0
for email in emails:
account = self._accounts.get_account_by_email_with_case_fallback(email)
if account is None:
new_accounts += 1
new_members += 1
elif self._members.get_role(workspace_id, account.id) is None:
new_members += 1
if new_members:
self._invitations.check_capacity(
workspace_id,
current_members=self._workspaces.count_members(workspace_id),
new_members=new_members,
new_accounts=new_accounts,
)
for email in emails:
try:
invitation = self.invite(context, email, language, role)
results.append(WorkspaceInvitationResult(email, "success", token=invitation.token))
except AccountAlreadyInTenantError:
results.append(
WorkspaceInvitationResult(email, "already_member", message="Account already in workspace.")
)
except Exception as error:
results.append(WorkspaceInvitationResult(email, "failed", message=str(error)))
return tuple(results)
def invite(
self,
context: RequestContext,
email: str,
language: str | None,
role: str = "normal",
) -> WorkspaceInvitation:
workspace_id = context.active_workspace_id
inviter_id = context.account_id
inviter = self._accounts.get_account_by_id(inviter_id)
workspace = self._workspaces.get(workspace_id)
if inviter is None:
raise ValueError("Inviter is required")
if workspace is None:
raise WorkspaceNotFoundError()
self._invitations.ensure_allowed(workspace_id)
normalized_email = email.lower()
join_role = TenantAccountRole.NORMAL if self._members.rbac_enabled else TenantAccountRole(role)
account = self._accounts.get_account_by_email_with_case_fallback(email)
requires_setup = False
if account is None:
self._members.check_permission(workspace_id, inviter_id, None, "add")
account = self._accounts.register(
email=normalized_email,
name=normalized_email.split("@")[0],
language=language,
status="pending",
is_setup=True,
check_normalized_email=True,
)
self._members.join_member(
workspace_id=workspace_id,
account_id=account.id,
email=account.email,
role=join_role,
operator_account_id=inviter_id,
)
self._workspaces.switch(account_id=account.id, workspace_id=workspace_id)
requires_setup = True
else:
self._members.check_permission(workspace_id, inviter_id, account.id, "add")
previous_role = self._members.get_role(workspace_id, account.id)
requires_setup = account.status == "pending"
if previous_role is None and (requires_setup or self._members.rbac_enabled):
self._members.join_member(
workspace_id=workspace_id,
account_id=account.id,
email=account.email,
role=join_role,
operator_account_id=inviter_id,
)
if account.status != "pending":
if self._members.rbac_enabled and previous_role is None:
self._members.assign_role(workspace_id, inviter_id, account.id, role)
if previous_role is not None or self._members.rbac_enabled:
raise AccountAlreadyInTenantError("Account already in tenant.")
if self._members.rbac_enabled:
self._members.assign_role(workspace_id, inviter_id, account.id, role)
token = self._invitations.create(InvitationToken(account.id, account.email, workspace_id, role, requires_setup))
self._invitations.send(
language=account.interface_language or "en-US",
email=account.email,
token=token,
inviter_name=inviter.name,
workspace_name=workspace.name,
)
return WorkspaceInvitation(workspace_id, account.id, normalized_email, role, token)
class OwnerTransferGateway(Protocol):
def is_ip_limited(self, ip_address: str) -> bool: ...
def is_verification_limited(self, email: str) -> bool: ...
def record_verification_failure(self, email: str) -> None: ...
def reset_verification_failures(self, email: str) -> None: ...
def send_confirmation(self, account: AccountSnapshot, workspace_name: str, language: str) -> str: ...
def read_token(self, token: str) -> OwnerTransferToken | None: ...
def issue_token(self, token: OwnerTransferToken) -> str: ...
def revoke_token(self, token: str) -> None: ...
def notify(self, *, old_owner: AccountSnapshot, new_owner: AccountSnapshot, workspace_name: str) -> None: ...
class WorkspaceOwnerTransferService:
def __init__(
self,
*,
accounts: AccountSnapshotQuery,
workspaces: WorkspaceMemberStore,
members: WorkspaceMemberService,
challenges: OwnerTransferGateway,
) -> None:
self._accounts = accounts
self._workspaces = workspaces
self._members = members
self._challenges = challenges
def _owner(self, context: RequestContext) -> AccountSnapshot:
if self._members.get_role(context.active_workspace_id, context.account_id) != TenantAccountRole.OWNER:
raise NoPermissionError("Only the workspace owner can transfer ownership.")
owner = self._accounts.get(context.account_id)
if owner is None:
raise AccountNotFoundError()
return owner
def send_code(self, context: RequestContext, *, ip_address: str, language: str | None) -> str:
if self._challenges.is_ip_limited(ip_address):
raise OwnerTransferSendIPLimitedError()
owner = self._owner(context)
workspace = self._workspaces.get(context.active_workspace_id)
if workspace is None:
raise WorkspaceNotFoundError()
return self._challenges.send_confirmation(
owner, workspace.name, "zh-Hans" if language == "zh-Hans" else "en-US"
)
def verify_code(self, context: RequestContext, *, token: str, code: str) -> tuple[str, str]:
owner = self._owner(context)
if self._challenges.is_verification_limited(owner.email):
raise OwnerTransferVerificationLimitError()
challenge = self._challenge(token, owner.email)
if challenge.code != code:
self._challenges.record_verification_failure(owner.email)
raise InvalidOwnerTransferCodeError()
self._challenges.revoke_token(token)
new_token = self._challenges.issue_token(OwnerTransferToken(owner.email, code))
self._challenges.reset_verification_failures(owner.email)
return owner.email, new_token
def _challenge(self, token: str, email: str) -> OwnerTransferToken:
challenge = self._challenges.read_token(token)
if challenge is None:
raise InvalidOwnerTransferTokenError()
if challenge.email != email:
raise InvalidOwnerTransferEmailError()
return challenge
def transfer(self, context: RequestContext, *, member_id: str, token: str) -> None:
owner = self._owner(context)
if owner.id == member_id:
raise CannotOperateSelfError("Cannot transfer ownership to self.")
self._challenge(token, owner.email)
self._challenges.revoke_token(token)
member = self._accounts.get(member_id)
if member is None:
raise AccountNotFoundError()
if self._members.get_role(context.active_workspace_id, member_id) is None:
raise MemberNotInTenantError("The new owner is not a workspace member.")
workspace = self._workspaces.get(context.active_workspace_id)
if workspace is None:
raise WorkspaceNotFoundError()
self._members.update_role(workspace.id, member.id, "owner", owner.id)
self._challenges.notify(old_owner=owner, new_owner=member, workspace_name=workspace.name)
@@ -0,0 +1,196 @@
"""Internal workspace creation and membership use cases."""
from collections.abc import Callable
from typing import Protocol
from enums.account import TenantAccountRole
from services.account.contracts import AccountCreation
from services.account_errors import AccountNormalizedEmailAlreadyInUseError, AccountNotFoundError
from services.entities.account_entities import AccountSnapshot
from services.errors.workspace import (
InvalidWorkspaceMemberRoleError,
WorkSpaceNotAllowedCreateError,
WorkspaceOwnerNotFoundError,
WorkspacesLimitExceededError,
)
from services.workspace.contracts import CreatedWorkspace, WorkspaceCreation, WorkspaceMembership
class WorkspaceOwnerQuery(Protocol):
def find_first_by_email(self, email: str) -> AccountSnapshot | None: ...
def get(self, account_id: str) -> AccountSnapshot | None: ...
def normalized_email_exists(self, email: str) -> bool: ...
class WorkspaceCreationPolicy(Protocol):
def is_workspace_creation_allowed(self) -> bool: ...
def has_workspace_capacity(self) -> bool: ...
class WorkspaceMembershipQuery(Protocol):
def list_ids_for_account(self, account_id: str) -> tuple[str, ...]: ...
def has_active_for_account(self, account_id: str) -> bool: ...
class WorkspaceProvisioningStore(Protocol):
def provision(
self,
prepare: Callable[[], WorkspaceCreation],
*,
owner_id: str | None,
account: AccountCreation | None = None,
only_if_no_active_workspace: bool = False,
) -> CreatedWorkspace | None:
"""Run preparation after eligibility checks, holding any required owner lock through commit."""
...
class WorkspaceProvisioningEffects(Protocol):
def prepare(self, name: str) -> WorkspaceCreation: ...
def bind_owner(self, workspace_id: str, account_id: str) -> None: ...
def created(self, workspace: CreatedWorkspace, *, owner_id: str | None) -> None: ...
def join_default_workspace(self, account_id: str) -> None: ...
class WorkspaceMemberWriter(Protocol):
def join_member(
self,
*,
workspace_id: str,
account_id: str,
email: str,
role: TenantAccountRole,
operator_account_id: str | None,
) -> WorkspaceMembership: ...
class WorkspaceProvisioningService:
def __init__(
self,
*,
owners: WorkspaceOwnerQuery,
provisioning: WorkspaceProvisioningStore,
effects: WorkspaceProvisioningEffects,
policies: WorkspaceCreationPolicy,
memberships: WorkspaceMembershipQuery,
members: WorkspaceMemberWriter,
) -> None:
self._owners = owners
self._provisioning = provisioning
self._effects = effects
self._policies = policies
self._memberships = memberships
self._members = members
def create(self, *, name: str, owner_email: str | None = None) -> CreatedWorkspace:
owner_id = None
if owner_email is not None:
owner = self._owners.find_first_by_email(owner_email)
if owner is None:
raise WorkspaceOwnerNotFoundError()
owner_id = owner.id
if not self._policies.has_workspace_capacity():
raise WorkspacesLimitExceededError()
workspace = self._create(name=name, owner_id=owner_id)
assert workspace is not None
return workspace
def create_owner_workspace(
self, account_id: str, *, name: str | None = None, is_setup: bool = False, if_missing: bool = False
) -> None:
if if_missing and self._memberships.list_ids_for_account(account_id):
return
if not is_setup and not self._policies.is_workspace_creation_allowed():
raise WorkSpaceNotAllowedCreateError()
if not self._policies.has_workspace_capacity():
raise WorkspacesLimitExceededError()
owner = self._owners.get(account_id)
if owner is None:
raise AccountNotFoundError()
self._create(name=name or f"{owner.name}'s Workspace", owner_id=owner.id)
def _create(
self,
*,
name: str,
owner_id: str | None,
account: AccountCreation | None = None,
only_if_no_active_workspace: bool = False,
) -> CreatedWorkspace | None:
def prepare() -> WorkspaceCreation:
creation = self._effects.prepare(name)
if owner_id is not None:
self._effects.bind_owner(creation.id, owner_id)
return creation
workspace = self._provisioning.provision(
prepare,
owner_id=owner_id,
account=account,
only_if_no_active_workspace=only_if_no_active_workspace,
)
if workspace is not None:
self._effects.created(workspace, owner_id=owner_id)
return workspace
def create_with_owner_workspace(
self,
*,
email: str,
name: str,
interface_language: str,
timezone: str,
ip_address: str,
) -> str:
if self._owners.normalized_email_exists(email):
raise AccountNormalizedEmailAlreadyInUseError
account = AccountCreation(
email=email,
name=name,
interface_language=interface_language,
interface_theme="light",
timezone=timezone,
ip_address=ip_address,
check_normalized_email=True,
)
self._create(name=f"{name}'s Workspace", owner_id=account.id, account=account)
self._effects.join_default_workspace(account.id)
return account.id
def ensure_owner_workspace(self, account_id: str) -> None:
owner = self._owners.get(account_id)
if owner is None:
raise AccountNotFoundError
if self._memberships.has_active_for_account(account_id):
return
self._create(name=f"{owner.name}'s Workspace", owner_id=account_id, only_if_no_active_workspace=True)
def join_member(
self,
*,
workspace_id: str,
account_id: str,
email: str,
role: str,
operator_account_id: str | None,
) -> WorkspaceMembership:
try:
member_role = TenantAccountRole(role)
except ValueError as exc:
raise InvalidWorkspaceMemberRoleError("invalid workspace member role.") from exc
if member_role == TenantAccountRole.OWNER:
raise InvalidWorkspaceMemberRoleError("cannot join workspace as owner.")
return self._members.join_member(
workspace_id=workspace_id,
account_id=account_id,
email=email,
role=member_role,
operator_account_id=operator_account_id,
)
@@ -0,0 +1,133 @@
"""Schedule existing resource deletion lifecycles for an enterprise workspace.
This service does not delete the Tenant or its memberships, and does not claim
that publishing child tasks means their physical cleanup has completed.
"""
import logging
from sqlalchemy.orm import Session, sessionmaker
from constants.resource_access_token import ResourceAccessTokenResourceType
from extensions.application_services.resource_access_token import build_resource_access_token_cleanup_service
from repositories.app.console_repository import ConsoleAppRepository
from repositories.knowledge import dataset_api_key_bindings
from repositories.knowledge.dataset_repository import SQLAlchemyDatasetRepository
from repositories.workspace.resource_cleanup_repository import WorkspaceResourceCleanupRepository
from services.agent.home_snapshot_service import AgentHomeSnapshotService
from services.agent.workspace_service import AgentWorkspaceService
from services.app_service import AppService
from services.knowledge.resource_scope import DatasetRef
from tasks.clean_dataset_task import clean_dataset_task
from tasks.collect_agent_resources_task import enqueue_agent_resource_collection
from tasks.remove_app_and_related_data_task import remove_app_and_related_data_task
logger = logging.getLogger(__name__)
class WorkspaceResourceCleanupService:
def __init__(
self,
*,
session_factory: sessionmaker[Session],
apps: ConsoleAppRepository,
datasets: SQLAlchemyDatasetRepository,
agent_resources: WorkspaceResourceCleanupRepository,
) -> None:
# The session factory only serves existing services that require a
# caller-owned session; drop it once they own their persistence.
self._session_factory = session_factory
self._apps = apps
self._datasets = datasets
self._agent_resources = agent_resources
def cleanup(self, workspace_id: str) -> None:
"""Attempt all resource groups; propagate failures to the caller."""
failures: list[str] = []
app_ids = self._apps.list_workspace_app_ids(workspace_id)
dataset_ids = self._datasets.list_workspace_dataset_ids(workspace_id)
for app_id in app_ids:
try:
self._delete_app(workspace_id, app_id)
except Exception:
logger.exception("Workspace App deletion failed: %s:%s", workspace_id, app_id)
failures.append(f"app:{app_id}")
for dataset_id in dataset_ids:
try:
self._delete_dataset(workspace_id, dataset_id)
except Exception:
logger.exception("Workspace Dataset deletion failed: %s:%s", workspace_id, dataset_id)
failures.append(f"dataset:{dataset_id}")
try:
self._retire_agents(workspace_id)
except Exception:
logger.exception("Workspace Agent retirement failed: %s", workspace_id)
failures.append("agents")
if failures:
raise RuntimeError(f"Workspace resource deletion failed for {workspace_id}: {', '.join(failures)}")
def _delete_app(self, workspace_id: str, app_id: str) -> None:
with self._session_factory() as session:
app = AppService.get_app_in_workspace(tenant_id=workspace_id, app_id=app_id, session=session)
if app is not None:
AppService().delete_app(app, session=session, account_id=None)
def _delete_dataset(self, workspace_id: str, dataset_id: str) -> None:
# Inner-API authentication authorizes the whole tenant. No member actor
# is available here; preserve the normal deletion effects without RBAC.
dataset_ref = DatasetRef(workspace_id, dataset_id)
dataset = self._datasets.get_cleanup_record(dataset_ref)
if dataset is None:
return
# Unlike the member deletion signal, also schedule incomplete or
# empty datasets so their relational data is not skipped.
clean_dataset_task.delay(
dataset.id,
workspace_id,
dataset.indexing_technique,
dataset.index_struct,
dataset.collection_binding_id,
dataset.doc_form or "text_model",
dataset.pipeline_id,
)
with self._session_factory.begin() as session:
dataset_api_key_bindings.delete_keys_scoped_only_to(session, dataset.id)
build_resource_access_token_cleanup_service(session=session).delete_resource_relations(
tenant_id=workspace_id,
resource_type=ResourceAccessTokenResourceType.KNOWLEDGE,
resource_id=dataset.id,
)
# Delete the row last so a failed step is retried from the remaining Dataset.
self._datasets.delete(dataset_ref)
def _retire_agents(self, workspace_id: str) -> None:
# Sweep independently of App records: archived, workflow-only and
# backing-App-less Agents must also be collected on repeated requests.
archived = self._agent_resources.archive_agents(workspace_id)
workspace_ids = self._agent_resources.list_agent_workspace_ids(workspace_id)
binding_ids = self._agent_resources.list_agent_workspace_binding_ids(workspace_id)
with self._session_factory.begin() as session:
snapshot_ids = AgentHomeSnapshotService.retire_all_for_tenant(session=session, tenant_id=workspace_id)
# Both retire calls skip resources that are no longer active.
for resource_id in workspace_ids:
AgentWorkspaceService.retire_workspace(
session=session, tenant_id=workspace_id, workspace_id=resource_id
)
for binding_id in binding_ids:
AgentWorkspaceService.retire_binding(session=session, tenant_id=workspace_id, binding_id=binding_id)
self._agent_resources.delete_agent_bindings(workspace_id)
# Backing App records can already be gone; re-publish their idempotent
# related-data cleanup before collecting the archived Agent aggregates.
for app_id in archived.backing_app_ids:
remove_app_and_related_data_task.delay(tenant_id=workspace_id, app_id=app_id)
enqueue_agent_resource_collection(
tenant_id=workspace_id,
binding_ids=binding_ids,
workspace_ids=workspace_ids,
home_snapshot_ids=snapshot_ids,
purge_agent_ids=archived.agent_ids,
)
@@ -0,0 +1,220 @@
"""Workspace management and listing use cases with application-owned ports."""
from collections.abc import Iterator, Mapping, Sequence
from typing import Protocol
from enums import CloudPlan
from machinery.context import RequestContext
from services.errors.file import UnsupportedFileTypeError
from services.errors.workspace import WorkspaceArchivedError, WorkspaceNotFoundError
from services.workspace.contracts import (
EffectiveCreditPool,
WorkspaceCustomConfig,
WorkspaceCustomConfigChanges,
WorkspaceFeatures,
WorkspacePage,
WorkspacePermission,
WorkspaceRecord,
WorkspaceSnapshot,
WorkspaceSummary,
)
class WorkspaceStore(Protocol):
def get(self, workspace_id: str) -> WorkspaceSnapshot | None: ...
def get_many(self, workspace_ids: Sequence[str]) -> tuple[WorkspaceSnapshot, ...]: ...
def list_memberships(self, account_id: str) -> tuple[WorkspaceSnapshot, ...]: ...
def find_membership(self, account_id: str, workspace_id: str) -> WorkspaceSnapshot | None: ...
def list_member_ids(self, workspace_id: str, *, offset: int, limit: int) -> tuple[str, ...]: ...
def list_all(self, *, page: int, limit: int) -> WorkspacePage: ...
def get_for_account(self, workspace_id: str, account_id: str) -> WorkspaceSnapshot | None: ...
def switch(self, *, account_id: str, workspace_id: str) -> WorkspaceSnapshot: ...
def rename(self, *, workspace_id: str, account_id: str, name: str) -> WorkspaceSnapshot: ...
def update_custom_config(
self, *, workspace_id: str, account_id: str, changes: WorkspaceCustomConfig
) -> WorkspaceSnapshot: ...
class WorkspaceFeatureGateway(Protocol):
def get_features(self, workspace_id: str) -> WorkspaceFeatures: ...
def get_effective_credit_pool(self, workspace_id: str) -> EffectiveCreditPool: ...
def logo_url(self, workspace_id: str) -> str: ...
def get_permission(self, workspace_id: str) -> WorkspacePermission: ...
class WorkspaceLogoGateway(Protocol):
def upload(self, context: RequestContext, *, filename: str, content: bytes, mimetype: str) -> str: ...
class WorkspaceService:
def __init__(
self, *, workspaces: WorkspaceStore, features: WorkspaceFeatureGateway, logos: WorkspaceLogoGateway
) -> None:
self._workspaces = workspaces
self._features = features
self._logos = logos
def get(self, workspace_id: str) -> WorkspaceSnapshot | None:
return self._workspaces.get(workspace_id)
def get_many(self, workspace_ids: Sequence[str]) -> tuple[WorkspaceSnapshot, ...]:
return self._workspaces.get_many(workspace_ids)
def list_memberships(self, account_id: str) -> tuple[WorkspaceSnapshot, ...]:
return self._workspaces.list_memberships(account_id)
def find_membership(self, account_id: str, workspace_id: str) -> WorkspaceSnapshot | None:
return self._workspaces.find_membership(account_id, workspace_id)
def iter_member_account_id_batches(self, workspace_id: str, batch_size: int) -> Iterator[tuple[str, ...]]:
if batch_size <= 0:
raise ValueError("batch_size must be positive")
offset = 0
while account_ids := self._workspaces.list_member_ids(workspace_id, offset=offset, limit=batch_size):
yield account_ids
offset += len(account_ids)
def list_all(self, *, page: int, limit: int) -> WorkspacePage:
return self._workspaces.list_all(page=page, limit=limit)
def _current(self, context: RequestContext) -> WorkspaceSnapshot:
workspace = self._workspaces.get_for_account(context.active_workspace_id, context.account_id)
if workspace is None:
raise WorkspaceNotFoundError()
return workspace
def current_summary(self, context: RequestContext) -> dict[str, object]:
workspace = self._current(context)
if workspace.status == "archive":
raise WorkspaceArchivedError()
credits = self.get_effective_credit_pool(workspace.id)
return {
"id": workspace.id,
"name": workspace.name,
"role": workspace.role,
"plan": credits.plan,
"credits": credits.remaining_credits,
}
def get_effective_credit_pool(self, workspace_id: str) -> EffectiveCreditPool:
return self._features.get_effective_credit_pool(workspace_id)
def switch(self, context: RequestContext, workspace_id: str) -> dict[str, object]:
workspace = self._workspaces.switch(account_id=context.account_id, workspace_id=workspace_id)
return self._tenant_info(workspace)
def custom_config(self, context: RequestContext) -> WorkspaceCustomConfig:
return self._public_config(self._current(context))
def update_custom_config(self, context: RequestContext, changes: WorkspaceCustomConfigChanges) -> dict[str, object]:
current = self._current(context).custom_config
config = WorkspaceCustomConfig(
remove_webapp_brand=changes.remove_webapp_brand
if changes.remove_webapp_brand is not None
else current.remove_webapp_brand,
replace_webapp_logo=changes.replace_webapp_logo
if changes.replace_webapp_logo is not None
else current.replace_webapp_logo,
)
workspace = self._workspaces.update_custom_config(
workspace_id=context.active_workspace_id, account_id=context.account_id, changes=config
)
return self._tenant_info(workspace)
def rename(self, context: RequestContext, name: str) -> dict[str, object]:
workspace = self._workspaces.rename(
workspace_id=context.active_workspace_id, account_id=context.account_id, name=name
)
return self._tenant_info(workspace)
def upload_logo(self, context: RequestContext, *, filename: str, content: bytes, mimetype: str) -> str:
if filename.split(".")[-1].lower() not in {"svg", "png"}:
raise UnsupportedFileTypeError()
return self._logos.upload(context, filename=filename, content=content, mimetype=mimetype)
def permission(self, context: RequestContext) -> WorkspacePermission:
return self._features.get_permission(context.active_workspace_id)
def _public_config(self, workspace: WorkspaceSnapshot) -> WorkspaceCustomConfig:
return WorkspaceCustomConfig(
remove_webapp_brand=workspace.custom_config.remove_webapp_brand,
replace_webapp_logo=self._features.logo_url(workspace.id)
if workspace.custom_config.replace_webapp_logo
else None,
)
def _tenant_info(self, workspace: WorkspaceSnapshot) -> dict[str, object]:
# Repository writes have committed and closed before Feature/Billing I/O.
features = self._features.get_features(workspace.id)
credits = features.credits
info: dict[str, object] = {
"id": workspace.id,
"name": workspace.name,
"status": workspace.status,
"created_at": workspace.created_at,
"role": workspace.role,
"plan": credits.plan,
"trial_end_reason": None,
}
# Preserve the existing workspace-wide privileged-member check.
if features.can_replace_logo and workspace.has_privileged_member:
info["custom_config"] = self._public_config(workspace)
if credits.plan is not None:
info["next_credit_reset_date"] = credits.next_credit_reset_date
if credits.quota_limit is not None:
info["trial_credits"] = credits.quota_limit
info["trial_credits_used"] = credits.quota_used
if credits.exhausted_at is not None:
info["trial_credits_exhausted_at"] = credits.exhausted_at
return info
class WorkspacePlanGateway(Protocol):
def resolve_many(self, workspace_ids: Sequence[str]) -> Mapping[str, str]: ...
class WorkspaceQuery(Protocol):
def list_for_account(self, account_id: str) -> Sequence[WorkspaceRecord]: ...
class WorkspaceQueryService:
def __init__(
self,
*,
workspaces: WorkspaceQuery,
plans: WorkspacePlanGateway,
) -> None:
self._workspaces = workspaces
self._plans = plans
def list_for_account(self, context: RequestContext) -> tuple[WorkspaceSummary, ...]:
records = tuple(self._workspaces.list_for_account(context.account_id))
# The repository closes its read Session before plan resolution
# performs Billing/Feature I/O.
plans = self._plans.resolve_many([record.id for record in records])
return tuple(
WorkspaceSummary(
id=record.id,
name=record.name,
plan=plans.get(record.id, CloudPlan.SANDBOX),
status=record.status,
created_at=record.created_at,
last_opened_at=record.last_opened_at,
current=record.id == context.active_workspace_id,
)
for record in records
)