From 75e99ca0712a2c09230e5c6f8d093dc526cc717d Mon Sep 17 00:00:00 2001
From: Tolmachev Igor <me@igorek.dev>
Date: Mon, 20 Apr 2026 20:56:35 +0300
Subject: Add users command

---
 libs/__init__.py |  3 +--
 libs/storage.py  | 75 --------------------------------------------------------
 libs/user.py     | 30 ++++++++++++++++++++---
 3 files changed, 28 insertions(+), 80 deletions(-)
 delete mode 100644 libs/storage.py

(limited to 'libs')

diff --git a/libs/__init__.py b/libs/__init__.py
index 55e6b19..48677db 100644
--- a/libs/__init__.py
+++ b/libs/__init__.py
@@ -1,7 +1,6 @@
-from . import fsm, invoice, msg, storage, user
+from . import fsm, invoice, msg, user
 
 __all__ = [
-    "storage",
     "fsm",
     "msg",
     "user",
diff --git a/libs/storage.py b/libs/storage.py
deleted file mode 100644
index 6220cfc..0000000
--- a/libs/storage.py
+++ /dev/null
@@ -1,75 +0,0 @@
-from pathlib import Path
-from typing import Any, Mapping
-
-from aiofiles import open as open
-from aiogram.fsm.state import State
-from aiogram.fsm.storage.base import (
-    BaseStorage,
-    DefaultKeyBuilder,
-    KeyBuilder,
-    StateType,
-    StorageKey,
-)
-from pydantic import TypeAdapter
-from pydantic.main import BaseModel
-
-
-class Record(BaseModel):
-    data: dict[str, Any] = {}
-    state: str | None = None
-
-
-class JsonStorage(BaseStorage):
-    file_path: Path
-    records: dict[str, Record]
-    records_adapter: TypeAdapter
-    key_builder: KeyBuilder
-
-    def __init__(self, file_path: Path, key_builder: KeyBuilder | None = None) -> None:
-        self.file_path = file_path
-        self.records = {}
-        self.records_adapter = TypeAdapter(dict[str, Record])
-        self.key_builder = DefaultKeyBuilder() if key_builder is None else key_builder
-
-    async def read(self) -> None:
-        async with open(self.file_path, "rb") as file:
-            json = await file.read()
-            self.records = self.records_adapter.validate_json(json)
-
-    async def flush(self) -> None:
-        async with open(self.file_path, "wb") as file:
-            json = self.records_adapter.dump_json(self.records)
-            await file.write(json)
-
-    async def get_record(self, key: StorageKey) -> Record:
-        await self.read()
-        record_key = self.key_builder.build(key)
-        if record_key not in self.records:
-            self.records[record_key] = Record()
-        return self.records[record_key]
-
-    async def set_state(self, key: StorageKey, state: StateType = None) -> None:
-        record = await self.get_record(key)
-        record.state = state.state if isinstance(state, State) else state
-        await self.flush()
-
-    async def get_state(self, key: StorageKey) -> str | None:
-        record = await self.get_record(key)
-        return record.state
-
-    async def set_data(self, key: StorageKey, data: Mapping[str, Any]) -> None:
-        if not isinstance(data, dict):
-            raise TypeError(
-                f"Data must be a dict or dict-like object, got {type(data).__name__}",
-                data,
-            )
-        record = await self.get_record(key)
-        record.data = data.copy()
-        await self.flush()
-
-    async def get_data(self, key: StorageKey) -> dict[str, Any]:
-        record = await self.get_record(key)
-        return record.data
-
-    async def close(self) -> None:
-        await self.flush()
diff --git a/libs/user.py b/libs/user.py
index b201ce9..d145da6 100644
--- a/libs/user.py
+++ b/libs/user.py
@@ -1,5 +1,29 @@
-from aiogram.types import Chat, User
+from aiogram import Bot
 
+from models import UserCache
+from shared import redis_users
 
-def mention(user: User | Chat) -> str:
-    return f'<a href="tg://user?id={user.id}">{user.full_name}</a>'
+
+async def set_user_cache(user_cache: UserCache) -> None:
+    await redis_users.set(
+        str(user_cache.id),
+        user_cache.model_dump_json(
+            exclude_defaults=True,
+            exclude_none=True,
+        ),
+    )
+
+
+async def get_user_cache(user_id: int) -> UserCache | None:
+    user_cache = await redis_users.get(str(user_id))
+    if user_cache is None:
+        return None
+    return UserCache.model_validate_json(user_cache)
+
+
+async def load_user_cache(bot: Bot, user_id: int) -> UserCache:
+    user_cache = await get_user_cache(user_id)
+    if user_cache is None:
+        user_cache = UserCache.from_chat(await bot.get_chat(user_id))
+        await set_user_cache(user_cache)
+    return user_cache
-- 
cgit v1.3