oldman 0.1.0__py3-none-any.whl

oldman/__init__.py

@@ -0,0 +1,14 @@
+"""
+@author:alex
+@date:2023/12/29
+@time:上午1:23
+"""
+
+__author__ = "alex"
+
+from oldman.runtime.bootstrap import (
+    ServiceBootstrapContext,
+    bootstrap_service,
+)
+
+__all__ = ["ServiceBootstrapContext", "bootstrap_service"]

oldman/apps/__init__.py

@@ -0,0 +1,23 @@
+"""
+@author:alex
+@date:2026/7/14
+@time:18:44
+"""
+
+__author__ = "alex"
+
+from oldman.apps.config import (
+    AppConfig,
+    AppNotInstalledError,
+    AppSettingsNotDefinedError,
+    AppSettingsNotReadyError,
+)
+from oldman.apps.registry import AppRegistry
+
+__all__ = [
+    "AppConfig",
+    "AppNotInstalledError",
+    "AppRegistry",
+    "AppSettingsNotDefinedError",
+    "AppSettingsNotReadyError",
+]

oldman/apps/admin/__init__.py

@@ -0,0 +1,15 @@
+"""Built-in Admin application."""
+
+from oldman.apps.admin.model_admin import AdminUserModelAdmin, ModelAdmin
+from oldman.apps.admin.runtime import install_admin
+from oldman.apps.admin.site import AdminSite, site
+from oldman.apps.admin.users import AdminUserManagementError
+
+__all__ = [
+    "AdminSite",
+    "AdminUserManagementError",
+    "AdminUserModelAdmin",
+    "ModelAdmin",
+    "install_admin",
+    "site",
+]

oldman/apps/admin/apps.py

@@ -0,0 +1,19 @@
+"""Installable Admin application metadata."""
+
+from oldman.apps import AppConfig
+from oldman.apps.admin.settings import AdminSettings
+from oldman.i18n import gettext_lazy as _
+
+
+class AdminAppConfig(AppConfig[AdminSettings]):
+    """Describe the built-in Admin application and its settings owner."""
+
+    label = "admin"
+    display_name = _("Administration")
+    icon = "ri-admin-line"
+    settings_model = AdminSettings
+
+
+app = AdminAppConfig()
+
+__all__ = ["AdminAppConfig", "app"]

oldman/apps/admin/commands.py

@@ -0,0 +1,94 @@
+"""User administration commands provided by the built-in Admin app."""
+
+from __future__ import annotations
+
+import typer
+
+from oldman.auth import (
+    change_user_password,
+    ensure_superuser,
+    get_user_by_username,
+    user_identity,
+)
+from oldman.cli import Command
+from oldman.i18n import gettext
+from oldman.i18n import gettext_lazy as _
+
+
+def _username(value: str | None) -> str:
+    """Return one non-empty username from an option or interactive prompt."""
+    username = (value if value is not None else typer.prompt(gettext("Username"))).strip()
+    if not username:
+        raise ValueError(gettext("Username cannot be empty."))
+    return username
+
+
+def _prompt_password() -> str:
+    """Read one password without exposing it in command arguments or terminal output."""
+    return str(
+        typer.prompt(
+            gettext("Password"),
+            hide_input=True,
+            confirmation_prompt=gettext("Confirm Password"),
+        )
+    )
+
+
+class CreateSuperuser(Command):
+    """Create one new active staff superuser."""
+
+    name = "createsuperuser"
+    help = _("Create Superuser")
+
+    async def handle(
+        self,
+        username: str | None = None,
+        email: str | None = None,
+    ) -> str:
+        """Prompt for missing credentials and create one configured User."""
+        selected_username = _username(username)
+        if await get_user_by_username(selected_username) is not None:
+            raise ValueError(gettext("Username already exists"))
+
+        selected_email = (
+            email
+            if email is not None
+            else str(
+                typer.prompt(
+                    gettext("Email"),
+                    default="",
+                    show_default=False,
+                )
+            )
+        )
+        await ensure_superuser(
+            selected_username,
+            _prompt_password(),
+            selected_email.strip() or None,
+        )
+        return gettext("User created")
+
+
+class ChangePassword(Command):
+    """Change one existing configured User password."""
+
+    name = "changepassword"
+    help = _("Change Password")
+
+    async def handle(self, username: str) -> str:
+        """Find the selected User and replace its password."""
+        selected_username = _username(username)
+        user = await get_user_by_username(selected_username)
+        if user is None:
+            raise ValueError(gettext("User not found."))
+
+        changed = await change_user_password(
+            user_identity(user),
+            _prompt_password(),
+        )
+        if changed is None:
+            raise ValueError(gettext("User not found."))
+        return gettext("Password changed")
+
+
+__all__ = ["ChangePassword", "CreateSuperuser"]

oldman/apps/admin/crud.py

@@ -0,0 +1,94 @@
+"""Admin model identity coercion helpers."""
+
+from __future__ import annotations
+
+import uuid as uuid_pkg
+from decimal import Decimal
+from typing import Any
+
+from sqlalchemy import Integer
+from sqlalchemy.sql.schema import Column
+
+
+def coerce_value(column: Column[Any], value: Any) -> Any:
+    """Coerce a form or identity value through one mapped column's Python type."""
+    value = first_value(value)
+    if value is None:
+        return None
+    if value == "" and column.nullable:
+        return None
+    try:
+        python_type = column.type.python_type
+    except (AttributeError, NotImplementedError):
+        return value
+    if isinstance(value, python_type):
+        return value
+    if python_type is bool:
+        normalized = str(value).strip().lower()
+        if normalized in {"1", "true", "yes", "on"}:
+            return True
+        if normalized in {"0", "false", "no", "off"}:
+            return False
+        raise ValueError(f"Invalid boolean value: {value!r}")
+    try:
+        if python_type is Decimal:
+            return Decimal(str(value))
+        if python_type is uuid_pkg.UUID:
+            return uuid_pkg.UUID(str(value))
+        return python_type(value)
+    except (ArithmeticError, TypeError, ValueError) as exc:
+        raise ValueError(f"Invalid {python_type.__name__} value: {value!r}") from exc
+
+
+def first_value(value: Any) -> Any:
+    """Return a scalar value from Sanic form mappings."""
+    if isinstance(value, (list, tuple)):
+        return value[0] if value else None
+    return value
+
+
+def explicit_primary_key_column(mapper: Any, *, dialect: Any = None) -> Any | None:
+    """Return a key that the active SQLAlchemy dialect cannot generate."""
+    primary_key = list(mapper.primary_key)
+    if len(primary_key) != 1:
+        raise ValueError("Admin models require exactly one primary key column")
+    column = primary_key[0]
+    if column.default is not None or column.server_default is not None or column.identity is not None:
+        return None
+    if not isinstance(column.type, Integer) or column.autoincrement not in {True, "auto", "ignore_fk"}:
+        return column
+    if getattr(column.table, "_autoincrement_column", None) is not column:
+        return column
+
+    if dialect is None:
+        # With no bound session, keep the framework's portable Integer default
+        # while requiring dialect-sensitive subclasses such as BigInteger.
+        return None if type(column.type) is Integer else column
+
+    dialect_name = str(getattr(dialect, "name", "")).lower()
+    if dialect_name == "sqlite":
+        # SQLite generates rowids only when the dialect renders the declared
+        # type as the exact token INTEGER (including Integer with_variant()).
+        rendered_type = str(column.type.compile(dialect=dialect)).strip().upper()
+        if rendered_type == "INTEGER":
+            return None
+        return column
+    if dialect_name in {"cockroachdb", "mariadb", "mssql", "mysql", "postgresql"}:
+        return None
+    return column
+
+
+def session_dialect(session: Any) -> Any | None:
+    """Return the SQLAlchemy dialect bound to a sync or async session."""
+    if session is None:
+        return None
+    bind = None
+    get_bind = getattr(session, "get_bind", None)
+    if callable(get_bind):
+        try:
+            bind = get_bind()
+        except (AttributeError, NotImplementedError):
+            bind = None
+    if bind is None:
+        bind = getattr(session, "bind", None)
+    return getattr(bind, "dialect", None)

oldman/apps/admin/forms.py

@@ -0,0 +1,323 @@
+"""Forms for the built-in Admin user manager."""
+
+from __future__ import annotations
+
+from functools import cache
+from typing import Any, cast
+
+from sqlalchemy import inspect as sqlalchemy_inspect
+from sqlalchemy import select
+from wtforms import (
+    BooleanField,
+    DateTimeLocalField,
+    PasswordField,
+    SelectField,
+    StringField,
+)
+from wtforms.validators import DataRequired, InputRequired, Length, Optional, Regexp
+
+from oldman.apps.admin.crud import explicit_primary_key_column, session_dialect
+from oldman.apps.admin.users import (
+    admin_user_identity_matches,
+    change_admin_user_password,
+)
+from oldman.i18n import gettext, gettext_lazy
+from oldman.web.auth.forms import PASSWORD_MESSAGE, PASSWORD_PATTERN
+from oldman.web.components.forms import (
+    DateTimePickerWidget,
+    FieldLayout,
+    TailwindForm,
+    TailwindModelForm,
+    TailwindTableFilterForm,
+)
+from oldman.web.components.forms.models import model_field_for_column
+
+BOOLEAN_FILTER_CHOICES = (
+    ("", cast(str, gettext_lazy("All"))),
+    ("true", cast(str, gettext_lazy("Yes"))),
+    ("false", cast(str, gettext_lazy("No"))),
+)
+EDITABLE_USER_FIELDS = ("username", "email", "display_name", "is_active", "is_staff", "is_superuser")
+
+
+class AdminLoginForm(TailwindForm):
+    """Collect the built-in Admin login credentials."""
+
+    username = StringField(
+        cast(str, gettext_lazy("Username")),
+        id="username",
+        validators=[DataRequired()],
+        render_kw={
+            "required": True,
+            "autocomplete": "username",
+            "placeholder": gettext_lazy("Enter username"),
+            "autofocus": True,
+        },
+    )
+    password = PasswordField(
+        cast(str, gettext_lazy("Password")),
+        id="password-input",
+        validators=[DataRequired()],
+        render_kw={
+            "required": True,
+            "autocomplete": "current-password",
+            "placeholder": gettext_lazy("Enter password"),
+        },
+    )
+
+
+class AdminUserFilterForm(TailwindTableFilterForm):
+    """Filter the configured Admin user table."""
+
+    q = StringField(
+        cast(str, gettext_lazy("Search")),
+        render_kw={"type": "search", "placeholder": gettext_lazy("Search username, email, display name")},
+    )
+    is_active = SelectField(cast(str, gettext_lazy("Active")), choices=BOOLEAN_FILTER_CHOICES, validators=[Optional()])
+    is_staff = SelectField(cast(str, gettext_lazy("Staff")), choices=BOOLEAN_FILTER_CHOICES, validators=[Optional()])
+    is_superuser = SelectField(cast(str, gettext_lazy("Superuser")), choices=BOOLEAN_FILTER_CHOICES, validators=[Optional()])
+    last_login_from = DateTimeLocalField(
+        cast(str, gettext_lazy("Last Login From")),
+        format="%Y-%m-%dT%H:%M",
+        validators=[Optional()],
+        widget=DateTimePickerWidget(date_format="Y-m-d\\TH:i"),
+    )
+    last_login_to = DateTimeLocalField(
+        cast(str, gettext_lazy("Last Login To")),
+        format="%Y-%m-%dT%H:%M",
+        validators=[Optional()],
+        widget=DateTimePickerWidget(date_format="Y-m-d\\TH:i"),
+    )
+
+    field_layout = (
+        FieldLayout("q", "lg:col-span-4 md:col-span-6"),
+        FieldLayout("is_active", "lg:col-span-2 md:col-span-6"),
+        FieldLayout("is_staff", "lg:col-span-2 md:col-span-6"),
+        FieldLayout("is_superuser", "lg:col-span-2 md:col-span-6"),
+        FieldLayout("last_login_from", "lg:col-span-2 md:col-span-6"),
+        FieldLayout("last_login_to", "lg:col-span-2 md:col-span-6"),
+    )
+
+
+class AdminUserModelForm(TailwindModelForm):
+    """Shared validation and persistence for configured Admin user models."""
+
+    current_user_id: int | None = None
+    confirm_password: Any
+    email: Any
+    password: Any
+    username: Any
+
+    async def clean_username(self) -> str:
+        """Validate username uniqueness before a database constraint can fail."""
+        username = str(self.username.data or "").strip()
+        if self.session is None or not username:
+            return username
+        result = await self.session.execute(select(self.model).where(self.model.username == username))
+        existing = result.scalar_one_or_none()
+        if existing is not None and not self.is_same_instance(existing):
+            self.add_error("username", gettext("Username already exists"))
+        return username
+
+    async def clean_email(self) -> str | None:
+        """Validate optional email uniqueness before persistence."""
+        email = str(self.email.data or "").strip()
+        if not email:
+            return None
+        if self.session is None:
+            return email
+        result = await self.session.execute(select(self.model).where(self.model.email == email))
+        existing = result.scalar_one_or_none()
+        if existing is not None and not self.is_same_instance(existing):
+            self.add_error("email", gettext("Email already exists"))
+        return email
+
+    async def clean_explicit_primary_key(self) -> Any:
+        """Validate a user-supplied primary key before database persistence."""
+        primary_key = list(self.mapper.primary_key)[0]
+        field_name = primary_key.key
+        value = self._fields[field_name].data
+        if self.session is None or value is None or value == "":
+            return value
+        result = await self.session.execute(select(self.model).where(getattr(self.model, field_name) == value))
+        existing = result.scalar_one_or_none()
+        if existing is not None and not self.is_same_instance(existing):
+            self.add_error(
+                field_name,
+                gettext("%(field)s already exists", field=self._fields[field_name].label.text),
+            )
+        return value
+
+    async def clean(self) -> None:
+        """Protect the current user and validate password confirmation."""
+        await super().clean()
+        if self.instance is not None and admin_user_identity_matches(self.instance, self.current_user_id):
+            if self.cleaned_data.get("is_active") is False:
+                self.add_error("is_active", gettext("cannot disable current user"))
+            if self.cleaned_data.get("is_staff") is False:
+                self.add_error("is_staff", gettext("cannot remove current user staff access"))
+            if self.cleaned_data.get("is_superuser") is False:
+                self.add_error("is_superuser", gettext("cannot remove current user superuser access"))
+        if "confirm_password" in self._fields and self.password.data != self.confirm_password.data:
+            self.add_error("confirm_password", gettext("Passwords do not match"))
+
+    async def save(self, *, commit: bool = False, session: Any = None) -> Any:
+        """Persist profile fields and hash the create-form password."""
+        user = await super().save(commit=False)
+        if bool(getattr(user, "is_superuser", False)):
+            user.is_staff = True
+        if "password" in self._fields:
+            change_admin_user_password(user, str(self.password.data or ""))
+        if commit:
+            active_session = session or self.session
+            if active_session is None:
+                raise ValueError("save(commit=True) requires a session")
+            active_session.add(user)
+            flush_result = active_session.flush()
+            import inspect
+
+            if inspect.isawaitable(flush_result):
+                await flush_result
+        return user
+
+    def is_same_instance(self, other: Any) -> bool:
+        """Compare rows without assuming the primary key is named ``id``."""
+        if self.instance is None:
+            return False
+        try:
+            primary_key = list(self.mapper.primary_key)
+            return len(primary_key) == 1 and getattr(other, primary_key[0].key) == getattr(self.instance, primary_key[0].key)
+        except (AttributeError, TypeError):
+            return other is self.instance
+
+    @property
+    def mapper(self):
+        """Return the mapped model metadata used by identity comparisons."""
+        from sqlalchemy import inspect as sqlalchemy_inspect
+
+        return sqlalchemy_inspect(self.model)
+
+
+@cache
+def admin_user_edit_form_class(user_model: type[Any]) -> type[AdminUserModelForm]:
+    """Build a shared ModelForm bound to the configured user model."""
+    return _admin_user_model_form_class(user_model, create=False, include_explicit_primary_key=False)
+
+
+def admin_user_create_form_class(user_model: type[Any], *, session: Any = None, dialect: Any = None) -> type[AdminUserModelForm]:
+    """Build a password-aware ModelForm bound to the configured user model."""
+    mapper = sqlalchemy_inspect(user_model)
+    resolved_dialect = dialect or session_dialect(session)
+    include_primary_key = explicit_primary_key_column(mapper, dialect=resolved_dialect) is not None
+    return _admin_user_model_form_class(
+        user_model,
+        create=True,
+        include_explicit_primary_key=include_primary_key,
+    )
+
+
+@cache
+def _admin_user_model_form_class(
+    user_model: type[Any],
+    *,
+    create: bool,
+    include_explicit_primary_key: bool,
+) -> type[AdminUserModelForm]:
+    mapper = sqlalchemy_inspect(user_model)
+    model_fields = list(EDITABLE_USER_FIELDS)
+    field_layout: list[FieldLayout] = [
+        FieldLayout("username", "md:col-span-6"),
+        FieldLayout("email", "md:col-span-6"),
+        FieldLayout("display_name", "md:col-span-6"),
+    ]
+    fields: dict[str, Any] = {
+        "username": StringField(
+            cast(str, gettext_lazy("Username")),
+            validators=[DataRequired(), Length(max=150)],
+            render_kw={"required": True, "maxlength": 150},
+        ),
+        "email": StringField(
+            cast(str, gettext_lazy("Email")),
+            validators=[Optional(), Length(max=254)],
+            render_kw={"maxlength": 254},
+        ),
+        "display_name": StringField(
+            cast(str, gettext_lazy("Display Name")),
+            validators=[Optional(), Length(max=150)],
+            render_kw={"maxlength": 150},
+        ),
+        "is_active": BooleanField(cast(str, gettext_lazy("Active"))),
+        "is_staff": BooleanField(cast(str, gettext_lazy("Staff"))),
+        "is_superuser": BooleanField(cast(str, gettext_lazy("Superuser"))),
+    }
+    primary_key = list(mapper.primary_key)[0]
+    if not create and primary_key.key in model_fields:
+        # Session identity is backed by the persisted primary key.  Editing it
+        # would orphan the active session and bypass the source self-protection
+        # rules, so custom protocol models may only collect it during create.
+        model_fields.remove(primary_key.key)
+        fields.pop(primary_key.key, None)
+        field_layout = [item for item in field_layout if item.name != primary_key.key]
+    if create:
+        if include_explicit_primary_key:
+            field_name = primary_key.key
+            if field_name not in fields:
+                fields[field_name] = model_field_for_column(primary_key, mapper=mapper)
+                model_fields.insert(0, field_name)
+                field_layout.insert(0, FieldLayout(field_name, "md:col-span-6"))
+            validators = list(fields[field_name].kwargs.get("validators", []))
+            if fields[field_name].field_class is not BooleanField and not any(
+                isinstance(validator, (DataRequired, InputRequired)) for validator in validators
+            ):
+                fields[field_name].kwargs["validators"] = [InputRequired(), *validators]
+            if not hasattr(AdminUserModelForm, f"clean_{field_name}"):
+                fields[f"clean_{field_name}"] = AdminUserModelForm.clean_explicit_primary_key
+        fields.update(
+            password=PasswordField(
+                cast(str, gettext_lazy("Password")),
+                validators=[
+                    DataRequired(),
+                    Length(min=8, max=128),
+                    Regexp(PASSWORD_PATTERN, message=PASSWORD_MESSAGE),
+                ],
+                render_kw={
+                    "required": True,
+                    "minlength": 8,
+                    "maxlength": 128,
+                    "pattern": PASSWORD_PATTERN,
+                    "autocomplete": "new-password",
+                },
+            ),
+            confirm_password=PasswordField(
+                cast(str, gettext_lazy("Confirm Password")),
+                validators=[DataRequired(), Length(min=8, max=128)],
+                render_kw={"required": True, "minlength": 8, "maxlength": 128, "autocomplete": "new-password"},
+            ),
+        )
+        field_layout.extend(
+            (
+                FieldLayout("password", "md:col-span-6"),
+                FieldLayout("confirm_password", "md:col-span-6"),
+            )
+        )
+    field_layout.extend(
+        (
+            FieldLayout("is_active", "md:col-span-4"),
+            FieldLayout("is_staff", "md:col-span-4"),
+            FieldLayout("is_superuser", "md:col-span-4"),
+        )
+    )
+    fields["field_layout"] = tuple(field_layout)
+    fields["Meta"] = type("Meta", (), {"model": user_model, "fields": model_fields})
+    suffix = "CreateForm" if create else "EditForm"
+    return type(f"{user_model.__name__}{suffix}", (AdminUserModelForm,), fields)
+
+
+__all__ = [
+    "AdminLoginForm",
+    "AdminUserFilterForm",
+    "PASSWORD_MESSAGE",
+    "PASSWORD_PATTERN",
+    "admin_user_create_form_class",
+    "admin_user_edit_form_class",
+]