Add application file

.dockerignore

@@ -0,0 +1,6 @@
+__pycache__
+*.pyc
+.env
+.git
+.gitignore
+README.md

.gitignore

@@ -0,0 +1,176 @@
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+run.py
+# End of https://www.toptal.com/developers/gitignore/api/python
+.env
+*.sqlite3
+__pycache__/

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+CMD ["python", "main.py"]
+
+EXPOSE 7860

app/config/config.py

@@ -0,0 +1,12 @@
+import os
+from typing import List
+from dotenv import load_dotenv
+
+load_dotenv()
+
+BOT_TOKEN = os.getenv('BOT_TOKEN')
+DATABASE_URL = os.getenv('DATABASE_URL')
+ADMIN_ID = [int(id) for id in os.getenv('ADMIN_IDS', '').split(',')]
+
+if not BOT_TOKEN:
+    raise ValueError("BOT_TOKEN not found in environment")

app/database/base.py

@@ -0,0 +1,15 @@
+from contextlib import asynccontextmanager
+from .models import async_session
+
+@asynccontextmanager
+async def get_session():
+    """Provide a transactional scope around a series of operations."""
+    session = async_session()
+    try:
+        yield session
+        await session.commit()
+    except Exception:
+        await session.rollback()
+        raise
+    finally:
+        await session.close()

app/database/models.py

@@ -0,0 +1,142 @@
+from datetime import datetime
+from typing import Optional
+from sqlalchemy import BigInteger, String, ForeignKey, Integer, DateTime, Boolean
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
+from sqlalchemy.ext.asyncio import AsyncAttrs, async_sessionmaker, create_async_engine
+from app.config.config import DATABASE_URL
+
+engine = create_async_engine(DATABASE_URL) # подключение и создание БД
+async_session = async_sessionmaker(engine, expire_on_commit=False)
+
+
+class Base(AsyncAttrs, DeclarativeBase):
+    """Base class for all models"""
+    pass
+
+
+class User(Base):
+    """User model for storing telegram user data"""
+    __tablename__ = 'users'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tg_id: Mapped[int] = mapped_column(BigInteger, unique=True, nullable=False)
+    name: Mapped[str] = mapped_column(String(100), nullable=True)
+    login: Mapped[str] = mapped_column(String(100), nullable=True)
+    contact: Mapped[str] = mapped_column(String(100), nullable=True)
+    subscription_status: Mapped[str] = mapped_column(
+        String(20), default='inactive')
+    # Relationships
+    test_attempts = relationship("TestAttempt", back_populates="user")
+    feedback = relationship("Feedback", back_populates="user")
+
+
+class Service(Base):
+    """Service model for storing available services"""
+    __tablename__ = 'services'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    service_name: Mapped[str] = mapped_column(String(100), unique=True, nullable=False)
+    service_description: Mapped[str] = mapped_column(String(500))
+    service_price: Mapped[int] = mapped_column(BigInteger, nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    # Relationships
+    feedback = relationship("Feedback", back_populates="service")
+
+
+class Test(Base):
+    """Test model for storing quiz/test information"""
+    __tablename__ = 'tests'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    test_name: Mapped[str] = mapped_column(String(100), unique=True, nullable=False)
+    test_type: Mapped[str] = mapped_column(String(20), nullable=False)
+    test_description: Mapped[str] = mapped_column(String(250))
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    completion_message: Mapped[Optional[str]] = mapped_column(String(1000))
+    # Relationships
+    questions = relationship("TestQuestion", back_populates="test", cascade="all, delete-orphan")
+    results = relationship("TestResult", back_populates="test", cascade="all, delete-orphan")
+    attempts = relationship("TestAttempt", back_populates="test")
+
+
+class TestQuestion(Base):
+    """Model for storing test questions"""
+    __tablename__ = 'test_questions'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    test_id: Mapped[int] = mapped_column(ForeignKey('tests.id', ondelete='CASCADE'), nullable=False)
+    question_content: Mapped[str] = mapped_column(String(150), nullable=False)
+    question_variants: Mapped[str] = mapped_column(String(500), nullable=False)  # JSON string
+    question_points: Mapped[str] = mapped_column(String(100), nullable=False)  # JSON string
+    # Relationships
+    test = relationship("Test", back_populates="questions")
+
+
+class TestResult(Base):
+    """Model for storing possible test results"""
+    __tablename__ = 'test_results'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    test_id: Mapped[int] = mapped_column(ForeignKey('tests.id', ondelete='CASCADE'), nullable=False)
+    min_points: Mapped[int] = mapped_column(Integer, nullable=False)
+    max_points: Mapped[int] = mapped_column(Integer, nullable=False)
+    result_text: Mapped[str] = mapped_column(String(1000), nullable=False)
+    # Relationships
+    test = relationship("Test", back_populates="results")
+
+
+class TestAttempt(Base):
+    """Model for storing user test attempts"""
+    __tablename__ = 'test_attempts'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey('users.id', ondelete='CASCADE'), nullable=False)
+    test_id: Mapped[int] = mapped_column(ForeignKey('tests.id', ondelete='CASCADE'), nullable=False)
+    score: Mapped[int] = mapped_column(Integer, nullable=True)
+    result: Mapped[Optional[str]] = mapped_column(String(1000), nullable=True)
+    completed_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.now, nullable=True)
+    # Relationships
+    user = relationship("User", back_populates="test_attempts")
+    test = relationship("Test", back_populates="attempts")
+
+
+class TestAnswer(Base):
+    """Stores individual answers for each question"""
+    __tablename__ = 'test_answers'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    attempt_id: Mapped[int] = mapped_column(ForeignKey('test_attempts.id', ondelete='CASCADE'))
+    question_id: Mapped[int] = mapped_column(ForeignKey('test_questions.id', ondelete='CASCADE'))
+    answer_given: Mapped[str] = mapped_column(String(500))
+    points_earned: Mapped[int] = mapped_column(Integer, nullable=True)
+
+
+class LeadMagnet(Base):
+    """Model for storing lead magnets/content triggers"""
+    __tablename__ = 'lead_magnets'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    trigger: Mapped[str] = mapped_column(String(50), unique=True, nullable=False)
+    content: Mapped[str] = mapped_column(String(500), nullable=False)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+
+
+class Feedback(Base):
+    """Model for storing user feedback"""
+    __tablename__ = 'feedback'
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    user_id: Mapped[int] = mapped_column(ForeignKey('users.id', ondelete='CASCADE'), nullable=False)
+    service_id: Mapped[int] = mapped_column(ForeignKey('services.id', ondelete='CASCADE'), nullable=False)
+    rating: Mapped[int] = mapped_column(Integer, nullable=False)
+    review: Mapped[str] = mapped_column(String(1000))
+    is_new: Mapped[bool] = mapped_column(Boolean, default=True, nullable=False)
+    # Relationships
+    user = relationship("User", back_populates="feedback")
+    service = relationship("Service", back_populates="feedback")
+
+
+async def async_main():
+    """Initialize database tables"""
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)

app/database/requests.py

@@ -0,0 +1,708 @@
+from typing import Optional, List, Dict, Any
+from sqlalchemy import select, update, delete, func
+from sqlalchemy.ext.asyncio import AsyncSession
+from app.database.models import *
+from app.database.base import get_session
+import json
+from app.utils.exceptions import DatabaseError, ValidationError
+
+
+async def set_user(tg_id: int) -> Optional[User]:
+    """Create a new user if not exists or return existing user."""
+    async with get_session() as session:
+        try:
+            query = select(User).where(User.tg_id == tg_id)
+            user = await session.scalar(query)
+            if not user:
+                user = User(tg_id=tg_id)
+                session.add(user)
+                print("User added")
+            return user
+        except Exception as e:
+            raise DatabaseError(f"Error setting user: {str(e)}")
+
+
+async def user_register(
+    tg_id: int,
+    name: str,
+    login: str,
+    contact: str,
+    subscribe: bool
+) -> None:
+    """Update user registration information."""
+    async with get_session() as session:
+        try:
+            query = update(User).where(User.tg_id == tg_id).values(
+                name=name,
+                login=login,
+                contact=contact,
+                subscription_status="active" if subscribe else "inactive"
+            )
+            await session.execute(query)
+        except Exception as e:
+            raise DatabaseError(f"Error registering user: {str(e)}")
+        
+
+async def check_login_unique(login: str) -> bool:
+   """Check if login is available"""
+   async with get_session() as session:
+       user = await session.scalar(
+           select(User).where(User.login == login)
+       )
+       return user is None
+
+
+async def get_catalog() -> Optional[List[str]]:
+    """Get list of all service names."""
+    async with get_session() as session:
+        try:
+            query = select(Service).where(Service.is_active == True)
+            result = await session.execute(query)
+            services = result.scalars().all()
+            return services if services else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting catalog: {str(e)}")
+
+
+async def get_service_info(service_idx: str) -> Optional[Service]:
+    """Get detailed information about a specific service."""
+    async with get_session() as session:
+        try:
+            query = select(Service).where(
+                Service.id == service_idx,
+                Service.is_active == True
+            )
+            service = await session.scalar(query)
+            return service if service else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting service info: {str(e)}")
+
+
+async def add_service(name: str, desc: str, price: int, active=bool) -> None:
+    """Add a new service to the catalog."""
+    async with get_session() as session:
+        try:
+            service = Service(
+                service_name=name,
+                service_description=desc,
+                service_price=price,
+                is_active=active
+            )
+            session.add(service)
+        except Exception as e:
+            raise DatabaseError(f"Error adding service: {str(e)}")
+        
+
+async def edit_service(serv_id: int, param: str, change: Any, active: bool) -> None:
+    """Edit an existing service."""
+    param_mapping = {
+        'name': 'service_name',
+        'desc': 'service_description',
+        'price': 'service_price'
+    }
+    
+    if param not in param_mapping:
+        raise ValueError(f"Invalid parameter: {param}")
+        
+    async with get_session() as session:
+        try:
+            query = update(Service).where(
+                Service.id == serv_id
+            ).values({param_mapping[param]: change})
+            await session.execute(query)
+        except Exception as e:
+            raise DatabaseError(f"Error editing service: {str(e)}")
+
+
+async def delete_service(serv_id: int) -> bool:
+    """Delete a service from the catalog."""
+    async with get_session() as session:
+        try:
+            query = select(Service).where(Service.id == serv_id)
+            service = await session.scalar(query)
+            if not service:
+                return False
+            feedback_query = select(Feedback).where(Feedback.service_id == service.id)
+            has_feedback = await session.scalar(feedback_query)
+            if has_feedback:
+                update_query = (
+                    update(Service)
+                    .where(Service.id == serv_id)
+                    .values(is_active=False)
+                )
+                await session.execute(update_query)
+            else:
+                await session.delete(service)
+            return True
+        except Exception as e:
+            raise DatabaseError(f"Error deleting service: {str(e)}")
+
+
+async def get_leadmagnets() -> Optional[List[str]]:
+    """Get list of all active lead magnets."""
+    async with get_session() as session:
+        try:
+            query = select(LeadMagnet.trigger).where(LeadMagnet.is_active == True)
+            result = await session.execute(query)
+            magnets = result.scalars().all()
+            return magnets if magnets else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting lead magnets: {str(e)}")
+
+
+async def get_leadmagnet_info(trigger: str) -> Optional[LeadMagnet]:
+    """Get detailed information about a specific lead magnet."""
+    async with get_session() as session:
+        try:
+            query = select(LeadMagnet).where(
+                LeadMagnet.trigger == trigger,
+                LeadMagnet.is_active == True
+            )
+            magnet = await session.scalar(query)
+            return magnet if magnet else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting lead magnet info: {str(e)}")
+
+
+async def add_leadmagnet(trigger: str, content: str, active: bool) -> None:
+    """Add a new lead magnet."""
+    async with get_session() as session:
+        try:
+            magnet = LeadMagnet(
+                trigger=trigger,
+                content=content,
+                is_active=active
+            )
+            session.add(magnet)
+        except Exception as e:
+            raise DatabaseError(f"Error adding lead magnet: {str(e)}")
+
+
+async def edit_leadmagnet(name, param, change):
+    async with get_session() as session:
+        replace_dict = {'trigger': 'trigger',
+                        'content': 'content',
+                        'status': 'is_active'}
+        query = select(LeadMagnet).where(LeadMagnet.trigger == name)
+        result = await session.execute(query)
+        lead = result.scalars().first()
+        if lead:
+            update_query = (
+                update(LeadMagnet)
+                .where(LeadMagnet.trigger == name)
+                .values({replace_dict[param]: change})
+                .execution_options(synchronize_session="fetch")
+            )
+            await session.execute(update_query)
+            await session.commit()
+
+
+async def delete_leadmagnet(name: str) -> None:
+    """Delete a lead magnet."""
+    async with get_session() as session:
+        try:
+            query = delete(LeadMagnet).where(LeadMagnet.trigger == name)
+            await session.execute(query)
+        except Exception as e:
+            raise DatabaseError(f"Error deleting lead magnet: {str(e)}")
+
+
+async def get_tests() -> Optional[List[str]]:
+    """Get list of all active tests."""
+    async with get_session() as session:
+        try:
+            query = select(Test).where(Test.is_active == True)
+            result = await session.execute(query)
+            tests = result.scalars().all()
+            return tests if tests else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting tests: {str(e)}")
+        
+
+async def add_test_wo_points(
+    name: str,
+    test_type: str,
+    desc: str,
+    status: bool,
+    completion_message: str
+) -> None:
+    """Add a new test without points system."""
+    async with get_session() as session:
+        try:
+            test = Test(
+                test_name=name,
+                test_type=test_type,
+                test_description=desc,
+                is_active=status,
+                completion_message=completion_message
+            )
+            session.add(test)
+        except Exception as e:
+            raise DatabaseError(f"Error adding test: {str(e)}")
+
+
+async def add_question_vars_wo_points(test_name: str, text: str) -> None:
+    """Add questions and variants to a test without points system."""
+    async with get_session() as session:
+        try:
+            # Get test ID
+            test = await session.scalar(
+                select(Test).where(Test.test_name == test_name)
+            )
+            if not test:
+                raise ValidationError(f"Test {test_name} not found")
+
+            # Split text into question and variants
+            parts = text.split('***')
+            if len(parts) != 2:
+                raise ValidationError("Invalid question format")
+
+            question = TestQuestion(
+                test_id=test.id,
+                question_content=parts[0].strip(),
+                question_variants=parts[1].strip(),
+                question_points="{}"  # Empty JSON for non-pointed questions
+            )
+            session.add(question)
+        except Exception as e:
+            raise DatabaseError(f"Error adding question: {str(e)}")
+
+
+async def add_test_result_w_points(test_name: str, text: str) -> None:
+    """Add test results with point ranges."""
+    async with get_session() as session:
+        try:
+            test = await session.scalar(
+                select(Test).where(Test.test_name == test_name)
+            )
+            if not test:
+                raise ValidationError(f"Test {test_name} not found")
+
+            parts = text.split('\n')
+            if len(parts) != 2:
+                raise ValidationError("Invalid result format")
+
+            point_range = parts[0].strip()
+            min_points, max_points = map(int, point_range.split('-'))
+            
+            result = TestResult(
+                test_id=test.id,
+                min_points=min_points,
+                max_points=max_points,
+                result_text=parts[1].strip()
+            )
+            session.add(result)
+        except Exception as e:
+            raise DatabaseError(f"Error adding test result: {str(e)}")
+
+
+async def delete_test(t_id: int) -> None:
+    """Delete a test and all related questions and results."""
+    async with get_session() as session:
+        try:
+            test = await session.scalar(
+                select(Test).where(Test.id == t_id)
+            )
+            if test:
+                await session.delete(test)  # Cascade will handle related records
+        except Exception as e:
+            raise DatabaseError(f"Error deleting test: {str(e)}")
+
+
+async def get_test(t_id: int) -> Optional[Dict[str, Any]]:
+    """Get complete test information including questions and results."""
+    async with get_session() as session:
+        try:
+            test_query = select(Test).where(
+                Test.id == t_id,
+                Test.is_active == True
+            )
+            test = await session.scalar(test_query)
+            
+            if not test:
+                return None
+                
+            questions_query = select(TestQuestion).where(
+                TestQuestion.test_id == test.id
+            )
+            results_query = select(TestResult).where(
+                TestResult.test_id == test.id
+            )
+            
+            questions = (await session.execute(questions_query)).scalars().all()
+            results = (await session.execute(results_query)).scalars().all()
+            
+            return {
+                "id": t_id,
+                "test": test,
+                "questions": questions,
+                "results": results
+            }
+        except Exception as e:
+            raise DatabaseError(f"Error getting test: {str(e)}")
+
+
+async def change_test_status(t_id: int, status: bool) -> None:
+    """Change test active status."""
+    async with get_session() as session:
+        try:
+            query = update(Test).where(
+                Test.id == t_id
+            ).values(is_active=True if status == "Да" else False)
+            await session.execute(query)
+        except Exception as e:
+            raise DatabaseError(f"Error changing test status: {str(e)}")
+        
+
+async def add_feedback(
+    user_id: int,
+    service_name: str,
+    rating: int,
+    review: str
+) -> None:
+    """Add new feedback for a service."""
+    async with get_session() as session:
+        try:
+            service = await session.scalar(
+                select(Service).where(Service.service_name == service_name)
+            )
+            if not service:
+                raise ValidationError(f"Service {service_name} not found")
+
+            feedback = Feedback(
+                user_id=user_id,
+                service_id=service.id,
+                rating=rating,
+                review=review,
+                is_new=True
+            )
+            session.add(feedback)
+        except Exception as e:
+            raise DatabaseError(f"Error adding feedback: {str(e)}")
+        
+
+async def get_new_feedback() -> Optional[List[Feedback]]:
+    """Get all new feedback entries."""
+    async with get_session() as session:
+        try:
+            query = select(Feedback).where(Feedback.is_new == True)
+            result = await session.execute(query)
+            feedback = result.scalars().all()
+            return feedback if feedback else None
+        except Exception as e:
+            raise DatabaseError(f"Error getting new feedback: {str(e)}")
+        
+
+async def mark_feedback_as_read(feedback_id: int) -> None:
+    """Mark feedback as read."""
+    async with get_session() as session:
+        try:
+            query = update(Feedback).where(
+                Feedback.id == feedback_id
+            ).values(is_new=False)
+            await session.execute(query)
+        except Exception as e:
+            raise DatabaseError(f"Error marking feedback as read: {str(e)}")
+        
+
+async def get_user_info(tg_id: int) -> Optional[User]:
+    """Get user information by Telegram ID"""
+    async with get_session() as session:
+        try:
+            query = select(User).where(User.tg_id == tg_id)
+            user = await session.scalar(query)
+            return user
+        except Exception as e:
+            raise DatabaseError(f"Error getting user info: {str(e)}")
+        
+
+async def start_test_attempt(user_id: int, test_id: str) -> Optional[Dict[str, Any]]:
+    """Create new test attempt and return first question"""
+    async with get_session() as session:
+        try:
+            test = await session.scalar(
+                select(Test).where(
+                    Test.id == test_id,
+                    Test.is_active == True
+                )
+            )
+            if not test:
+                return None
+            user = await session.scalar(
+                select(User).where(User.tg_id == user_id)
+            )
+            if not user:
+                return None
+
+            # Create test attempt
+            attempt = TestAttempt(
+                user_id=user_id,
+                test_id=test.id
+            )
+            session.add(attempt)
+            await session.flush()  # Get attempt ID
+
+            # Get first question
+            question = await session.scalar(
+                select(TestQuestion)
+                .where(TestQuestion.test_id == test.id)
+                .order_by(TestQuestion.id)
+            )
+            await session.commit()
+            return {
+                "attempt_id": attempt.id,
+                "question": question,
+                "total_questions": await session.scalar(
+                    select(func.count()).select_from(TestQuestion)
+                    .where(TestQuestion.test_id == test.id)
+                )
+            }
+        except Exception as e:
+            raise DatabaseError(f"Error starting test: {str(e)}")
+
+
+async def record_answer(attempt_id: int, question_id: int, answer: str) -> Optional[Dict[str, Any]]:
+    """Record user's answer and return next question or result"""
+    async with get_session() as session:
+        try:
+            # Get the test attempt first
+            attempt = await session.scalar(
+                select(TestAttempt).where(TestAttempt.id == attempt_id)
+            )
+            if not attempt:
+                raise DatabaseError("Test attempt not found")
+
+            # Get question and test
+            question = await session.scalar(
+                select(TestQuestion).where(TestQuestion.id == question_id)
+            )
+            if not question:
+                raise DatabaseError("Question not found")
+
+            test = await session.scalar(
+                select(Test).where(Test.id == question.test_id)
+            )
+
+            # Calculate points
+            points = 0
+            if test.test_type == "С баллами":
+                variants_raw = question.question_variants.split('\n')
+                for variant in variants_raw:
+                    if variant.strip():
+                        try:
+                            variant_parts = variant.strip().split('...')
+                            if len(variant_parts) == 2:
+                                variant_text, points_str = variant_parts
+                                if variant_text.strip() == answer.split("...")[0].strip():
+                                    points = int(points_str.strip())
+                                    break
+                        except ValueError:
+                            continue
+
+            # Create and save answer record
+            answer_record = TestAnswer(
+                attempt_id=attempt_id,
+                question_id=question_id,
+                answer_given=answer,
+                points_earned=points
+            )
+            session.add(answer_record)
+            await session.flush()
+
+            # Get next question
+            next_question = await session.scalar(
+                select(TestQuestion)
+                .where(TestQuestion.test_id == test.id)
+                .where(TestQuestion.id > question_id)
+                .order_by(TestQuestion.id)
+            )
+
+            if next_question:
+                await session.commit()
+                return {"next_question": next_question}
+
+            # If no next question, test is complete
+            # Calculate total score
+            answers = await session.scalars(
+                select(TestAnswer)
+                .where(TestAnswer.attempt_id == attempt_id)
+            )
+            total_score = sum(ans.points_earned for ans in answers.all())
+
+            # Update attempt with final score
+            attempt.score = total_score
+            
+            if test.test_type == "С баллами":
+                # Get appropriate result
+                result = await session.scalar(
+                    select(TestResult)
+                    .where(TestResult.test_id == test.id)
+                    .where(TestResult.min_points <= total_score)
+                    .where(TestResult.max_points >= total_score)
+                )
+
+                attempt.result = result.result_text if result else None
+
+                result_dict = {
+                    "completed": True,
+                    "total_points": total_score,
+                    "result": result.result_text if result else None
+                }
+            else:
+                result_dict = {
+                    "completed": True,
+                    "result": test.completion_message
+                }
+                attempt.result = test.completion_message
+
+            await session.commit()
+            return result_dict
+
+        except Exception as e:
+            await session.rollback()
+            raise DatabaseError(f"Error recording answer: {str(e)}")
+        
+
+async def check_user_registered(user_id: int) -> bool:
+   """Check if user has completed registration"""
+   async with get_session() as session:
+       try:
+           user = await session.scalar(
+               select(User)
+               .where(User.tg_id == user_id)
+           )
+           print(f"User found: {user}")  # Debug print
+           return bool(user.name)
+       except Exception as e:
+           raise DatabaseError(f"Error checking user registration: {str(e)}")
+       
+
+async def get_user_test_results(user_login: str) -> List[Dict[str, Any]]:
+    """Get all test results for a user"""
+    async with get_session() as session:
+        try:
+            user = await session.scalar(
+               select(User).where(User.login == user_login)
+            )
+            if not user:
+               return "Пользователь не найден"
+            attempts = await session.execute(
+                select(TestAttempt, Test)
+                .join(Test)
+                .where(TestAttempt.user_id == user.tg_id)
+                .order_by(TestAttempt.completed_at.desc())
+            )
+            if attempts:
+                return ([
+                    {
+                        "test_name": test.test_name,
+                        "completed_at": attempt.completed_at,
+                        "score": attempt.score,
+                        "result": attempt.result
+                    }
+                    for attempt, test in attempts
+                    ])
+        
+        except Exception as e:
+            raise DatabaseError(f"Error getting test results: {str(e)}")
+        
+
+async def get_user_registration_info(user_id: int) -> str:
+   """Get formatted user registration information"""
+   async with get_session() as session:
+       try:
+           user = await session.scalar(
+               select(User).where(User.tg_id == user_id)
+           )
+           if not user:
+               return "Информация о пользователе не найдена"
+               
+           return (
+               "📋 Ваша регистрационная информация:\n"
+               f"ID: {user.tg_id}\n"
+               f"Имя: {user.name or 'Не указано'}\n"
+               f"Логин: {user.login or 'Не указано'}\n"
+               f"Контакт: {user.contact or 'Не указано'}\n"
+               f"Статус подписки: {'Активна' if user.subscription_status == 'active' else 'Неактивна'}"
+           )
+       except Exception as e:
+           raise DatabaseError(f"Error getting user info: {str(e)}")
+
+
+async def get_all_test_answers() -> List[Dict[str, Any]]:
+   """Fetch all test answers with related information"""
+   async with get_session() as session:
+       try:
+           result = await session.execute(
+               select(TestAnswer, TestAttempt, User, Test, TestQuestion)
+               .join(TestAttempt, TestAttempt.id == TestAnswer.attempt_id)
+               .join(User, User.id == TestAttempt.user_id)
+               .join(Test, Test.id == TestAttempt.test_id)
+               .join(TestQuestion, TestQuestion.id == TestAnswer.question_id)
+               .order_by(TestAttempt.completed_at.desc())
+           )
+           answers = result.fetchall()
+           print(answers)  # Debug print
+
+           return [
+               {
+                   "answer_id": answer.id,
+                   "user_name": user.name,
+                   "test_name": test.test_name,
+                   "question": question.question_content,
+                   "answer_given": answer.answer_given,
+                   "points_earned": answer.points_earned,
+                   "completed_at": attempt.completed_at.strftime("%d.%m.%Y %H:%M")
+               }
+               for answer, attempt, user, test, question in answers
+           ]
+
+       except Exception as e:
+           raise DatabaseError(f"Error fetching test answers: {str(e)}")
+       
+
+async def own_login_check(user_id: int, login: str) -> bool:
+    """Check if the provided login matches the user's login"""
+    async with get_session() as session:
+         try:
+              user = await session.scalar(
+                select(User).where(User.tg_id == user_id)
+              )
+              if not user:
+                return False
+              return user.login == login
+         except Exception as e:
+              raise DatabaseError(f"Error checking login: {str(e)}")
+         
+
+async def update_user_data(user_id: int, param: str, change: Any) -> None:
+    async with get_session() as session:
+        replace_dict = {'Имя': 'name',
+                        'Логин': 'login',
+                        'Контакт': 'contact',
+                        'Статус подписки на рассылку': 'subscription_status'}
+        query = select(User).where(User.tg_id == user_id)
+        result = await session.execute(query)
+        user = result.scalars().first()
+        if user:
+            update_query = (
+                update(User)
+                .where(User.tg_id == user_id)
+                .values({replace_dict[param]: change})
+                .execution_options(synchronize_session="fetch")
+            )
+            await session.execute(update_query)
+            await session.commit()
+
+
+async def get_broadcast_users() -> List[int]:
+    """Fetch all users for broadcasting"""
+    async with get_session() as session:
+        try:
+            result = await session.scalars(
+                select(User.tg_id)
+                .where(User.subscription_status == 'active')
+            )
+            return result.fetchall()
+        except Exception as e:
+            raise DatabaseError(f"Error fetching broadcast users: {str(e)}")

app/handlers/admin/broadcast.py

@@ -0,0 +1,34 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import admin_keyboards as kb
+from app.states import Other
+from app.database.requests import get_broadcast_users
+from app.middleware.authentification import admin_check
+from time import sleep
+from random import randint
+
+router = Router()
+
+@router.message(F.text == 'Отправить сообщение в рассылку')
+async def compose_message(message: Message, state: FSMContext):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await state.set_state(Other.admin_send_mailing)
+    await message.answer('Напишите Ваше сообщение')
+
+
+@router.message(Other.admin_send_mailing)
+async def send_message(message: Message, state: FSMContext):
+    user_ids = await get_broadcast_users()
+    if not user_ids:
+        await message.answer("Нет подписчиков для рассылки")
+        return
+    for user_id in user_ids:
+        await message.copy_to(user_id)
+        sleep(randint(1,5))
+    await message.answer(f"Сообщение отправлено {len(user_ids)} пользователям")
+    await state.clear()
+    

app/handlers/admin/catalog.py

@@ -0,0 +1,108 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import admin_keyboards as kb
+from app.states import AdminAddService, AdminStates
+from app.middleware.authentification import admin_check
+
+router = Router()
+
+@router.message(F.text == 'Отредактировать каталог услуг')
+async def catalog_editor_start(message: Message):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await message.answer(
+        'Текущие услуги. Нажмите на услугу для редактирования',
+        reply_markup=await kb.admin_keyboard_service_catalog()
+    )
+
+
+@router.callback_query(F.data.startswith('change_service_'))
+async def edit_service(callback: CallbackQuery):
+    await callback.answer('')
+    service = await rq.get_service_info(callback.data.split('_')[2])
+    await callback.message.answer(f'Услуга {service.service_name} \n\n'
+                                  f'Описание: {service.service_description}\n'
+                                  f'Цена: {service.service_price} рублей \n\n'
+                                  f'Что Вы хотите изменить?',
+                                  reply_markup=await kb.admin_change_service(service.id))
+
+
+@router.callback_query(F.data == 'add_service')
+async def add_service(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем услугу')
+    await state.set_state(AdminAddService.admin_add_name)
+    await callback.message.answer('Введите название новой услуги')
+
+
+@router.message(AdminAddService.admin_add_name)
+async def add_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(AdminAddService.admin_add_desc)
+    await message.answer('Введите описание новой услуги')
+
+
+@router.message(AdminAddService.admin_add_desc)
+async def add_desc(message: Message, state: FSMContext):
+    await state.update_data(desc=message.text)
+    await state.set_state(AdminAddService.admin_add_price)
+    await message.answer('Введите цену услуги в рублях')
+
+
+@router.message(AdminAddService.admin_add_price)
+async def add_price(message: Message, state: FSMContext):
+    await state.update_data(price=message.text)
+    data = await state.get_data()
+    await rq.add_service(data['name'], data['desc'], data['price'], True)
+    await message.answer('Услуга сохранена! Теперь можно изменить ее, выбрав услугу в меню и отредактировав',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@router.callback_query(F.data.startswith('editservice_'))
+async def begin_service_edit(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_edit_service)
+    await state.update_data(service_id=callback.data.split('_')[2])
+    await state.update_data(parameter_changed=callback.data.split("_")[1])
+    replace_dict = {'name': 'ое название', 'desc': 'ое описание', 'price': 'ую цену'}
+    await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} услуги')
+
+
+@router.message(AdminStates.admin_edit_service)
+async def finish_service_edit(message: Message, state: FSMContext):
+    await state.update_data(change=message.text)
+    data = await state.get_data()
+    await rq.edit_service(data['service_id'], data['parameter_changed'], data['change'], True)
+    await state.clear()
+    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)
+
+
+@router.callback_query(F.data.startswith('deleteservice_'))
+async def confirm_service_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_service)
+    await state.update_data(serv_id=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить услугу?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminStates.admin_delete_service)
+async def delete_or_not_delete(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_service(data['serv_id'])
+        await state.clear()
+        await message.answer('Услуга была успешно удалена! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@router.callback_query(F.data == 'admin_to_main')
+async def return_to_main(callback: CallbackQuery):
+    await callback.answer('Возвращаемся в меню')
+    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)

app/handlers/admin/leadmagnets.py

@@ -0,0 +1,112 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import admin_keyboards as kb
+from app.states import AdminAddLeadmagnet, AdminStates
+from app.middleware.authentification import admin_check
+
+router = Router()
+
+@router.message(F.text == 'Отредактировать кодовые слова')
+async def view_leadmagnets(message: Message):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await message.answer(
+        'Текущие лидмагниты. Нажмите для редактирования',
+        reply_markup=await kb.admin_keyboard_leadmagnets()
+    )
+
+
+@router.callback_query(F.data == 'add_leadmanget')
+async def add_leadmagnet(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем лидмагнит')
+    await state.set_state(AdminAddLeadmagnet.admin_set_trigger)
+    await callback.message.answer('Введите кодовое слово (пожалуйста, не используйте "_" в названии!)')
+
+
+@router.message(AdminAddLeadmagnet.admin_set_trigger)
+async def add_trigger(message: Message, state: FSMContext):
+    await state.update_data(trigger=message.text)
+    await state.set_state(AdminAddLeadmagnet.admin_set_content)
+    await message.answer('Введите содержание лидмагнита '
+                         '(сообщение, которое получит пользователь после отправки кодового слова)')
+
+
+@router.message(AdminAddLeadmagnet.admin_set_content)
+async def add_content(message: Message, state: FSMContext):
+    await state.update_data(content=message.text)
+    await state.set_state(AdminAddLeadmagnet.admin_set_status)
+    await message.answer('Хотите ли Вы сделать данный лидмагнит активным? Активные лидмагниты будут тут же доступны для '
+                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminAddLeadmagnet.admin_set_status)
+async def set_leadmagnet_status(message: Message, state: FSMContext):
+    await state.update_data(status=message.text)
+    data = await state.get_data()
+    await rq.add_leadmagnet(data['trigger'], data['content'], True if data['status'] == 'Да' else False)
+    await message.answer('Лидмагнит сохранен! Теперь можно отредактировать его, выбрав его в меню',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@router.callback_query(F.data.startswith('change_leadmagnet_'))
+async def edit_leadmagnet(callback: CallbackQuery):
+    await callback.answer('')
+    leadmagnet = await rq.get_leadmagnet_info(callback.data.split('_')[2])
+    await callback.message.answer(f'Триггер: {leadmagnet.trigger} \n\n'
+                                  f'Содержание: {leadmagnet.content}\n'
+                                  f'Активен? {leadmagnet.is_active}\n\n'
+                                  f'Что Вы хотите изменить?',
+                                  reply_markup=await kb.admin_change_leadmagnet(leadmagnet.trigger))
+
+
+@router.callback_query(F.data.startswith('editleadmagnet_'))
+async def begin_leadmagnet_edit(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_edit_leadmagnet)
+    await state.update_data(leadmagnet=callback.data.split('_')[2])
+    await state.update_data(parameter_changed=callback.data.split("_")[1])
+    replace_dict = {'trigger': 'ый триггер', 'content': 'ое содержание'}
+    if callback.data.split("_")[1] != 'status':
+        await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} лидмагнита')
+    elif callback.data.split("_")[1] == 'status':
+        await callback.message.answer(f'Должен ли лидмагнит быть активным?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminStates.admin_edit_leadmagnet)
+async def finish_leadmagnet_edit(message: Message, state: FSMContext):
+    await state.update_data(change=message.text)
+    data = await state.get_data()
+    await rq.edit_leadmagnet(data['leadmagnet'], data['parameter_changed'], True if data['change'] == 'Да' else False)
+    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)
+
+
+@router.callback_query(F.data.startswith('deleteleadmagnet_'))
+async def confirm_leadmagnet_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_leadmagnet)
+    await state.update_data(leadmagnet=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить лидмагнит {callback.data.split("_")[1]}?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminStates.admin_delete_leadmagnet)
+async def delete_or_not_delete(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_leadmagnet(data['leadmagnet'])
+        await state.clear()
+        await message.answer('Лидмагнит был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@router.callback_query(F.data == 'admin_to_main')
+async def return_to_main(callback: CallbackQuery):
+    await callback.answer('Возвращаемся в меню')
+    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)

app/handlers/admin/router.py

@@ -0,0 +1,31 @@
+from aiogram import Router, F
+from aiogram.types import Message
+from app.middleware.authentification import admin_check
+from app.keyboards import admin_keyboards as kb
+from .catalog import router as catalog_router
+from .leadmagnets import router as leadmagnets_router
+from .tests import router as tests_router
+from .view_tests import router as view_tests_router
+from .broadcast import router as broadcast_router
+
+admin_router = Router()
+
+admin_router.include_router(catalog_router)
+admin_router.include_router(leadmagnets_router)
+admin_router.include_router(tests_router)
+admin_router.include_router(view_tests_router)
+admin_router.include_router(broadcast_router)
+
+@admin_router.message(F.text.lower() == 'вход для админов')
+async def admin_enter(message: Message):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await message.answer('Здравствуйте! Что Вы хотите сделать?', 
+                        reply_markup=kb.admin_main)
+
+@admin_router.message(F.text == 'Вернуться в пользовательский интерфейс')
+async def return_as_user(message: Message):
+    await message.answer(
+        'Спасибо! Для возврата в пользовательский режим отправьте /start'
+    )

app/handlers/admin/tests.py

@@ -0,0 +1,203 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import admin_keyboards as kb
+from app.states import AdminAddTest, AdminStates
+from app.middleware.authentification import admin_check
+
+router = Router()
+
+@router.message(F.text == 'Отредактировать тесты')
+async def test_editor_start(message: Message):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await message.answer(
+        'Текущие тесты. Нажмите для редактирования',
+        reply_markup=await kb.admin_keyboard_tests()
+    )
+
+
+@router.callback_query(F.data == 'add_test')
+async def add_test(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем тест')
+    await state.set_state(AdminAddTest.admin_set_title)
+    await callback.message.answer('Введите название теста (пожалуйста, не используйте "_" в названии!)')
+
+
+@router.message(AdminAddTest.admin_set_title)
+async def add_test_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(AdminAddTest.admin_set_desc)
+    await message.answer('Введите краткое описание теста')
+
+
+@router.message(AdminAddTest.admin_set_desc)
+async def add_test_desc(message: Message, state: FSMContext):
+    await state.update_data(desc=message.text)
+    await state.set_state(AdminAddTest.admin_set_status)
+    await message.answer('Хотите ли Вы сделать данный тест активным? Активные тесты будут тут же доступны для '
+                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminAddTest.admin_set_status)
+async def add_test_status(message: Message, state: FSMContext):
+    await state.update_data(status=message.text)
+    await state.set_state(AdminAddTest.admin_set_type)
+    await message.answer('Введите тип теста: с баллами или без баллов. Тесты с баллами предполагают вывод разных '
+                         'итогов теста в зависимости от количества набранных баллов, тесты без баллов предполагают '
+                         'одно и то же сообщение по итогам прохождения', reply_markup=kb.test_type_keyboard)
+
+
+@router.message(AdminAddTest.admin_set_type)
+async def add_test_type(message: Message, state: FSMContext):
+    await state.update_data(type=message.text)
+    if message.text == 'С баллами':
+        await state.update_data(completion_message=None)
+        data = await state.get_data()
+        await rq.add_test_wo_points(data['name'], data['type'], data['desc'], True if data['status'] == 'Да' else False,
+                                    data['completion_message'])
+        await state.set_state(AdminAddTest.admin_set_completion_result_set)
+        await message.answer('Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
+                             'достижения в следующем формате: \n'
+                             '22-24 \n'
+                             'Вы получили результат 1!')
+    if message.text == 'Без баллов':
+        await state.set_state(AdminAddTest.admin_set_completion_result)
+        await message.answer('Введите сообщение, показывающееся в конце теста')
+
+
+@router.message(AdminAddTest.admin_set_completion_result)
+async def add_test_completion_wo(message: Message, state: FSMContext):
+    await state.update_data(completion_message=message.text)
+    data = await state.get_data()
+    await rq.add_test_wo_points(data['name'], data['type'], data['desc'], True if data['status'] == 'Да' else False, data['completion_message'])
+    await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+    await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. Например: \n\n'
+                         'В каком году Юрий Гагарин полетел в космос?\n***\n'
+                         '1963 год \n'
+                         '1961 год \n'
+                         '1968 год')
+
+
+@router.message(AdminAddTest.admin_add_question_vars_wo_points)
+async def add_question_wo(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.add_question_vars_wo_points(data['name'], message.text)
+    await state.set_state(AdminAddTest.admin_end_questions)
+    await message.answer('Хотите ли вы добавить еще один вопрос?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminAddTest.admin_end_questions)
+async def do_we_continue_q(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+        await message.answer('Введите вопрос, придерживаясь такого же форматирования, как раньше')
+    elif message.text == 'Нет':
+        await state.clear()
+        await message.answer('Спасибо! Ваш тест сохранен! Можно вернуться в меню!', reply_markup=kb.admin_back)
+
+
+@router.message(AdminAddTest.admin_set_completion_result_set)
+async def add_test_completion_w(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.add_test_result_w_points(data['name'], message.text)
+    await state.set_state(AdminAddTest.admin_end_results)
+    await message.answer('Хотите ли вы добавить еще вариант?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminAddTest.admin_end_results)
+async def add_test_completion_choice(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        await state.set_state(AdminAddTest.admin_set_completion_result_set)
+        await message.answer(
+            'Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
+            'достижения в следующем формате: \n'
+            '22-24 \n'
+            'Вы получили результат 1!')
+    if message.text == 'Нет':
+        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+        await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. После каждого ответа '
+                             'указывайте количество баллов, начисляемых за этот вариант, через .... Например: \n\n'
+                         'В каком году Юрий Гагарин полетел в космос?\n***\n'
+                         '1963 год...0 \n'
+                         '1961 год...2 \n'
+                         '1968 год...0')
+
+
+@router.callback_query(F.data.startswith('change_test_'))
+async def view_test(callback: CallbackQuery):
+    await callback.answer('')
+    test_data = await rq.get_test(callback.data.split('_')[2])
+    results_string = ''
+    if not test_data['results']:
+        results_string += 'Отдельных результатов теста нет'
+    else:
+        for i in range(len(test_data['results'])):
+            results_string += f'Результат теста для количества очков {test_data["results"][i].max_points} - {test_data["results"][i].min_points}: \n' \
+                             f'{test_data["results"][i].result_text} \n'
+    questions_string = ''
+    if not test_data['questions']:
+        questions_string += 'У этого теста нет вопросов'
+    else:
+        for i in range(len(test_data['questions'])):
+            questions_string += f'Вопрос {i+1}: {test_data["questions"][i].question_content} \n' \
+                              f'Варианты ответа: {test_data["questions"][i].question_variants} \n'
+    await callback.message.answer(f'Название теста: {test_data["test"].test_name}, \n'
+                                  f'Тип теста: {test_data["test"].test_type}, \n'
+                                  f'Описание теста: {test_data["test"].test_description} \n'
+                                  f'Статус активности теста: {test_data["test"].is_active} \n'
+                                  f'Сообщение о завершении теста: {test_data["test"].completion_message} \n'
+                                  f'Возможные результаты теста: \n{results_string} \n\n'
+                                  f'Вопросы теста: \n{questions_string} \n\n'
+                                  f'На данный момент подробное редактирование тестов не поддерживается. Если Вы хотите '
+                                  f'изменить статус активности теста, нажмите на соответствующую кнопку внизу. Если Вы '
+                                  f'хотите внести в тест содержательные изменения, мы рекомендуем удалить тест и '
+                                  f'внести его заново!',
+                                  reply_markup= await kb.admin_change_test(test_data['id']))
+
+
+@router.callback_query(F.data.startswith('edittest_status_'))
+async def change_status(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.update_data(id=callback.data.split('_')[2])
+    await state.set_state(AdminStates.admin_edit_test_status)
+    await callback.message.answer(f'Должен ли тест быть активным?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminStates.admin_edit_test_status)
+async def set_new_status(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.change_test_status(data['id'], message.text)
+    await message.answer('Изменения были сохранены! Теперь можно вернуться в меню!',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@router.callback_query(F.data.startswith('deletetest_'))
+async def confirm_test_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_test)
+    await state.update_data(id=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить тест?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(AdminStates.admin_delete_test)
+async def delete_or_not_delete_test(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_test(data['id'])
+        await state.clear()
+        await message.answer('Тест был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@router.callback_query(F.data == 'admin_to_main')
+async def return_to_main(callback: CallbackQuery):
+    await callback.answer('Возвращаемся в меню')
+    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)

app/handlers/admin/view_tests.py

@@ -0,0 +1,57 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import admin_keyboards as kb
+from app.database.requests import get_user_test_results, get_all_test_answers
+from app.states import TestStates
+from app.middleware.authentification import admin_check
+
+router = Router()
+
+@router.message(F.text == "Просмотреть результаты тестов")
+async def name_provide(message: Message, state: FSMContext):
+    if not await admin_check(message, {}):
+        await message.answer("У вас нет доступа к админ-панели")
+        return
+    await state.set_state(TestStates.name_get)
+    await message.answer("Введите имя пользователя, результаты тестов которого хотите посмотреть. Для просмотра результатов теста пользователь должен быть зарегистрирован!")
+
+
+@router.message(TestStates.name_get)
+async def show_user_results(message: Message, state: FSMContext):
+    results = await get_user_test_results(message.text)
+    
+    if isinstance(results, str):
+        await message.answer(results, reply_markup=kb.admin_main)
+        return
+
+    if not results:
+        await message.answer(
+            "📊 У пользователя пока нет результатов тестов",
+            reply_markup=kb.admin_main
+        )
+        return
+
+    response = f"📋 Результаты тестов пользователя {message.text}:\n\n"
+
+    for result in results:
+        completed_date = result['completed_at'].strftime("%d.%m.%Y %H:%M")
+        response += (
+            f"🔷 Тест: {result['test_name']}\n"
+            f"📅 Дата прохождения: {completed_date}\n"
+            f"📊 Набрано баллов: {result['score'] if result['score'] is not None else 'Нет баллов'}\n"
+            f"📝 Результат: {result['result'] if result['result'] else 'Не определен'}\n"
+            f"{'─' * 30}\n\n"
+        )
+
+    await message.answer(
+        response,
+        reply_markup=kb.admin_main,
+        parse_mode="HTML"
+    )
+
+@router.callback_query(F.data == 'admin_to_main')
+async def return_to_main(callback: CallbackQuery):
+    await callback.answer('Возвращаемся в меню')
+    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)

app/handlers/admin_route.py

@@ -0,0 +1,392 @@
+from aiogram.types import Message, CallbackQuery
+from aiogram import F, Router
+from aiogram.fsm.context import FSMContext
+
+import app.keyboards.admin_keyboards as kb
+import app.database.requests as rq
+from app.states import AdminAddService, AdminAddLeadmagnet, AdminAddTest, AdminStates
+
+admin_router = Router()
+
+
+@admin_router.message((F.text == 'Вход для админов'))
+async def admin_enter(message: Message):
+    await message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)
+
+
+@admin_router.message(F.text == 'Отредактировать каталог услуг')
+async def catalog_editor_start(message: Message):
+    await message.answer('Сейчас у нас представлены следующие услуги. Нажмите на услугу, чтобы отредактировать ее ',
+                         reply_markup=await kb.admin_keyboard_service_catalog())
+
+
+@admin_router.callback_query(F.data.startswith('change_service_'))
+async def edit_service(callback: CallbackQuery):
+    await callback.answer('')
+    service = await rq.get_service_info(callback.data.split('_')[2])
+    await callback.message.answer(f'Услуга {service.service_name} \n\n'
+                                  f'Описание: {service.service_description}\n'
+                                  f'Цена: {service.service_price} рублей \n\n'
+                                  f'Что Вы хотите изменить?',
+                                  reply_markup=await kb.admin_change_service(service.service_name))
+
+
+@admin_router.callback_query(F.data == 'admin_to_main')
+async def return_to_main(callback: CallbackQuery):
+    await callback.answer('Возвращаемся в меню')
+    await callback.message.answer('Здравствуйте! Что Вы хотите сделать?', reply_markup=kb.admin_main)
+
+
+@admin_router.callback_query(F.data == 'add_service')
+async def add_service(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем услугу')
+    await state.set_state(AdminAddService.admin_add_name)
+    await callback.message.answer('Введите название новой услуги')
+
+
+@admin_router.message(AdminAddService.admin_add_name)
+async def add_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(AdminAddService.admin_add_desc)
+    await message.answer('Введите описание новой услуги')
+
+
+@admin_router.message(AdminAddService.admin_add_desc)
+async def add_desc(message: Message, state: FSMContext):
+    await state.update_data(desc=message.text)
+    await state.set_state(AdminAddService.admin_add_price)
+    await message.answer('Введите цену услуги в рублях')
+
+
+@admin_router.message(AdminAddService.admin_add_price)
+async def add_price(message: Message, state: FSMContext):
+    await state.update_data(price=message.text)
+    data = await state.get_data()
+    await rq.add_service(data['name'], data['desc'], data['price'])
+    await message.answer('Услуга сохранена! Теперь можно изменить ее, выбрав услугу в меню и отредактировав',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@admin_router.callback_query(F.data.startswith('editservice_'))
+async def begin_service_edit(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_edit_service)
+    await state.update_data(service=callback.data.split('_')[2])
+    await state.update_data(parameter_changed=callback.data.split("_")[1])
+    replace_dict = {'name': 'ое название', 'desc': 'ое описание', 'price': 'ую цену'}
+    await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} услуги')
+
+
+@admin_router.message(AdminStates.admin_edit_service)
+async def finish_service_edit(message: Message, state: FSMContext):
+    await state.update_data(change=message.text)
+    data = await state.get_data()
+    await rq.edit_service(data['service'], data['parameter_changed'], data['change'])
+    await state.clear()
+    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)
+
+
+@admin_router.callback_query(F.data.startswith('deleteservice_'))
+async def confirm_service_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_service)
+    await state.update_data(name=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить услугу {callback.data.split("_")[1]}?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminStates.admin_delete_service)
+async def delete_or_not_delete(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_service(data['name'])
+        await state.clear()
+        await message.answer('Услуга была успешно удалена! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@admin_router.message(F.text == 'Отредактировать кодовые слова')
+async def view_leadmagnets(message: Message):
+    await message.answer('Вот текущие лидмагниты. Нажмите на подходящий лидмагнит, чтобы изменить его.',
+                         reply_markup=await kb.admin_keyboard_leadmagnets())
+
+
+@admin_router.callback_query(F.data == 'add_leadmanget')
+async def add_leadmagnet(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем лидмагнит')
+    await state.set_state(AdminAddLeadmagnet.admin_set_trigger)
+    await callback.message.answer('Введите кодовое слово (пожалуйста, не используйте "_" в названии!)')
+
+
+@admin_router.message(AdminAddLeadmagnet.admin_set_trigger)
+async def add_trigger(message: Message, state: FSMContext):
+    await state.update_data(trigger=message.text)
+    await state.set_state(AdminAddLeadmagnet.admin_set_content)
+    await message.answer('Введите содержание лидмагнита '
+                         '(сообщение, которое получит пользователь после отправки кодового слова)')
+
+
+@admin_router.message(AdminAddLeadmagnet.admin_set_content)
+async def add_content(message: Message, state: FSMContext):
+    await state.update_data(content=message.text)
+    await state.set_state(AdminAddLeadmagnet.admin_set_status)
+    await message.answer('Хотите ли Вы сделать данный лидмагнит активным? Активные лидмагниты будут тут же доступны для '
+                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminAddLeadmagnet.admin_set_status)
+async def set_leadmagnet_status(message: Message, state: FSMContext):
+    await state.update_data(status=message.text)
+    data = await state.get_data()
+    await rq.add_leadmagnet(data['trigger'], data['content'], data['status'])
+    await message.answer('Лидмагнит сохранен! Теперь можно отредактировать его, выбрав его в меню',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@admin_router.callback_query(F.data.startswith('change_leadmagnet_'))
+async def edit_leadmagnet(callback: CallbackQuery):
+    await callback.answer('')
+    leadmagnet = await rq.get_leadmagnet_info(callback.data.split('_')[2])
+    await callback.message.answer(f'Триггер: {leadmagnet.trigger} \n\n'
+                                  f'Содержание: {leadmagnet.content}\n'
+                                  f'Активен? {leadmagnet.active_status}\n\n'
+                                  f'Что Вы хотите изменить?',
+                                  reply_markup=await kb.admin_change_leadmagnet(leadmagnet.trigger))
+
+
+@admin_router.callback_query(F.data.startswith('editleadmagnet_'))
+async def begin_leadmagnet_edit(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_edit_leadmagnet)
+    await state.update_data(leadmagnet=callback.data.split('_')[2])
+    await state.update_data(parameter_changed=callback.data.split("_")[1])
+    replace_dict = {'trigger': 'ый триггер', 'content': 'ое содержание'}
+    if callback.data.split("_")[1] != 'status':
+        await callback.message.answer(f'Введите нов{replace_dict[callback.data.split("_")[1]]} лидмагнита')
+    elif callback.data.split("_")[1] == 'status':
+        await callback.message.answer(f'Должен ли лидмагнит быть активным?', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminStates.admin_edit_leadmagnet)
+async def finish_leadmagnet_edit(message: Message, state: FSMContext):
+    await state.update_data(change=message.text)
+    data = await state.get_data()
+    await rq.edit_leadmagnet(data['leadmagnet'], data['parameter_changed'], data['change'])
+    await message.answer(f'Информация была обновлена, можно вернуться на главную', reply_markup=kb.admin_back)
+
+
+@admin_router.callback_query(F.data.startswith('deleteleadmagnet_'))
+async def confirm_leadmagnet_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_leadmagnet)
+    await state.update_data(leadmagnet=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить лидмагнит {callback.data.split("_")[1]}?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminStates.admin_delete_leadmagnet)
+async def delete_or_not_delete(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_leadmagnet(data['leadmagnet'])
+        await state.clear()
+        await message.answer('Лидмагнит был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@admin_router.message(F.text == 'Отредактировать тесты')
+async def test_editor_start(message: Message):
+    await message.answer('Сейчас у нас имеются следующие тесты. Нажмите на тест, чтобы отредактировать его ',
+                         reply_markup=await kb.admin_keyboard_tests())
+
+
+@admin_router.callback_query(F.data == 'add_test')
+async def add_test(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('Добавляем тест')
+    await state.set_state(AdminAddTest.admin_set_title)
+    await callback.message.answer('Введите название теста (пожалуйста, не используйте "_" в названии!)')
+
+
+@admin_router.message(AdminAddTest.admin_set_title)
+async def add_test_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(AdminAddTest.admin_set_desc)
+    await message.answer('Введите краткое описание теста')
+
+
+@admin_router.message(AdminAddTest.admin_set_desc)
+async def add_test_desc(message: Message, state: FSMContext):
+    await state.update_data(desc=message.text)
+    await state.set_state(AdminAddTest.admin_set_status)
+    await message.answer('Хотите ли Вы сделать данный тест активным? Активные тесты будут тут же доступны для '
+                         'взаимодействия в пользовательском интерфейсе.', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminAddTest.admin_set_status)
+async def add_test_status(message: Message, state: FSMContext):
+    await state.update_data(status=message.text)
+    await state.set_state(AdminAddTest.admin_set_type)
+    await message.answer('Введите тип теста: с баллами или без баллов. Тесты с баллами предполагают вывод разных '
+                         'итогов теста в зависимости от количества набранных баллов, тесты без баллов предполагают '
+                         'одно и то же сообщение по итогам прохождения', reply_markup=kb.test_type_keyboard)
+
+
+@admin_router.message(AdminAddTest.admin_set_type)
+async def add_test_type(message: Message, state: FSMContext):
+    await state.update_data(type=message.text)
+    if message.text == 'С баллами':
+        await state.update_data(completion_message=None)
+        data = await state.get_data()
+        await rq.add_test_wo_points(data['name'], data['type'], data['desc'], data['status'],
+                                    data['completion_message'])
+        await state.set_state(AdminAddTest.admin_set_completion_result_set)
+        await message.answer('Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
+                             'достижения в следующем формате: \n'
+                             '22-24 \n'
+                             'Вы получили результат 1!')
+    if message.text == 'Без баллов':
+        await state.set_state(AdminAddTest.admin_set_completion_result)
+        await message.answer('Введите сообщение, показывающееся в конце теста')
+
+
+@admin_router.message(AdminAddTest.admin_set_completion_result)
+async def add_test_completion_wo(message: Message, state: FSMContext):
+    await state.update_data(completion_message=message.text)
+    data = await state.get_data()
+    await rq.add_test_wo_points(data['name'], data['type'], data['desc'], data['status'], data['completion_message'])
+    await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+    await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. Например: \n\n'
+                         'В каком году Юрий Гагарин полетел в космос?\n>>>\n'
+                         '1963 год \n'
+                         '1961 год \n'
+                         '1968 год')
+
+
+@admin_router.message(AdminAddTest.admin_add_question_vars_wo_points)
+async def add_question_wo(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.add_question_vars_wo_points(data['name'], message.text)
+    await state.set_state(AdminAddTest.admin_end_questions)
+    await message.answer('Хотите ли вы добавить еще один вопрос?', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminAddTest.admin_end_questions)
+async def do_we_continue_q(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+        await message.answer('Введите вопрос, придерживаясь такого же форматирования, как раньше')
+    elif message.text == 'Нет':
+        await state.clear()
+        await message.answer('Спасибо! Ваш тест сохранен! Можно вернуться в меню!', reply_markup=kb.admin_back)
+
+
+@admin_router.message(AdminAddTest.admin_set_completion_result_set)
+async def add_test_completion_w(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.add_test_result_w_points(data['name'], message.text)
+    await state.set_state(AdminAddTest.admin_end_results)
+    await message.answer('Хотите ли вы добавить еще вариант?', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminAddTest.admin_end_results)
+async def add_test_completion_choice(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        await state.set_state(AdminAddTest.admin_set_completion_result_set)
+        await message.answer(
+            'Введите вариант сообщения, показывающегося в конце теста, и количество баллов, нужное для его '
+            'достижения в следующем формате: \n'
+            '22-24 \n'
+            'Вы получили результат 1!')
+    if message.text == 'Нет':
+        await state.set_state(AdminAddTest.admin_add_question_vars_wo_points)
+        await message.answer('Введите первый вопрос, на следующих строках введите варианты ответа. После каждого ответа '
+                             'указывайте количество баллов, начисляемых за этот вариант, через .... Например: \n\n'
+                         'В каком году Юрий Гагарин полетел в космос?\n>>>\n'
+                         '1963 год...0 \n'
+                         '1961 год...2 \n'
+                         '1968 год...0')
+
+
+@admin_router.callback_query(F.data.startswith('change_test_'))
+async def view_test(callback: CallbackQuery):
+    await callback.answer('')
+    test_data = await rq.get_test(callback.data.split('_')[2])
+    results_string = ''
+    if not test_data['results']:
+        results_string += 'Отдельных результатов теста нет'
+    else:
+        for i in range(len(test_data['results'])):
+            results_string += f'Результат теста для количества очков {test_data["results"][i].pointrange}: \n' \
+                             f'{test_data["results"][i].result_text} \n'
+    questions_string = ''
+    if not test_data['questions']:
+        questions_string += 'У этого теста нет вопросов'
+    else:
+        for i in range(len(test_data['questions'])):
+            questions_string += f'Вопрос {i+1}: {test_data["questions"][i].question_content} \n' \
+                              f'Варианты ответа: {test_data["questions"][i].question_variants} \n'
+    await callback.message.answer(f'Название теста: {test_data["test"].test_name}, \n'
+                                  f'Тип теста: {test_data["test"].test_type}, \n'
+                                  f'Описание теста: {test_data["test"].test_description} \n'
+                                  f'Статус активности теста: {test_data["test"].active_status} \n'
+                                  f'Сообщение о завершении теста: {test_data["test"].completion_message} \n'
+                                  f'Возможные результаты теста: \n{results_string} \n\n'
+                                  f'Вопросы теста: \n{questions_string} \n\n'
+                                  f'На данный момент подробное редактирование тестов не поддерживается. Если Вы хотите '
+                                  f'изменить статус активности теста, нажмите на соответствующую кнопку внизу. Если Вы '
+                                  f'хотите внести в тест содержательные изменения, мы рекомендуем удалить тест и '
+                                  f'внести его заново!',
+                                  reply_markup= await kb.admin_change_test(test_data['test'].test_name))
+
+
+@admin_router.callback_query(F.data.startswith('edittest_status_'))
+async def change_status(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.update_data(name=callback.data.split('_')[2])
+    await state.set_state(AdminStates.admin_edit_test_status)
+    await callback.message.answer(f'Должен ли тест быть активным?', reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminStates.admin_edit_test_status)
+async def set_new_status(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await rq.change_test_status(data['name'], message.text)
+    await message.answer('Изменения были сохранены! Теперь можно вернуться в меню!',
+                         reply_markup=kb.admin_back)
+    await state.clear()
+
+
+@admin_router.callback_query(F.data.startswith('deletetest_'))
+async def confirm_test_deletion(callback: CallbackQuery, state: FSMContext):
+    await callback.answer('')
+    await state.set_state(AdminStates.admin_delete_test)
+    await state.update_data(name=callback.data.split("_")[1])
+    await callback.message.answer(f'Вы уверены, что хотите удалить тест {callback.data.split("_")[1]}?',
+                            reply_markup=kb.yes_no_keyboard)
+
+
+@admin_router.message(AdminStates.admin_delete_test)
+async def delete_or_not_delete_test(message: Message, state: FSMContext):
+    if message.text == 'Нет':
+        await state.clear()
+        await message.answer('Тогда вернемся в меню :)', reply_markup=kb.admin_back)
+
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.delete_test(data['name'])
+        await state.clear()
+        await message.answer('Тест был успешно удален! Можно вернуться в меню', reply_markup=kb.admin_back)
+
+
+@admin_router.message(F.text == 'Вернуться в пользовательский интерфейс')
+async def return_as_user(message: Message):
+    await message.answer('Спасибо! Удачного Вам дня! Отправьте в чат /start, чтобы вернуться в пользовательский режим '
+                         'редактирования!')

app/handlers/user/catalog.py

@@ -0,0 +1,74 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+from app.states import Other
+from app.database.requests import check_user_registered
+from app.config.config import ADMIN_ID
+
+router = Router()
+
+@router.message(F.text == 'Посмотреть каталог услуг')
+async def get_catalog(message: Message):
+    await message.answer('Спасибо за интерес! Вот наш перечень услуг. '
+                         'Пожалуйста, выберите самую подходящую и нажмите на соответствующую кнопку, '
+                         'чтобы узнать о ней подробнее:', reply_markup=await kb.user_keyboard_catalog())
+
+
+@router.callback_query(F.data.startswith('service_'))
+async def service_info(callback: CallbackQuery,state: FSMContext):
+    await callback.answer('')
+    service_info = await rq.get_service_info(callback.data.split('_')[1])
+    service_string = f"Вот информация по выбранной Вами услуге: \n" \
+                     f"Название: {service_info.service_name} \n" \
+                     f"Описание: {service_info.service_description} \n" \
+                     f"Цена: {service_info.service_price}. \n\n" \
+                     f"Хотите ли Вы воспользоваться данной услугой?"
+    await callback.answer('')
+    await state.set_state(Other.user_pre_buy_service)
+    await state.update_data(user_id=callback.from_user.id,
+                            user_username=callback.from_user.username,
+                            service=service_info.service_name)
+    await callback.message.answer(service_string, reply_markup=kb.service_confirm)
+
+
+@router.message(F.text == 'Да, связаться с Ниной')
+async def admin_prompt(message: Message, state: FSMContext):
+    await state.set_state(Other.user_buy_service)
+    await message.answer('Напишите Нине и изложите Вашу проблему - это поможет ей лучше понять Ваш конкретный случай'
+                         ' и сделать Ваш разговор более предметным!')
+
+
+@router.message(Other.user_buy_service)
+async def admin_connect(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await message.bot.send_message(chat_id=ADMIN_ID[0],
+                           text=f'Здравствуйте! Поступил новый заказ на услугу {data["service"]} от пользователя'
+                                f' @{data["user_username"]}')
+    await message.send_copy(ADMIN_ID[0])
+    await message.answer('Спасибо за обращение! Скоро Нина свяжется с Вами в личных сообщениях для обсуждения '
+                         'подробностей Вашего заказа!')
+    await state.clear()
+    registration_status = await check_user_registered(message.from_user.id)
+    if registration_status:
+        await message.answer('Вы можете вернуться в меню и посмотреть, какие еще услуги мы предлагаем!',
+                         reply_markup=kb.user_back_wo_reg)
+    elif not registration_status:
+        await message.answer('Вы можете вернуться в меню и посмотреть, какие еще услуги мы предлагаем! Еще мы предлагаем '
+                         'зарегистрироваться, чтобы получить возможность не пропускать всё самое важное, что происходит '
+                         'в канале. Также регистрация позволит Вам вступить в СЕКРЕТНЫЙ КЛУБ пользователей, которые'
+                         ' будут иметь доступ к специальным акциям и ВКУСНЫМ ЦЕНАМ для своих!',
+                         reply_markup=kb.user_back)
+
+
+@router.message(F.text == 'Нет, вернуться в меню')
+async def np_service_return_to_menu(message: Message, state: FSMContext):
+    await state.clear()
+    await message.answer('Чем я могу Вам помочь?', reply_markup=kb.user_main)
+
+
+@router.callback_query(F.data == "user_to_main")
+async def register(callback: CallbackQuery):
+    await callback.answer("Возвращаемся в меню")
+    await callback.message.answer("Чем я могу Вам помочь?", reply_markup=kb.user_main)

app/handlers/user/info_check.py

@@ -0,0 +1,55 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+from app.database.requests import check_user_registered, update_user_data, check_login_unique, own_login_check
+from app.states import Other
+
+router = Router()
+
+@router.message(F.text == "Посмотреть сохраненные сведения о себе")
+async def get_info(message: Message):
+    registration_status = await check_user_registered(message.from_user.id)
+    if registration_status:
+        user_info = await rq.get_user_registration_info(message.from_user.id)
+        await message.answer(user_info, reply_markup=kb.user_infocheck_back)
+    elif not registration_status:
+        await message.answer("Вы не зарегистрированы. Пожалуйста, зарегистрируйтесь, чтобы увидеть сохраненные сведения о себе.", reply_markup=kb.user_back)
+        return
+    
+
+@router.callback_query(F.data == 'data_correct')
+async def correction_info(callback: CallbackQuery, state: FSMContext):
+    await state.set_state(Other.user_data_check)
+    await callback.message.answer('Вы правда хотите изменить регистрационные данные?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(Other.user_data_check)
+async def register_check(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        await state.set_state(Other.user_data_correct)
+        await message.answer('Упс :( Что Вы хотите исправить?', reply_markup=kb.register_correct_keyboard)
+    if message.text == 'Нет':
+        await message.answer('Хорошо! Если что-то изменится, Вы всегда можете обновить свои данные!', reply_markup=kb.user_back_wo_reg)
+        await state.clear()
+
+
+@router.message(Other.user_data_correct)
+async def correction_info(message: Message, state: FSMContext):
+    await state.update_data(correction=message.text)
+    print("check")
+    await state.set_state(Other.user_data_finish)
+    await message.answer('Какие данные Вы хотите внести?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(Other.user_data_finish)
+async def correction_info_set(message: Message, state: FSMContext):
+    data = await state.get_data()
+    if data['correction'] == 'Логин':
+        if not await check_login_unique(message.text) and not own_login_check(message.from_user.id, message.text):
+            await message.answer('Этот логин уже занят. Пожалуйста, выберите другой.')
+            return
+    await update_user_data(message.from_user.id, data['correction'], message.text)
+    await state.clear()
+    await message.answer('Изменения внесены!', reply_markup=kb.user_back_wo_reg)

app/handlers/user/leadmagnets.py

@@ -0,0 +1,71 @@
+from aiogram import Router, F
+from aiogram.types import Message
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+from app.states import LeadMagnetStates
+
+router = Router()
+
+@router.message(F.text == "Ввести кодовое слово")
+async def start_leadmagnet_input(message: Message, state: FSMContext):
+    await state.set_state(LeadMagnetStates.waiting_for_keyword)
+    await message.answer(
+        "Пожалуйста, введите кодовое слово.\n"
+        "Для возврата в меню напишите 'отмена'",
+        reply_markup=kb.user_back
+    )
+
+@router.message(LeadMagnetStates.waiting_for_keyword)
+async def process_leadmagnet(message: Message, state: FSMContext):
+    if message.text.lower() == 'отмена':
+        await state.clear()
+        await message.answer(
+            "Возвращаемся в главное меню",
+            reply_markup=kb.user_main
+        )
+        return
+
+    leadmagnet = await rq.get_leadmagnet_info(message.text)
+    
+    if not leadmagnet:
+        await message.answer(
+            "К сожалению, такое кодовое слово не найдено.\n"
+            "Проверьте правильность написания или попробуйте другое слово.\n"
+            "Для возврата в меню напишите 'отмена'"
+        )
+        return
+        
+    if not leadmagnet.is_active:
+        await message.answer(
+            "К сожалению, это кодовое слово больше не активно.\n"
+            "Попробуйте другое слово или вернитесь в меню, написав 'отмена'"
+        )
+        return
+
+    # Send leadmagnet content
+    await message.answer(leadmagnet.content)
+    
+    # Clear state and offer registration if user is not registered
+    await state.clear()
+    
+    user = await rq.get_user_info(message.from_user.id)
+    if not user or not user.contact:
+        await message.answer(
+            "Хотите получать больше полезных материалов?\n"
+            "Зарегистрируйтесь, чтобы не пропустить новые акции и предложения!",
+            reply_markup=await kb.get_registration_keyboard()
+        )
+    else:
+        await message.answer(
+            "Можете ввести другое кодовое слово или вернуться в меню",
+            reply_markup=kb.leadmagnet_keyboard
+        )
+
+@router.message(F.text == "Вернуться в главное меню")
+async def return_to_main_menu(message: Message, state: FSMContext):
+    await state.clear()
+    await message.answer(
+        "Возвращаемся в главное меню",
+        reply_markup=kb.user_main
+    )

app/handlers/user/messaging.py

@@ -0,0 +1,28 @@
+from aiogram import Router, F
+from aiogram.types import Message
+from aiogram.fsm.context import FSMContext
+from app.config.config import ADMIN_ID
+from app.keyboards import user_keyboards as kb
+from app.states import MessageStates
+
+router = Router()
+
+@router.message(F.text == 'Связаться с Ниной')
+async def pre_contact_admin(message: Message, state: FSMContext):
+    await state.set_state(MessageStates.user_contact_admin)
+    await message.answer('Напишите ваше сообщение для Нины')
+
+
+@router.message(MessageStates.user_contact_admin)
+async def contact_admin(message: Message, state: FSMContext):
+    await message.bot.send_message(
+        chat_id=ADMIN_ID[0],
+        text=f'Сообщение от @{message.from_user.username}:'
+    )
+    await message.forward(ADMIN_ID[0])
+    
+    await message.answer(
+        'Сообщение отправлено! Нина ответит вам в ближайшее время.',
+        reply_markup=kb.user_back_wo_reg
+    )
+    await state.clear()

app/handlers/user/registration.py

@@ -0,0 +1,96 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+from app.states import Register
+from app.database.requests import check_login_unique
+
+router = Router()
+
+@router.callback_query(F.data == "user_register")
+async def register_start(callback: CallbackQuery, state: FSMContext):
+    await state.set_state(Register.user_register_name)
+    await callback.message.answer('Как к вам обращаться?')
+
+
+@router.message(Register.user_register_name)
+async def register_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(Register.user_register_login)
+    await message.answer(
+        'Выберите свой логин. Он должен быть уникальным!'
+    )
+
+
+@router.message(Register.user_register_login)
+async def register_name(message: Message, state: FSMContext):
+   if not await check_login_unique(message.text):
+       await message.answer('Этот логин уже занят. Пожалуйста, выберите другой.')
+       return
+   await state.update_data(login=message.text)
+   await state.set_state(Register.user_register_contact)
+   await message.answer('Укажите предпочтительный способ связи с вами')
+
+
+@router.message(Register.user_register_contact)
+async def register_contact(message: Message, state: FSMContext):
+    await state.update_data(contact=message.text)
+    await state.set_state(Register.user_register_subscribe)
+    await message.answer(
+        'Хотите получать уведомления о новинках и специальных предложениях?',
+        reply_markup=kb.yes_no_keyboard
+    )
+
+
+@router.message(Register.user_register_subscribe)
+async def register_subscribe(message: Message, state: FSMContext):
+    await state.update_data(include_in_broadcast=message.text)
+    if message.text == 'Да':
+        await message.answer('Спасибо за регистрацию! Добро пожаловать в наш тайный клуб клиентов!')
+    elif message.text == 'Нет':
+        await message.answer('Спасибо за регистрацию! Если Вы измените свое решение, Вы всегда можете подписаться '
+                             'на наши секретные материалы, воспользовавшись ботом!')
+    data = await state.get_data()
+    await state.set_state(Register.user_register_check)
+    await message.answer(f'Давайте проверим еще раз:'
+                         f'\n - Ваше имя - {data["name"]},'
+                         f'\n - Ваш логин - {data["login"]},'
+                         f'\n - Ваш контакт - {data["contact"]}, '
+                         f'\n - Подписаны ли Вы на секретную рассылку: {data["include_in_broadcast"]} '
+                         f'\n\n Всё верно?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.message(Register.user_register_check)
+async def register_check(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.user_register(message.from_user.id, data["name"], data["login"], data["contact"], data["include_in_broadcast"])
+        await message.answer('Ура! Спасибо, что Вы с нами! Хотите ли Вы сделать что-то еще?', reply_markup=kb.user_main)
+        await state.clear()
+    if message.text == 'Нет':
+        await state.set_state(Register.user_register_correct)
+        await message.answer('Упс :( Что Вы хотите исправить?', reply_markup=kb.register_correct_keyboard)
+
+
+@router.message(Register.user_register_correct)
+async def choose_the_correction(message: Message, state: FSMContext):
+    if message.text == 'Имя':
+        await state.set_state(Register.user_register_name)
+        await message.answer('Как к Вам обращаться?')
+    elif message.text == 'Логин':
+        await state.set_state(Register.user_register_login)
+        await message.answer('Выберите свой логин. Он должен быть уникальным!')
+    elif message.text == 'Контакт':
+        await state.set_state(Register.user_register_contact)
+        await message.answer('Оставьте контакт, с которого Вам будет удобнее всего общаться с нами')
+    elif message.text == 'Статус подписки на рассылку':
+        await state.set_state(Register.user_register_subscribe)
+        await message.answer('Хотите ли Вы получать от нас уведомления о новинках, акциях и даже '
+                             'СЕКРЕТНЫХ ��АСПРОДАЖАХ ДЛЯ СВОИХ?', reply_markup=kb.yes_no_keyboard)
+
+
+@router.callback_query(F.data == "user_to_main")
+async def register(callback: CallbackQuery):
+    await callback.answer("Возвращаемся в меню")
+    await callback.message.answer("Чем я могу Вам помочь?", reply_markup=kb.user_main)

app/handlers/user/router.py

@@ -0,0 +1,50 @@
+from aiogram import Router
+from aiogram.filters import Command
+from aiogram.types import Message
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+
+from .catalog import router as catalog_router
+from .registration import router as registration_router
+from .messaging import router as messaging_router
+from .leadmagnets import router as leadmagnet_router
+from .tests import router as test_router
+from .info_check import router as info_check_router
+from .send_feedback import router as send_feedback_router
+
+user_router = Router()
+
+user_router.include_router(catalog_router)
+user_router.include_router(leadmagnet_router)
+user_router.include_router(registration_router)
+user_router.include_router(messaging_router)
+user_router.include_router(test_router)
+user_router.include_router(info_check_router)
+user_router.include_router(send_feedback_router)
+
+
+@user_router.message(Command('start'))
+async def cmd_start(message: Message):
+    await rq.set_user(message.from_user.id)
+    await message.answer(
+        'Добро пожаловать! Я - телеграм-бот Нины Смирновой. '
+        'Я могу помочь вам:\n'
+        '- Узнать о наших услугах\n'
+        '- Связать вас с Ниной\n'
+        '- Показать полезные материалы\n'
+        '- Записать ваш отзыв\n'
+        '- Предложить интересные тесты\n\n'
+        'Чем могу помочь?',
+        reply_markup=kb.user_main
+    )
+
+@user_router.message(Command('help'))
+async def cmd_help(message: Message):
+    await message.answer(
+        'Я могу помочь вам:\n'
+        '1. Просмотреть каталог услуг\n'
+        '2. Связаться с Ниной\n'
+        '3. Пройти тесты\n'
+        '4. Оставить отзыв\n'
+        '5. Зарегистрироваться для доступа к специальным предложениям'
+    )

app/handlers/user/send_feedback.py

@@ -0,0 +1,42 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.keyboards import user_keyboards as kb
+from app.states import MessageStates
+from app.keyboards.user_keyboards import user_keyboard_feedback
+from app.database import requests as rq
+from app.config.config import ADMIN_ID
+
+router = Router()
+
+@router.message(F.text == 'Оставить отзыв')
+async def pre_contact_admin(message: Message, state: FSMContext):
+    await state.set_state(MessageStates.user_send_feedback)
+    await message.answer('Выберите услугу, на которую Вы хотите оставить отзыв', reply_markup=await user_keyboard_feedback())
+
+
+@router.callback_query(F.data.startswith('feedback_'))
+async def choose_service(callback: CallbackQuery, state: FSMContext):
+    await state.set_state(MessageStates.user_choosing_feedback_service)
+    await callback.answer('')
+    service_info = await rq.get_service_info(callback.data.split('_')[1])
+    await state.update_data(name=service_info.service_name)
+    await callback.message.answer(f"Введите ваш отзыв на услугу {service_info.service_name}")
+
+
+@router.message(MessageStates.user_choosing_feedback_service)
+async def contact_admin(message: Message, state: FSMContext):
+    await state.set_state(MessageStates.user_sending_feedback)
+    data = await state.get_data()
+    print(data)
+    await message.bot.send_message(
+        chat_id=ADMIN_ID[0],
+        text=f'Новый отзыв на услугу #{data["name"]}:'
+    )
+    await message.forward(ADMIN_ID[0])
+    
+    await message.answer(
+        'Отзыв отправлен! Спасибо за использование наших услуг!.',
+        reply_markup=kb.user_back_wo_reg
+    )
+    await state.clear()

app/handlers/user/tests.py

@@ -0,0 +1,74 @@
+from aiogram import Router, F
+from aiogram.types import Message, CallbackQuery
+from aiogram.fsm.context import FSMContext
+from app.database import requests as rq
+from app.keyboards import user_keyboards as kb
+from app.states import TestStates
+from app.database.requests import check_user_registered
+
+router = Router()
+
+@router.message(F.text == "Пройти тест")
+async def show_available_tests(message: Message):
+    registration_status = await check_user_registered(message.from_user.id)
+    if registration_status:
+        await message.answer(
+            "Выберите тест:",
+            reply_markup=await kb.get_tests_keyboard()
+        )
+    if not registration_status:
+        await message.answer(
+            "Зарегистрируйтесь, чтобы сохранить Ваши результаты и получить персональные рекомендации!",
+            reply_markup=kb.user_back
+        )
+
+@router.callback_query(F.data.startswith("start_test_"))
+async def start_test(callback: CallbackQuery, state: FSMContext):
+    test_id = callback.data.split("_")[2]
+    test_data = await rq.start_test_attempt(
+        callback.from_user.id,
+        test_id
+    )
+    
+    if not test_data:
+        await callback.message.answer("Тест недоступен")
+        return
+
+    await state.set_state(TestStates.answering)
+    await state.update_data(
+        attempt_id=test_data["attempt_id"],
+        current_question=1,
+        total_questions=test_data["total_questions"]
+    )
+
+    await callback.message.answer(
+        f"Вопрос 1 из {test_data['total_questions']}:\n\n"
+        f"{test_data['question'].question_content}",
+        reply_markup=await kb.get_test_question_keyboard(test_data["question"])
+    )
+
+@router.callback_query(F.data.startswith("test_answer_"))
+async def process_answer(callback: CallbackQuery, state: FSMContext):
+    _, _, question_id, answer = callback.data.split("_")
+    
+    data = await state.get_data()
+    result = await rq.record_answer(data["attempt_id"],
+        int(question_id),
+        answer
+    )
+
+    if result.get("completed"):
+        await callback.message.answer(
+            f"Тест завершен!\n\n"
+            f"Ваш результат: {result['result']}"
+        )
+        await state.clear()
+    else:
+        current_q = data["current_question"] + 1
+        await state.update_data(current_question=current_q)
+        
+        await callback.message.answer(
+            f"Вопрос {current_q} из {data['total_questions']}:\n\n"
+            f"{result['next_question'].question_content}",
+            reply_markup=await kb.get_test_question_keyboard(result["next_question"])
+        )

app/handlers/user_route.py

@@ -0,0 +1,168 @@
+from aiogram.filters.command import Command
+from aiogram.types import Message, CallbackQuery
+from aiogram import F, Router, Bot
+from aiogram.fsm.context import FSMContext
+
+import app.keyboards.user_keyboards as kb
+import app.database.requests as rq
+from app.states import Register, Other
+
+user_router = Router()
+bot = Bot(token='5569983238:AAFo8J083zUWOk879M7YMYfhAreeiLovGcE')
+
+
+@user_router.message(Command('start'))
+async def cmd_start(message: Message):
+    await rq.set_user(message.from_user.id)
+    await message.answer('Добро пожаловать! Я - телеграм-бот Нины Смирновой, и моя основная задача - взаимодействие с '
+                         'Вами: я могу предоставить Вам информацию о наших услугах и связать Вас с Ниной, а также '
+                         'показать Вам интересные и полезные материалы от Нины. Еще я могу записать Ваш отзыв, '
+                         'если Вы уже воспользовались нашими услугами! А еще (только это секрет) у меня есть очень'
+                         'интересные тесты, которые позволят Вам лучше понять себя и Вашего ребенка! \n\n '
+                         'Чем я могу Вам помочь?',
+                         reply_markup=kb.user_main)
+
+
+@user_router.message(Command('help'))
+async def cmd_help(message: Message):
+    await message.answer('Это кнопка помощи')
+
+
+@user_router.message(F.text == 'Посмотреть каталог услуг')
+async def get_catalog(message: Message):
+    await message.answer('Спасибо за интерес! Вот наш перечень услуг. '
+                         'Пожалуйста, выберите самую подходящую и нажмите на соответствующую кнопку, '
+                         'чтобы узнать о ней подробнее:', reply_markup=await kb.user_keyboard_catalog())
+
+
+@user_router.callback_query(F.data.startswith('service_'))
+async def service_info(callback: CallbackQuery,state: FSMContext):
+    await callback.answer('')
+    service_info = await rq.get_service_info(callback.data.split('_')[1])
+    service_string = f"Вот информация по выбранной Вами услуге: \n" \
+                     f"Название: {service_info.service_name} \n" \
+                     f"Описание: {service_info.service_description} \n" \
+                     f"Цена: {service_info.service_price}. \n\n" \
+                     f"Хотите ли Вы воспользоваться данной услугой?"
+    await callback.answer('')
+    await state.set_state(Other.user_pre_buy_service)
+    await state.update_data(user_id=callback.from_user.id,
+                            user_username=callback.from_user.username,
+                            service=service_info.service_name)
+    await callback.message.answer(service_string, reply_markup=kb.service_confirm)
+
+
+@user_router.message(F.text == 'Да, связаться с Ниной')
+async def admin_prompt(message: Message, state: FSMContext):
+    await state.set_state(Other.user_buy_service)
+    await message.answer('Напишите Нине и изложите Вашу проблему - это поможет ей лучше понять Ваш конкретный случай'
+                         ' и сделать Ваш разговор более предметным!')
+
+
+@user_router.message(Other.user_buy_service)
+async def admin_connect(message: Message, state: FSMContext):
+    data = await state.get_data()
+    await bot.send_message(chat_id=1658604792,
+                           text=f'Здравствуйте! Поступил новый заказ на услугу {data["service"]} от пользователя'
+                                f' @{data["user_username"]}')
+    await message.send_copy(1658604792)
+    await message.answer('Спасибо за обращение! Скоро Нина свяжется с Вами в личных сообщениях для обсуждения '
+                         'подробностей Вашего заказа!')
+    await state.clear()
+    await message.answer('Вы можете вернуться в меню и посмотреть, какие еще услуги мы предлагаем! Еще мы предлагаем '
+                         'зарегистрироваться, чтобы получить возможность не пропускать всё самое важное, что происходит '
+                         'в канале. Также регистрация позволит ��ам вступить в СЕКРЕТНЫЙ КЛУБ пользователей, которые'
+                         ' будут иметь доступ к специальным акциям и ВКУСНЫМ ЦЕНАМ для своих!',
+                         reply_markup=kb.user_back)
+
+
+@user_router.message(F.text == 'Нет, вернуться в меню')
+async def np_service_return_to_menu(message: Message, state: FSMContext):
+    await state.clear()
+    await message.answer('Чем я могу Вам помочь?', reply_markup=kb.user_main)
+
+
+@user_router.callback_query(F.data == "user_register")
+async def register(callback: CallbackQuery, state: FSMContext):
+    await state.set_state(Register.user_register_name)
+    await callback.message.answer('Как к Вам обращаться?')
+
+
+@user_router.callback_query(F.data == "user_to_main")
+async def register(callback: CallbackQuery):
+    await callback.answer("Возвращаемся в меню")
+    await callback.message.answer("Чем я могу Вам помочь?", reply_markup=kb.user_main)
+
+
+@user_router.message(Register.user_register_name)
+async def register_name(message: Message, state: FSMContext):
+    await state.update_data(name=message.text)
+    await state.set_state(Register.user_register_contact)
+    await message.answer('Оставьте контакт, с которого Вам будет удобнее всего общаться с нами')
+
+
+@user_router.message(Register.user_register_contact)
+async def register_contact(message: Message, state: FSMContext):
+    await state.update_data(contact=message.text)
+    await state.set_state(Register.user_register_subscribe)
+    await message.answer('Хотите ли Вы получать от нас уведомления о новинках, акциях и даже '
+                         'СЕКРЕТНЫХ РАСПРОДАЖАХ ДЛЯ СВОИХ?', reply_markup=kb.yes_no_keyboard)
+
+
+@user_router.message(Register.user_register_subscribe)
+async def register_subscribe(message: Message, state: FSMContext):
+    await state.update_data(include_in_broadcast=message.text)
+    if message.text == 'Да':
+        await message.answer('Спасибо за регистрацию! Добро пожаловать в наш тайный клуб клиентов!')
+    elif message.text == 'Нет':
+        await message.answer('Спасибо за регистрацию! Если Вы измените свое решение, Вы всегда можете подписаться '
+                             'на наши секретные материалы, воспользовавшись ботом!')
+    data = await state.get_data()
+    await state.set_state(Register.user_register_check)
+    await message.answer(f'Давайте проверим еще раз:'
+                         f'\n - Ваше имя - {data["name"]},'
+                         f'\n - Ваш контакт - {data["contact"]}, '
+                         f'\n - Подписаны ли Вы на секретную рассылку: {data["include_in_broadcast"]} '
+                         f'\n\n Всё верно?', reply_markup=kb.yes_no_keyboard)
+
+
+@user_router.message(Register.user_register_check)
+async def register_check(message: Message, state: FSMContext):
+    if message.text == 'Да':
+        data = await state.get_data()
+        await rq.user_register(message.from_user.id, data["name"], data["contact"], data["include_in_broadcast"])
+        await message.answer('Ура! Спасибо, что Вы с нами! Хотите ли Вы сделать что-то еще?', reply_markup=kb.user_main)
+        await state.clear()
+    if message.text == 'Нет':
+        await state.set_state(Register.user_register_correct)
+        await message.answer('Упс :( Что Вы хотите исправить?', reply_markup=kb.register_correct_keyboard)
+
+
+@user_router.message(Register.user_register_correct)
+async def choose_the_correction(message: Message, state: FSMContext):
+    if message.text == 'Имя':
+        await state.set_state(Register.user_register_name)
+        await message.answer('Как к Вам обращаться?')
+    elif message.text == 'Контакт':
+        await state.set_state(Register.user_register_contact)
+        await message.answer('Оставьте контакт, с которого Вам будет удобнее всего общаться с нами')
+    elif message.text == 'Статус подписки на рассылку':
+        await state.set_state(Register.user_register_subscribe)
+        await message.answer('Хотите ли Вы получать от нас уведомления о новинках, акциях и даже '
+                             'СЕКРЕТНЫХ РАСПРОДАЖАХ ДЛЯ СВОИХ?', reply_markup=kb.yes_no_keyboard)
+
+
+@user_router.message(F.text == 'Связаться с Ниной')
+async def pre_get_back_to_admin(message: Message, state: FSMContext):
+    await state.set_state(Other.user_contact_admin)
+    await message.answer('Введите Ваше сообщение - и я отправлю его Нине!')
+
+
+@user_router.message(Other.user_contact_admin)
+async def get_back_to_admin(message: Message, state: FSMContext):
+    await bot.send_message(chat_id=1658604792,
+                           text=f'Здравствуйте! Вам поступило сообщение от пользователя'
+                                f' @{message.from_user.username}:')
+    await message.send_copy(1658604792)
+    await message.answer('Спасибо за обращение! Нина получила Ваше сообщение и ответит Вам, как только сможет!',
+                         reply_markup=kb.user_back_wo_reg)

app/keyboards/admin_keyboards.py

@@ -0,0 +1,84 @@
+from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from app.database.requests import get_catalog, get_leadmagnets, get_tests
+
+
+async def admin_keyboard_service_catalog():
+    all_items = await get_catalog()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=item.service_name, callback_data=f'change_service_{item.id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    keyboard.add(InlineKeyboardButton(text='Добавить услугу', callback_data='add_service'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def admin_change_service(service_id):
+    keyboard = InlineKeyboardBuilder()
+    keyboard.add(InlineKeyboardButton(text='Название', callback_data=f'editservice_name_{service_id}'))
+    keyboard.add(InlineKeyboardButton(text='Описание', callback_data=f'editservice_desc_{service_id}'))
+    keyboard.add(InlineKeyboardButton(text='Цена', callback_data=f'editservice_price_{service_id}'))
+    keyboard.add(InlineKeyboardButton(text='Удалить услугу', callback_data=f'deleteservice_{service_id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def admin_keyboard_leadmagnets():
+    all_items = await get_leadmagnets()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=item, callback_data=f'change_leadmagnet_{item}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    keyboard.add(InlineKeyboardButton(text='Добавить кодовое слово', callback_data='add_leadmanget'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def admin_change_leadmagnet(trigger):
+    keyboard = InlineKeyboardBuilder()
+    keyboard.add(InlineKeyboardButton(text='Слово-триггер', callback_data=f'editleadmagnet_trigger_{trigger}'))
+    keyboard.add(InlineKeyboardButton(text='Содержание лидмагнита', callback_data=f'editleadmagnet_content_{trigger}'))
+    keyboard.add(InlineKeyboardButton(text='Статус активности лидмагнита', callback_data=f'editleadmagnet_status_{trigger}'))
+    keyboard.add(InlineKeyboardButton(text='Удалить лидмагнит', callback_data=f'deleteleadmagnet_{trigger}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def admin_change_test(t_id):
+    keyboard = InlineKeyboardBuilder()
+    keyboard.add(
+        InlineKeyboardButton(text='Статус активности теста', callback_data=f'edittest_status_{t_id}'))
+    keyboard.add(InlineKeyboardButton(text='Удалить тест', callback_data=f'deletetest_{t_id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def admin_keyboard_tests():
+    all_items = await get_tests()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=item.test_name, callback_data=f'change_test_{item.id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='admin_to_main'))
+    keyboard.add(InlineKeyboardButton(text='Добавить тест', callback_data='add_test'))
+    return keyboard.adjust(1).as_markup()
+
+
+admin_main = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Отредактировать каталог услуг'),
+                                           KeyboardButton(text='Отредактировать тесты')],
+                                          [KeyboardButton(text='Отредактировать кодовые слова'),
+                                           KeyboardButton(text='Отправить сообщение в рассылку'),],
+                                           [KeyboardButton(text='Просмотреть результаты тестов')],
+                                           [KeyboardButton(text='Вернуться в пользовательский интерфейс')]],
+                                resize_keyboard=True,
+                                input_field_placeholder='Выберите подходящий Вам вариант, нажав на кнопку внизу:')
+
+admin_back = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text='Вернуться в меню',
+                                                                         callback_data='admin_to_main')]])
+
+yes_no_keyboard = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Да'), KeyboardButton(text='Нет')]],
+                                         resize_keyboard=True)
+
+test_type_keyboard = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='С баллами'), KeyboardButton(text='Без баллов')]],
+                                         resize_keyboard=True)

app/keyboards/user_keyboards.py

@@ -0,0 +1,98 @@
+from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, InlineKeyboardMarkup, InlineKeyboardButton
+from aiogram.utils.keyboard import InlineKeyboardBuilder
+from app.database.requests import get_catalog, get_tests
+from app.database.requests import check_login_unique
+
+
+async def user_keyboard_catalog():
+    all_items = await get_catalog()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=item.service_name, callback_data=f'service_{item.id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='user_to_main'))
+    return keyboard.adjust(1).as_markup()
+
+
+async def user_keyboard_feedback():
+    all_items = await get_catalog()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=item.service_name, callback_data=f'feedback_{item.id}'))
+    keyboard.add(InlineKeyboardButton(text='Вернуться', callback_data='user_to_main'))
+    return keyboard.adjust(1).as_markup()
+
+
+user_main = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Посмотреть каталог услуг'),
+                                           KeyboardButton(text='Пройти тест')],
+                                          [KeyboardButton(text='Ввести кодовое слово'),
+                                           KeyboardButton(text='Оставить отзыв')],
+                                          [KeyboardButton(text='Посмотреть сохраненные сведения о себе'),
+                                           KeyboardButton(text='Связаться с Ниной')]],
+                                resize_keyboard=True,
+                                input_field_placeholder='Выберите подходящий Вам вариант, нажав на кнопку внизу:')
+
+
+yes_no_keyboard = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Да'), KeyboardButton(text='Нет')]],
+                                         resize_keyboard=True)
+
+register_correct_keyboard = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Имя'),
+                                                           KeyboardButton(text='Контакт'),
+                                                           KeyboardButton(text='Логин'),
+                                                           KeyboardButton(text='Статус подписки на рассылку')]],
+                                                resize_keyboard=True,
+                                                input_field_placeholder='Выберите, какой параметр Вы бы хотели изменить')
+
+service_confirm = ReplyKeyboardMarkup(keyboard=[[KeyboardButton(text='Да, связаться с Ниной'),
+                                                 KeyboardButton(text='Нет, вернуться в меню')]],
+                                      resize_keyboard=True)
+
+user_back = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text='Зарегистрироваться',
+                                                                         callback_data='user_register')],
+                                                  [InlineKeyboardButton(text='Вернуться в меню',
+                                                                        callback_data='user_to_main')]])
+
+user_back_wo_reg = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text='Вернуться в меню',
+                                                                        callback_data='user_to_main')]])
+
+
+user_infocheck_back = InlineKeyboardMarkup(inline_keyboard=[[InlineKeyboardButton(text='Вернуться в меню',
+                                                                        callback_data='user_to_main'),
+                                                          InlineKeyboardButton(text='Изменить данные',
+                                                                        callback_data='data_correct')]])
+
+
+leadmagnet_keyboard = ReplyKeyboardMarkup(
+    keyboard=[
+        [KeyboardButton(text="Ввести кодовое слово")],
+        [KeyboardButton(text="Вернуться в главное меню")]
+    ],
+    resize_keyboard=True
+)
+
+
+async def get_test_question_keyboard(question) -> InlineKeyboardMarkup:
+    """Create keyboard for test question variants"""
+    variants = question.question_variants.split('\n')
+    buttons = []
+    for variant in variants:
+        variant = variant.strip()
+        if variant:
+            buttons.append([
+                InlineKeyboardButton(
+                    text=variant.split('...')[0],
+                    callback_data=f"test_answer_{question.id}_{variant}"
+                )
+            ])
+    return InlineKeyboardMarkup(inline_keyboard=buttons)
+
+
+async def get_tests_keyboard():
+    all_items = await get_tests()
+    keyboard = InlineKeyboardBuilder()
+    if all_items:
+        for item in all_items:
+            keyboard.add(InlineKeyboardButton(text=f"📝 {item.test_name}", callback_data=f"start_test_{item.id}"))
+    keyboard.add(InlineKeyboardButton(text="◀️ Вернуться в меню", callback_data="user_to_main"))
+    return keyboard.adjust(1).as_markup()

app/middleware/authentification.py

@@ -0,0 +1,10 @@
+from typing import Dict, Any
+from aiogram.types import Message
+from app.config.config import ADMIN_ID
+from app.database.requests import check_user_registered
+
+async def admin_check(message: Message, data: Dict[str, Any]) -> bool:
+    return message.from_user.id in ADMIN_ID
+
+async def registration_check(message: Message, data: Dict[str, Any]) -> bool:
+    return await check_user_registered(message.from_user.id)

app/states.py

@@ -0,0 +1,77 @@
+from aiogram.fsm.state import State, StatesGroup
+
+
+class AdminStates(StatesGroup):
+    admin_delete_service = State()
+    admin_edit_service = State()
+    admin_edit_leadmagnet = State()
+    admin_delete_leadmagnet = State()
+    admin_add_test = State()
+    admin_broadcast = State()
+    admin_edit_test_status = State()
+    admin_delete_test = State()
+
+
+class AdminAddService(StatesGroup):
+    admin_add_name = State()
+    admin_add_desc = State()
+    admin_add_price = State()
+
+
+class AdminAddLeadmagnet(StatesGroup):
+    admin_set_status = State()
+    admin_set_trigger = State()
+    admin_set_content = State()
+
+
+class AdminAddTest(StatesGroup):
+    admin_set_title = State()
+    admin_set_type = State()
+    admin_set_desc = State()
+    admin_set_status = State()
+    admin_set_completion_result_set = State()
+    admin_set_completion_result = State()
+    admin_add_question_content = State()
+    admin_add_question_vars = State()
+    admin_add_question_vars_wo_points = State()
+    admin_end_results = State()
+    admin_end_questions = State()
+    admin_add_question_points = State()
+
+
+class Register(StatesGroup):
+    user_register_name = State()
+    user_register_login = State()
+    user_register_contact = State()
+    user_register_subscribe = State()
+    user_register_check = State()
+    user_register_correct = State()
+
+
+class Other(StatesGroup):
+    user_buy_service = State()
+    user_pre_buy_service = State()
+    user_pass_test = State()
+    user_receive_magnet = State()
+    user_leave_feedback = State()
+    user_contact_admin = State()
+    user_data_check = State()
+    user_data_correct = State()
+    user_data_finish = State()
+    admin_send_mailing = State()
+
+
+class MessageStates(StatesGroup):
+    user_contact_admin = State()
+    user_send_feedback = State()
+    user_choosing_feedback_service = State()
+    user_sending_feedback = State()
+
+
+class LeadMagnetStates(StatesGroup):
+    waiting_for_keyword = State()
+
+
+class TestStates(StatesGroup):
+    answering = State()
+    name_get = State()

app/utils/exceptions.py

@@ -0,0 +1,7 @@
+class DatabaseError(Exception):
+    """Base exception for database operations."""
+    pass
+
+class ValidationError(Exception):
+    """Exception for data validation errors."""
+    pass

docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.8'
+
+services:
+ bot:
+   build: .
+   env_file:
+     - .env
+   volumes:
+     - ./db.sqlite3:/app/db.sqlite3
+   ports:
+     - "7860:7860"
+   restart: always

env.example

@@ -0,0 +1,3 @@
+BOT_TOKEN=8787878787878787878787
+DATABASE_URL=sqlite+aiosqlite:///db.sqlite3
+ADMIN_IDS=ID1,ID2,ID3

main.py

@@ -0,0 +1,45 @@
+import asyncio
+import logging
+from aiogram import Bot, Dispatcher
+from app.database.models import async_main
+from app.handlers.user.router import user_router
+from app.handlers.admin.router import admin_router
+from app.config.config import BOT_TOKEN
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+async def shutdown(bot: Bot):
+    """Выключение"""
+    logger.info("Выключение бота...")
+    await bot.close()
+    logger.info("Бот успешно выключен")
+
+
+async def main():
+    try:
+        await async_main()
+        bot = Bot(token=BOT_TOKEN)
+        dp = Dispatcher()
+        dp.include_router(user_router)
+        dp.include_router(admin_router)
+        logger.info("Бот запускается...")
+        await dp.start_polling(bot)
+    except Exception as e:
+        logger.error(f"Error in main function: {e}")
+        await shutdown(bot)
+        raise
+
+
+if __name__ == '__main__':
+    try:
+        asyncio.run(main())
+    except (KeyboardInterrupt, RuntimeError) as e:
+        logger.warning(f"Бот выключен: {type(e).__name__}")
+    except Exception as e:
+        logger.error(f"Внезапная ошибка: {e}")

requirements.txt

@@ -0,0 +1,25 @@
+aiofiles==24.1.0
+aiogram==3.17.0
+aiogram_broadcaster==0.6.4
+aiohappyeyeballs==2.4.4
+aiohttp==3.11.11
+aiosignal==1.3.2
+aiosqlite==0.20.0
+annotated-types==0.7.0
+asyncio==3.4.3
+attrs==24.3.0
+certifi==2024.12.14
+frozenlist==1.5.0
+greenlet==3.1.1
+idna==3.10
+magic-filter==1.0.12
+multidict==6.1.0
+propcache==0.2.1
+pydantic==2.10.5
+pydantic_core==2.27.2
+python-dotenv==1.0.1
+setuptools==75.1.0
+SQLAlchemy==2.0.37
+typing_extensions==4.12.2
+wheel==0.44.0
+yarl==1.18.3