Template
mirror of
https://github.com/djimboy/djimbo_template_aio3.git
synced 2026-08-25 22:47:43 +00:00
Update aiogram 3 template
This commit is contained in:
dj
+117
-31
@@ -1,42 +1,128 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import configparser
|
||||
from functools import lru_cache
|
||||
from pathlib import Path
|
||||
from typing import List
|
||||
|
||||
from apscheduler.schedulers.asyncio import AsyncIOScheduler
|
||||
from pydantic import AliasChoices, Field, field_validator
|
||||
from pydantic_settings import BaseSettings, SettingsConfigDict
|
||||
from pytz import UnknownTimeZoneError, timezone
|
||||
|
||||
# Токен бота
|
||||
BOT_TOKEN = configparser.ConfigParser()
|
||||
BOT_TOKEN.read("settings.ini")
|
||||
BOT_TOKEN = BOT_TOKEN['settings']['bot_token'].strip().replace(' ', '')
|
||||
BASE_DIR = Path(__file__).resolve().parents[2]
|
||||
ENV_PATH = BASE_DIR / ".env"
|
||||
|
||||
# Пути к файлам
|
||||
PATH_DATABASE = "tgbot/data/database.db" # Путь к БД
|
||||
PATH_LOGS = "tgbot/data/logs.log" # Путь к Логам
|
||||
|
||||
# Образы и конфиги
|
||||
BOT_STATUS_NOTIFICATION = True # Оповещение админам о запуске бота (True или False)
|
||||
BOT_TIMEZONE = "Europe/Moscow" # Временная зона бота
|
||||
BOT_SCHEDULER = AsyncIOScheduler(timezone=BOT_TIMEZONE) # Образ шедулера
|
||||
# Все настройки из окружения или локального .env
|
||||
class Settings(BaseSettings):
|
||||
model_config = SettingsConfigDict(
|
||||
env_file=ENV_PATH,
|
||||
env_file_encoding="utf-8",
|
||||
extra="ignore",
|
||||
populate_by_name=True,
|
||||
)
|
||||
|
||||
bot_token: str = Field(default="", validation_alias=AliasChoices("BOT_TOKEN", "bot_token"))
|
||||
admin_ids: List[int] = Field(default_factory=list, validation_alias=AliasChoices("BOT_ADMIN_IDS", "admin_id"))
|
||||
database_export: bool = Field(default=False,
|
||||
validation_alias=AliasChoices("BOT_DATABASE_EXPORT", "allow_database_export"))
|
||||
status_notification: bool = Field(default=True, validation_alias="BOT_STATUS_NOTIFICATION")
|
||||
timezone: str = Field(default="Europe/Moscow", validation_alias="BOT_TIMEZONE")
|
||||
database_path: str = Field(default="tgbot/data/database.db", validation_alias="PATH_DATABASE")
|
||||
logs_path: str = Field(default="tgbot/data/logs.log", validation_alias="PATH_LOGS")
|
||||
user_cache_ttl: int = Field(default=300, ge=0, validation_alias="BOT_USER_CACHE_TTL")
|
||||
throttle_rate: float = Field(default=0.5, ge=0, validation_alias="BOT_THROTTLE_RATE")
|
||||
|
||||
@field_validator("bot_token", "timezone", "database_path", "logs_path", mode="before")
|
||||
@classmethod
|
||||
def _strip_string(cls, value: object) -> str:
|
||||
return str(value or "").strip()
|
||||
|
||||
@field_validator("admin_ids", mode="before")
|
||||
@classmethod
|
||||
def _parse_admin_ids(cls, value: object) -> List[int]:
|
||||
if value is None or value == "":
|
||||
return []
|
||||
|
||||
if isinstance(value, int):
|
||||
values = [value]
|
||||
elif isinstance(value, str):
|
||||
values = [admin_id for admin_id in value.replace(" ", "").split(",") if admin_id]
|
||||
elif isinstance(value, (list, tuple, set)):
|
||||
values = list(value)
|
||||
else:
|
||||
raise ValueError("BOT_ADMIN_IDS должен быть числом или списком чисел через запятую")
|
||||
|
||||
admin_ids = []
|
||||
|
||||
for admin_id in values:
|
||||
try:
|
||||
parsed_id = int(admin_id)
|
||||
except (TypeError, ValueError) as error:
|
||||
raise ValueError("BOT_ADMIN_IDS должен содержать только Telegram ID через запятую") from error
|
||||
|
||||
if parsed_id <= 0:
|
||||
raise ValueError("BOT_ADMIN_IDS должен содержать Telegram ID больше нуля")
|
||||
|
||||
admin_ids.append(parsed_id)
|
||||
|
||||
return admin_ids
|
||||
|
||||
@field_validator("timezone")
|
||||
@classmethod
|
||||
def _validate_timezone(cls, value: str) -> str:
|
||||
try:
|
||||
timezone(value)
|
||||
except UnknownTimeZoneError as error:
|
||||
raise ValueError("BOT_TIMEZONE должен быть корректной временной зоной, например Europe/Moscow") from error
|
||||
|
||||
return value
|
||||
|
||||
@field_validator("database_path", "logs_path")
|
||||
@classmethod
|
||||
def _validate_path(cls, value: str) -> str:
|
||||
if not value:
|
||||
raise ValueError("Путь к файлу не должен быть пустым")
|
||||
|
||||
return value
|
||||
|
||||
@property
|
||||
def admins(self) -> List[int]:
|
||||
return list(self.admin_ids)
|
||||
|
||||
def resolve_path(self, path_value: str) -> Path:
|
||||
path = Path(path_value)
|
||||
|
||||
if path.is_absolute():
|
||||
return path
|
||||
|
||||
return BASE_DIR / path
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def get_settings() -> Settings:
|
||||
return Settings()
|
||||
|
||||
|
||||
settings = get_settings()
|
||||
|
||||
# Константы чтобы не ломать старые импорты в шаблоне
|
||||
BOT_TOKEN = settings.bot_token.replace(" ", "")
|
||||
PATH_DATABASE = str(settings.resolve_path(settings.database_path))
|
||||
PATH_LOGS = str(settings.resolve_path(settings.logs_path))
|
||||
BOT_STATUS_NOTIFICATION = settings.status_notification
|
||||
BOT_DATABASE_EXPORT = settings.database_export
|
||||
BOT_TIMEZONE = settings.timezone
|
||||
BOT_USER_CACHE_TTL = settings.user_cache_ttl
|
||||
BOT_THROTTLE_RATE = settings.throttle_rate
|
||||
BOT_SCHEDULER = AsyncIOScheduler(timezone=BOT_TIMEZONE)
|
||||
|
||||
|
||||
# Получение администраторов бота
|
||||
def get_admins() -> list[int]:
|
||||
read_admins = configparser.ConfigParser()
|
||||
read_admins.read('settings.ini')
|
||||
def get_admins() -> List[int]:
|
||||
return settings.admins
|
||||
|
||||
admins = read_admins['settings']['admin_id'].strip().replace(" ", "")
|
||||
|
||||
if "," in admins:
|
||||
admins = admins.split(",")
|
||||
else:
|
||||
if len(admins) >= 1:
|
||||
admins = [admins]
|
||||
else:
|
||||
admins = []
|
||||
|
||||
while "" in admins: admins.remove("")
|
||||
while " " in admins: admins.remove(" ")
|
||||
while "," in admins: admins.remove(",")
|
||||
while "\r" in admins: admins.remove("\r")
|
||||
while "\n" in admins: admins.remove("\n")
|
||||
|
||||
return list(map(int, admins))
|
||||
# Проверка настроек, которые нужны именно для запуска бота
|
||||
def validate_bot_config() -> None:
|
||||
if not BOT_TOKEN:
|
||||
raise RuntimeError("В .env не заполнен параметр BOT_TOKEN")
|
||||
|
||||
@@ -1,2 +1,5 @@
|
||||
from .db_settings import Settingsx, ModelBase as ModelSettings
|
||||
from .db_users import Usersx, ModelBase as ModelUsers
|
||||
from .db_settings import SettingsModel, SettingsRepository
|
||||
from .db_users import UserModel, UsersRepository
|
||||
|
||||
ModelSettings = SettingsModel
|
||||
ModelUsers = UserModel
|
||||
|
||||
@@ -1,494 +0,0 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import sqlite3
|
||||
from typing import Any, Generic, TypeVar, Optional
|
||||
|
||||
from pydantic.fields import FieldInfo
|
||||
from pydantic_core import PydanticUndefinedType
|
||||
|
||||
from tgbot.data.config import PATH_DATABASE
|
||||
from tgbot.database.adb_migration import CONST_MIGRATE_TABLES, CONST_MIGRATE_COLUMNS
|
||||
from tgbot.utils.const_functions import ded
|
||||
|
||||
|
||||
# noinspection PyProtectedMember
|
||||
|
||||
################################################################################
|
||||
############################### SUPPORT FUNCTIONS ##############################
|
||||
# Converting the resulting list into a dictionary
|
||||
def dict_factory(cursor, row) -> dict:
|
||||
save_dict = {}
|
||||
|
||||
for idx, col in enumerate(cursor.description):
|
||||
save_dict[col[0]] = row[idx]
|
||||
|
||||
return save_dict
|
||||
|
||||
|
||||
# Formatting a query without arguments
|
||||
def update_format(sql, parameters: dict) -> tuple[str, list]:
|
||||
values = ", ".join([
|
||||
f"{item} = ?" for item in parameters
|
||||
])
|
||||
sql += f" {values}"
|
||||
|
||||
return sql, list(parameters.values())
|
||||
|
||||
|
||||
# Formatting a query with arguments
|
||||
def update_format_where(sql, parameters: dict) -> tuple[str, list]:
|
||||
sql += " WHERE "
|
||||
|
||||
sql += " AND ".join([
|
||||
f"{item} = ?" for item in parameters
|
||||
])
|
||||
|
||||
return sql, list(parameters.values())
|
||||
|
||||
|
||||
################################################################################
|
||||
################# BASIC CLASS FOR WORKING WITH DATABASE TABLES #################
|
||||
ModelTranslator = TypeVar("ModelTranslator", bound="ModelBase")
|
||||
|
||||
|
||||
class Databasex(Generic[ModelTranslator]):
|
||||
def __init__(self):
|
||||
self.storage_name = "storage"
|
||||
self.column_one = False
|
||||
self.table_model = None
|
||||
|
||||
# Delete entry
|
||||
def delete(self, **kwargs):
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"DELETE FROM {self.storage_name}"
|
||||
sql, parameters = update_format_where(sql, kwargs)
|
||||
|
||||
con.execute(sql, parameters)
|
||||
|
||||
# Clear all entries
|
||||
def clear(self):
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"DELETE FROM {self.storage_name}"
|
||||
|
||||
con.execute(sql)
|
||||
|
||||
# Get entry
|
||||
def get(self, **kwargs) -> Optional[ModelTranslator]:
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"SELECT * FROM {self.storage_name}"
|
||||
sql, parameters = update_format_where(sql, kwargs)
|
||||
|
||||
response = con.execute(sql, parameters).fetchone()
|
||||
|
||||
if response is not None:
|
||||
response = self.table_model(**response)
|
||||
|
||||
return response
|
||||
|
||||
# Get entries
|
||||
def gets(self, **kwargs) -> list[Optional[ModelTranslator]]:
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"SELECT * FROM {self.storage_name}"
|
||||
sql, parameters = update_format_where(sql, kwargs)
|
||||
|
||||
response = con.execute(sql, parameters).fetchall()
|
||||
|
||||
return [self.table_model(**cache_object) for cache_object in response]
|
||||
|
||||
# Get all entries
|
||||
def get_all(self) -> list[Optional[ModelTranslator]]:
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"SELECT * FROM {self.storage_name}"
|
||||
|
||||
response = con.execute(sql).fetchall()
|
||||
|
||||
return [self.table_model(**cache_object) for cache_object in response]
|
||||
|
||||
# Edit entry
|
||||
def update(self, **kwargs):
|
||||
...
|
||||
|
||||
# Export column names, default data, and type hints
|
||||
def fields(self) -> dict[str, list[dict[str, Any]]]:
|
||||
for field_name, field_data in self.table_model.model_fields.items():
|
||||
field_name: str
|
||||
field_data: FieldInfo
|
||||
|
||||
column_data = [
|
||||
{
|
||||
'column': field_name,
|
||||
'type': field_data.annotation,
|
||||
'value': field_data.default,
|
||||
} for field_name, field_data in self.table_model.model_fields.items()
|
||||
]
|
||||
|
||||
return {'column_data': column_data, 'column_one': self.column_one}
|
||||
|
||||
|
||||
################################################################################
|
||||
################################################################################
|
||||
# Export all tables from the Database to a list
|
||||
def database_export_fields_db() -> list:
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
|
||||
database_tables = con.execute("SELECT * FROM sqlite_master where type='table'").fetchall()
|
||||
database_tables_db = [table['name'] for table in database_tables]
|
||||
|
||||
# If there are service tables, remove them from the list of available tables.
|
||||
if "sqlite_sequence" in database_tables_db:
|
||||
database_tables_db.remove("sqlite_sequence")
|
||||
if "sqlite_master" in database_tables_db:
|
||||
database_tables_db.remove("sqlite_master")
|
||||
|
||||
return database_tables_db
|
||||
|
||||
|
||||
# Export all tables, columns, and typehints from structures
|
||||
def database_export_fields_structure() -> dict:
|
||||
# Import all table models
|
||||
import tgbot.database as import_modeles
|
||||
|
||||
# Storing all structure files (db_X.py) in a single list
|
||||
all_tables = [
|
||||
getattr(import_modeles, name)
|
||||
for name in dir(import_modeles)
|
||||
if (
|
||||
isinstance(getattr(import_modeles, name), type) and
|
||||
(name.istitle() and name.endswith("x"))
|
||||
)
|
||||
]
|
||||
|
||||
save_tables = {} # Storage of all sorted and converted tables/columns
|
||||
|
||||
# Iterating through tables and columns
|
||||
for table in all_tables:
|
||||
table_fields = table().fields()
|
||||
|
||||
column_data = table_fields['column_data']
|
||||
column_one = table_fields['column_one']
|
||||
|
||||
cache_columns = []
|
||||
|
||||
# If the table name is not in the dictionary, add it.
|
||||
if table().storage_name not in save_tables:
|
||||
save_tables[table().storage_name] = {
|
||||
'column_one': column_one,
|
||||
'column_datas': [],
|
||||
}
|
||||
|
||||
# Column sorting
|
||||
for table_field in column_data:
|
||||
column_name = table_field['column']
|
||||
column_type = table_field['type'].__name__
|
||||
column_value = table_field['value']
|
||||
|
||||
# Replacing python date types with SQL
|
||||
column_type = column_type.replace(
|
||||
"str", "TEXT",
|
||||
).replace(
|
||||
"int", "INTEGER",
|
||||
).replace(
|
||||
"float", "REAL",
|
||||
)
|
||||
|
||||
# If there is no default value, replace it with - None
|
||||
if isinstance(column_value, PydanticUndefinedType):
|
||||
column_value = None
|
||||
|
||||
# Default values based on type hints
|
||||
if column_type == "TEXT":
|
||||
if "status" in column_name.lower():
|
||||
column_value = "False"
|
||||
else:
|
||||
column_value = "None"
|
||||
elif column_type == "INTEGER":
|
||||
column_value = 0
|
||||
elif column_type == "REAL":
|
||||
column_value = 0.0
|
||||
else:
|
||||
column_value = table_field['value']
|
||||
|
||||
save_tables[table().storage_name]['column_datas'].append(
|
||||
{
|
||||
'column': column_name,
|
||||
'type': column_type,
|
||||
'value': column_value,
|
||||
}
|
||||
)
|
||||
|
||||
return save_tables
|
||||
|
||||
|
||||
################################################################################
|
||||
################################################################################
|
||||
# Database migration
|
||||
def database_migration():
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
|
||||
# If there are values for tables or columns, perform migration.
|
||||
if len(CONST_MIGRATE_TABLES) > 0 or len(CONST_MIGRATE_COLUMNS) > 0:
|
||||
print(f"|| Migrating | Data was found")
|
||||
|
||||
# Export existing tables in the Database
|
||||
database_tables_db = database_export_fields_db()
|
||||
|
||||
# Renaming tables - iterating through tables
|
||||
for table_name_later, table_name_new in CONST_MIGRATE_TABLES.items():
|
||||
if table_name_later in database_tables_db:
|
||||
print(f"|| Migrating | Table '{table_name_later}' renamed to '{table_name_new}' (✓)")
|
||||
con.execute(f"ALTER TABLE {table_name_later} RENAME TO {table_name_new}")
|
||||
else:
|
||||
print(f"|| Migrating | Table '{table_name_later}' for renamed not found (X)")
|
||||
|
||||
# Renaming columns - iterating through tables with columns inside
|
||||
for table_name in CONST_MIGRATE_COLUMNS:
|
||||
if table_name in database_tables_db:
|
||||
# Unloading existing columns from the current table
|
||||
columns_export = [
|
||||
column['name'] for column in con.execute(f"PRAGMA table_info({table_name})").fetchall()
|
||||
]
|
||||
|
||||
# Browsing columns to rename them
|
||||
for column_name_later, column_name_new in CONST_MIGRATE_COLUMNS[table_name].items():
|
||||
if column_name_later in columns_export:
|
||||
print(
|
||||
f"|| Migrating | Column '{column_name_later}' renamed to '{column_name_new}' from table '{table_name}' (✓)"
|
||||
)
|
||||
con.execute(
|
||||
f"ALTER TABLE {table_name} RENAME COLUMN {column_name_later} TO {column_name_new}"
|
||||
)
|
||||
else:
|
||||
print(
|
||||
f"|| Migrating | Column '{column_name_later}' from table '{table_name}' not found (X)"
|
||||
)
|
||||
else:
|
||||
print(f"|| Migrating | Table '{table_name}' for renamed column(s) not found (X)")
|
||||
|
||||
else:
|
||||
print(f"|| Migrating | Data not found")
|
||||
|
||||
print(f"||")
|
||||
|
||||
|
||||
# Checking the relevance of columns (adding new ones, deleting old ones)
|
||||
def database_check_columns():
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
|
||||
symbol_log = True
|
||||
|
||||
# Exporting tables and columns from structures
|
||||
fields_structure = database_export_fields_structure()
|
||||
|
||||
for number, field in enumerate(fields_structure.items()):
|
||||
table_name: str = field[0] # Table name
|
||||
table_data: dict = field[1] # Table data
|
||||
|
||||
column_datas = table_data['column_datas'] # Column name, type, and value
|
||||
|
||||
columns_cache_add = [] # Columns that will be added to the database
|
||||
columns_cache_edit_columns = [] # Columns whose date types will be changed in the database
|
||||
columns_cache_edit_data = None # Which table columns will change date types in the database?
|
||||
|
||||
# Unloading existing columns from the current table
|
||||
column_datas_types_db = [column for column in con.execute(f"PRAGMA table_info({table_name})").fetchall()]
|
||||
|
||||
# Unloading existing column names from the current table
|
||||
columns_export_db = [column['name'] for column in column_datas_types_db]
|
||||
|
||||
# Iterating through columns from a structure
|
||||
for column_structure in column_datas:
|
||||
# If a column from the structure is present in the database table
|
||||
if column_structure['column'] in columns_export_db:
|
||||
columns_export_db.remove(column_structure['column'])
|
||||
|
||||
# Date type of the current column in the Structure
|
||||
column_type_structure = column_structure['type']
|
||||
|
||||
# Date type of the current column in the database
|
||||
column_type_database = [
|
||||
column for column in con.execute(f"PRAGMA table_info({table_name})").fetchall() if
|
||||
column_structure['column'] == column['name']
|
||||
]
|
||||
|
||||
# If the date column type (DB) is in the list, extract it.
|
||||
if len(column_type_database) > 0:
|
||||
column_type_database = column_type_database[0]['type']
|
||||
|
||||
# If the date types differ and have not been saved before, add them to the dictionary.
|
||||
if column_type_structure != column_type_database:
|
||||
if columns_cache_edit_data is None:
|
||||
columns_cache_edit_data = column_datas
|
||||
|
||||
if column_structure['column'] not in columns_cache_edit_columns:
|
||||
columns_cache_edit_columns.append(
|
||||
f"{column_structure['column']}: {column_type_database} -> {column_type_structure} "
|
||||
)
|
||||
else:
|
||||
# If a column from the structure is not present in the database, save it for addition.
|
||||
columns_cache_add.append(column_structure)
|
||||
|
||||
# The remaining columns that are present in the database table but are missing from the structure
|
||||
columns_cache_delete = columns_export_db
|
||||
|
||||
# Adding new columns
|
||||
for column in columns_cache_add:
|
||||
print(f"|| Modification | Column '{column['column']}' added to table '{table_name}'")
|
||||
con.execute(
|
||||
f"ALTER TABLE {table_name} ADD COLUMN {column['column']} {column['type']} DEFAULT '{column['value']}'"
|
||||
)
|
||||
|
||||
# Deleting existing obsolete columns
|
||||
for column in columns_cache_delete:
|
||||
print(f"|| Modification | Column '{column}' deleted from table '{table_name}'")
|
||||
con.execute(f"ALTER TABLE {table_name} DROP COLUMN {column}")
|
||||
|
||||
# Changing the date types of columns in a table
|
||||
sql_edit_columns_create_table = []
|
||||
sql_edit_columns_insert_values = []
|
||||
columns_cache_edit_columns = ", ".join(columns_cache_edit_columns)
|
||||
|
||||
if columns_cache_edit_data is not None:
|
||||
for column in columns_cache_edit_data:
|
||||
if column['type'] == "TEXT":
|
||||
sql_edit_columns_create_table.append(
|
||||
f"{column['column']} {column['type']} DEFAULT '{column['value']}'"
|
||||
)
|
||||
else:
|
||||
sql_edit_columns_create_table.append(
|
||||
f"{column['column']} {column['type']} DEFAULT {column['value']}"
|
||||
)
|
||||
|
||||
sql_edit_columns_insert_values.append(column['column'])
|
||||
|
||||
sql_edit_columns_create_table = ", ".join(sql_edit_columns_create_table)
|
||||
sql_edit_columns_create_table = f"CREATE TABLE {table_name}_new ({sql_edit_columns_create_table})"
|
||||
|
||||
sql_edit_columns_insert_values = ", ".join(sql_edit_columns_insert_values)
|
||||
sql_edit_columns_insert_values = f"INSERT INTO {table_name}_new ({sql_edit_columns_insert_values}) SELECT {sql_edit_columns_insert_values} FROM {table_name}"
|
||||
|
||||
con.execute(sql_edit_columns_create_table) # Creating a new table
|
||||
con.execute(sql_edit_columns_insert_values) # Transferring data from old columns to new ones
|
||||
con.execute(f"DROP TABLE {table_name};")
|
||||
con.execute(f"ALTER TABLE {table_name}_new RENAME TO {table_name};")
|
||||
|
||||
print(
|
||||
f"|| Modification | Columns '{columns_cache_edit_columns}' was edit data type for table '{table_name}'"
|
||||
)
|
||||
|
||||
|
||||
# Creating/deleting tables, columns, and records
|
||||
def database_initialization():
|
||||
print("======== DATABASE PROCESSING ========")
|
||||
database_migration() # Migration check
|
||||
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
|
||||
# List of exported tables and columns from structures
|
||||
database_fields = database_export_fields_structure()
|
||||
|
||||
# List of exported tables from the structure
|
||||
database_tables_import = [table for table in database_fields.keys()]
|
||||
|
||||
# List of tables available in the Database
|
||||
database_tables_db = database_export_fields_db()
|
||||
|
||||
# List of tables to be deleted that are not present in imports but are present in the database
|
||||
database_tables_delete = [
|
||||
table for table in database_tables_db if table not in database_tables_import
|
||||
]
|
||||
|
||||
# Browse the list of imported tables, columns, and default records to create them.
|
||||
for number, db_field in enumerate(database_fields.items()):
|
||||
table_name: str = db_field[0] # Table name
|
||||
table_data: dict = db_field[1] # Table data
|
||||
|
||||
column_one = table_data['column_one'] # Will the table have one record or more
|
||||
column_datas = table_data['column_datas'] # Column name, data type, and value
|
||||
column_len = len(column_datas) # Length (number) of all columns in the table
|
||||
|
||||
# Checking for the required number of records in a table
|
||||
if len(con.execute(f"PRAGMA table_info({table_name})").fetchall()) == column_len:
|
||||
print(f"|| Creating | Table '{table_name}' was found ({number + 1}/{len(database_fields)})")
|
||||
else:
|
||||
print(f"|| Creating | Table '{table_name}' not found ({number + 1}/{len(database_fields)})")
|
||||
|
||||
# Column names with type hints (user_id INTEGER, user_name TEXT)
|
||||
columns_cache_create = []
|
||||
|
||||
# Column names without type hints (user_id, user_name)
|
||||
columns_cache_insert = []
|
||||
|
||||
# Default data for automatic entry into columns (settings, payment systems)
|
||||
columns_values = []
|
||||
|
||||
############################################################
|
||||
##################### CREATING TABLES ######################
|
||||
for column in column_datas:
|
||||
column_name = column['column'] # Table name
|
||||
column_value = column['value'] # Default value in column
|
||||
column_type = column['type'] # Entry data type (INTEGER, TEXT, REAL, ...)
|
||||
|
||||
# Incrementable entry check
|
||||
if column_name == "increment":
|
||||
column_execute_create = "increment INTEGER PRIMARY KEY AUTOINCREMENT"
|
||||
else:
|
||||
column_execute_create = f"{column_name} {column_type}"
|
||||
|
||||
columns_cache_insert.append(column_name)
|
||||
columns_cache_create.append(column_execute_create)
|
||||
|
||||
# If default data is available, add it.
|
||||
if column_one and column_value is not None:
|
||||
columns_values.append(column_value)
|
||||
|
||||
# Collecting a request with all added columns
|
||||
column_execute_create = ",\n".join(columns_cache_create)
|
||||
column_execute_create = ded(f"""
|
||||
CREATE TABLE IF NOT EXISTS {table_name}(
|
||||
{column_execute_create}
|
||||
)
|
||||
""")
|
||||
|
||||
# Request to create a table and columns
|
||||
con.execute(column_execute_create)
|
||||
|
||||
############################################################
|
||||
####################### ADDING ENTRY #######################
|
||||
# If there is a record to add and the table supports only one record
|
||||
if column_one and len(columns_values) > 0:
|
||||
column_check_have = con.execute(f"SELECT * FROM {table_name}").fetchall()
|
||||
|
||||
# If there is no entry in the table, add it.
|
||||
if len(column_check_have) == 0:
|
||||
# Request collection
|
||||
column_execute_insert = ",\n".join(columns_cache_insert)
|
||||
column_execute_insert = ded(f"""
|
||||
INSERT INTO {table_name}(
|
||||
{column_execute_insert}
|
||||
)
|
||||
VALUES ({"?," * (len(columns_cache_insert) - 1) + "?"})
|
||||
""")
|
||||
|
||||
# Request to add entries to the table
|
||||
con.execute(column_execute_insert, columns_values)
|
||||
|
||||
print(f"|| Creating | Table '{table_name}' was created ({number + 1}/{len(database_fields)})")
|
||||
|
||||
# If there are tables to be deleted, delete them.
|
||||
if len(database_tables_delete) > 0:
|
||||
for table_name in database_tables_delete:
|
||||
print(f"|| Database | Table '{table_name}' was deleted")
|
||||
con.execute(f"DROP TABLE {table_name}")
|
||||
|
||||
print("||")
|
||||
database_check_columns() # Checking the relevance of columns
|
||||
print("=====================================")
|
||||
print()
|
||||
@@ -1,36 +0,0 @@
|
||||
# Example with migration - Tables
|
||||
#
|
||||
# CONST_MIGRATE_TABLES = {
|
||||
# 'old_table_name1': 'new_table_name1',
|
||||
# 'old_table_name2': 'new_table_name2',
|
||||
# }
|
||||
|
||||
|
||||
# Example with migration - Columns
|
||||
# CONST_MIGRATE_COLUMNS = {
|
||||
# 'name_of_the_table_in_which_the_column_is_located1': {
|
||||
# 'old_column_name11': 'new_column_name11',
|
||||
# 'old_column_name12': 'new_column_name12',
|
||||
# },
|
||||
# 'name_of_the_table_in_which_the_column_is_located2': {
|
||||
# 'old_column_name21': 'new_column_name21',
|
||||
# 'old_column_name22': 'new_column_name22',
|
||||
# },
|
||||
# }
|
||||
|
||||
|
||||
################################################################################
|
||||
############################### MIGRATION TABLES ###############################
|
||||
CONST_MIGRATE_TABLES = {
|
||||
# 'storage_refillme': 'storage_refill',
|
||||
# 'storage_purchasesme': 'storage_purchases',
|
||||
}
|
||||
|
||||
################################################################################
|
||||
############################### MIGRATION COLUMNS ##############################
|
||||
CONST_MIGRATE_COLUMNS = {
|
||||
# 'storage_refill': {
|
||||
# 'refill_methodme': 'refill_method',
|
||||
# 'refill_amountme': 'refill_amount',
|
||||
# },
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from collections.abc import AsyncIterator
|
||||
from contextlib import AbstractAsyncContextManager, asynccontextmanager
|
||||
from pathlib import Path
|
||||
|
||||
from sqlalchemy import event
|
||||
from sqlalchemy.ext.asyncio import AsyncAttrs, AsyncSession, async_sessionmaker, create_async_engine
|
||||
from sqlalchemy.orm import DeclarativeBase
|
||||
|
||||
from tgbot.data.config import PATH_DATABASE
|
||||
|
||||
database_path = Path(PATH_DATABASE)
|
||||
database_url = f"sqlite+aiosqlite:///{database_path.as_posix()}"
|
||||
|
||||
engine = create_async_engine(database_url, echo=False)
|
||||
session_factory = async_sessionmaker(engine, expire_on_commit=False)
|
||||
|
||||
|
||||
# Общая база для всех SQLAlchemy-моделей
|
||||
class Base(AsyncAttrs, DeclarativeBase):
|
||||
pass
|
||||
|
||||
|
||||
# SQLite по умолчанию не включает foreign keys, поэтому включаем явно
|
||||
@event.listens_for(engine.sync_engine, "connect")
|
||||
def _enable_sqlite_foreign_keys(dbapi_connection, connection_record) -> None:
|
||||
cursor = dbapi_connection.cursor()
|
||||
cursor.execute("PRAGMA foreign_keys=ON")
|
||||
cursor.close()
|
||||
|
||||
|
||||
# Открываем сессию и сами отвечаем за сохранение или откат
|
||||
@asynccontextmanager
|
||||
async def _session_scope() -> AsyncIterator[AsyncSession]:
|
||||
async with session_factory() as session:
|
||||
try:
|
||||
yield session
|
||||
await session.commit()
|
||||
except Exception:
|
||||
await session.rollback()
|
||||
raise
|
||||
|
||||
|
||||
# Отдельная обертка, чтобы IDE нормально видела асинхронный контекст
|
||||
def session_scope() -> AbstractAsyncContextManager[AsyncSession]:
|
||||
return _session_scope()
|
||||
|
||||
|
||||
# Закрываем пул соединений при остановке приложения
|
||||
async def close_database() -> None:
|
||||
await engine.dispose()
|
||||
@@ -1,43 +1,61 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import sqlite3
|
||||
from sqlalchemy import Boolean, Integer
|
||||
from sqlalchemy import update as sqlalchemy_update
|
||||
from sqlalchemy.dialects.sqlite import insert
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
from tgbot.data.config import PATH_DATABASE
|
||||
from tgbot.database.adb_helper import Databasex, dict_factory, update_format
|
||||
from tgbot.database.core import Base, session_scope
|
||||
from tgbot.database.repository import BaseRepository
|
||||
|
||||
|
||||
# Table model
|
||||
class ModelBase(BaseModel):
|
||||
status_work: str # Status bot work
|
||||
# Модель настроек бота
|
||||
class SettingsModel(Base):
|
||||
__tablename__ = "storage_settings"
|
||||
|
||||
class Config:
|
||||
json_schema_extra = {
|
||||
'storage_name': 'storage_settings'
|
||||
}
|
||||
id: Mapped[int] = mapped_column(Integer, primary_key=True, default=1)
|
||||
status_work: Mapped[bool] = mapped_column(Boolean, nullable=False, default=False)
|
||||
|
||||
|
||||
# Settings
|
||||
class Settingsx(Databasex[ModelBase]):
|
||||
ModelBase = SettingsModel
|
||||
BaseModel = SettingsModel
|
||||
|
||||
|
||||
# Репозиторий настроек бота
|
||||
class SettingsRepository(BaseRepository[SettingsModel]):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.table_model = ModelBase
|
||||
self.storage_name = self.table_model.model_json_schema()['storage_name']
|
||||
self.column_one = True
|
||||
self.table_model = SettingsModel
|
||||
self.storage_name = SettingsModel.__tablename__
|
||||
|
||||
# Get entry
|
||||
def get(self) -> ModelBase:
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"SELECT * FROM {self.storage_name}"
|
||||
# Создание строки настроек если их еще нет
|
||||
async def ensure_default(self) -> None:
|
||||
statement = insert(SettingsModel).values(id=1, status_work=False)
|
||||
statement = statement.on_conflict_do_nothing(index_elements=[SettingsModel.id])
|
||||
|
||||
return ModelBase(**con.execute(sql).fetchone())
|
||||
async with session_scope() as session:
|
||||
await session.execute(statement)
|
||||
|
||||
# Edit entry
|
||||
def update(self, **kwargs):
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"UPDATE {self.storage_name} SET"
|
||||
sql, parameters = update_format(sql, kwargs)
|
||||
# Настройки должны быть всегда, поэтому при пустой таблице создаем дефолт
|
||||
async def get(self) -> SettingsModel:
|
||||
settings = await super().get(id=1)
|
||||
|
||||
con.execute(sql, parameters)
|
||||
if settings is None:
|
||||
await self.ensure_default()
|
||||
settings = await super().get(id=1)
|
||||
|
||||
if settings is None:
|
||||
raise RuntimeError("Настройки бота по умолчанию не сохранились")
|
||||
|
||||
return settings
|
||||
|
||||
# Обновление единственной строки настроек
|
||||
async def update(self, **kwargs) -> None:
|
||||
if not kwargs:
|
||||
return
|
||||
|
||||
async with session_scope() as session:
|
||||
await session.execute(
|
||||
sqlalchemy_update(SettingsModel)
|
||||
.where(SettingsModel.id == 1)
|
||||
.values(**kwargs)
|
||||
)
|
||||
|
||||
+87
-59
@@ -1,78 +1,106 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import sqlite3
|
||||
from sqlalchemy import BigInteger, Integer, String, or_
|
||||
from sqlalchemy import update as sqlalchemy_update
|
||||
from sqlalchemy.dialects.sqlite import insert
|
||||
from sqlalchemy.orm import Mapped, mapped_column
|
||||
|
||||
from pydantic import BaseModel
|
||||
|
||||
from tgbot.data.config import PATH_DATABASE
|
||||
from tgbot.database.adb_helper import Databasex, dict_factory, update_format
|
||||
from tgbot.utils.const_functions import get_unix, ded
|
||||
from tgbot.database.core import Base, session_scope
|
||||
from tgbot.database.repository import BaseRepository
|
||||
from tgbot.utils.const_functions import get_unix
|
||||
|
||||
|
||||
# Table model
|
||||
class ModelBase(BaseModel):
|
||||
increment: int # increment
|
||||
user_id: int # User id
|
||||
user_login: str # User username
|
||||
user_name: str # User name
|
||||
user_surname: str # User surname
|
||||
user_fullname: str # User fullname (name + surname)
|
||||
user_unix: int # Date of user registration in the bot (in UNIX time)
|
||||
# Модель пользователя Telegram
|
||||
class UserModel(Base):
|
||||
__tablename__ = "storage_users"
|
||||
|
||||
class Config:
|
||||
json_schema_extra = {
|
||||
'storage_name': 'storage_users'
|
||||
}
|
||||
increment: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
|
||||
user_id: Mapped[int] = mapped_column(BigInteger, nullable=False, unique=True, index=True)
|
||||
user_login: Mapped[str] = mapped_column(String(255), nullable=False, default="")
|
||||
user_name: Mapped[str] = mapped_column(String(255), nullable=False, default="")
|
||||
user_surname: Mapped[str] = mapped_column(String(255), nullable=False, default="")
|
||||
user_fullname: Mapped[str] = mapped_column(String(511), nullable=False, default="")
|
||||
user_unix: Mapped[int] = mapped_column(Integer, nullable=False, default=get_unix)
|
||||
|
||||
|
||||
# Users
|
||||
class Usersx(Databasex[ModelBase]):
|
||||
ModelBase = UserModel
|
||||
BaseModel = UserModel
|
||||
|
||||
|
||||
# Репозиторий пользователей
|
||||
class UsersRepository(BaseRepository[UserModel]):
|
||||
def __init__(self):
|
||||
super().__init__()
|
||||
self.table_model = ModelBase
|
||||
self.storage_name = self.table_model.model_json_schema()['storage_name']
|
||||
self.column_one = False
|
||||
self.table_model = UserModel
|
||||
self.storage_name = UserModel.__tablename__
|
||||
|
||||
# Add entry
|
||||
def add(
|
||||
# Для совместимости add ведет себя как upsert
|
||||
async def add(
|
||||
self,
|
||||
user_id: int,
|
||||
user_login: str,
|
||||
user_name: str,
|
||||
user_surname: str,
|
||||
user_fullname: str,
|
||||
):
|
||||
user_unix = get_unix()
|
||||
) -> UserModel:
|
||||
return await self.upsert(
|
||||
user_id=user_id,
|
||||
user_login=user_login,
|
||||
user_name=user_name,
|
||||
user_surname=user_surname,
|
||||
user_fullname=user_fullname,
|
||||
)
|
||||
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
# Создание пользователя или обновление его данных по user_id
|
||||
async def upsert(
|
||||
self,
|
||||
user_id: int,
|
||||
user_login: str,
|
||||
user_name: str,
|
||||
user_surname: str,
|
||||
user_fullname: str,
|
||||
) -> UserModel:
|
||||
statement = insert(UserModel).values(
|
||||
user_id=user_id,
|
||||
user_login=user_login,
|
||||
user_name=user_name,
|
||||
user_surname=user_surname,
|
||||
user_fullname=user_fullname,
|
||||
user_unix=get_unix(),
|
||||
)
|
||||
statement = statement.on_conflict_do_update(
|
||||
index_elements=[UserModel.user_id],
|
||||
set_={
|
||||
"user_login": statement.excluded.user_login,
|
||||
"user_name": statement.excluded.user_name,
|
||||
"user_surname": statement.excluded.user_surname,
|
||||
"user_fullname": statement.excluded.user_fullname,
|
||||
},
|
||||
where=or_(
|
||||
UserModel.user_login != statement.excluded.user_login,
|
||||
UserModel.user_name != statement.excluded.user_name,
|
||||
UserModel.user_surname != statement.excluded.user_surname,
|
||||
UserModel.user_fullname != statement.excluded.user_fullname,
|
||||
),
|
||||
)
|
||||
|
||||
con.execute(
|
||||
ded(f"""
|
||||
INSERT INTO {self.storage_name} (
|
||||
user_id,
|
||||
user_login,
|
||||
user_name,
|
||||
user_surname,
|
||||
user_fullname,
|
||||
user_unix
|
||||
) VALUES (?, ?, ?, ?, ?, ?)
|
||||
"""),
|
||||
[
|
||||
user_id,
|
||||
user_login,
|
||||
user_name,
|
||||
user_surname,
|
||||
user_fullname,
|
||||
user_unix,
|
||||
],
|
||||
async with session_scope() as session:
|
||||
await session.execute(statement)
|
||||
|
||||
user = await self.get(user_id=user_id)
|
||||
|
||||
if user is None:
|
||||
raise RuntimeError("Пользователь не сохранился")
|
||||
|
||||
return user
|
||||
|
||||
# Обновление пользователя по Telegram ID
|
||||
async def update(self, user_id: int, **kwargs) -> None:
|
||||
if not kwargs:
|
||||
return
|
||||
|
||||
async with session_scope() as session:
|
||||
await session.execute(
|
||||
sqlalchemy_update(UserModel)
|
||||
.where(UserModel.user_id == user_id)
|
||||
.values(**kwargs)
|
||||
)
|
||||
|
||||
# Edit entry
|
||||
def update(self, user_id: int, **kwargs):
|
||||
with sqlite3.connect(PATH_DATABASE) as con:
|
||||
con.row_factory = dict_factory
|
||||
sql = f"UPDATE {self.storage_name} SET"
|
||||
sql, parameters = update_format(sql, kwargs)
|
||||
parameters.append(user_id)
|
||||
|
||||
con.execute(sql + "WHERE user_id = ?", parameters)
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import asyncio
|
||||
from contextlib import AbstractAsyncContextManager
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
from alembic import command
|
||||
from alembic.config import Config
|
||||
from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
|
||||
|
||||
from tgbot.database.core import database_url
|
||||
|
||||
PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
||||
ALEMBIC_INI = PROJECT_ROOT / "alembic.ini"
|
||||
MIGRATIONS_DIR = PROJECT_ROOT / "migrations"
|
||||
|
||||
|
||||
# Собираем конфиг Alembic так, чтобы команды работали из любой папки
|
||||
def get_alembic_config(url: str = database_url) -> Config:
|
||||
config = Config(str(ALEMBIC_INI))
|
||||
config.set_main_option("script_location", str(MIGRATIONS_DIR))
|
||||
config.set_main_option("sqlalchemy.url", url)
|
||||
|
||||
return config
|
||||
|
||||
|
||||
# Применяем все миграции до последней версии
|
||||
async def run_migrations(engine: Optional[AsyncEngine] = None) -> None:
|
||||
if engine is None:
|
||||
config = get_alembic_config()
|
||||
loop = asyncio.get_running_loop()
|
||||
await loop.run_in_executor(None, command.upgrade, config, "head")
|
||||
return
|
||||
|
||||
config = get_alembic_config(str(engine.url))
|
||||
|
||||
async with engine_context(engine) as connection:
|
||||
await connection.run_sync(_upgrade_with_connection, config)
|
||||
|
||||
|
||||
# Отдельная обертка нужна, чтобы IDE корректно видела async context manager
|
||||
def engine_context(engine: AsyncEngine) -> AbstractAsyncContextManager[AsyncConnection]:
|
||||
return engine.begin()
|
||||
|
||||
|
||||
# Alembic умеет работать с синхронным соединением внутри async-engine
|
||||
def _upgrade_with_connection(connection, config: Config) -> None:
|
||||
config.attributes["connection"] = connection
|
||||
command.upgrade(config, "head")
|
||||
|
||||
|
||||
# Ручной запуск миграций из консоли
|
||||
async def _main() -> None:
|
||||
await run_migrations()
|
||||
print("Миграции базы данных применены")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(_main())
|
||||
@@ -0,0 +1,106 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from typing import Generic, List, Optional, Type, TypeVar
|
||||
|
||||
from sqlalchemy import delete as sqlalchemy_delete
|
||||
from sqlalchemy import select
|
||||
from sqlalchemy import update as sqlalchemy_update
|
||||
from sqlalchemy.exc import SQLAlchemyError
|
||||
|
||||
from tgbot.database.core import Base, database_path, session_scope
|
||||
from tgbot.utils.misc.bot_logging import bot_logger
|
||||
|
||||
ModelTranslator = TypeVar("ModelTranslator", bound=Base)
|
||||
|
||||
|
||||
# Базовый репозиторий с общими методами работы с БД
|
||||
class BaseRepository(Generic[ModelTranslator]):
|
||||
def __init__(self):
|
||||
self.storage_name = "storage"
|
||||
self.table_model: Optional[Type[ModelTranslator]] = None
|
||||
|
||||
# Без модели репозиторий работать не должен
|
||||
def _model(self) -> Type[ModelTranslator]:
|
||||
if self.table_model is None:
|
||||
raise RuntimeError("Модель базы данных не настроена")
|
||||
|
||||
return self.table_model
|
||||
|
||||
# Удаление только по явному фильтру, без случайной чистки всей таблицы
|
||||
async def delete(self, **kwargs) -> None:
|
||||
if not kwargs:
|
||||
raise ValueError("Для удаления нужен хотя бы один фильтр")
|
||||
|
||||
model = self._model()
|
||||
|
||||
async with session_scope() as session:
|
||||
await session.execute(sqlalchemy_delete(model).filter_by(**kwargs))
|
||||
|
||||
# Полное удаление всех строк таблицы. Название намеренно прямое.
|
||||
async def delete_all_rows(self) -> None:
|
||||
model = self._model()
|
||||
|
||||
async with session_scope() as session:
|
||||
await session.execute(sqlalchemy_delete(model))
|
||||
|
||||
# Возвращение первой записи по фильтру
|
||||
async def get(self, **kwargs) -> Optional[ModelTranslator]:
|
||||
model = self._model()
|
||||
statement = select(model).filter_by(**kwargs)
|
||||
|
||||
async with session_scope() as session:
|
||||
response = await session.execute(statement)
|
||||
|
||||
return response.scalars().first()
|
||||
|
||||
# Возвращение всех записей по фильтру
|
||||
async def gets(self, **kwargs) -> List[ModelTranslator]:
|
||||
model = self._model()
|
||||
statement = select(model).filter_by(**kwargs)
|
||||
|
||||
async with session_scope() as session:
|
||||
response = await session.execute(statement)
|
||||
|
||||
return list(response.scalars().all())
|
||||
|
||||
# Возвращение всей таблицы
|
||||
async def get_all(self) -> List[ModelTranslator]:
|
||||
model = self._model()
|
||||
|
||||
async with session_scope() as session:
|
||||
response = await session.execute(select(model))
|
||||
|
||||
return list(response.scalars().all())
|
||||
|
||||
# Обновляем только записи, которые попали под фильтр
|
||||
async def update(self, filters: dict, **kwargs) -> None:
|
||||
if not filters:
|
||||
raise ValueError("Для обновления нужен хотя бы один фильтр")
|
||||
|
||||
if not kwargs:
|
||||
return
|
||||
|
||||
model = self._model()
|
||||
|
||||
async with session_scope() as session:
|
||||
await session.execute(
|
||||
sqlalchemy_update(model)
|
||||
.filter_by(**filters)
|
||||
.values(**kwargs)
|
||||
)
|
||||
|
||||
|
||||
# Готовим подключение к БД. Сами миграции запускаются отдельно через migrate.py.
|
||||
async def prepare_database() -> None:
|
||||
database_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Импортируем модели, чтобы репозитории работали с уже загруженными таблицами
|
||||
import tgbot.database # noqa: F401
|
||||
|
||||
from tgbot.database.db_settings import SettingsRepository
|
||||
|
||||
try:
|
||||
await SettingsRepository().ensure_default()
|
||||
except SQLAlchemyError as error:
|
||||
raise RuntimeError("База данных не готова. Запусти миграции командой: python migrate.py") from error
|
||||
|
||||
bot_logger.info("База данных готова")
|
||||
@@ -5,31 +5,31 @@ from aiogram.utils.keyboard import InlineKeyboardBuilder
|
||||
from tgbot.utils.const_functions import ikb
|
||||
|
||||
|
||||
# Inline keyboards for users
|
||||
# Инлайн-клавиатура для пользователя
|
||||
def user_finl() -> InlineKeyboardMarkup:
|
||||
keyboard = InlineKeyboardBuilder()
|
||||
|
||||
keyboard.row(
|
||||
ikb("User X", data="user_inline_x"),
|
||||
ikb("User 1", data="user_inline:user_btn"),
|
||||
ikb("User 2", data="..."),
|
||||
ikb("Действие", data="user_inline_x"),
|
||||
ikb("Раздел", data="user_inline:user_btn"),
|
||||
ikb("Скоро", data="..."),
|
||||
).row(
|
||||
ikb("User Unknown", data="unknown"),
|
||||
ikb("Неизвестная кнопка", data="unknown"),
|
||||
)
|
||||
|
||||
return keyboard.as_markup()
|
||||
|
||||
|
||||
# Inline keyboards for admins
|
||||
# Инлайн-клавиатура для админа
|
||||
def admin_finl() -> InlineKeyboardMarkup:
|
||||
keyboard = InlineKeyboardBuilder()
|
||||
|
||||
keyboard.row(
|
||||
ikb("Admin X", data="admin_inline_x"),
|
||||
ikb("Admin 1", data="admin_inline:admin_btn"),
|
||||
ikb("Admin 2", data="..."),
|
||||
ikb("Действие", data="admin_inline_x"),
|
||||
ikb("Раздел", data="admin_inline:admin_btn"),
|
||||
ikb("Скоро", data="..."),
|
||||
).row(
|
||||
ikb("Admin Unknown", data="unknown"),
|
||||
ikb("Неизвестная кнопка", data="unknown"),
|
||||
)
|
||||
|
||||
return keyboard.as_markup()
|
||||
|
||||
@@ -11,12 +11,12 @@ def menu_frep(user_id: int) -> ReplyKeyboardMarkup:
|
||||
keyboard = ReplyKeyboardBuilder()
|
||||
|
||||
keyboard.row(
|
||||
rkb("User button"),
|
||||
rkb("Пользовательское меню"),
|
||||
)
|
||||
|
||||
if user_id in get_admins():
|
||||
keyboard.row(
|
||||
rkb("Admin button"),
|
||||
rkb("Админ-меню"),
|
||||
)
|
||||
|
||||
return keyboard.as_markup(resize_keyboard=True)
|
||||
|
||||
@@ -5,9 +5,16 @@ from tgbot.middlewares.middleware_throttling import ThrottlingMiddleware
|
||||
from tgbot.middlewares.middleware_user import ExistsUserMiddleware
|
||||
|
||||
|
||||
# Register all middlewares
|
||||
def register_all_middlwares(dp: Dispatcher):
|
||||
# Подключение всех мидлварей
|
||||
def register_all_middlewares(dp: Dispatcher):
|
||||
dp.callback_query.outer_middleware(ExistsUserMiddleware())
|
||||
dp.message.outer_middleware(ExistsUserMiddleware())
|
||||
|
||||
dp.message.middleware(ThrottlingMiddleware())
|
||||
throttling = ThrottlingMiddleware()
|
||||
dp.message.middleware(throttling)
|
||||
dp.callback_query.middleware(throttling)
|
||||
|
||||
|
||||
# Старое имя оставлено, чтобы не ломать импорт в чужих проектах на базе шаблона
|
||||
def register_all_middlwares(dp: Dispatcher):
|
||||
register_all_middlewares(dp)
|
||||
|
||||
@@ -1,55 +1,78 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import time
|
||||
from typing import Any, Awaitable, Callable, Dict, Union
|
||||
from typing import Any, Awaitable, Callable, Dict, Optional, Union
|
||||
|
||||
from aiogram import BaseMiddleware
|
||||
from aiogram.dispatcher.flags import get_flag
|
||||
from aiogram.types import Message, User
|
||||
from aiogram.types import CallbackQuery, Message, TelegramObject, User
|
||||
from cachetools import TTLCache
|
||||
|
||||
from tgbot.data.config import BOT_THROTTLE_RATE
|
||||
|
||||
# Antiflood
|
||||
|
||||
# Простая защита от спама
|
||||
class ThrottlingMiddleware(BaseMiddleware):
|
||||
def __init__(self, default_rate: Union[int, float] = 0.5) -> None:
|
||||
def __init__(self, default_rate: Union[int, float] = BOT_THROTTLE_RATE) -> None:
|
||||
# Базовая задержка между сообщениями
|
||||
self.default_rate = default_rate
|
||||
|
||||
self.users = TTLCache(maxsize=10_000, ttl=600)
|
||||
self.message_users = TTLCache(maxsize=10_000, ttl=600)
|
||||
self.callback_users = TTLCache(maxsize=10_000, ttl=600)
|
||||
|
||||
async def __call__(self, handler: Callable[[Message, Dict[str, Any]], Awaitable[Any]], event: Message, data):
|
||||
this_user: User = data.get("event_from_user")
|
||||
async def __call__(self, handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]], event: TelegramObject, data):
|
||||
# Если юзер спамит, постепенно увеличиваем паузу
|
||||
this_user: Optional[User] = data.get("event_from_user")
|
||||
|
||||
if get_flag(data, "rate") is not None:
|
||||
self.default_rate = get_flag(data, "rate")
|
||||
|
||||
if self.default_rate == 0:
|
||||
if this_user is None:
|
||||
return await handler(event, data)
|
||||
|
||||
if this_user.id not in self.users:
|
||||
self.users[this_user.id] = {
|
||||
'last_throttled': int(time.time()),
|
||||
flag_rate = get_flag(data, "rate")
|
||||
rate = float(self.default_rate if flag_rate is None else flag_rate)
|
||||
|
||||
if rate == 0:
|
||||
return await handler(event, data)
|
||||
|
||||
now_time = time.monotonic()
|
||||
bucket = self._get_bucket(event)
|
||||
user_key = this_user.id
|
||||
|
||||
if user_key not in bucket:
|
||||
bucket[user_key] = {
|
||||
'last_throttled': now_time,
|
||||
'count_throttled': 0,
|
||||
'now_rate': self.default_rate,
|
||||
'now_rate': rate,
|
||||
}
|
||||
|
||||
return await handler(event, data)
|
||||
else:
|
||||
if int(time.time()) - self.users[this_user.id]['last_throttled'] >= self.users[this_user.id]['now_rate']:
|
||||
self.users.pop(this_user.id)
|
||||
if now_time - bucket[user_key]['last_throttled'] >= bucket[user_key]['now_rate']:
|
||||
bucket.pop(user_key)
|
||||
|
||||
return await handler(event, data)
|
||||
else:
|
||||
self.users[this_user.id]['last_throttled'] = int(time.time())
|
||||
bucket[user_key]['last_throttled'] = now_time
|
||||
bucket[user_key]['count_throttled'] += 1
|
||||
|
||||
if self.users[this_user.id]['count_throttled'] == 0:
|
||||
self.users[this_user.id]['count_throttled'] = 1
|
||||
self.users[this_user.id]['now_rate'] = self.default_rate + 2
|
||||
if bucket[user_key]['count_throttled'] == 1:
|
||||
bucket[user_key]['now_rate'] = rate + 2
|
||||
await self._warn_user(event)
|
||||
elif bucket[user_key]['count_throttled'] == 2:
|
||||
bucket[user_key]['now_rate'] = rate + 3
|
||||
else:
|
||||
bucket[user_key]['now_rate'] = rate + 5
|
||||
|
||||
return await handler(event, data)
|
||||
elif self.users[this_user.id]['count_throttled'] == 1:
|
||||
self.users[this_user.id]['count_throttled'] = 2
|
||||
self.users[this_user.id]['now_rate'] = self.default_rate + 3
|
||||
return None
|
||||
|
||||
await event.reply("<b>❗ Please, do not spam.")
|
||||
elif self.users[this_user.id]['count_throttled'] == 2:
|
||||
self.users[this_user.id]['count_throttled'] = 3
|
||||
self.users[this_user.id]['now_rate'] = self.default_rate + 5
|
||||
# Для сообщений и колбэков держим разные лимиты, чтобы они не мешали друг другу
|
||||
def _get_bucket(self, event: TelegramObject) -> TTLCache:
|
||||
if isinstance(event, CallbackQuery):
|
||||
return self.callback_users
|
||||
|
||||
return self.message_users
|
||||
|
||||
# Предупреждаем там, где это возможно для конкретного типа апдейта
|
||||
async def _warn_user(self, event: TelegramObject) -> None:
|
||||
if isinstance(event, Message):
|
||||
await event.reply("<b>❗ Пожалуйста, не спамьте</b>")
|
||||
elif isinstance(event, CallbackQuery) or hasattr(event, "answer"):
|
||||
await event.answer("❗ Пожалуйста, не спамьте", cache_time=1)
|
||||
|
||||
@@ -1,48 +1,55 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from aiogram import BaseMiddleware
|
||||
from cachetools import TTLCache
|
||||
|
||||
from tgbot.database.db_users import Usersx
|
||||
from tgbot.data.config import BOT_USER_CACHE_TTL
|
||||
from tgbot.database.db_users import UsersRepository
|
||||
from tgbot.utils.const_functions import clear_html
|
||||
|
||||
|
||||
# Проверка юзера в БД и его добавление
|
||||
# Проверка юзера в БД и его добавление/обновление
|
||||
class ExistsUserMiddleware(BaseMiddleware):
|
||||
def __init__(self, cache_ttl: int = BOT_USER_CACHE_TTL) -> None:
|
||||
self.users = UsersRepository()
|
||||
self.cache = TTLCache(maxsize=10_000, ttl=cache_ttl)
|
||||
|
||||
async def __call__(self, handler, event, data):
|
||||
this_user = data.get("event_from_user")
|
||||
|
||||
if not this_user.is_bot:
|
||||
get_user = Usersx().get(user_id=this_user.id)
|
||||
|
||||
if this_user is not None and not this_user.is_bot:
|
||||
user_id = this_user.id
|
||||
user_login = this_user.username
|
||||
user_login = this_user.username or ""
|
||||
user_name = clear_html(this_user.first_name)
|
||||
user_surname = clear_html(this_user.last_name)
|
||||
user_fullname = clear_html(this_user.first_name)
|
||||
user_language = this_user.language_code
|
||||
|
||||
if user_login is None: user_login = ""
|
||||
if user_name is None: user_name = ""
|
||||
if user_surname is None: user_surname = ""
|
||||
if user_fullname is None: user_fullname = ""
|
||||
if user_language != "ru": user_language = "en"
|
||||
|
||||
if len(user_surname) >= 1: user_fullname += f" {user_surname}"
|
||||
|
||||
if get_user is None:
|
||||
Usersx().add(user_id, user_login.lower(), user_name, user_surname, user_fullname)
|
||||
user_data = (
|
||||
user_login.lower(),
|
||||
user_name,
|
||||
user_surname,
|
||||
user_fullname,
|
||||
)
|
||||
|
||||
cached_user = self.cache.get(user_id)
|
||||
|
||||
if cached_user is None or cached_user["data"] != user_data:
|
||||
user = await self.users.upsert(
|
||||
user_id=user_id,
|
||||
user_login=user_data[0],
|
||||
user_name=user_data[1],
|
||||
user_surname=user_data[2],
|
||||
user_fullname=user_data[3],
|
||||
)
|
||||
self.cache[user_id] = {"data": user_data, "user": user}
|
||||
else:
|
||||
if user_name != get_user.user_name:
|
||||
Usersx().update(get_user.user_id, user_name=user_name)
|
||||
user = cached_user["user"]
|
||||
|
||||
if user_surname != get_user.user_surname:
|
||||
Usersx().update(get_user.user_id, user_surname=user_surname)
|
||||
|
||||
if user_fullname != get_user.user_fullname:
|
||||
Usersx().update(get_user.user_id, user_fullname=user_fullname)
|
||||
|
||||
if user_login.lower() != get_user.user_login:
|
||||
Usersx().update(get_user.user_id, user_login=user_login.lower())
|
||||
|
||||
data['User'] = Usersx().get(user_id=user_id)
|
||||
data['User'] = user
|
||||
|
||||
return await handler(event, data)
|
||||
|
||||
+20
-17
@@ -1,30 +1,33 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from aiogram import Dispatcher, F
|
||||
from aiogram import Dispatcher
|
||||
|
||||
from tgbot.routers import main_errors, main_missed, main_start
|
||||
from tgbot.routers.admin import admin_menu
|
||||
from tgbot.routers.user import user_menu
|
||||
from tgbot.utils.misc.bot_filters import IsAdmin
|
||||
from tgbot.utils.misc.bot_filters import IsAdmin, IsPrivate
|
||||
|
||||
|
||||
# Register all routers
|
||||
# Подключение всех роутеров
|
||||
def register_all_routers(dp: Dispatcher):
|
||||
# Connect filters
|
||||
main_errors.router.message.filter(F.chat.type == "private")
|
||||
main_start.router.message.filter(F.chat.type == "private")
|
||||
# Общие фильтры для приватных чатов
|
||||
main_errors.router.message.filter(IsPrivate())
|
||||
main_start.router.message.filter(IsPrivate())
|
||||
|
||||
user_menu.router.message.filter(F.chat.type == "private")
|
||||
admin_menu.router.message.filter(F.chat.type == "private", IsAdmin())
|
||||
user_menu.router.message.filter(IsPrivate())
|
||||
user_menu.router.callback_query.filter(IsPrivate())
|
||||
admin_menu.router.message.filter(IsPrivate(), IsAdmin())
|
||||
admin_menu.router.callback_query.filter(IsPrivate(), IsAdmin())
|
||||
|
||||
main_missed.router.message.filter(F.chat.type == "private")
|
||||
main_missed.router.message.filter(IsPrivate())
|
||||
main_missed.router.callback_query.filter(IsPrivate())
|
||||
|
||||
# Connect needed routers
|
||||
dp.include_router(main_errors.router) # Router - error
|
||||
dp.include_router(main_start.router) # Router - main
|
||||
# Базовые роутеры, которые нужны всегда
|
||||
dp.include_router(main_errors.router) # Ошибки
|
||||
dp.include_router(main_start.router) # Старт и главное меню
|
||||
|
||||
# Connect usebles routers (users и admins)
|
||||
dp.include_router(user_menu.router) # Router - user
|
||||
dp.include_router(admin_menu.router) # Router - admin
|
||||
# Роутеры для пользователей и админов
|
||||
dp.include_router(user_menu.router) # Пользовательские обработчики
|
||||
dp.include_router(admin_menu.router) # Админские обработчики
|
||||
|
||||
# Connect needed routers
|
||||
dp.include_router(main_missed.router) # Router - missed handlers
|
||||
# Обработка всего, что не поймали выше
|
||||
dp.include_router(main_missed.router) # Пропущенные сообщения и колбэки
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
import aiofiles
|
||||
from aiogram import Router, Bot, F
|
||||
@@ -7,87 +7,105 @@ from aiogram.filters import Command
|
||||
from aiogram.types import FSInputFile, Message, CallbackQuery
|
||||
from aiogram.utils.media_group import MediaGroupBuilder
|
||||
|
||||
from tgbot.data.config import PATH_DATABASE, PATH_LOGS
|
||||
from tgbot.database.db_users import BaseModel as UserModel
|
||||
from tgbot.data.config import BOT_DATABASE_EXPORT, PATH_DATABASE, PATH_LOGS
|
||||
from tgbot.database.db_users import UserModel
|
||||
from tgbot.keyboards.inline_main import admin_finl
|
||||
from tgbot.utils.const_functions import get_date
|
||||
from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
|
||||
router = Router(name=__name__)
|
||||
LOGS_DIR = Path(PATH_LOGS).parent
|
||||
SERVICE_LOG_FILES = (
|
||||
LOGS_DIR / "sv_log_err.log",
|
||||
LOGS_DIR / "sv_log_out.log",
|
||||
)
|
||||
|
||||
|
||||
# Message - Admin button
|
||||
@router.message(F.text == 'Admin button')
|
||||
# Кнопка админского меню
|
||||
@router.message(F.text == 'Админ-меню')
|
||||
async def admin_button_inline(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
await message.answer(
|
||||
"Inline admin keyboards",
|
||||
"Инлайн-клавиатура админа",
|
||||
reply_markup=admin_finl()
|
||||
)
|
||||
|
||||
|
||||
# Callback - Admin X
|
||||
# Колбэк для демо-действия админа
|
||||
@router.callback_query(F.data == 'admin_inline_x')
|
||||
async def admin_callback_inline_x(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await call.answer(f"Click Admin X")
|
||||
await call.answer("Админское действие выполнено")
|
||||
|
||||
|
||||
# Callback - Admin
|
||||
# Колбэк с параметром из админской кнопки
|
||||
@router.callback_query(F.data.startswith('admin_inline:'))
|
||||
async def admin_callback_inline(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
get_data = call.data.split(":")[1]
|
||||
|
||||
await call.answer(f"Click Admin - {get_data}", True)
|
||||
await call.answer(f"Выбран админский раздел: {get_data}", True)
|
||||
|
||||
|
||||
# Get Database file
|
||||
# Отправка файла базы админам
|
||||
@router.message(Command(commands=['db', 'database']))
|
||||
async def admin_database(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
if not BOT_DATABASE_EXPORT:
|
||||
await message.answer("<b>📦 Экспорт базы данных отключён в настройках</b>")
|
||||
return
|
||||
|
||||
if not Path(PATH_DATABASE).is_file():
|
||||
await message.answer("<b>📦 Файл базы данных не найден</b>")
|
||||
return
|
||||
|
||||
await message.answer_document(
|
||||
FSInputFile(PATH_DATABASE),
|
||||
caption=f"<b>📦 #BACKUP | <code>{get_date()}</code></b>",
|
||||
caption=f"<b>📦 #БЭКАП | <code>{get_date()}</code></b>",
|
||||
)
|
||||
|
||||
|
||||
# Get Logs file
|
||||
# Отправка логов админам
|
||||
@router.message(Command(commands=['log', 'logs']))
|
||||
async def admin_log(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
media_group = MediaGroupBuilder(
|
||||
caption=f"<b>🖨 #LOGS | <code>{get_date(full=False)}</code></b>",
|
||||
)
|
||||
log_files = []
|
||||
|
||||
if os.path.isfile(PATH_LOGS):
|
||||
media_group.add_document(media=FSInputFile(PATH_LOGS))
|
||||
if Path(PATH_LOGS).is_file():
|
||||
log_files.append(PATH_LOGS)
|
||||
|
||||
if os.path.isfile("tgbot/data/sv_log_err.log"):
|
||||
media_group.add_document(media=FSInputFile("tgbot/data/sv_log_err.log"))
|
||||
for log_file in SERVICE_LOG_FILES:
|
||||
if log_file.is_file():
|
||||
log_files.append(str(log_file))
|
||||
|
||||
if os.path.isfile("tgbot/data/sv_log_out.log"):
|
||||
media_group.add_document(media=FSInputFile("tgbot/data/sv_log_out.log"))
|
||||
caption = f"<b>🖨 #ЛОГИ | <code>{get_date(full=False)}</code></b>"
|
||||
|
||||
await message.answer_media_group(media=media_group.build())
|
||||
if len(log_files) == 0:
|
||||
await message.answer("<b>🖨 Логи не найдены</b>")
|
||||
elif len(log_files) == 1:
|
||||
await message.answer_document(FSInputFile(log_files[0]), caption=caption)
|
||||
else:
|
||||
media_group = MediaGroupBuilder(caption=caption)
|
||||
|
||||
for log_file in log_files:
|
||||
media_group.add_document(media=FSInputFile(log_file))
|
||||
|
||||
await message.answer_media_group(media=media_group.build())
|
||||
|
||||
|
||||
# Clear logs file
|
||||
# Очистка файлов логов
|
||||
@router.message(Command(commands=['clear_log', 'clear_logs', 'log_clear', 'logs_clear']))
|
||||
async def admin_logs_clear(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
if os.path.isfile(PATH_LOGS):
|
||||
async with aiofiles.open(PATH_LOGS, "w") as file:
|
||||
await file.write(f"{get_date()} | LOGS WAS CLEAR")
|
||||
log_files = [Path(PATH_LOGS), *SERVICE_LOG_FILES]
|
||||
|
||||
if os.path.isfile("tgbot/data/sv_log_err.log"):
|
||||
async with aiofiles.open("tgbot/data/sv_log_err.log", "w") as file:
|
||||
await file.write(f"{get_date()} | LOGS WAS CLEAR")
|
||||
for log_file in log_files:
|
||||
if not log_file.is_file():
|
||||
continue
|
||||
|
||||
if os.path.isfile("tgbot/data/sv_log_out.log"):
|
||||
async with aiofiles.open("tgbot/data/sv_log_out.log", "w") as file:
|
||||
await file.write(f"{get_date()} | LOGS WAS CLEAR")
|
||||
async with aiofiles.open(log_file, "w", encoding="utf-8") as file:
|
||||
await file.write(f"{get_date()} | ЛОГИ ОЧИЩЕНЫ")
|
||||
|
||||
await message.answer("<b>🖨 The logs have been cleared</b>")
|
||||
await message.answer("<b>🖨 Логи очищены</b>")
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from aiogram import Router
|
||||
from aiogram.filters import ExceptionMessageFilter
|
||||
from aiogram.exceptions import TelegramBadRequest
|
||||
from aiogram.filters import ExceptionTypeFilter
|
||||
from aiogram.handlers import ErrorHandler
|
||||
|
||||
from tgbot.utils.misc.bot_logging import bot_logger
|
||||
@@ -8,22 +9,19 @@ from tgbot.utils.misc.bot_logging import bot_logger
|
||||
router = Router(name=__name__)
|
||||
|
||||
|
||||
# Error with block forbidden user
|
||||
# Ошибка при отправке сообщения пользователю, который заблокировал бота
|
||||
# @router.errors(ExceptionTypeFilter(TelegramForbiddenError))
|
||||
# class MyHandler(ErrorHandler):
|
||||
# class ForbiddenErrorHandler(ErrorHandler):
|
||||
# async def handle(self):
|
||||
# ...
|
||||
|
||||
|
||||
# Error with edit duplicate message
|
||||
@router.errors(ExceptionMessageFilter(
|
||||
"Bad Request: message is not modified: specified new message content and reply markup are exactly the same as a current content and reply markup of the message")
|
||||
)
|
||||
class MyHandler(ErrorHandler):
|
||||
# Безопасно игнорируем повторное редактирование сообщения без изменений
|
||||
@router.errors(ExceptionTypeFilter(TelegramBadRequest))
|
||||
class MessageNotModifiedHandler(ErrorHandler):
|
||||
async def handle(self):
|
||||
bot_logger.exception(
|
||||
f"====================\n"
|
||||
f"Exception name: {self.exception_name}\n"
|
||||
f"Exception message: {self.exception_message}\n"
|
||||
f"===================="
|
||||
)
|
||||
if "message is not modified" in self.exception_message.lower():
|
||||
bot_logger.debug("Telegram отклонил повторное редактирование сообщения без изменений")
|
||||
return True
|
||||
|
||||
raise self.event
|
||||
|
||||
@@ -9,28 +9,28 @@ from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
router = Router(name=__name__)
|
||||
|
||||
|
||||
# Callback with delete message
|
||||
# Колбэк для удаления текущего сообщения
|
||||
@router.callback_query(F.data == 'close_this')
|
||||
async def main_callback_close(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: ModelUsers):
|
||||
await del_message(call.message)
|
||||
|
||||
|
||||
# Callback with processing miss button
|
||||
# Колбэк-заглушка для пустых кнопок
|
||||
@router.callback_query(F.data == '...')
|
||||
async def main_callback_answer(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: ModelUsers):
|
||||
await call.answer(cache_time=30)
|
||||
|
||||
|
||||
# Callback with processing miss callback data
|
||||
# Ответ на колбэк, который никто не обработал
|
||||
@router.callback_query()
|
||||
async def main_callback_missed(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: ModelUsers):
|
||||
await call.answer(f"❗️ Miss callback: {call.data}", True)
|
||||
await call.answer(f"❗️ Неизвестный колбэк: {call.data}", True)
|
||||
|
||||
|
||||
# Processing all unknowns callback datas
|
||||
# Ответ на неизвестные сообщения
|
||||
@router.message()
|
||||
async def main_message_missed(message: Message, bot: Bot, state: FSM, arSession: ARS, User: ModelUsers):
|
||||
await message.answer(
|
||||
"♦️ Unknown command.\n"
|
||||
"♦️ Enter /start",
|
||||
"♦️ Неизвестная команда\n"
|
||||
"♦️ Введите /start",
|
||||
)
|
||||
|
||||
@@ -3,7 +3,7 @@ from aiogram import Router, Bot, F
|
||||
from aiogram.filters import Command
|
||||
from aiogram.types import Message
|
||||
|
||||
from tgbot.database.db_users import BaseModel as UserModel
|
||||
from tgbot.database.db_users import UserModel
|
||||
from tgbot.keyboards.reply_main import menu_frep
|
||||
from tgbot.utils.const_functions import ded
|
||||
from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
@@ -11,7 +11,7 @@ from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
router = Router(name=__name__)
|
||||
|
||||
|
||||
# Main menu
|
||||
# Главное меню пользователя
|
||||
@router.message(F.text.in_(('menu', 'return', 'start')))
|
||||
@router.message(Command(commands=['start']))
|
||||
async def main_start(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
@@ -19,8 +19,8 @@ async def main_start(message: Message, bot: Bot, state: FSM, arSession: ARS, Use
|
||||
|
||||
await message.answer(
|
||||
ded(f"""
|
||||
🔸 Hello, {User.user_name}
|
||||
🔸 Enter /start or /menu
|
||||
🔸 Привет, {User.user_name}
|
||||
🔸 Введи /start или /menu
|
||||
"""),
|
||||
reply_markup=menu_frep(message.from_user.id),
|
||||
)
|
||||
|
||||
@@ -3,7 +3,7 @@ from aiogram import Router, Bot, F
|
||||
from aiogram.filters import Command
|
||||
from aiogram.types import Message, CallbackQuery
|
||||
|
||||
from tgbot.database.db_users import BaseModel as UserModel
|
||||
from tgbot.database.db_users import UserModel
|
||||
from tgbot.keyboards.inline_main import user_finl
|
||||
from tgbot.keyboards.reply_main import menu_frep
|
||||
from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
@@ -11,37 +11,37 @@ from tgbot.utils.misc.bot_models import FSM, ARS
|
||||
router = Router(name=__name__)
|
||||
|
||||
|
||||
# Message - User button
|
||||
@router.message(F.text == 'User button')
|
||||
# Кнопка пользовательского меню
|
||||
@router.message(F.text == 'Пользовательское меню')
|
||||
async def user_button_inline(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
await message.answer(
|
||||
"Inline user keyboards",
|
||||
"Инлайн-клавиатура пользователя",
|
||||
reply_markup=user_finl()
|
||||
)
|
||||
|
||||
|
||||
# Command - /menu
|
||||
# Команда возврата в меню
|
||||
@router.message(Command(commands="menu"))
|
||||
async def user_command_menu(message: Message, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await state.clear()
|
||||
|
||||
await message.answer(
|
||||
"Enter command - /menu",
|
||||
"Команда /menu открывает главное меню",
|
||||
reply_markup=menu_frep(message.from_user.id),
|
||||
)
|
||||
|
||||
|
||||
# Callback - User X
|
||||
# Колбэк для демо-действия
|
||||
@router.callback_query(F.data == 'user_inline_x')
|
||||
async def user_callback_inline_x(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
await call.answer(f"Click User X")
|
||||
await call.answer("Действие выполнено")
|
||||
|
||||
|
||||
# Callback - User
|
||||
# Колбэк с параметром из пользовательской кнопки
|
||||
@router.callback_query(F.data.startswith('user_inline:'))
|
||||
async def user_callback_inline(call: CallbackQuery, bot: Bot, state: FSM, arSession: ARS, User: UserModel):
|
||||
get_data = call.data.split(":")[1]
|
||||
|
||||
await call.answer(f"Click User - {get_data}", True)
|
||||
await call.answer(f"Выбран раздел: {get_data}", True)
|
||||
|
||||
@@ -4,20 +4,21 @@ from typing import Optional
|
||||
import aiohttp
|
||||
|
||||
|
||||
# In handler
|
||||
# Пример использования в обработчике
|
||||
# session = await arSession.get_session()
|
||||
# response = await session.get(...)
|
||||
# response = await session.post(...)
|
||||
|
||||
# Асинхронная сессия для запросов
|
||||
class AsyncRequestSession:
|
||||
def __init__(self) -> None:
|
||||
def __init__(self, timeout: int = 30) -> None:
|
||||
self._session: Optional[aiohttp.ClientSession] = None
|
||||
self._timeout = aiohttp.ClientTimeout(total=timeout)
|
||||
|
||||
# Получение сессии
|
||||
async def get_session(self) -> aiohttp.ClientSession:
|
||||
if self._session is None:
|
||||
new_session = aiohttp.ClientSession()
|
||||
new_session = aiohttp.ClientSession(timeout=self._timeout)
|
||||
self._session = new_session
|
||||
|
||||
return self._session
|
||||
@@ -25,6 +26,7 @@ class AsyncRequestSession:
|
||||
# Закрытие сессии
|
||||
async def close(self) -> None:
|
||||
if self._session is None:
|
||||
return None
|
||||
return
|
||||
|
||||
await self._session.close()
|
||||
self._session = None
|
||||
|
||||
+114
-169
@@ -1,26 +1,35 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import random
|
||||
import html
|
||||
import secrets
|
||||
import string
|
||||
import textwrap
|
||||
import time
|
||||
import uuid
|
||||
from datetime import datetime
|
||||
from typing import Union
|
||||
from typing import List, Optional, Union
|
||||
|
||||
import pytz
|
||||
from aiogram import Bot
|
||||
from aiogram.types import (InlineKeyboardButton, KeyboardButton, WebAppInfo, Message, InlineKeyboardMarkup,
|
||||
ReplyKeyboardMarkup)
|
||||
from pytz import timezone
|
||||
|
||||
from tgbot.data.config import get_admins, BOT_TIMEZONE
|
||||
from tgbot.utils.misc.bot_logging import bot_logger
|
||||
|
||||
|
||||
#################################### AIOGRAM ###################################
|
||||
# Generate replay button
|
||||
# Быстрая сборка реплай-кнопки
|
||||
def rkb(text: str) -> KeyboardButton:
|
||||
return KeyboardButton(text=text)
|
||||
|
||||
|
||||
# Generate inline button
|
||||
def ikb(text: str, data: str = None, url: str = None, switch: str = None, web: str = None) -> InlineKeyboardButton:
|
||||
# Быстрая сборка инлайн-кнопки
|
||||
def ikb(
|
||||
text: str,
|
||||
data: Optional[str] = None,
|
||||
url: Optional[str] = None,
|
||||
switch: Optional[str] = None,
|
||||
web: Optional[str] = None,
|
||||
) -> InlineKeyboardButton:
|
||||
if data is not None:
|
||||
return InlineKeyboardButton(text=text, callback_data=data)
|
||||
elif url is not None:
|
||||
@@ -30,24 +39,24 @@ def ikb(text: str, data: str = None, url: str = None, switch: str = None, web: s
|
||||
elif web is not None:
|
||||
return InlineKeyboardButton(text=text, web_app=WebAppInfo(url=web))
|
||||
else:
|
||||
raise "Unknown data"
|
||||
raise ValueError("Не указано действие для инлайн-кнопки")
|
||||
|
||||
|
||||
# Deleting a message with error handling from Telegram
|
||||
# Удаление сообщения без падения на ошибках Telegram
|
||||
async def del_message(message: Message):
|
||||
try:
|
||||
await message.delete()
|
||||
except:
|
||||
...
|
||||
except Exception:
|
||||
bot_logger.debug("Не удалось удалить сообщение", exc_info=True)
|
||||
|
||||
|
||||
# Smart messaging (automatic sending of messages with or without photos)
|
||||
# Отправка текста с фото, если оно передано или обычным сообщением
|
||||
async def smart_message(
|
||||
bot: Bot,
|
||||
user_id: int,
|
||||
text: str,
|
||||
keyboard: Union[InlineKeyboardMarkup, ReplyKeyboardMarkup] = None,
|
||||
photo: Union[str, None] = None,
|
||||
keyboard: Optional[Union[InlineKeyboardMarkup, ReplyKeyboardMarkup]] = None,
|
||||
photo: Optional[str] = None,
|
||||
):
|
||||
if photo is not None and photo.title() != "None":
|
||||
await bot.send_photo(
|
||||
@@ -64,7 +73,7 @@ async def smart_message(
|
||||
)
|
||||
|
||||
|
||||
# Send a message to all administrators
|
||||
# Отправка сообщения всем админам
|
||||
async def send_admins(bot: Bot, text: str, markup=None, not_me=0):
|
||||
for admin in get_admins():
|
||||
try:
|
||||
@@ -75,69 +84,44 @@ async def send_admins(bot: Bot, text: str, markup=None, not_me=0):
|
||||
reply_markup=markup,
|
||||
disable_web_page_preview=True,
|
||||
)
|
||||
except:
|
||||
...
|
||||
except Exception:
|
||||
bot_logger.warning("Не удалось отправить сообщение админу %s", admin, exc_info=True)
|
||||
|
||||
|
||||
##################################### MISC #####################################
|
||||
# Removing indents in a multi-line string ("""text""")
|
||||
################################## РАЗНОЕ ######################################
|
||||
# Убирает лишние отступы в многострочном тексте
|
||||
def ded(get_text: str) -> str:
|
||||
if get_text is not None:
|
||||
split_text = get_text.split("\n")
|
||||
if split_text[0] == "": split_text.pop(0)
|
||||
if split_text[-1] == "": split_text.pop()
|
||||
save_text = []
|
||||
|
||||
for text in split_text:
|
||||
while text.startswith(" "):
|
||||
text = text[1:].strip()
|
||||
|
||||
save_text.append(text)
|
||||
get_text = "\n".join(save_text)
|
||||
else:
|
||||
get_text = ""
|
||||
|
||||
return get_text
|
||||
return textwrap.dedent(get_text or "").strip()
|
||||
|
||||
|
||||
# Cleaning text of HTML tags ('<b>test</b>' -> *b*test*/b*)
|
||||
# Чистит HTML-символы, чтобы Telegram не сломал разметку
|
||||
def clear_html(get_text: str) -> str:
|
||||
if get_text is not None:
|
||||
if "</" in get_text: get_text = get_text.replace("<", "*")
|
||||
if "<" in get_text: get_text = get_text.replace("<", "*")
|
||||
if ">" in get_text: get_text = get_text.replace(">", "*")
|
||||
else:
|
||||
get_text = ""
|
||||
|
||||
return get_text
|
||||
return html.escape(get_text or "", quote=False)
|
||||
|
||||
|
||||
# Cleaning up gaps in the list (['', 1, ' ', 2] -> [1, 2])
|
||||
# Убирает пустые и мусорные элементы из списка
|
||||
def clear_list(get_list: list) -> list:
|
||||
while "" in get_list: get_list.remove("")
|
||||
while " " in get_list: get_list.remove(" ")
|
||||
while "." in get_list: get_list.remove(".")
|
||||
while "," in get_list: get_list.remove(",")
|
||||
while "\r" in get_list: get_list.remove("\r")
|
||||
while "\n" in get_list: get_list.remove("\n")
|
||||
trash = {"", " ", ".", ",", "\r", "\n"}
|
||||
|
||||
return get_list
|
||||
return [value for value in get_list if value not in trash]
|
||||
|
||||
|
||||
# Split the list into several parts ([1, 2, 3, 4] 2 -> [[1, 2], [3, 4]])
|
||||
def split_list(get_list: list, count: int) -> list[list]:
|
||||
# Делит список на части нужного размера
|
||||
def split_list(get_list: list, count: int) -> List[list]:
|
||||
return [get_list[i:i + count] for i in range(0, len(get_list), count)]
|
||||
|
||||
|
||||
# Get the current date (True - date with time, False - date without time)
|
||||
# Возвращает текущую дату, при full=True еще и время
|
||||
def get_date(full: bool = True) -> str:
|
||||
bot_timezone = timezone(BOT_TIMEZONE)
|
||||
|
||||
if full:
|
||||
return datetime.now(pytz.timezone(BOT_TIMEZONE)).strftime("%d.%m.%Y %H:%M:%S")
|
||||
return datetime.now(bot_timezone).strftime("%d.%m.%Y %H:%M:%S")
|
||||
else:
|
||||
return datetime.now(pytz.timezone(BOT_TIMEZONE)).strftime("%d.%m.%Y")
|
||||
return datetime.now(bot_timezone).strftime("%d.%m.%Y")
|
||||
|
||||
|
||||
# Get the current Unix time (True - time in nanoseconds, False - time in seconds)
|
||||
# Возвращает Unix-время: секунды или наносекунды
|
||||
def get_unix(full: bool = False) -> int:
|
||||
if full:
|
||||
return time.time_ns()
|
||||
@@ -145,89 +129,90 @@ def get_unix(full: bool = False) -> int:
|
||||
return int(time.time())
|
||||
|
||||
|
||||
# Converting Unix to date and dates to Unix
|
||||
# Конвертирует дату в Unix и обратно
|
||||
def convert_date(from_time, full=True, second=True) -> Union[str, int]:
|
||||
from tgbot.data.config import BOT_TIMEZONE
|
||||
bot_timezone = timezone(BOT_TIMEZONE)
|
||||
from_time = str(from_time).strip().replace("-", ".")
|
||||
|
||||
if "-" in str(from_time):
|
||||
from_time = from_time.replace("-", ".")
|
||||
|
||||
if str(from_time).isdigit():
|
||||
if from_time.isdigit():
|
||||
from_timestamp = int(from_time)
|
||||
if full:
|
||||
to_time = datetime.fromtimestamp(from_time, pytz.timezone(BOT_TIMEZONE)).strftime("%d.%m.%Y %H:%M:%S")
|
||||
to_time = datetime.fromtimestamp(from_timestamp, bot_timezone).strftime("%d.%m.%Y %H:%M:%S")
|
||||
elif second:
|
||||
to_time = datetime.fromtimestamp(from_time, pytz.timezone(BOT_TIMEZONE)).strftime("%d.%m.%Y %H:%M")
|
||||
to_time = datetime.fromtimestamp(from_timestamp, bot_timezone).strftime("%d.%m.%Y %H:%M")
|
||||
else:
|
||||
to_time = datetime.fromtimestamp(from_time, pytz.timezone(BOT_TIMEZONE)).strftime("%d.%m.%Y")
|
||||
to_time = datetime.fromtimestamp(from_timestamp, bot_timezone).strftime("%d.%m.%Y")
|
||||
else:
|
||||
if " " in str(from_time):
|
||||
cache_time = from_time.split(" ")
|
||||
parts = from_time.split()
|
||||
|
||||
if ":" in cache_time[0]:
|
||||
cache_date = cache_time[1].split(".")
|
||||
cache_time = cache_time[0].split(":")
|
||||
else:
|
||||
cache_date = cache_time[0].split(".")
|
||||
cache_time = cache_time[1].split(":")
|
||||
|
||||
if len(cache_date[0]) == 4:
|
||||
x_year, x_month, x_day = cache_date[0], cache_date[1], cache_date[2]
|
||||
else:
|
||||
x_year, x_month, x_day = cache_date[2], cache_date[1], cache_date[0]
|
||||
|
||||
x_hour, x_minute, x_second = cache_time[0], cache_time[1], cache_time[2]
|
||||
|
||||
from_time = f"{x_day}.{x_month}.{x_year} {x_hour}:{x_minute}:{x_second}"
|
||||
if len(parts) == 2 and ":" in parts[0]:
|
||||
time_part, date_part = parts
|
||||
elif len(parts) == 2:
|
||||
date_part, time_part = parts
|
||||
else:
|
||||
cache_date = from_time.split(".")
|
||||
date_part, time_part = from_time, "00:00:00"
|
||||
|
||||
if len(cache_date[0]) == 4:
|
||||
x_year, x_month, x_day = cache_date[0], cache_date[1], cache_date[2]
|
||||
else:
|
||||
x_year, x_month, x_day = cache_date[2], cache_date[1], cache_date[0]
|
||||
date_values = date_part.split(".")
|
||||
time_values = time_part.split(":")
|
||||
|
||||
from_time = f"{x_day}.{x_month}.{x_year}"
|
||||
if len(time_values) == 2:
|
||||
time_values.append("0")
|
||||
|
||||
if " " in str(from_time):
|
||||
to_time = int(datetime.strptime(from_time, "%d.%m.%Y %H:%M:%S").timestamp())
|
||||
if len(date_values[0]) == 4:
|
||||
x_year, x_month, x_day = date_values[0], date_values[1], date_values[2]
|
||||
else:
|
||||
to_time = int(datetime.strptime(from_time, "%d.%m.%Y").timestamp())
|
||||
x_day, x_month, x_year = date_values[0], date_values[1], date_values[2]
|
||||
|
||||
date_time = datetime(
|
||||
int(x_year),
|
||||
int(x_month),
|
||||
int(x_day),
|
||||
int(time_values[0]),
|
||||
int(time_values[1]),
|
||||
int(time_values[2]),
|
||||
)
|
||||
date_time = bot_timezone.localize(date_time)
|
||||
to_time = int(date_time.timestamp())
|
||||
|
||||
return to_time
|
||||
|
||||
|
||||
# Generation of a unique ID
|
||||
# Генерация числового уникального ID
|
||||
def gen_id(len_id: int = 16) -> int:
|
||||
mac_address = uuid.getnode()
|
||||
time_unix = int(str(time.time_ns())[:len_id])
|
||||
random_int = int(''.join(random.choices('0123456789', k=len_id)))
|
||||
if len_id <= 0:
|
||||
raise ValueError("Длина ID должна быть больше нуля")
|
||||
|
||||
return mac_address + time_unix + random_int
|
||||
first_digit = secrets.choice("123456789")
|
||||
other_digits = "".join(secrets.choice(string.digits) for _ in range(len_id - 1))
|
||||
|
||||
return int(f"{first_digit}{other_digits}")
|
||||
|
||||
|
||||
# Password generation | default, number, letter, onechar
|
||||
# Генерация пароля под разные сценарии
|
||||
def gen_password(len_password: int = 16, type_password: str = "default") -> str:
|
||||
char_password = list("1234567890abcdefghigklmnopqrstuvyxwzABCDEFGHIGKLMNOPQRSTUVYXWZ")
|
||||
if len_password <= 0:
|
||||
raise ValueError("Длина пароля должна быть больше нуля")
|
||||
|
||||
if type_password == "default":
|
||||
char_password = list("1234567890abcdefghigklmnopqrstuvyxwzABCDEFGHIGKLMNOPQRSTUVYXWZ")
|
||||
alphabet = string.ascii_letters + string.digits
|
||||
elif type_password == "letter":
|
||||
char_password = list("abcdefghigklmnopqrstuvyxwzABCDEFGHIGKLMNOPQRSTUVYXWZ")
|
||||
alphabet = string.ascii_letters
|
||||
elif type_password == "number":
|
||||
char_password = list("1234567890")
|
||||
alphabet = string.digits
|
||||
elif type_password == "onechar":
|
||||
char_password = list("1234567890")
|
||||
alphabet = string.digits
|
||||
else:
|
||||
raise ValueError("Неизвестный тип пароля")
|
||||
|
||||
random.shuffle(char_password)
|
||||
random_chars = "".join([random.choice(char_password) for x in range(len_password)])
|
||||
random_chars = "".join(secrets.choice(alphabet) for _ in range(len_password))
|
||||
|
||||
if type_password == "onechar":
|
||||
random_chars = f"{random.choice('abcdefghigklmnopqrstuvyxwzABCDEFGHIGKLMNOPQRSTUVYXWZ')}{random_chars[1:]}"
|
||||
random_chars = f"{secrets.choice(string.ascii_letters)}{random_chars[1:]}"
|
||||
|
||||
return random_chars
|
||||
|
||||
|
||||
# Addition to the correct time (1 -> 1 day, 3 -> 3 days)
|
||||
# Склоняет единицы времени под число
|
||||
def convert_times(get_time: int, get_type: str = "day") -> str:
|
||||
get_time = int(get_time)
|
||||
if get_time < 0: get_time = 0
|
||||
@@ -255,20 +240,20 @@ def convert_times(get_time: int, get_type: str = "day") -> str:
|
||||
return f"{get_time} {get_list[count]}"
|
||||
|
||||
|
||||
# Boolean type check
|
||||
# Приводит строку или число к bool
|
||||
def is_bool(value: Union[bool, str, int]) -> bool:
|
||||
value = str(value).lower()
|
||||
value = str(value).strip().lower()
|
||||
|
||||
if value in ('y', 'yes', 't', 'true', 'on', '1'):
|
||||
return True
|
||||
elif value in ('n', 'no', 'f', 'false', 'off', '0'):
|
||||
return False
|
||||
else:
|
||||
raise ValueError(f"invalid truth value {value}")
|
||||
raise ValueError(f"Некорректное bool-значение: {value}")
|
||||
|
||||
|
||||
################################### NUMBERS ####################################
|
||||
# Converting exponential numbers to a readable form (1e-06 -> 0.000001)
|
||||
################################### ЧИСЛА ######################################
|
||||
# Приводит число к читаемой строке без лишних нулей
|
||||
def snum(amount: Union[int, float], remains: int = 2) -> str:
|
||||
format_str = "{:." + str(remains) + "f}"
|
||||
str_amount = format_str.format(float(amount))
|
||||
@@ -288,38 +273,20 @@ def snum(amount: Union[int, float], remains: int = 2) -> str:
|
||||
return str(str_amount)
|
||||
|
||||
|
||||
# Convert any number to a real number, removing trailing zeros (remains - rounding)
|
||||
# Приводит входное значение к int или float
|
||||
def to_float(get_number, remains: int = 2) -> Union[int, float]:
|
||||
if "," in str(get_number):
|
||||
get_number = str(get_number).replace(",", ".")
|
||||
value = str(get_number).strip().replace(" ", "").replace(",", ".")
|
||||
number = round(float(value), remains)
|
||||
|
||||
if "." in str(get_number):
|
||||
get_last = str(get_number).split(".")
|
||||
if number.is_integer():
|
||||
return int(number)
|
||||
|
||||
if str(get_last[1]).endswith("0"):
|
||||
while True:
|
||||
if str(get_number).endswith("0"):
|
||||
get_number = str(get_number)[:-1]
|
||||
else:
|
||||
break
|
||||
|
||||
get_number = round(float(get_number), remains)
|
||||
|
||||
str_number = snum(get_number)
|
||||
if "." in str_number:
|
||||
if str_number.split(".")[1] == "0":
|
||||
get_number = int(get_number)
|
||||
else:
|
||||
get_number = float(get_number)
|
||||
else:
|
||||
get_number = int(get_number)
|
||||
|
||||
return get_number
|
||||
return number
|
||||
|
||||
|
||||
# Converting a real number to an integer
|
||||
# Округляет число до int
|
||||
def to_int(get_number: float) -> int:
|
||||
if "," in get_number:
|
||||
if "," in str(get_number):
|
||||
get_number = str(get_number).replace(",", ".")
|
||||
|
||||
get_number = int(round(float(get_number)))
|
||||
@@ -327,7 +294,7 @@ def to_int(get_number: float) -> int:
|
||||
return get_number
|
||||
|
||||
|
||||
# Data validation for numbers
|
||||
# Проверяет, является ли значение числом
|
||||
def is_number(get_number: Union[str, int, float]) -> bool:
|
||||
if str(get_number).isdigit():
|
||||
return True
|
||||
@@ -337,39 +304,17 @@ def is_number(get_number: Union[str, int, float]) -> bool:
|
||||
try:
|
||||
float(get_number)
|
||||
return True
|
||||
except ValueError:
|
||||
except (TypeError, ValueError):
|
||||
return False
|
||||
|
||||
|
||||
# Converting a number to a readable form (123456789 -> 123,456,789)
|
||||
# Форматирует число с разделением тысяч
|
||||
def format_rate(amount: Union[float, int], around: int = 2) -> str:
|
||||
if "," in str(amount): amount = float(str(amount).replace(",", "."))
|
||||
if " " in str(amount): amount = float(str(amount).replace(" ", ""))
|
||||
amount = str(round(amount, around))
|
||||
value = str(amount).strip().replace(" ", "").replace(",", ".")
|
||||
number = round(float(value), around)
|
||||
response = f"{number:,.{around}f}".replace(",", " ")
|
||||
|
||||
out_amount, save_remains = [], ""
|
||||
|
||||
if "." in amount: save_remains = amount.split(".")[1]
|
||||
save_amount = [char for char in str(int(float(amount)))]
|
||||
|
||||
if len(save_amount) % 3 != 0:
|
||||
if (len(save_amount) - 1) % 3 == 0:
|
||||
out_amount.extend([save_amount[0]])
|
||||
save_amount.pop(0)
|
||||
elif (len(save_amount) - 2) % 3 == 0:
|
||||
out_amount.extend([save_amount[0], save_amount[1]])
|
||||
save_amount.pop(1)
|
||||
save_amount.pop(0)
|
||||
else:
|
||||
print("Error 4388326")
|
||||
|
||||
for x, char in enumerate(save_amount):
|
||||
if x % 3 == 0: out_amount.append(" ")
|
||||
out_amount.append(char)
|
||||
|
||||
response = "".join(out_amount).strip() + "." + save_remains
|
||||
|
||||
if response.endswith("."):
|
||||
response = response[:-1]
|
||||
if "." in response:
|
||||
response = response.rstrip("0").rstrip(".")
|
||||
|
||||
return response
|
||||
|
||||
@@ -2,29 +2,32 @@
|
||||
from aiogram import Bot
|
||||
from aiogram.types import BotCommand, BotCommandScopeChat, BotCommandScopeDefault
|
||||
|
||||
from tgbot.data.config import get_admins
|
||||
from tgbot.data.config import BOT_DATABASE_EXPORT, get_admins
|
||||
from tgbot.utils.misc.bot_logging import bot_logger
|
||||
|
||||
# Commands for users
|
||||
# Команды для обычных пользователей
|
||||
user_commands = [
|
||||
BotCommand(command="start", description="♻️ Restart bot"),
|
||||
BotCommand(command="menu", description="🌀 Get keyboards"),
|
||||
BotCommand(command="start", description="♻️ Перезапуск бота"),
|
||||
BotCommand(command="menu", description="🌀 Получение клавиатуры"),
|
||||
]
|
||||
|
||||
# Commands for admins
|
||||
# Команды для админов
|
||||
admin_commands = [
|
||||
BotCommand(command="start", description="♻️ Restart bot"),
|
||||
BotCommand(command="menu", description="🌀 Get keyboards"),
|
||||
BotCommand(command="log", description="🖨 Get Logs"),
|
||||
BotCommand(command="db", description="📦 Get Database"),
|
||||
BotCommand(command="start", description="♻️ Перезапуск бота"),
|
||||
BotCommand(command="menu", description="🌀 Получение клавиатуры"),
|
||||
BotCommand(command="log", description="🖨 Получить логи"),
|
||||
]
|
||||
|
||||
if BOT_DATABASE_EXPORT:
|
||||
admin_commands.append(BotCommand(command="db", description="📦 Получить БД"))
|
||||
|
||||
# Set commands
|
||||
|
||||
# Обновление списка команд в Telegram
|
||||
async def set_commands(bot: Bot):
|
||||
await bot.set_my_commands(user_commands, scope=BotCommandScopeDefault())
|
||||
|
||||
for admin in get_admins():
|
||||
try:
|
||||
await bot.set_my_commands(admin_commands, scope=BotCommandScopeChat(chat_id=admin))
|
||||
except:
|
||||
...
|
||||
except Exception:
|
||||
bot_logger.warning("Не удалось обновить команды для админа %s", admin, exc_info=True)
|
||||
|
||||
@@ -1,14 +1,30 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
from typing import Union
|
||||
|
||||
from aiogram.filters import BaseFilter
|
||||
from aiogram.types import Message
|
||||
from aiogram.types import CallbackQuery, Message
|
||||
|
||||
from tgbot.data.config import get_admins
|
||||
|
||||
|
||||
# Filter on admin right
|
||||
# Проверка, что действия совершает админ
|
||||
class IsAdmin(BaseFilter):
|
||||
async def __call__(self, message: Message) -> bool:
|
||||
if message.from_user.id in get_admins():
|
||||
async def __call__(self, event: Union[Message, CallbackQuery]) -> bool:
|
||||
user = getattr(event, "from_user", None)
|
||||
|
||||
return bool(user and user.id in get_admins())
|
||||
|
||||
|
||||
# Проверка приватного чата
|
||||
class IsPrivate(BaseFilter):
|
||||
async def __call__(self, event: Union[Message, CallbackQuery]) -> bool:
|
||||
chat = getattr(event, "chat", None)
|
||||
message = getattr(event, "message", None)
|
||||
|
||||
if chat is None and message is not None:
|
||||
chat = message.chat
|
||||
|
||||
if chat is None:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
return chat.type == "private"
|
||||
|
||||
@@ -1,32 +1,58 @@
|
||||
# - *- coding: utf- 8 - *-
|
||||
import logging as bot_logger
|
||||
import logging
|
||||
from logging.handlers import RotatingFileHandler
|
||||
from pathlib import Path
|
||||
|
||||
import colorlog
|
||||
|
||||
from tgbot.data.config import PATH_LOGS
|
||||
|
||||
# Logging format
|
||||
log_formatter_file = bot_logger.Formatter("%(levelname)s | %(asctime)s | %(filename)s:%(lineno)d | %(message)s")
|
||||
log_formatter_console = colorlog.ColoredFormatter(
|
||||
"%(purple)s%(levelname)s %(blue)s|%(purple)s %(asctime)s %(blue)s|%(purple)s %(filename)s:%(lineno)d %(blue)s|%(purple)s %(message)s%(red)s",
|
||||
datefmt="%d-%m-%Y %H:%M:%S",
|
||||
)
|
||||
LOG_FILE_MAX_BYTES = 5 * 1024 * 1024
|
||||
LOG_FILE_BACKUP_COUNT = 5
|
||||
|
||||
# Logging in file logs.log
|
||||
file_handler = bot_logger.FileHandler(PATH_LOGS, "w", "utf-8")
|
||||
file_handler.setFormatter(log_formatter_file)
|
||||
file_handler.setLevel(bot_logger.INFO)
|
||||
# Папка под логи создается сама, чтобы бот не падал на старте
|
||||
log_path = Path(PATH_LOGS)
|
||||
log_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Logging in console
|
||||
console_handler = bot_logger.StreamHandler()
|
||||
console_handler.setFormatter(log_formatter_console)
|
||||
console_handler.setLevel(bot_logger.CRITICAL)
|
||||
# Один общий логгер для всего шаблона
|
||||
bot_logger = logging.getLogger("tgbot")
|
||||
bot_logger.setLevel(logging.INFO)
|
||||
bot_logger.propagate = False
|
||||
|
||||
# Connect logging settings
|
||||
bot_logger.basicConfig(
|
||||
format="%(levelname)s | %(asctime)s | %(filename)s:%(lineno)d | %(message)s",
|
||||
handlers=[
|
||||
file_handler,
|
||||
console_handler
|
||||
]
|
||||
)
|
||||
if not bot_logger.handlers:
|
||||
# Формат для файла: без цветов
|
||||
file_formatter = logging.Formatter(
|
||||
"%(levelname)s | %(asctime)s | %(name)s | %(filename)s:%(lineno)d | %(message)s",
|
||||
datefmt="%d-%m-%Y %H:%M:%S",
|
||||
)
|
||||
# Формат для консоли: коротко и с цветами
|
||||
console_formatter = colorlog.ColoredFormatter(
|
||||
"%(log_color)s%(levelname)s%(reset)s | %(blue)s%(asctime)s%(reset)s | "
|
||||
"%(purple)s%(filename)s:%(lineno)d%(reset)s | %(message)s",
|
||||
datefmt="%d-%m-%Y %H:%M:%S",
|
||||
log_colors={
|
||||
"DEBUG": "cyan",
|
||||
"INFO": "green",
|
||||
"WARNING": "yellow",
|
||||
"ERROR": "red",
|
||||
"CRITICAL": "bold_red",
|
||||
},
|
||||
)
|
||||
|
||||
# Не очищаем файл, а крутим по размеру
|
||||
file_handler = RotatingFileHandler(
|
||||
log_path,
|
||||
maxBytes=LOG_FILE_MAX_BYTES,
|
||||
backupCount=LOG_FILE_BACKUP_COUNT,
|
||||
encoding="utf-8",
|
||||
)
|
||||
file_handler.setFormatter(file_formatter)
|
||||
file_handler.setLevel(logging.INFO)
|
||||
|
||||
# В консоль выводим то, что важно видеть сразу
|
||||
console_handler = logging.StreamHandler()
|
||||
console_handler.setFormatter(console_formatter)
|
||||
console_handler.setLevel(logging.INFO)
|
||||
|
||||
bot_logger.addHandler(file_handler)
|
||||
bot_logger.addHandler(console_handler)
|
||||
|
||||
@@ -3,5 +3,6 @@ from aiogram.fsm.context import FSMContext
|
||||
|
||||
from tgbot.services.api_session import AsyncRequestSession
|
||||
|
||||
# Короткие алиасы для типизации обработчиков
|
||||
FSM = FSMContext
|
||||
ARS = AsyncRequestSession
|
||||
|
||||
@@ -2,24 +2,28 @@
|
||||
from aiogram import Bot
|
||||
from aiogram.types import FSInputFile
|
||||
|
||||
from tgbot.data.config import get_admins, PATH_DATABASE, BOT_STATUS_NOTIFICATION
|
||||
from tgbot.data.config import BOT_DATABASE_EXPORT, BOT_STATUS_NOTIFICATION, PATH_DATABASE, get_admins
|
||||
from tgbot.utils.const_functions import get_date, send_admins
|
||||
from tgbot.utils.misc.bot_logging import bot_logger
|
||||
|
||||
|
||||
# Notification after run bot (for all admins)
|
||||
# Уведомление админам после запуска
|
||||
async def startup_notify(bot: Bot):
|
||||
if len(get_admins()) >= 1 and BOT_STATUS_NOTIFICATION:
|
||||
await send_admins(bot, "<b>✅ Bot was started</b>")
|
||||
await send_admins(bot, "<b>✅ Бот запущен</b>")
|
||||
|
||||
|
||||
# Autobackup Database
|
||||
# Автобэкап базы для админов
|
||||
async def autobackup_admin(bot: Bot):
|
||||
if not BOT_DATABASE_EXPORT:
|
||||
return
|
||||
|
||||
for admin in get_admins():
|
||||
try:
|
||||
await bot.send_document(
|
||||
admin,
|
||||
FSInputFile(PATH_DATABASE),
|
||||
caption=f"<b>📦 #AUTOBACKUP | <code>{get_date()}</code></b>",
|
||||
caption=f"<b>📦 #АВТОБЭКАП | <code>{get_date()}</code></b>",
|
||||
)
|
||||
except:
|
||||
...
|
||||
except Exception:
|
||||
bot_logger.warning("Не удалось отправить автобэкап админу %s", admin, exc_info=True)
|
||||
|
||||
Reference in New Issue
Block a user