fix(dashboard): fix config copy failing silently in Safari (iOS & macOS)

.github/workflows/build-dev.yml

@@ -2,11 +2,9 @@ name: Build-Docker-dev
 
 on:
   push:
-    branches:
-      - "dev"
-      - "next"
-      - "nats-io"
-
+    branches-ignore: 
+      - main
+
 permissions:
   contents: read
   packages: write

app/models/user.py

@@ -245,7 +245,7 @@ def validate_username(cls, v):
         # Skip validation if username is None (for random strategy)
         if v is None:
             return v
-        return UserValidator.validate_username(v)
+        return UserValidator.validate_username(username=v, len_check=False)
 
     @model_validator(mode="after")
     def validate_username_strategy(self):

app/node/__init__.py

@@ -65,8 +65,8 @@ async def update_node(self, node: Node, max_message_size: int | None = None) ->
 
             self._nodes[node.id] = new_node
 
-        # Stop the old node in the background so we don't block callers.
-        asyncio.create_task(self._shutdown_node(old_node))
+        # Stop the old node after releasing the lock.
+        await self._shutdown_node(old_node)
 
         return new_node
 

app/operation/admin.py

@@ -79,6 +79,9 @@ async def modify_admin(
                 message="You're not allowed to modify sudoer's account. Use pasarguard cli  / tui instead.", code=403
             )
 
+        if db_admin.username == current_admin.username and modified_admin.is_disabled is True:
+            await self.raise_error(message="You're not allowed to disable your own account.", code=403)
+
         if modified_admin.telegram_id is not None:
             existing_admins = await find_admins_by_telegram_id(
                 db, modified_admin.telegram_id, exclude_admin_id=db_admin.id, limit=1

app/operation/user.py

@@ -51,19 +51,18 @@
     ModifyUserByTemplate,
     RemoveUsersResponse,
     UserCreate,
-    UserSimple,
-    UsersSimpleResponse,
     UserModify,
     UsernameGenerationStrategy,
     UserNotificationResponse,
     UserResponse,
+    UserSimple,
     UsersResponse,
+    UsersSimpleResponse,
     UserSubscriptionUpdateChart,
     UserSubscriptionUpdateChartSegment,
     UserSubscriptionUpdateList,
 )
-from app.node.sync import remove_user as sync_remove_user
-from app.node.sync import sync_user, sync_users
+from app.node.sync import remove_user as sync_remove_user, sync_user, sync_users
 from app.operation import BaseOperation, OperatorType
 from app.settings import subscription_settings
 from app.utils.jwt import create_subscription_token
@@ -83,9 +82,9 @@ def _is_non_blocking_sync_operator(operator_type: OperatorType) -> bool:
 
     @staticmethod
     def _format_validation_errors(error: ValidationError) -> str:
-        return "; ".join(
-            [f"{'.'.join(str(loc_part) for loc_part in err['loc'])}: {err['msg']}" for err in error.errors()]
-        )
+        return "; ".join([
+            f"{'.'.join(str(loc_part) for loc_part in err['loc'])}: {err['msg']}" for err in error.errors()
+        ])
 
     @staticmethod
     async def generate_subscription_url(user: UserNotificationResponse):
@@ -105,7 +104,14 @@ async def _generate_usernames(
         count: int,
         strategy: UsernameGenerationStrategy,
         start_number: int | None = None,
+        username_prefix: str | None = None,
+        username_suffix: str | None = None,
     ) -> list[str]:
+        def _apply_affixes(candidate: str) -> str:
+            return (
+                f"{username_prefix if username_prefix else ''}{candidate}{username_suffix if username_suffix else ''}"
+            )
+
         if count <= 0:
             await self.raise_error(message="count must be greater than zero", code=400)
         if start_number is not None and start_number < 0:
@@ -125,7 +131,7 @@ async def _generate_usernames(
                 attempts += 1
                 if attempts > max_attempts:
                     await self.raise_error(message="unable to generate unique usernames", code=500)
-                candidate = secrets.token_hex(6)
+                candidate = _apply_affixes(secrets.token_hex(6))
                 if candidate in seen:
                     continue
                 seen.add(candidate)
@@ -136,7 +142,13 @@ async def _generate_usernames(
             if not base_username:
                 await self.raise_error(message="base username is required for sequence strategy", code=400)
 
-            prefix = base_username
+            sequence_base_username = _apply_affixes(base_username)
+
+            if not (3 <= len(sequence_base_username) <= 128):
+                await self.raise_error(
+                    message="base username with affixes must be between 3 and 128 characters", code=400
+                )
+
             width = 0
             inferred_start_number = 1
 
@@ -146,7 +158,7 @@ async def _generate_usernames(
                 suffix = str(current)
                 if width:
                     suffix = suffix.zfill(width)
-                generated.append(f"{prefix}{suffix}")
+                generated.append(f"{sequence_base_username}{suffix}")
                 current += 1
             return generated
 
@@ -620,16 +632,26 @@ def apply_settings(user_args: UserCreate | UserModify, template: UserTemplate) -
 
         return user_args
 
-    def _build_user_create_from_template(
-        self, user_template: UserTemplate, payload: CreateUserFromTemplate
-    ) -> UserCreate:
-        new_user_args = self.load_base_user_args(user_template)
-        new_user_args["username"] = (
+    @staticmethod
+    def _apply_template_username_affixes(username: str, user_template: UserTemplate) -> str:
+        return (
             f"{user_template.username_prefix if user_template.username_prefix else ''}"
-            f"{payload.username}"
+            f"{username}"
             f"{user_template.username_suffix if user_template.username_suffix else ''}"
         )
 
+    def _build_user_create_from_template(
+        self,
+        user_template: UserTemplate,
+        payload: CreateUserFromTemplate,
+        apply_template_username_affixes: bool = True,
+    ) -> UserCreate:
+        new_user_args = self.load_base_user_args(user_template)
+        username = payload.username
+        if apply_template_username_affixes:
+            username = self._apply_template_username_affixes(username, user_template)
+        new_user_args["username"] = username
+
         try:
             new_user = UserCreate(**new_user_args, note=payload.note)
         except ValidationError as e:
@@ -711,6 +733,8 @@ async def bulk_create_users_from_template(
             count=bulk_users.count,
             strategy=bulk_users.strategy,
             start_number=bulk_users.start_number,
+            username_prefix=user_template.username_prefix,
+            username_suffix=user_template.username_suffix,
         )
 
         def builder(username: str):
@@ -719,7 +743,11 @@ def builder(username: str):
                 user_template_id=template_payload.user_template_id,
                 note=template_payload.note,
             )
-            return self._build_user_create_from_template(user_template, payload)
+            return self._build_user_create_from_template(
+                user_template,
+                payload,
+                apply_template_username_affixes=False,
+            )
 
         users_to_create = self._build_bulk_user_models(candidate_usernames, builder)
 

app/telegram/__init__.py

@@ -7,17 +7,19 @@
 from aiogram.client.session.aiohttp import AiohttpSession
 from aiogram.enums import ParseMode
 from aiogram.exceptions import TelegramBadRequest, TelegramNetworkError, TelegramRetryAfter, TelegramUnauthorizedError
+from aiogram.fsm.storage.memory import MemoryStorage
 from nats.js.kv import KeyValue
 from python_socks._errors import ProxyConnectionError
 
 from app import on_shutdown, on_startup
 from app.models.settings import RunMethod, Telegram
-from app.settings import telegram_settings
-from app.utils.logger import get_logger
 from app.nats import is_nats_enabled
 from app.nats.client import setup_nats_kv
+from app.settings import telegram_settings
+from app.utils.logger import get_logger
 from config import NATS_TELEGRAM_KV_BUCKET
 
+from .fsm_storage import NatsFSMStorage
 from .handlers import include_routers
 from .middlewares import setup_middlewares
 
@@ -29,14 +31,21 @@ def __init__(self):
         self._bot: Bot | None = None
         self._polling_task: asyncio.Task | None = None
         self._lock = Lock()
-        self._dp = Dispatcher()
+        self._dp = self._create_dispatcher()
         self._handlers_registered = False
         self._shutdown_in_progress = False
         self._stop_requested = False
         self._settings_key: tuple | None = None
         self._kv: KeyValue | None = None
         self._nats_conn = None
 
+    @staticmethod
+    def _create_dispatcher() -> Dispatcher:
+        if is_nats_enabled():
+            storage = NatsFSMStorage(NATS_TELEGRAM_KV_BUCKET)
+            return Dispatcher(storage=storage, events_isolation=storage.create_isolation())
+        return Dispatcher(storage=MemoryStorage())
+
     def get_bot(self) -> Bot | None:
         return self._bot
 
@@ -132,6 +141,10 @@ async def shutdown(self):
         async with self._lock:
             self._stop_requested = True
             await self._shutdown_locked()
+            try:
+                await self._dp.fsm.close()
+            except Exception:
+                pass
             # Close NATS KV connection if one was opened
             if self._nats_conn:
                 try: