chore: 纳入本地 Dify 1.19.0 源码及品牌与免登改动
演示目录只保留可重建的源码。运行密钥、数据卷、依赖和带口令的本地配置不进入仓库。 Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
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
|
||||
)
|
||||
Reference in new issue
Block a user