merge to main

.env.example

@@ -1 +0,0 @@
-SQLALCHEMY_DATABASE_URI=sqlite+aiosqlite:///:memory:

.gitignore

@@ -1,140 +0,0 @@
-# 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
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow
-__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/
-
-.vscode

Dockerfile

@@ -1,54 +0,0 @@
-# Use official Python 3.12 slim image
-FROM python:3.12-slim
-
-# Set environment variables
-ENV SQLALCHEMY_DATABASE_URI=postgresql+asyncpg://avnadmin:AVNS_W4PzkCRVJw0ASHFYc8i@pg-5cdc7c9-aryanjain19082002-7775.j.aivencloud.com:25607/defaultdb
-ENV PYTHONUNBUFFERED=1
-ENV POETRY_VERSION=1.8.2
-
-# Set work directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    curl \
-    build-essential \
-    libreoffice \
-    default-jre-headless \
-    fonts-dejavu \
-    fonts-liberation \
-    fontconfig \
-    xvfb \
-    dbus-x11 \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
-
-# Install Poetry
-RUN curl -sSL https://install.python-poetry.org | python3 -
-ENV PATH="/root/.local/bin:$PATH"
-
-# Copy only dependency files first to leverage Docker cache
-COPY pyproject.toml poetry.lock* /app/
-
-# Install dependencies (without creating a virtualenv)
-RUN poetry config virtualenvs.create false \
- && poetry install --no-interaction --no-ansi
-
-RUN mkdir -p /tmp/.config/libreoffice && \
- chmod 755 /tmp/.config/libreoffice
-
-RUN mkdir -p /files && chmod 777 /files
-
-ENV HOME=/tmp \
- TMPDIR=/tmp \
- JAVA_HOME=/usr/lib/jvm/default-java
-
-# Copy the entire project
-COPY . /app/
-
-# Expose the port Uvicorn will run on
-EXPOSE 7860
-
-# Run the FastAPI application
-CMD ["uvicorn", "src.app:app", "--reload", "--host", "0.0.0.0", "--port", "7860"]

alembic.ini

@@ -1,141 +0,0 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts.
-# this is typically a path given in POSIX (e.g. forward slashes)
-# format, relative to the token %(here)s which refers to the location of this
-# ini file
-script_location = %(here)s/alembic
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
-# for all available tokens
-# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.  for multiple paths, the path separator
-# is defined by "path_separator" below.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library and tzdata library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to <script_location>/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "path_separator"
-# below.
-# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions
-
-# path_separator; This indicates what character is used to split lists of file
-# paths, including version_locations and prepend_sys_path within configparser
-# files such as alembic.ini.
-# The default rendered in new alembic.ini files is "os", which uses os.pathsep
-# to provide os-dependent path splitting.
-#
-# Note that in order to support legacy alembic.ini files, this default does NOT
-# take place if path_separator is not present in alembic.ini.  If this
-# option is omitted entirely, fallback logic is as follows:
-#
-# 1. Parsing of the version_locations option falls back to using the legacy
-#    "version_path_separator" key, which if absent then falls back to the legacy
-#    behavior of splitting on spaces and/or commas.
-# 2. Parsing of the prepend_sys_path option falls back to the legacy
-#    behavior of splitting on spaces, commas, or colons.
-#
-# Valid values for path_separator are:
-#
-# path_separator = :
-# path_separator = ;
-# path_separator = space
-# path_separator = newline
-#
-# Use os.pathsep. Default configuration used for new projects.
-path_separator = os
-
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-# database URL.  This is consumed by the user-maintained env.py script only.
-# other means of configuring database URLs may be customized within the env.py
-# file.
-sqlalchemy.url = driver://user:pass@host/db
-
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = check --fix REVISION_SCRIPT_FILENAME
-
-# Logging configuration.  This is also consumed by the user-maintained
-# env.py script only.
-[loggers]
-keys = root,sqlalchemy,alembic
-
-[handlers]
-keys = console
-
-[formatters]
-keys = generic
-
-[logger_root]
-level = WARNING
-handlers = console
-qualname =
-
-[logger_sqlalchemy]
-level = WARNING
-handlers =
-qualname = sqlalchemy.engine
-
-[logger_alembic]
-level = INFO
-handlers =
-qualname = alembic
-
-[handler_console]
-class = StreamHandler
-args = (sys.stderr,)
-level = NOTSET
-formatter = generic
-
-[formatter_generic]
-format = %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %H:%M:%S

alembic/README

@@ -1 +0,0 @@
-Generic single-database configuration with an async dbapi.

alembic/env.py

@@ -1,95 +0,0 @@
-import asyncio
-from logging.config import fileConfig
-
-from alembic import context
-from sqlalchemy import pool
-from sqlalchemy.engine import Connection
-from sqlalchemy.ext.asyncio import async_engine_from_config
-
-from src.models import *
-
-# this is the Alembic Config object, which provides
-# access to the values within the .ini file in use.
-config = context.config
-
-# Interpret the config file for Python logging.
-# This line sets up loggers basically.
-if config.config_file_name is not None:
-    fileConfig(config.config_file_name)
-
-# add your model's MetaData object here
-# for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
-target_metadata = Base.metadata
-
-# other values from the config, defined by the needs of env.py,
-# can be acquired:
-# my_important_option = config.get_main_option("my_important_option")
-# ... etc.
-
-
-def run_migrations_offline() -> None:
-    """Run migrations in 'offline' mode.
-
-    This configures the context with just a URL
-    and not an Engine, though an Engine is acceptable
-    here as well.  By skipping the Engine creation
-    we don't even need a DBAPI to be available.
-
-    Calls to context.execute() here emit the given string to the
-    script output.
-
-    """
-    url = config.get_main_option("sqlalchemy.url")
-    context.configure(
-        url=url,
-        target_metadata=target_metadata,
-        literal_binds=True,
-        dialect_opts={"paramstyle": "named"},
-    )
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-def do_run_migrations(connection: Connection) -> None:
-    context.configure(connection=connection, target_metadata=target_metadata)
-
-    with context.begin_transaction():
-        context.run_migrations()
-
-
-async def run_async_migrations() -> None:
-    """In this scenario we need to create an Engine
-    and associate a connection with the context.
-
-    """
-
-    connectable = async_engine_from_config(
-        config.get_section(config.config_ini_section, {}),
-        prefix="sqlalchemy.",
-        poolclass=pool.NullPool,
-    )
-
-    async with connectable.connect() as connection:
-        await connection.run_sync(do_run_migrations)
-
-    await connectable.dispose()
-
-
-def run_migrations_online() -> None:
-    """Run migrations in 'online' mode."""
-
-    connectable = config.attributes.get("connection", None)
-
-    if connectable is None:
-        asyncio.run(run_async_migrations())
-    else:
-        do_run_migrations(connectable)
-
-
-if context.is_offline_mode():
-    run_migrations_offline()
-else:
-    run_migrations_online()

alembic/script.py.mako

@@ -1,28 +0,0 @@
-"""${message}
-
-Revision ID: ${up_revision}
-Revises: ${down_revision | comma,n}
-Create Date: ${create_date}
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-${imports if imports else ""}
-
-# revision identifiers, used by Alembic.
-revision: str = ${repr(up_revision)}
-down_revision: Union[str, None] = ${repr(down_revision)}
-branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
-depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    ${upgrades if upgrades else "pass"}
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    ${downgrades if downgrades else "pass"}

alembic/versions/0402a665d940_update_rfp_table.py

@@ -1,28 +0,0 @@
-"""update rfp table
-
-Revision ID: 0402a665d940
-Revises: c70330d677c0
-Create Date: 2025-06-04 10:36:51.925465
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '0402a665d940'
-down_revision: Union[str, None] = 'c70330d677c0'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.add_column("rfps", sa.Column("target_award_date", sa.DateTime(), nullable=True))
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_column("rfps", "target_award_date")

alembic/versions/11d43047d470_initial_tables.py

@@ -1,118 +0,0 @@
-"""Initial tables
-
-Revision ID: 11d43047d470
-Revises: 
-Create Date: 2025-05-29 13:59:12.209373
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-from sqlalchemy.dialects import postgresql
-
-
-# revision identifiers, used by Alembic.
-revision: str = '11d43047d470'
-down_revision: Union[str, None] = None
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table(
-        'rfps',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('rfp_number', sa.String(), nullable=True),
-        sa.Column('received_proposals', sa.Integer(), nullable=True),
-        sa.Column('evaluated_count', sa.Integer(), nullable=True),
-        sa.Column('awaiting_evaluation', sa.Integer(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposals',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('rfp_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('rfps.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('name', sa.String(), nullable=True),
-        sa.Column('status', sa.Enum('APPROVED', 'EVALUATED', 'IN_REVIEW', name='proposalstatus'), nullable=False),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_ai_analyses',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('ai_score', sa.Float(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_strengths',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('strength_point', sa.String(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_rejection_reasons',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('reason', sa.String(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_weaknesses',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('weakness_point', sa.String(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_improvements',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('improvement_point', sa.String(), nullable=True),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        'proposal_detail_analyses',
-        sa.Column('id', postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column('proposal_id', postgresql.UUID(as_uuid=True), sa.ForeignKey('proposals.id', ondelete="CASCADE"), nullable=False),
-        sa.Column('ai_assessment_result', sa.String(), nullable=True),
-        sa.Column('confidence', sa.Float(), nullable=True),
-        sa.Column('operation_criteria', sa.Enum(
-            'MISSION_ALIGNMENT', 'TECHNICAL_FEASIBILITY', 'COST_EFFICIENCY', 'RISK_ASSESSMENT',
-            name='operationcriteria'), nullable=False),
-        sa.Column('created_at', sa.DateTime(), nullable=False),
-        sa.Column('updated_at', sa.DateTime(), nullable=False),
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table('proposal_detail_analyses')
-    op.drop_table('proposal_improvements')
-    op.drop_table('proposal_weaknesses')
-    op.drop_table('proposal_rejection_reasons')
-    op.drop_table('proposal_strengths')
-    op.drop_table('proposal_ai_analyses')
-    op.drop_table('proposals')
-    op.drop_table('rfps')
-    # ### end Alembic commands ###

alembic/versions/3ba37b484f31_update_enum_type.py

@@ -1,56 +0,0 @@
-"""update enum type
-
-Revision ID: 3ba37b484f31
-Revises: 718e96a6869a
-Create Date: 2025-06-05 10:04:03.238833
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = "3ba37b484f31"
-down_revision: Union[str, None] = "718e96a6869a"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.execute(
-        "CREATE TYPE analysistype_new AS ENUM ('STRENGTHS', 'WEAKNESSES', 'DEFICIENCIES')"
-    )
-
-    op.execute(
-        """
-        ALTER TABLE analysis
-        ALTER COLUMN analysis_type TYPE analysistype_new
-        USING analysis_type::text::analysistype_new
-    """
-    )
-
-    op.execute("DROP TYPE analysistype")
-
-    op.execute("ALTER TYPE analysistype_new RENAME TO analysistype")
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.execute(
-        "CREATE TYPE analysistype_old AS ENUM ('STRENGHTS', 'WEAKNESSES', 'DEFICIENCIES')"
-    )
-
-    op.execute(
-        """
-        ALTER TABLE analysis
-        ALTER COLUMN analysis_type TYPE analysistype_old
-        USING analysis_type::text::analysistype_old
-    """
-    )
-
-    op.execute("DROP TYPE analysistype")
-    op.execute("ALTER TYPE analysistype_old RENAME TO analysistype")

alembic/versions/718e96a6869a_update_tables.py

@@ -1,125 +0,0 @@
-"""update tables
-
-Revision ID: 718e96a6869a
-Revises: a3bbab758ddb
-Create Date: 2025-06-05 05:27:57.408552
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = "718e96a6869a"
-down_revision: Union[str, None] = "a3bbab758ddb"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.add_column("rfps", sa.Column("ko_name", sa.String(), nullable=True))
-    op.add_column("rfps", sa.Column("award_type", sa.String(), nullable=True))
-    op.add_column("rfps", sa.Column("google_drive_id", sa.String(), nullable=True))
-
-    op.add_column("proposals", sa.Column("ai_score", sa.Float(), nullable=True))
-    op.add_column("proposals", sa.Column("final_score", sa.Float(), nullable=True))
-
-    op.create_table(
-        "comparative_weights",
-        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column(
-            "rfp_id",
-            postgresql.UUID(as_uuid=True),
-            sa.ForeignKey("rfps.id", ondelete="CASCADE"),
-            nullable=False,
-            unique=True,
-        ),
-        sa.Column(
-            "technical_weight",
-            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
-            nullable=False,
-        ),
-        sa.Column(
-            "management_weight",
-            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
-            nullable=False,
-        ),
-        sa.Column(
-            "past_performance_weight",
-            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
-            nullable=False,
-        ),
-        sa.Column(
-            "price_weight",
-            sa.Enum("NONE", "LOW", "MEDIUM", "HIGH", name="comparativeweights"),
-            nullable=False,
-        ),
-        sa.Column("strengths_weight", sa.Float(), nullable=False, default=15),
-        sa.Column("weaknesses_weight", sa.Float(), nullable=False),
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        "evaluations",
-        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column(
-            "proposal_id",
-            postgresql.UUID(as_uuid=True),
-            sa.ForeignKey("proposals.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column(
-            "evaluation_type",
-            sa.Enum(
-                "TECHNICAL",
-                "MANAGEMENT",
-                "PAST_PERFORMANCE",
-                "PRICE",
-                name="evaluationtype",
-            ),
-            nullable=False,
-        ),
-        sa.Column("ai_score", sa.Float(), nullable=True),
-        sa.Column("adjusted_score", sa.Float(), nullable=True),
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-    )
-
-    op.create_table(
-        "analysis",
-        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column(
-            "evaluation_id",
-            postgresql.UUID(as_uuid=True),
-            sa.ForeignKey("evaluations.id", ondelete="CASCADE"),
-            nullable=False,
-        ),
-        sa.Column("insights", sa.Text(), nullable=True),
-        sa.Column(
-            "analysis_type",
-            sa.Enum("STRENGHTS", "WEAKNESSES", "DEFICIENCIES", name="analysistype"),
-            nullable=False,
-        ),
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_column("rfps", "ko_name")
-    op.drop_column("rfps", "award_type")
-    op.drop_column("rfps", "google_drive_id")
-
-    op.drop_column("proposals", "ai_score")
-    op.drop_column("proposals", "final_score")
-
-    op.drop_table("comparative_weights")
-    op.drop_table("evaluations")
-    op.drop_table("analysis")

alembic/versions/7fae52a30825_update_rfp_table.py

@@ -1,31 +0,0 @@
-"""update rfp table
-
-Revision ID: 7fae52a30825
-Revises: 0402a665d940
-Create Date: 2025-06-04 11:00:24.081115
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '7fae52a30825'
-down_revision: Union[str, None] = '0402a665d940'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    status = sa.Enum("ACTIVE", "IN_PROGRESS", "NOT_YET_STARTED", "CUSTOMER_HOLD", "UNSOLVED_ISSUES", "AWARDED", "PROTESTED", name="rfpstatus")
-    status.create(op.get_bind())
-    op.add_column("rfps", sa.Column("status", status, nullable=False, server_default="ACTIVE"))
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    sa.Enum(name='rfpstatus').drop(op.get_bind(), checkfirst=True)
-    op.drop_column("rfps", "status")

alembic/versions/7fb86c16841c_add_flag_in_rfp_table.py

@@ -1,36 +0,0 @@
-"""add flag in rfp table
-
-Revision ID: 7fb86c16841c
-Revises: b5d2f8b83d7e
-Create Date: 2025-06-06 11:06:57.084499
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '7fb86c16841c'
-down_revision: Union[str, None] = 'b5d2f8b83d7e'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.add_column("rfps", sa.Column("flag", sa.Boolean(), nullable=True, server_default=sa.text("FALSE")))
-    op.execute("UPDATE rfps SET flag = FALSE")
-    op.alter_column(
-        "rfps",
-        "flag",
-        existing_type=sa.Boolean(),
-        nullable=False,
-        server_default=sa.text("FALSE"),
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_column("rfps", "flag")

alembic/versions/80b53babd4e6_update_flag_column_name.py

@@ -1,36 +0,0 @@
-"""update flag column name
-
-Revision ID: 80b53babd4e6
-Revises: 7fb86c16841c
-Create Date: 2025-06-06 11:29:29.960724
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = '80b53babd4e6'
-down_revision: Union[str, None] = '7fb86c16841c'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.alter_column(
-        'rfps',
-        'flag',
-        new_column_name='comparative_weights_locked'
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.alter_column(
-        'rfps',
-        'comparative_weights_locked',
-        new_column_name='flag'
-    )

alembic/versions/a3bbab758ddb_categorize_the_analysis.py

@@ -1,91 +0,0 @@
-"""categorize the analysis
-
-Revision ID: a3bbab758ddb
-Revises: 7fae52a30825
-Create Date: 2025-06-04 14:01:24.366580
-
-"""
-
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = "a3bbab758ddb"
-down_revision: Union[str, None] = "7fae52a30825"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    strength_category_enum = sa.Enum(
-        "TECHNICAL", "MANAGEMENT", "PAST_PERFORMANCE", "PRICE", name="strengthcategory"
-    )
-    strength_category_enum.create(op.get_bind())
-    op.add_column(
-        "proposal_strengths",
-        sa.Column(
-            "category",
-            strength_category_enum,
-            nullable=False,
-            server_default="TECHNICAL",
-        ),
-    )
-    weakness_category_enum = sa.Enum(
-        "TECHNICAL", "MANAGEMENT", "PAST_PERFORMANCE", "PRICE", name="weaknesscategory"
-    )
-    weakness_category_enum.create(op.get_bind())
-    op.add_column(
-        "proposal_weaknesses",
-        sa.Column(
-            "category",
-            weakness_category_enum,
-            nullable=False,
-            server_default="TECHNICAL",
-        ),
-    )
-    rejection_category_enum = sa.Enum(
-        "TECHNICAL", "MANAGEMENT", "PAST_PERFORMANCE", "PRICE", name="rejectioncategory"
-    )
-    rejection_category_enum.create(op.get_bind())
-    op.add_column(
-        "proposal_rejection_reasons",
-        sa.Column(
-            "category",
-            rejection_category_enum,
-            nullable=False,
-            server_default="TECHNICAL",
-        ),
-    )
-    improvement_category_enum = sa.Enum(
-        "TECHNICAL",
-        "MANAGEMENT",
-        "PAST_PERFORMANCE",
-        "PRICE",
-        name="improvementcategory",
-    )
-    improvement_category_enum.create(op.get_bind())
-    op.add_column(
-        "proposal_improvements",
-        sa.Column(
-            "category",
-            improvement_category_enum,
-            nullable=False,
-            server_default="TECHNICAL",
-        ),
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    sa.Enum(name="strengthcategory").drop(op.get_bind(), checkfirst=True)
-    op.drop_column("proposal_strengths", "category")
-    sa.Enum(name="weaknesscategory").drop(op.get_bind(), checkfirst=True)
-    op.drop_column("proposal_weaknesses", "category")
-    sa.Enum(name="rejectioncategory").drop(op.get_bind(), checkfirst=True)
-    op.drop_column("proposal_rejection_reasons", "category")
-    sa.Enum(name="improvementcategory").drop(op.get_bind(), checkfirst=True)
-    op.drop_column("proposal_improvements", "category")

alembic/versions/b5d2f8b83d7e_add_flag_and_status.py

@@ -1,41 +0,0 @@
-"""add flag and status
-
-Revision ID: b5d2f8b83d7e
-Revises: 3ba37b484f31
-Create Date: 2025-06-05 20:00:52.297117
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'b5d2f8b83d7e'
-down_revision: Union[str, None] = '3ba37b484f31'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.add_column("comparative_weights", sa.Column("flag", sa.Boolean(), nullable=True, server_default=sa.text("FALSE")))
-    op.execute("UPDATE comparative_weights SET flag = FALSE")
-    op.alter_column(
-        "comparative_weights",
-        "flag",
-        existing_type=sa.Boolean(),
-        nullable=False,
-        server_default=sa.text("FALSE"),
-    )
-    analysis_enum = sa.Enum("ACCEPTED", "REJECTED", "PENDING", name="analysisstatus")
-    analysis_enum.create(op.get_bind())
-    op.add_column("analysis", sa.Column("status", analysis_enum, nullable=False, server_default="PENDING"))
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_column("comparative_weights", "flag")
-    
-    sa.Enum(name="analysisstatus").drop(op.get_bind(), checkfirst=True)
-    op.drop_column("analysis", "status")

alembic/versions/c70330d677c0_add_evaluation_criteria.py

@@ -1,38 +0,0 @@
-"""add evaluation_criteria
-
-Revision ID: c70330d677c0
-Revises: e825902b2e8a
-Create Date: 2025-06-02 19:38:53.073958
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-from sqlalchemy.dialects import postgresql
-
-
-# revision identifiers, used by Alembic.
-revision: str = 'c70330d677c0'
-down_revision: Union[str, None] = 'e825902b2e8a'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.create_table(
-        "evaluation_criteria_details",
-        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column("rfp_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("evaluation_criteria", sa.String(), nullable=True),
-        sa.Column("evaluation_criteria_type", sa.Enum("EVALUATION", "GATE", name="evaluationcriteriatype"), nullable=False),
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_table("evaluation_criteria_details")

alembic/versions/e825902b2e8a_alter_tables.py

@@ -1,49 +0,0 @@
-"""alter tables
-
-Revision ID: e825902b2e8a
-Revises: 11d43047d470
-Create Date: 2025-06-02 16:32:45.552509
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-import sqlalchemy as sa
-
-from sqlalchemy.dialects import postgresql
-
-# revision identifiers, used by Alembic.
-revision: str = 'e825902b2e8a'
-down_revision: Union[str, None] = '11d43047d470'
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Upgrade schema."""
-    op.add_column("rfps", sa.Column("name", sa.String(), nullable=True))
-
-    op.add_column("proposals", sa.Column("tep", sa.String(), nullable=True))
-
-    gate_criteria_enum = sa.Enum('PASS', 'FAIL', 'IN_REVIEW', name='gatecriteria')
-    gate_criteria_enum.create(op.get_bind())
-    op.add_column('proposals', sa.Column('gate_criteria', gate_criteria_enum, nullable=False, server_default='IN_REVIEW'))
-
-    op.create_table(
-        "letters",
-        sa.Column("id", postgresql.UUID(as_uuid=True), primary_key=True),
-        sa.Column("proposal_id", postgresql.UUID(as_uuid=True), sa.ForeignKey("proposals.id", ondelete="CASCADE"), nullable=False),
-        sa.Column("letter", sa.Text(), nullable=True),
-        sa.Column("letter_type", sa.Enum("UO", "DEBRIEF", name="lettertype"), nullable=False),
-        sa.Column("created_at", sa.DateTime(), nullable=False),
-        sa.Column("updated_at", sa.DateTime(), nullable=False),
-    )
-
-
-def downgrade() -> None:
-    """Downgrade schema."""
-    op.drop_table("letters")
-    sa.Enum(name='gatecriteria').drop(op.get_bind(), checkfirst=True)
-    op.drop_column("proposals", "gate_criteria")
-    op.drop_column("proposals", "tep")
-    op.drop_column("rfps", "name")

pyproject.toml

@@ -1,32 +0,0 @@
-[tool.poetry]
-name = "proposal-evaluation"
-version = "0.1.0"
-description = ""
-authors = ["Aryan Jain <77013565+aryanjain1908@users.noreply.github.com>"]
-readme = "README.md"
-
-[tool.poetry.dependencies]
-python = "^3.12"
-uvicorn = "^0.34.2"
-fastapi = "^0.115.12"
-python-dotenv = "^1.1.0"
-alembic = "^1.16.1"
-asyncpg = "^0.30.0"
-loguru = "^0.7.3"
-pydantic = "^2.11.5"
-aiosqlite = "^0.21.0"
-python-multipart = "^0.0.20"
-pypdf2 = "^3.0.1"
-pymupdf = "^1.26.0"
-python-docx = "^1.1.2"
-docx2pdf = "^0.1.8"
-openpyxl = "^3.1.5"
-pandas = "^2.3.0"
-numpy = "^2.2.6"
-aiofiles = "^24.1.0"
-markdown2 = "^2.5.3"
-
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"

src/__init__.py

@@ -1,15 +0,0 @@
-from dotenv import load_dotenv
-import os
-
-from .app import app
-from .config import logger
-
-load_dotenv()
-
-if not os.getenv("SQLALCHEMY_DATABASE_URI"):
-    logger.error("SQLALCHEMY_DATABASE_URI is not set")
-    raise ValueError("SQLALCHEMY_DATABASE_URI is not set")
-
-__all__ = ["app"]
-__version__ = "0.1.0"
-__author__ = "Aryan Jain"

src/app.py

@@ -1,65 +0,0 @@
-import asyncio
-import os
-from contextlib import asynccontextmanager
-from threading import Thread
-
-from alembic import command
-from alembic.config import Config
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-
-from src.config import DatabaseConfig, logger
-from src.controllers import api_router
-
-
-
-def run_upgrade(connection, alembic_config: Config):
-    alembic_config.attributes["connection"] = connection
-    command.upgrade(alembic_config, "head")
-
-
-async def run_migrations():
-    logger.info("Running migrations if any...")
-    alembic_config = Config("alembic.ini")
-    alembic_config.set_main_option(
-        "sqlalchemy.url", os.getenv("SQLALCHEMY_DATABASE_URI")
-    )
-    async with DatabaseConfig.get_engine().begin() as session:
-        await session.run_sync(run_upgrade, alembic_config)
-
-
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    try:
-        logger.info("Starting up the application...")
-        await run_migrations()
-        logger.info("Application started successfully...")
-        yield
-    except Exception as e:
-        logger.error(f"Error during startup: {str(e)}")
-        raise
-    finally:
-        logger.info("Shutting down the application...")
-        logger.info("Application shutdown complete.")
-
-
-app = FastAPI(lifespan=lifespan)
-
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=os.getenv(
-        "CORS_ALLOW_ORIGINS", "http://localhost, http://127.0.0.1"
-    ).split(", "),
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-
-@app.get("/")
-async def check_health():
-    return {"response": "Service is healthy!"}
-
-
-app.include_router(api_router, prefix="/api/v1")

src/config/__init__.py

@@ -1,9 +0,0 @@
-from ._databse_config import DatabaseConfig
-from ._logger import logger
-
-__all__ = [
-    "DatabaseConfig",
-    "logger",
-]
-__version__ = "0.1.0"
-__author__ = "Aryan Jain"

src/config/_databse_config.py

@@ -1,37 +0,0 @@
-import os
-import threading
-from contextlib import asynccontextmanager
-
-from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
-
-
-class DatabaseConfig:
-    _thread_local = threading.local()
-
-    @classmethod
-    def get_engine(cls):
-        if not hasattr(cls._thread_local, "engine"):
-            cls._thread_local.engine = create_async_engine(
-                url=os.getenv("SQLALCHEMY_DATABASE_URI"),
-                pool_pre_ping=True,
-                pool_recycle=3600,
-            )
-        return cls._thread_local.engine
-
-    @classmethod
-    def _get_session_factory(cls):
-        if not hasattr(cls._thread_local, "session_factory"):
-            cls._thread_local.session_factory = async_sessionmaker(
-                bind=cls.get_engine(),
-                autoflush=False,
-                autocommit=False,
-                expire_on_commit=False,
-            )
-        return cls._thread_local.session_factory
-
-    @classmethod
-    @asynccontextmanager
-    async def async_session(cls):
-        session_factory = cls._get_session_factory()
-        async with session_factory() as session:
-            yield session

src/config/_logger.py

@@ -1,8 +0,0 @@
-import os
-
-from loguru import logger
-
-LOG_FILE = os.getenv("LOG_FILE")
-if LOG_FILE:
-    LOG_RETENTION = os.getenv("LOG_RETENTION", "90 days")
-    logger.add(LOG_FILE, retention=LOG_RETENTION)

src/controllers/__init__.py

@@ -1,28 +0,0 @@
-from fastapi import APIRouter
-from ._rfp_controller import RFPController
-from ._proposal_controller import ProposalController
-from ._proposal_ai_analysis_controller import ProposalAIController
-from ._proposal_detailed_analysis_controller import ProposalDetailedController
-from ._letter_controller import LetterController
-from ._evaluation_controller import EvaluationController
-from ._comparative_weight_controller import ComparativeWeightController
-from ._proposal_evaluation_controller import ProposalEvaluationController
-from ._analysis_conteoller import AnalysisController
-from ._file_controller import FileController
-
-api_router = APIRouter()
-
-api_router.include_router(RFPController().router)
-api_router.include_router(ProposalController().router)
-# api_router.include_router(ProposalAIController().router)
-# api_router.include_router(ProposalDetailedController().router)
-api_router.include_router(LetterController().router)
-api_router.include_router(EvaluationController().router)
-api_router.include_router(ComparativeWeightController().router)
-api_router.include_router(ProposalEvaluationController().router)
-api_router.include_router(AnalysisController().router)
-api_router.include_router(FileController().router)
-
-__all__ = ["api_router"]
-__version__ = "0.1.0"
-__author__ = "Aryan Jain"

src/controllers/_analysis_conteoller.py

@@ -1,249 +0,0 @@
-from fastapi import APIRouter, Body, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.models import AnalysisType, AnalysisStatus
-from src.services import AnalysisService
-
-
-class Analysis(BaseModel):
-    id: UUID
-    evaluation_id: UUID
-    insights: str
-    analysis_type: AnalysisType
-    status: AnalysisStatus
-    created_at: datetime
-    updated_at: datetime
-
-
-class Response(BaseModel):
-    status: str
-    data: Optional[List[Analysis]] = None
-
-
-class CreateAnalysis(BaseModel):
-    insights: str
-    analysis_type: AnalysisType
-    status: Optional[AnalysisStatus] = None
-
-
-class CreateAnalysisRequest(BaseModel):
-    data: List[CreateAnalysis]
-    analysis_score_type: Optional[str] = None
-
-
-class UpdateAnalysis(BaseModel):
-    insights: Optional[str] = None
-    analysis_type: Optional[AnalysisType] = None
-    status: Optional[AnalysisStatus] = None
-
-
-class Deleteresponse(BaseModel):
-    status: str
-
-
-class AnalysisController:
-    def __init__(self):
-        self.service = AnalysisService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
-            self.get_analysis_by_proposal_and_rfp_id_and_evaluation_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
-            self.get_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
-            self.create_analysis_by_proposal_and_rfp_id_and_evaluation_id,
-            methods=["POST"],
-            response_model=Response,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
-            self.update_analysis_by_proposal_and_rfp_id_and_evaluation_id,
-            methods=["PUT"],
-            response_model=Response,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
-            self.update_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
-            methods=["PUT"],
-            response_model=Response,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis",
-            self.delete_analysis_by_proposal_and_rfp_id_and_evaluation_id,
-            methods=["DELETE"],
-            response_model=Deleteresponse,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{evaluation_id}/analysis/{id}",
-            self.delete_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id,
-            methods=["DELETE"],
-            response_model=Deleteresponse,
-            tags=["Analysis by Proposal and RFP ID and Evaluation ID and ID"],
-        )
-
-    async def get_analysis_by_proposal_and_rfp_id_and_evaluation_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        analysis_type: AnalysisType = Query(None),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.get_analysis(
-                    evaluation_id=evaluation_id, analysis_type=analysis_type
-                )
-                return Response(
-                    status="success",
-                    data=[Analysis(**result) for result in results],
-                )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def get_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        id: str = Path(...),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.get_analysis(evaluation_id=evaluation_id, id=id)
-                return Response(
-                    status="success",
-                    data=[Analysis(**result) for result in results],
-                )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def create_analysis_by_proposal_and_rfp_id_and_evaluation_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        analysis: CreateAnalysisRequest = Body(...),
-    ):
-        try:
-            async with self.service() as service:
-                evaluation_analysis = analysis.model_dump(
-                    mode="json", exclude_unset=True
-                )
-                results = await service.create_analysis(
-                    evaluation_id=evaluation_id,
-                    evaluation_analysis=evaluation_analysis["data"],
-                    analysis_score_type=(
-                        evaluation_analysis["analysis_score_type"]
-                        if "analysis_score_type" in evaluation_analysis
-                        else None
-                    ),
-                )
-                return Response(
-                    status="success",
-                    data=[Analysis(**result) for result in results],
-                )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def update_analysis_by_proposal_and_rfp_id_and_evaluation_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        analysis: CreateAnalysisRequest = Body(...),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.update_analysis(
-                    evaluation_id=evaluation_id,
-                    proposal_analysis=analysis.model_dump(
-                        mode="json", exclude_unset=True
-                    )["data"],
-                )
-                return Response(
-                    status="success",
-                    data=[Analysis(**result) for result in results],
-                )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def update_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        id: str = Path(...),
-        analysis: UpdateAnalysis = Body(...),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.update_analysis(
-                    evaluation_id=evaluation_id,
-                    id=id,
-                    proposal_analysis=analysis.model_dump(
-                        mode="json", exclude_unset=True
-                    ),
-                )
-                return Response(
-                    status="success",
-                    data=[Analysis(**result) for result in results],
-                )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def delete_analysis_by_proposal_and_rfp_id_and_evaluation_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.delete_analysis(evaluation_id=evaluation_id)
-                return Deleteresponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))
-
-    async def delete_analysis_by_proposal_and_rfp_id_and_evaluation_id_and_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_id: str = Path(...),
-        id: str = Path(...),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.delete_analysis(
-                    evaluation_id=evaluation_id, id=id
-                )
-                return Deleteresponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail=str(e))

src/controllers/_comparative_weight_controller.py

@@ -1,237 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.models import Weights
-from src.services import ComparativeWeightService
-
-
-class ComparitiveWeight(BaseModel):
-    id: UUID
-    rfp_id: UUID
-    technical_weight: Weights
-    management_weight: Weights
-    past_performance_weight: Weights
-    price_weight: Weights
-    strengths_weight: float
-    weaknesses_weight: float
-    flag: Optional[bool] = False
-    created_at: datetime
-    updated_at: datetime
-
-
-class ResponseComparativeWeight(BaseModel):
-    status: str
-    data: Optional[List[ComparitiveWeight]]
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class ComparativeWeightRequest(BaseModel):
-    technical_weight: Optional[Weights] = None
-    management_weight: Optional[Weights] = None
-    past_performance_weight: Optional[Weights] = None
-    price_weight: Optional[Weights] = None
-    strengths_weight: Optional[float] = None
-    weaknesses_weight: Optional[float] = None
-    flag: Optional[bool] = None
-
-
-class ComparativeWeightController:
-    def __init__(self):
-        self.comparative_weight_service = ComparativeWeightService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights",
-            self.get_comparative_weights_by_rfp_id,
-            methods=["GET"],
-            response_model=ResponseComparativeWeight,
-            tags=["Comparative Weights by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights/{id}",
-            self.get_comparative_weights_by_id,
-            methods=["GET"],
-            response_model=ResponseComparativeWeight,
-            tags=["Comparative Weights by RFP ID and ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights",
-            self.create_comparative_weights,
-            methods=["POST"],
-            response_model=ResponseComparativeWeight,
-            tags=["Comparative Weights by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights/{id}",
-            self.update_comparative_weights_by_id,
-            methods=["PUT"],
-            response_model=ResponseComparativeWeight,
-            tags=["Comparative Weights by RFP ID and ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights",
-            self.update_comparative_weights,
-            methods=["PUT"],
-            response_model=ResponseComparativeWeight,
-            tags=["Comparative Weights by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights",
-            self.delete_comparative_weights,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Comparative Weights by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/comparative-weights/{id}",
-            self.delete_comparative_weights_by_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Comparative Weights by RFP ID and ID"],
-        )
-
-    async def get_comparative_weights_by_rfp_id(self, rfp_id: str = Path(...)):
-        try:
-            async with self.comparative_weight_service() as service:
-                comparative_weights = await service.get_comparative_weights(
-                    rfp_id=rfp_id
-                )
-            return ResponseComparativeWeight(
-                status="success",
-                data=[
-                    ComparitiveWeight(**comparative_weight)
-                    for comparative_weight in comparative_weights
-                ],
-            )
-        except Exception as e:
-            logger.error(f"Error getting comparative weights by rfp id: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error getting comparative weights by rfp id"
-            )
-
-    async def get_comparative_weights_by_id(
-        self, rfp_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.comparative_weight_service() as service:
-                comparative_weights = await service.get_comparative_weights(
-                    rfp_id=rfp_id, id=id
-                )
-            return ResponseComparativeWeight(
-                status="success",
-                data=[
-                    ComparitiveWeight(**comparative_weight)
-                    for comparative_weight in comparative_weights
-                ],
-            )
-        except Exception as e:
-            logger.error(f"Error getting comparative weights by id: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error getting comparative weights by id"
-            )
-
-    async def create_comparative_weights(
-        self, comparative_weights: ComparativeWeightRequest, rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.comparative_weight_service() as service:
-                comparative_weights = await service.create_comparative_weights(
-                    rfp_id=rfp_id,
-                    comparative_weights=comparative_weights.model_dump(
-                        mode="json", exclude_unset=True
-                    ),
-                )
-            return ResponseComparativeWeight(
-                status="success",
-                data=[
-                    ComparitiveWeight(**comparative_weight)
-                    for comparative_weight in comparative_weights
-                ],
-            )
-        except Exception as e:
-            logger.error(f"Error creating comparative weights: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error creating comparative weights"
-            )
-
-    async def update_comparative_weights(
-        self, comparative_weights: ComparativeWeightRequest, rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.comparative_weight_service() as service:
-                comparative_weights = await service.update_comparative_weights(
-                    rfp_id=rfp_id,
-                    comparative_weights=comparative_weights.model_dump(
-                        mode="json", exclude_unset=True
-                    ),
-                )
-            return ResponseComparativeWeight(
-                status="success",
-                data=[
-                    ComparitiveWeight(**comparative_weight)
-                    for comparative_weight in comparative_weights
-                ],
-            )
-        except Exception as e:
-            logger.error(f"Error updating comparative weights: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error updating comparative weights"
-            )
-
-    async def update_comparative_weights_by_id(
-        self,
-        comparative_weights: ComparativeWeightRequest,
-        rfp_id: str = Path(...),
-        id: str = Path(...),
-    ):
-        try:
-            async with self.comparative_weight_service() as service:
-                comparative_weights = await service.update_comparative_weights(
-                    rfp_id=rfp_id,
-                    id=id,
-                    comparative_weights=comparative_weights.model_dump(
-                        mode="json", exclude_unset=True
-                    ),
-                )
-            return ResponseComparativeWeight(
-                status="success",
-                data=[
-                    ComparitiveWeight(**comparative_weight)
-                    for comparative_weight in comparative_weights
-                ],
-            )
-        except Exception as e:
-            logger.error(f"Error updating comparative weights by id: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error updating comparative weights by id"
-            )
-
-    async def delete_comparative_weights(self, rfp_id: str = Path(...)):
-        try:
-            async with self.comparative_weight_service() as service:
-                await service.delete_comparative_weights(rfp_id=rfp_id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(f"Error deleting comparative weights: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error deleting comparative weights"
-            )
-
-    async def delete_comparative_weights_by_id(
-        self, rfp_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.comparative_weight_service() as service:
-                await service.delete_comparative_weights(rfp_id=rfp_id, id=id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(f"Error deleting comparative weights: {e}")
-            raise HTTPException(
-                status_code=500, detail="Error deleting comparative weights"
-            )

src/controllers/_evaluation_controller.py

@@ -1,299 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.services import EvaluationService
-from src.models import EvaluationCriteriaType
-
-
-class EvaluationCriteria(BaseModel):
-    id: UUID
-    rfp_id: UUID
-    evaluation_criteria: str
-    evaluation_criteria_type: EvaluationCriteriaType
-    created_at: datetime
-    updated_at: datetime
-
-
-class EvaluationResponse(BaseModel):
-    status: str
-    data: List[EvaluationCriteria]
-
-
-class EvaluationRequest(BaseModel):
-    rfp_id: UUID
-    evaluation_criteria: str
-    evaluation_criteria_type: EvaluationCriteriaType
-
-
-class CreateEvaluationRequest(BaseModel):
-    evaluation_criteria: str
-    evaluation_criteria_type: EvaluationCriteriaType
-
-
-class UpdateEvaluationRequest(BaseModel):
-    rfp_id: Optional[UUID] = None
-    evaluation_criteria: Optional[str] = None
-    evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
-
-
-class UpdateEvaluationCriteriaByRFPRequest(BaseModel):
-    evaluation_criteria: Optional[str] = None
-    evaluation_criteria_type: Optional[EvaluationCriteriaType] = None
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class EvaluationController:
-    def __init__(self):
-        self.evaluation_service = EvaluationService
-        self.router = APIRouter()
-        # self.router.add_api_route(
-        #     "/evaluation-criteria",
-        #     self.get_criteria,
-        #     methods=["GET"],
-        #     response_model=EvaluationResponse,
-        #     tags=["Evaluation Criteria"],
-        # )
-        # self.router.add_api_route(
-        #     "/evaluation-criteria/{id}",
-        #     self.get_criteria_by_id,
-        #     methods=["GET"],
-        #     response_model=EvaluationResponse,
-        #     tags=["Evaluation Criteria by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria",
-            self.get_criteria_by_rfp_id,
-            methods=["GET"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria/{id}",
-            self.get_criteria_by_proposal_and_rfp_id,
-            methods=["GET"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by Proposal and RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/evaluation-criteria",
-        #     self.create_criteria,
-        #     methods=["POST"],
-        #     response_model=EvaluationResponse,
-        #     tags=["Evaluation Criteria"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria",
-            self.create_criteria_by_rfp_id,
-            methods=["POST"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/evaluation-criteria/{id}",
-        #     self.update_criteria,
-        #     methods=["PUT"],
-        #     response_model=EvaluationResponse,
-        #     tags=["Evaluation Criteria by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria/{id}",
-            self.update_criteria_by_proposal_and_rfp_id,
-            methods=["PUT"],
-            response_model=EvaluationResponse,
-            tags=["Evaluation Criteria by Proposal and RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/evaluation-criteria/{id}",
-        #     self.delete_criteria,
-        #     methods=["DELETE"],
-        #     response_model=DeleteResponse,
-        #     tags=["Evaluation Criteria by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria",
-            self.delete_criteria_by_rfp_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Evaluation Criteria by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/evaluation-criteria/{id}",
-            self.delete_criteria_by_proposal_and_rfp_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Evaluation Criteria by Proposal and RFP ID"],
-        )
-
-    async def get_criteria(self):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.get_criteria()
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error fetching evaluation criteria"
-            )
-
-    async def get_criteria_by_id(self, id: str = Path(...)):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.get_criteria(id=id)
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error fetching evaluation criteria"
-            )
-
-    async def get_criteria_by_rfp_id(
-        self,
-        rfp_id: str = Path(...),
-        criteria_type: Optional[EvaluationCriteriaType] = Query(None),
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.get_criteria(
-                    rfp_id=rfp_id, evaluation_criteria_type=criteria_type
-                )
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error fetching evaluation criteria"
-            )
-
-    async def get_criteria_by_proposal_and_rfp_id(
-        self, rfp_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.get_criteria(rfp_id=rfp_id, id=id)
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error fetching evaluation criteria"
-            )
-
-    async def create_criteria(self, criteria: EvaluationRequest):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.create_criteria(
-                    criteria.model_dump(exclude_unset=True, mode="json")
-                )
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error creating evaluation criteria"
-            )
-
-    async def create_criteria_by_rfp_id(
-        self, criteria: CreateEvaluationRequest, rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                data = criteria.model_dump(exclude_unset=True, mode="json")
-                data["rfp_id"] = rfp_id
-                result = await service.create_criteria(evaluation_criteria=data)
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error creating evaluation criteria"
-            )
-
-    async def update_criteria(
-        self, criteria: UpdateEvaluationRequest, id: str = Path(...)
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                result = await service.update_criteria(
-                    id=id,
-                    evaluation_criteria=criteria.model_dump(
-                        exclude_unset=True, mode="json"
-                    ),
-                )
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error updating evaluation criteria"
-            )
-
-    async def update_criteria_by_proposal_and_rfp_id(
-        self,
-        criteria: UpdateEvaluationCriteriaByRFPRequest,
-        rfp_id: str = Path(...),
-        id: str = Path(...),
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                data = criteria.model_dump(exclude_unset=True, mode="json")
-                data["rfp_id"] = rfp_id
-                result = await service.update_criteria(id=id, evaluation_criteria=data)
-            return EvaluationResponse(
-                status="success", data=[EvaluationCriteria(**r) for r in result]
-            )
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error updating evaluation criteria"
-            )
-
-    async def delete_criteria(self, id: str = Path(...)):
-        try:
-            async with self.evaluation_service() as service:
-                await service.delete_criteria(id=id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error deleting evaluation criteria"
-            )
-
-    async def delete_criteria_by_rfp_id(self, rfp_id: str = Path(...)):
-        try:
-            async with self.evaluation_service() as service:
-                await service.delete_criteria(rfp_id=rfp_id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error deleting evaluation criteria"
-            )
-
-    async def delete_criteria_by_proposal_and_rfp_id(
-        self, rfp_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.evaluation_service() as service:
-                await service.delete_criteria(rfp_id=rfp_id, id=id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(
-                status_code=500, detail="Error deleting evaluation criteria"
-            )

src/controllers/_file_controller.py

@@ -1,34 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path, UploadFile, File
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.services import FileService
-
-import io
-
-class Response(BaseModel):
-    status: str
-    data: str
-
-class FileController:
-    def __init__(self):
-        self.service = FileService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/files",
-            self.get_files_extrcated_text,
-            methods=["POST"],
-            tags=["Files"],
-        )
-
-    async def get_files_extrcated_text(self, file: UploadFile = File(...)):
-        try:
-            async with self.service() as service:
-                result = await service.extract_file(file=file)
-            return result
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error processing file")

src/controllers/_letter_controller.py

@@ -1,263 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.services import LetterService
-from src.models import LetterType
-
-
-class Letter(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    letter: str
-    letter_type: LetterType
-    created_at: datetime
-    updated_at: datetime
-
-
-class Response(BaseModel):
-    status: str
-    data: List[Letter]
-
-
-class LetterRequest(BaseModel):
-    proposal_id: UUID
-    letter: str
-    letter_type: LetterType
-
-
-class CreateLetterRequest(BaseModel):
-    letter: str
-    letter_type: LetterType
-
-
-class UpdateLetterRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    letter: Optional[str] = None
-    letter_type: Optional[LetterType] = None
-
-
-class UpdateLetterRequestByProposalAndId(BaseModel):
-    letter: Optional[str] = None
-    letter_type: Optional[LetterType] = None
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class LetterController:
-    def __init__(self):
-        self.letter_service = LetterService
-        self.router = APIRouter()
-        # self.router.add_api_route(
-        #     "/letters",
-        #     self.get_letters,
-        #     methods=["GET"],
-        #     response_model=Response,
-        #     tags=["Letters"],
-        # )
-        # self.router.add_api_route(
-        #     "/letters/{id}",
-        #     self.get_letters_by_id,
-        #     methods=["GET"],
-        #     response_model=Response,
-        #     tags=["Letters by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
-            self.get_letters_by_proposal_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Letters by Proposal ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
-            self.get_letters_by_proposal_and_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Letters by Proposal and ID"],
-        )
-        # self.router.add_api_route(
-        #     "/letters",
-        #     self.create_letter,
-        #     methods=["POST"],
-        #     response_model=Response,
-        #     tags=["Letters"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
-            self.create_letters_by_proposal_id,
-            methods=["POST"],
-            response_model=Response,
-            tags=["Letters by Proposal ID"],
-        )
-        # self.router.add_api_route(
-        #     "/letters/{id}",
-        #     self.update_letter,
-        #     methods=["PUT"],
-        #     response_model=Response,
-        #     tags=["Letters by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
-            self.update_letters_by_proposal_and_id,
-            methods=["PUT"],
-            response_model=Response,
-            tags=["Letters by Proposal and ID"],
-        )
-        # self.router.add_api_route(
-        #     "/letters/{id}",
-        #     self.delete_letter,
-        #     methods=["DELETE"],
-        #     response_model=DeleteResponse,
-        #     tags=["Letters by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters",
-            self.delete_letters_by_proposal_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Letters by Proposal ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/letters/{id}",
-            self.delete_letters_by_proposal_and_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Letters by Proposal and ID"],
-        )
-
-    async def get_letters(self):
-        try:
-            async with self.letter_service() as service:
-                result = await service.get_letters()
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error fetching letters")
-
-    async def get_letters_by_id(self, id: str = Path(...)):
-        try:
-            async with self.letter_service() as service:
-                result = await service.get_letters(id=id)
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error fetching letter")
-
-    async def get_letters_by_proposal_id(
-        self,
-        proposal_id: str = Path(...),
-        letter_type: LetterType = Query(None),
-        rfp_id: str = Path(...),
-    ):
-        try:
-            async with self.letter_service() as service:
-                result = await service.get_letters(
-                    proposal_id=proposal_id, letter_type=letter_type
-                )
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error fetching letter")
-
-    async def get_letters_by_proposal_and_id(
-        self, proposal_id: str = Path(...), id: str = Path(...), rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.letter_service() as service:
-                result = await service.get_letters(proposal_id=proposal_id, id=id)
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error fetching letter")
-
-    async def create_letter(self, letter: LetterRequest):
-        try:
-            async with self.letter_service() as service:
-                result = await service.create_letter(
-                    letter.model_dump(exclude_unset=True, mode="json")
-                )
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error creating letter")
-
-    async def create_letters_by_proposal_id(
-        self,
-        letter: CreateLetterRequest,
-        proposal_id: str = Path(...),
-        rfp_id: str = Path(...),
-    ):
-        try:
-            async with self.letter_service() as service:
-                data = letter.model_dump(exclude_unset=True, mode="json")
-                data["proposal_id"] = proposal_id
-                result = await service.create_letter(letter=data)
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error creating letter")
-
-    async def update_letter(self, letter: UpdateLetterRequest, id: str = Path(...)):
-        try:
-            async with self.letter_service() as service:
-                result = await service.update_letter(
-                    id=id, letter=letter.model_dump(exclude_unset=True, mode="json")
-                )
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error updating letter")
-
-    async def update_letters_by_proposal_and_id(
-        self,
-        letter: UpdateLetterRequestByProposalAndId,
-        proposal_id: str = Path(...),
-        id: str = Path(...),
-        rfp_id: str = Path(...),
-    ):
-        try:
-            async with self.letter_service() as service:
-                data = letter.model_dump(exclude_unset=True, mode="json")
-                data["proposal_id"] = proposal_id
-                result = await service.update_letter(id=id, letter=data)
-            return Response(status="success", data=[Letter(**r) for r in result])
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error updating letter")
-
-    async def delete_letter(self, id: str = Path(...)):
-        try:
-            async with self.letter_service() as service:
-                result = await service.delete_letter(id=id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error deleting letter")
-
-    async def delete_letters_by_proposal_id(
-        self, proposal_id: str = Path(...), rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.letter_service() as service:
-                result = await service.delete_letter(proposal_id=proposal_id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error deleting letter")
-
-    async def delete_letters_by_proposal_and_id(
-        self, proposal_id: str = Path(...), id: str = Path(...), rfp_id: str = Path(...)
-    ):
-        try:
-            async with self.letter_service() as service:
-                result = await service.delete_letter(proposal_id=proposal_id, id=id)
-            return DeleteResponse(status="success")
-        except Exception as e:
-            logger.error(e)
-            raise HTTPException(status_code=500, detail="Error deleting letter")

src/controllers/_proposal_ai_analysis_controller.py

@@ -1,1783 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-
-from src.services import ProposalAIAnalysisService
-
-from src.models import QueryType, CreateOrUpdateType, Category
-
-
-class ProposalAIAnalysis(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    ai_score: float
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalStrength(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    strength_point: str
-    category: Category
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalWeakness(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    weakness_point: str
-    category: Category
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalRejectionReason(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    reason: str
-    category: Category
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalImprovement(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    improvement_point: str
-    category: Category
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalAllStrengthsResponse(BaseModel):
-    status: str
-    data: Optional[List[str]]
-
-
-class ProposalAllWeaknessesResponse(BaseModel):
-    status: str
-    data: Optional[List[str]]
-
-
-class ProposalAllRejectionReasonsResponse(BaseModel):
-    status: str
-    data: Optional[List[str]]
-
-
-class ProposalAllImprovementsResponse(BaseModel):
-    status: str
-    data: Optional[List[str]]
-
-
-class ProposalAIAnalysisResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalAIAnalysis]]
-
-
-class ProposalStrengthResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalStrength]]
-
-
-class ProposalWeaknessResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalWeakness]]
-
-
-class ProposalRejectionReasonResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalRejectionReason]]
-
-
-class ProposalImprovementResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalImprovement]]
-
-class Analysis(BaseModel):
-    strengths: Optional[List[str]] = None
-    weaknesses: Optional[List[str]] = None
-    rejection_reasons: Optional[List[str]] = None
-    improvements: Optional[List[str]] = None
-
-class ProposalCompleteAnalysis(BaseModel):
-    ai_score: float
-    technical: Optional[Analysis] = None
-    management: Optional[Analysis] = None
-    past_performance: Optional[Analysis] = None
-    price: Optional[Analysis] = None
-
-
-class ProposalCompleteAnalysisResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalCompleteAnalysis]]
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class ProposalStrengthRequest(BaseModel):
-    proposal_id: UUID
-    strength_point: str
-    category: Category
-
-
-class UpdateProposalStrengthRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    strength_point: Optional[str] = None
-    category: Optional[Category] = None
-
-
-class ProposalWeaknessRequest(BaseModel):
-    proposal_id: UUID
-    weakness_point: str
-    category: Category
-
-
-class UpdateProposalWeaknessRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    weakness_point: Optional[str] = None
-    category: Optional[Category] = None
-
-
-class ProposalRejectionReasonRequest(BaseModel):
-    proposal_id: UUID
-    reason: str
-    category: Category
-
-
-class UpdateProposalRejectionReasonRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    reason: Optional[str] = None
-    category: Optional[Category] = None
-
-
-class ProposalImprovementRequest(BaseModel):
-    proposal_id: UUID
-    improvement_point: str
-    category: Category
-
-
-class UpdateProposalImprovementRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    improvement_point: Optional[str] = None
-    category: Optional[Category] = None
-
-
-class CreateAiAnalysisRequest(BaseModel):
-    proposal_id: UUID
-    ai_score: float
-
-class CreateAIAnalysisRequestByProposalId(BaseModel):
-    ai_score: float
-
-class UpdateAiAnalysisRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    ai_score: Optional[float] = None
-
-class UpdateAIAnalysisRequestByProposalId(BaseModel):
-    ai_score: Optional[float] = None
-
-class CreateAllProposalStrengthsRequest(BaseModel):
-    strength_point: List[str]
-    category: Category
-
-class UpdateAllProposalStrengthsRequest(BaseModel):
-    strength_point: Optional[List[str]] = None
-
-class CreateAllProposalWeaknessRequest(BaseModel):
-    weakness_point: List[str]
-    category: Category
-
-
-class CreateAllProposalRejectionReasonsRequest(BaseModel):
-    reason: List[str]
-    category: Category
-
-
-class CreateAllProposalImprovementsRequest(BaseModel):
-    improvement_point: List[str]
-    category: Category
-
-
-class CreateAllProposalAnalysisRequest(BaseModel):
-    ai_score: float
-    technical: Optional[Analysis] = None
-    management: Optional[Analysis] = None
-    past_performance: Optional[Analysis] = None
-    price: Optional[Analysis] = None
-
-
-class UpdateAllProposalAnalysisRequest(BaseModel):
-    ai_score: Optional[float] = None
-    technical: Optional[Analysis] = None
-    management: Optional[Analysis] = None
-    past_performance: Optional[Analysis] = None
-    price: Optional[Analysis] = None
-
-
-class ProposalAIController:
-    def __init__(self):
-        self.__service = ProposalAIAnalysisService
-        self.router = APIRouter()
-
-        # self.router.add_api_route(
-        #     "/proposal-strengths",
-        #     self.get_proposal_strengths,
-        #     methods=["GET"],
-        #     tags=["Proposal Strengths"],
-        #     response_model=ProposalStrengthResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-strengths/{id}",
-        #     self.get_proposal_strengths_by_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Strengths by ID"],
-        #     response_model=ProposalStrengthResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths",
-            self.get_proposal_strengths_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal Strengths by Proposal ID"],
-            response_model=ProposalAllStrengthsResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths/{category}",
-            self.get_proposal_strengths_by_proposal_and_category,
-            methods=["GET"],
-            tags=["Proposal Strengths by Proposal and Category"],
-            response_model=ProposalAllStrengthsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/rfps/{rfp_id}/proposals/{proposal_id}/strengths/{id}",
-        #     self.get_proposal_strengths_by_proposal_and_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Strengths by Proposal and ID"],
-        #     response_model=ProposalStrengthResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-strengths",
-        #     self.create_proposal_strengths,
-        #     methods=["POST"],
-        #     tags=["Proposal Strengths"],
-        #     response_model=ProposalStrengthResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths",
-            self.create_all_proposal_strengths,
-            methods=["POST"],
-            tags=["Proposal Strengths by Proposal ID"],
-            response_model=ProposalAllStrengthsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-strengths/{id}",
-        #     self.update_proposal_strengths,
-        #     methods=["PUT"],
-        #     tags=["Proposal Strengths by ID"],
-        #     response_model=ProposalStrengthResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths/{category}",
-            self.update_all_proposal_strengths,
-            methods=["PUT"],
-            tags=["Proposal Strengths by Proposal and Category"],
-            response_model=ProposalAllStrengthsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-strengths/{id}",
-        #     self.delete_proposal_strength,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Strengths by ID"],
-        #     response_model=DeleteResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths",
-            self.delete_all_proposal_strengths,
-            methods=["DELETE"],
-            tags=["Proposal Strengths by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/strengths/{category}",
-            self.delete_proposal_strengths_by_proposal_and_category,
-            methods=["DELETE"],
-            tags=["Proposal Strengths by Proposal and Category"],
-            response_model=DeleteResponse,
-        )
-        # self.router.add_api_route(
-        #     "rfps/{rfp_id}/proposals/{proposal_id}/strengths/{id}",
-        #     self.delete_proposal_strengths_by_proposal_and_id,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Strengths by Proposal and ID"],
-        #     response_model=DeleteResponse,
-        # )
-
-        # self.router.add_api_route(
-        #     "/proposal-weakness",
-        #     self.get_proposal_weakness,
-        #     methods=["GET"],
-        #     tags=["Proposal Weakness"],
-        #     response_model=ProposalWeaknessResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-weakness/{id}",
-        #     self.get_proposal_weakness_by_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Weakness by ID"],
-        #     response_model=ProposalWeaknessResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/weakness",
-            self.get_proposal_weakness_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal Weakness by Proposal ID"],
-            response_model=ProposalAllWeaknessesResponse,
-        )
-        # self.router.add_api_route(
-        #     "/rfps/{rfp_id}/proposals/{proposal_id}/weakness/{id}",
-        #     self.get_proposal_weakness_by_proposal_and_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Weakness by Proposal and ID"],
-        #     response_model=ProposalWeaknessResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-weakness",
-        #     self.create_proposal_weakness,
-        #     methods=["POST"],
-        #     tags=["Proposal Weakness"],
-        #     response_model=ProposalWeaknessResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/weakness",
-            self.create_all_proposal_weakness,
-            methods=["POST"],
-            tags=["Proposal Weakness by Proposal ID"],
-            response_model=ProposalAllWeaknessesResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-weakness/{id}",
-        #     self.update_proposal_weakness,
-        #     methods=["PUT"],
-        #     tags=["Proposal Weakness by ID"],
-        #     response_model=ProposalWeaknessResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/weakness",
-            self.update_all_proposal_weakness,
-            methods=["PUT"],
-            tags=["Proposal Weakness by Proposal ID"],
-            response_model=ProposalAllWeaknessesResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-weakness/{id}",
-        #     self.delete_proposal_weakness,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Weakness by ID"],
-        #     response_model=DeleteResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/weakness",
-            self.delete_all_proposal_weakness,
-            methods=["DELETE"],
-            tags=["Proposal Weakness by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/weakness/{category}",
-            self.delete_proposal_weakness_by_proposal_and_category,
-            methods=["DELETE"],
-            tags=["Proposal Weakness by Proposal and Category"],
-            response_model=DeleteResponse,
-        )
-        # self.router.add_api_route(
-        #     "/rfps/{rfp_id}/proposals/{proposal_id}/weakness/{id}",
-        #     self.delete_proposal_weakness_by_proposal_and_id,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Weakness by Proposal and ID"],
-        #     response_model=DeleteResponse,
-        # )
-
-        # self.router.add_api_route(
-        #     "/proposal-rejections",
-        #     self.get_proposal_rejections,
-        #     methods=["GET"],
-        #     tags=["Proposal Rejections"],
-        #     response_model=ProposalRejectionReasonResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-rejections/{id}",
-        #     self.get_proposal_rejections_by_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Rejections by ID"],
-        #     response_model=ProposalRejectionReasonResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/rejections",
-            self.get_proposal_rejections_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal Rejections by Proposal ID"],
-            response_model=ProposalAllRejectionReasonsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/rfps/{rfp_id}/proposals/{proposal_id}/rejections/{id}",
-        #     self.get_proposal_rejections_by_proposal_and_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Rejections by Proposal and ID"],
-        #     response_model=ProposalRejectionReasonResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-rejections",
-        #     self.create_proposal_rejections,
-        #     methods=["POST"],
-        #     tags=["Proposal Rejections"],
-        #     response_model=ProposalRejectionReasonResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/rejections",
-            self.create_all_proposal_rejections,
-            methods=["POST"],
-            tags=["Proposal Rejections by Proposal ID"],
-            response_model=ProposalAllRejectionReasonsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-rejections/{id}",
-        #     self.update_proposal_rejections,
-        #     methods=["PUT"],
-        #     tags=["Proposal Rejections by ID"],
-        #     response_model=ProposalRejectionReasonResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/rejections",
-            self.update_all_proposal_rejections,
-            methods=["PUT"],
-            tags=["Proposal Rejections by Proposal ID"],
-            response_model=ProposalAllRejectionReasonsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-rejections/{id}",
-        #     self.delete_proposal_rejections,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Rejections by ID"],
-        #     response_model=DeleteResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/rejections",
-            self.delete_all_proposal_rejections,
-            methods=["DELETE"],
-            tags=["Proposal Rejections by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/rejections/{category}",
-            self.delete_proposal_rejections_by_proposal_and_category,
-            methods=["DELETE"],
-            tags=["Proposal Rejections by Proposal and Category"],
-            response_model=DeleteResponse,
-        )
-        # self.router.add_api_route(
-        #     "/rfps/{rfp_id}/proposals/{proposal_id}/proposal-rejections/{id}",
-        #     self.delete_proposal_rejections_by_proposal_and_id,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Rejections by Proposal and ID"],
-        #     response_model=DeleteResponse,
-        # )
-
-        # self.router.add_api_route(
-        #     "/proposal-improvements",
-        #     self.get_proposal_improvements,
-        #     methods=["GET"],
-        #     tags=["Proposal Improvements"],
-        #     response_model=ProposalImprovementResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-improvements/{id}",
-        #     self.get_proposal_improvements_by_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Improvements by ID"],
-        #     response_model=ProposalImprovementResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/improvements",
-            self.get_proposal_improvements_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal Improvements by Proposal ID"],
-            response_model=ProposalAllImprovementsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}/proposal-improvements/{id}",
-        #     self.get_proposal_improvements_by_proposal_and_id,
-        #     methods=["GET"],
-        #     tags=["Proposal Improvements by Proposal and ID"],
-        #     response_model=ProposalImprovementResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-improvements",
-        #     self.create_proposal_improvements,
-        #     methods=["POST"],
-        #     tags=["Proposal Improvements"],
-        #     response_model=ProposalImprovementResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/improvements",
-            self.create_all_proposal_improvements,
-            methods=["POST"],
-            tags=["Proposal Improvements by Proposal ID"],
-            response_model=ProposalAllImprovementsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-improvements/{id}",
-        #     self.update_proposal_improvements,
-        #     methods=["PUT"],
-        #     tags=["Proposal Improvements by ID"],
-        #     response_model=ProposalImprovementResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/improvements",
-            self.update_all_proposal_improvements,
-            methods=["PUT"],
-            tags=["Proposal Improvements by Proposal ID"],
-            response_model=ProposalAllImprovementsResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-improvements/{id}",
-        #     self.delete_proposal_improvements,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Improvements by ID"],
-        #     response_model=DeleteResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/improvements",
-            self.delete_all_proposal_improvements,
-            methods=["DELETE"],
-            tags=["Proposal Improvements by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/improvements/{category}",
-            self.delete_proposal_improvements_by_proposal_and_category,
-            methods=["DELETE"],
-            tags=["Proposal Improvements by Proposal and Category"],
-            response_model=DeleteResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}/proposal-improvements/{id}",
-        #     self.delete_proposal_improvements_by_proposal_and_id,
-        #     methods=["DELETE"],
-        #     tags=["Proposal Improvements by Proposal and ID"],
-        #     response_model=DeleteResponse,
-        # )
-
-        # self.router.add_api_route(
-        #     "/proposal-ai-score",
-        #     self.get_proposal_ai_score,
-        #     methods=["GET"],
-        #     tags=["Proposal AI Score"],
-        #     response_model=ProposalAIAnalysisResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-ai-score/{id}",
-        #     self.get_proposal_ai_score_by_id,
-        #     methods=["GET"],
-        #     tags=["Proposal AI Score by ID"],
-        #     response_model=ProposalAIAnalysisResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/ai-score",
-            self.get_proposal_ai_score_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal AI Score by Proposal ID"],
-            response_model=ProposalAIAnalysisResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}/proposal-ai-score/{id}",
-        #     self.get_proposal_ai_score_by_proposal_and_id,
-        #     methods=["GET"],
-        #     tags=["Proposal AI Score by Proposal and ID"],
-        #     response_model=ProposalAIAnalysisResponse,
-        # )
-        # self.router.add_api_route(
-        #     "/proposal-ai-score",
-        #     self.create_proposal_ai_score,
-        #     methods=["POST"],
-        #     tags=["Proposal AI Score"],
-        #     response_model=ProposalAIAnalysisResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/ai-score",
-            self.create_proposal_ai_score_by_proposal_id,
-            methods=["POST"],
-            tags=["Proposal AI Score by Proposal ID"],
-            response_model=ProposalAIAnalysisResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-ai-score/{id}",
-        #     self.update_proposal_ai_score,
-        #     methods=["PUT"],
-        #     tags=["Proposal AI Score by ID"],
-        #     response_model=ProposalAIAnalysisResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/ai-score",
-            self.update_proposal_ai_score_by_proposal_id,
-            methods=["PUT"],
-            tags=["Proposal AI Score by Proposal ID"],
-            response_model=ProposalAIAnalysisResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposal-ai-score/{id}",
-        #     self.delete_proposal_ai_score,
-        #     methods=["DELETE"],
-        #     tags=["Proposal AI Score by ID"],
-        #     response_model=DeleteResponse,
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/ai-score",
-            self.delete_proposal_ai_score_by_proposal_id,
-            methods=["DELETE"],
-            tags=["Proposal AI Score by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}/proposal-ai-score/{id}",
-        #     self.delete_proposal_ai_score_by_proposal_and_id,
-        #     methods=["DELETE"],
-        #     tags=["Proposal AI Score by Proposal and ID"],
-        #     response_model=DeleteResponse,
-        # )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/analysis",
-            self.get_all_proposal_analysis,
-            methods=["GET"],
-            tags=["Proposal Complete Analysis"],
-            response_model=ProposalCompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/analysis",
-            self.create_proposal_analysis,
-            methods=["POST"],
-            tags=["Proposal Complete Analysis"],
-            response_model=ProposalCompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/analysis",
-            self.update_proposal_analysis,
-            methods=["PUT"],
-            tags=["Proposal Complete Analysis"],
-            response_model=ProposalCompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/analysis",
-            self.delete_proposal_analysis,
-            methods=["DELETE"],
-            tags=["Proposal Complete Analysis"],
-            response_model=DeleteResponse,
-        )
-
-    async def get_proposal_strengths(
-        self
-    ):
-        async with self.__service() as service:
-            try:
-                strengths = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS
-                )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in strengths]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve strengths."
-                )
-            
-    async def get_proposal_strengths_by_id(self, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                strength = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS, id=id
-                )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in strength]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve strength."
-                )
-            
-    async def get_proposal_strengths_by_proposal_id(self, rfp_id: UUID = Path(...), proposal_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                strength = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id
-                )
-                return ProposalAllStrengthsResponse(
-                    status="success", data=[s["strength_point"] for s in strength]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve strength."
-                )
-            
-    async def get_proposal_strengths_by_proposal_and_category(self, rfp_id: UUID = Path(...), proposal_id: UUID = Path(...), category: Category = Path(...)):
-        async with self.__service() as service:
-            try:
-                strength = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, category=category
-                )
-                return ProposalAllStrengthsResponse(
-                    status="success", data=[s["strength_point"] for s in strength]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve strength."
-                )
-            
-    async def get_proposal_strengths_by_proposal_and_id(self, rfp_id: UUID = Path(...), proposal_id: UUID = Path(...), id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                strength = await service.get_all_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, id=id
-                )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in strength]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve strength."
-                )
-
-    async def create_proposal_strengths(self, strength: ProposalStrengthRequest):
-        async with self.__service() as service:
-            try:
-                created = await service.create_data(
-                    query_type=QueryType.STRENGTHS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=strength.model_dump(mode="json"),
-                )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create strength."
-                )
-
-    async def create_all_proposal_strengths(
-        self, strengths: CreateAllProposalStrengthsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                strengths_request = strengths.model_dump(mode="json", exclude_unset=True)
-                strengths_request["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.STRENGTHS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=strengths_request,
-                )
-                return ProposalAllStrengthsResponse(
-                    status="success", data=[s["strength_point"] for s in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create strengths."
-                )
-
-    async def update_proposal_strengths(self, strength: UpdateProposalStrengthRequest, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                strength_request = strength.model_dump(mode="json", exclude_unset=True)
-                strength_request["id"] = id
-                updated = await service.update_data(
-                    query_type=QueryType.STRENGTHS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=strength_request,
-                )
-                return ProposalStrengthResponse(
-                    status="success", data=[ProposalStrength(**s) for s in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update strength."
-                )
-
-    async def update_all_proposal_strengths(
-        self, strengths: UpdateAllProposalStrengthsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...), category: Category = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                strengths_request = strengths.model_dump(mode="json", exclude_unset=True)
-                strengths_request["proposal_id"] = proposal_id
-                strengths_request["category"] = category
-                updated = await service.update_data(
-                    query_type=QueryType.STRENGTHS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=strengths_request,
-                )
-                return ProposalAllStrengthsResponse(
-                    status="success", data=[s["strength_point"] for s in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update strengths."
-                )
-
-    async def delete_proposal_strength(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.STRENGTHS, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete strength."
-                )
-            
-    async def delete_all_proposal_strengths(self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete strengths."
-                )
-            
-    async def delete_proposal_strengths_by_proposal_and_category(self, proposal_id: UUID = Path(...), category: Category = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, category=category
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete strength."
-                )
-            
-    async def delete_proposal_strengths_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.STRENGTHS, proposal_id=proposal_id, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete strength."
-                )
-
-    async def get_proposal_weakness(
-        self
-    ):
-        async with self.__service() as service:
-            try:
-                weaknesses = await service.get_all_data(
-                    query_type=QueryType.WEAKNESSES
-                )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in weaknesses]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve weaknesses."
-                )
-            
-    async def get_proposal_weakness_by_id(self, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                weakness = await service.get_all_data(
-                    query_type=QueryType.WEAKNESSES, id=id
-                )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in weakness]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve weakness."
-                )
-            
-    async def get_proposal_weakness_by_proposal_id(self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...), category: Category = Query(None)):
-        async with self.__service() as service:
-            try:
-                weakness = await service.get_all_data(
-                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, category=category
-                )
-                return ProposalAllWeaknessesResponse(
-                    status="success", data=[w["weakness_point"] for w in weakness]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve weakness."
-                )
-            
-    async def get_proposal_weakness_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                weakness = await service.get_all_data(
-                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, id=id
-                )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in weakness]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve weakness."
-                )
-
-    async def create_proposal_weakness(self, weakness: ProposalWeaknessRequest):
-        async with self.__service() as service:
-            try:
-                created = await service.create_data(
-                    query_type=QueryType.WEAKNESSES,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=weakness.model_dump(mode="json"),
-                )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create weakness."
-                )
-
-    async def create_all_proposal_weakness(
-        self, weaknesses: CreateAllProposalWeaknessRequest, proposal_id: UUID
-    ):
-        async with self.__service() as service:
-            try:
-                weakness_request = weaknesses.model_dump(mode="json", exclude_unset=True)
-                weakness_request["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.WEAKNESSES,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=weakness_request,
-                )
-                return ProposalAllWeaknessesResponse(
-                    status="success", data=[w["weakness_point"] for w in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create weaknesses."
-                )
-
-    async def update_proposal_weakness(self, weakness: UpdateProposalWeaknessRequest, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                weakness_request = weakness.model_dump(mode="json", exclude_unset=True)
-                weakness_request["id"] = id
-                updated = await service.update_data(
-                    query_type=QueryType.WEAKNESSES,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=weakness_request,
-                )
-                return ProposalWeaknessResponse(
-                    status="success", data=[ProposalWeakness(**w) for w in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update weakness."
-                )
-
-    async def update_all_proposal_weakness(
-        self, weaknesses: CreateAllProposalWeaknessRequest, proposal_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                weakness_request = weaknesses.model_dump(mode="json", exclude_unset=True)
-                weakness_request["proposal_id"] = proposal_id
-                updated = await service.update_data(
-                    query_type=QueryType.WEAKNESSES,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=weakness_request,
-                )
-                return ProposalAllWeaknessesResponse(
-                    status="success", data=[w["weakness_point"] for w in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update weaknesses."
-                )
-
-    async def delete_proposal_weakness(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.WEAKNESSES, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete weakness."
-                )
-            
-    async def delete_all_proposal_weakness(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete weaknesses."
-                )
-            
-    async def delete_proposal_weakness_by_proposal_and_category(self, proposal_id: UUID = Path(...), category: Category = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, category=category
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete weakness."
-                )
-            
-    async def delete_proposal_weakness_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.WEAKNESSES, proposal_id=proposal_id, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete weakness."
-                )
-
-    async def get_proposal_rejections(
-        self
-    ):
-        async with self.__service() as service:
-            try:
-                rejection_reasons = await service.get_all_data(
-                    query_type=QueryType.REJECTION_REASONS
-                )
-                return ProposalRejectionReasonResponse(
-                    status="success",
-                    data=[ProposalRejectionReason(**r) for r in rejection_reasons],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve rejection reasons."
-                )
-    
-    async def get_proposal_rejections_by_id(self, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                rejection_reason = await service.get_all_data(
-                    query_type=QueryType.REJECTION_REASONS, id=id
-                )
-                return ProposalRejectionReasonResponse(
-                    status="success", data=[ProposalRejectionReason(**r) for r in rejection_reason]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve rejection reason."
-                )
-            
-    async def get_proposal_rejections_by_proposal_id(self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...), category: Category = Query(None)):
-        async with self.__service() as service:
-            try:
-                rejection_reason = await service.get_all_data(
-                    query_type=QueryType.REJECTION_REASONS, proposal_id=proposal_id, category=category
-                )
-                return ProposalAllRejectionReasonsResponse(
-                    status="success", data=[r["reason"] for r in rejection_reason]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve rejection reason."
-                )
-            
-    async def get_proposal_rejections_by_proposal_and_id(self, proposal_id: UUID = Path(...), id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                rejection_reason = await service.get_all_data(
-                    query_type=QueryType.REJECTION_REASONS, proposal_id=proposal_id, id=id
-                )
-                return ProposalRejectionReasonResponse(
-                    status="success", data=[ProposalRejectionReason(**r) for r in rejection_reason]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve rejection reason."
-                )
-
-    async def create_proposal_rejections(
-        self, rejection_reason: ProposalRejectionReasonRequest
-    ):
-        async with self.__service() as service:
-            try:
-                created = await service.create_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=rejection_reason.model_dump(mode="json"),
-                )
-                return ProposalRejectionReasonResponse(
-                    status="success",
-                    data=[ProposalRejectionReason(**r) for r in created],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create rejection reason."
-                )
-
-    async def create_all_proposal_rejections(
-        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                rejection_reasons_data = rejection_reasons.model_dump(mode="json", exclude_unset=True)
-                rejection_reasons_data["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=rejection_reasons_data,
-                )
-                return ProposalAllRejectionReasonsResponse(
-                    status="success",
-                    data=[r["reason"] for r in created],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create rejection reasons."
-                )
-
-    async def update_proposal_rejections(
-        self, rejection_reason: UpdateProposalRejectionReasonRequest, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                rejection_reason_data = rejection_reason.model_dump(mode="json", exclude_unset=True)
-                rejection_reason_data["id"] = id
-                updated = await service.update_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=rejection_reason_data,
-                )
-                return ProposalRejectionReasonResponse(
-                    status="success",
-                    data=[ProposalRejectionReason(**r) for r in updated],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update rejection reason."
-                )
-
-    async def update_all_proposal_rejections(
-        self, rejection_reasons: CreateAllProposalRejectionReasonsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                rejection_reasons_data = rejection_reasons.model_dump(mode="json", exclude_unset=True)
-                rejection_reasons_data["proposal_id"] = proposal_id
-                updated = await service.update_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=rejection_reasons_data,
-                )
-                return ProposalAllRejectionReasonsResponse(
-                    status="success",
-                    data=[r["reason"] for r in updated],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update rejection reasons."
-                )
-
-    async def delete_proposal_rejections(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete rejection reason."
-                )
-            
-    async def delete_all_proposal_rejections(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete rejection reasons."
-                )
-            
-    async def delete_proposal_rejections_by_proposal_and_category(
-        self, proposal_id: UUID = Path(...), category: str = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    category=category,
-                    proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete rejection reason."
-                )
-            
-    async def delete_proposal_rejections_by_proposal_and_id(
-        self, proposal_id: UUID = Path(...), id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.REJECTION_REASONS,
-                    id=id,
-                    proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete rejection reason."
-                )
-
-    async def get_proposal_improvements(
-        self
-    ):
-        async with self.__service() as service:
-            try:
-                improvements = await service.get_all_data(
-                    query_type=QueryType.IMPROVEMENTS
-                )
-                return ProposalImprovementResponse(
-                    status="success",
-                    data=[ProposalImprovement(**r) for r in improvements],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve improvements."
-                )
-            
-    async def get_proposal_improvements_by_id(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                improvements = await service.get_all_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    id=id
-                )
-                return ProposalImprovementResponse(
-                    status="success",
-                    data=[ProposalImprovement(**r) for r in improvements],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve improvements."
-                )
-            
-    async def get_proposal_improvements_by_proposal_id(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...), category: Category = Query(None)
-    ):
-        async with self.__service() as service:
-            try:
-                improvements = await service.get_all_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    proposal_id=proposal_id,
-                    category=category
-                )
-                return ProposalAllImprovementsResponse(
-                    status="success",
-                    data=[r["improvement_point"] for r in improvements],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve improvements."
-                )
-            
-    async def get_proposal_improvements_by_proposal_and_id(
-        self, proposal_id: UUID = Path(...), id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                improvements = await service.get_all_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    id=id,
-                    proposal_id=proposal_id
-                )
-                return ProposalImprovementResponse(
-                    status="success",
-                    data=[ProposalImprovement(**r) for r in improvements],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve improvements."
-                )
-
-    async def create_proposal_improvements(
-        self, improvement: ProposalImprovementRequest
-    ):
-        async with self.__service() as service:
-            try:
-                created = await service.create_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=improvement.model_dump(mode="json"),
-                )
-                return ProposalImprovementResponse(
-                    status="success", data=[ProposalImprovement(**r) for r in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create improvement."
-                )
-
-    async def create_all_proposal_improvements(
-        self, improvements: CreateAllProposalImprovementsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                data = improvements.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=data,
-                )
-                return ProposalAllImprovementsResponse(
-                    status="success", data=[r["improvement_point"] for r in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create improvements."
-                )
-
-    async def update_proposal_improvements(
-        self, improvement: UpdateProposalImprovementRequest, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                data = improvement.model_dump(mode="json", exclude_unset=True)
-                data["id"] = id
-                updated = await service.update_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=data,
-                )
-                return ProposalImprovementResponse(
-                    status="success", data=[ProposalImprovement(**r) for r in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update improvement."
-                )
-
-    async def update_all_proposal_improvements(
-        self, improvements: CreateAllProposalImprovementsRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                data = improvements.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                updated = await service.update_data(
-                    query_type=QueryType.IMPROVEMENTS,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=data,
-                )
-                return ProposalAllImprovementsResponse(
-                    status="success", data=[r["improvement_point"] for r in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update improvements."
-                )
-
-    async def delete_proposal_improvements(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.IMPROVEMENTS, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete improvement."
-                )
-            
-    async def delete_all_proposal_improvements(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.IMPROVEMENTS, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete improvements."
-                )
-            
-    async def delete_proposal_improvements_by_proposal_and_category(
-        self, category: str = Path(...), proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.IMPROVEMENTS, category=category, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete improvement."
-                )
-            
-    async def delete_proposal_improvements_by_proposal_and_id(
-        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.IMPROVEMENTS, id=id, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete improvement."
-                )
-
-    async def get_proposal_ai_score(
-        self
-    ):
-        async with self.__service() as service:
-            try:
-                scores = await service.get_all_data(
-                    query_type=QueryType.AI_SCORE
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve AI scores."
-                )
-            
-    async def get_proposal_ai_score_by_id(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                scores = await service.get_all_data(
-                    query_type=QueryType.AI_SCORE, id=id
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve AI scores."
-                )
-            
-    async def get_proposal_ai_score_by_proposal_id(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                scores = await service.get_all_data(
-                    query_type=QueryType.AI_SCORE, proposal_id=proposal_id
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve AI scores."
-                )
-            
-    async def get_proposal_ai_score_by_proposal_and_id(
-        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                scores = await service.get_all_data(
-                    query_type=QueryType.AI_SCORE, id=id, proposal_id=proposal_id
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in scores]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve AI scores."
-                )
-
-    async def create_proposal_ai_score(self, score: CreateAiAnalysisRequest):
-        async with self.__service() as service:
-            try:
-                created = await service.create_data(
-                    query_type=QueryType.AI_SCORE,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=score.model_dump(mode="json"),
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create AI score."
-                )
-            
-    async def create_proposal_ai_score_by_proposal_id(self, score: CreateAIAnalysisRequestByProposalId, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                data = score.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.AI_SCORE,
-                    create_or_update_type=CreateOrUpdateType.ID,
-                    data=data,
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in created]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create AI score."
-                )
-
-    async def update_proposal_ai_score(self, score: UpdateAiAnalysisRequest, id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                if id:
-                    data = score.model_dump(mode="json", exclude_unset=True)
-                    data["id"] = id
-                    updated = await service.update_data(
-                        query_type=QueryType.AI_SCORE,
-                        create_or_update_type=CreateOrUpdateType.ID,
-                        data=data,
-                    )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update AI score."
-                )
-            
-    async def update_proposal_ai_score_by_proposal_id(self, score: UpdateAIAnalysisRequestByProposalId, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                data = score.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                updated = await service.update_data(
-                    query_type=QueryType.AI_SCORE,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=data,
-                )
-                return ProposalAIAnalysisResponse(
-                    status="success", data=[ProposalAIAnalysis(**r) for r in updated]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update AI score."
-                )
-
-    async def delete_proposal_ai_score(
-        self, id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.AI_SCORE, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete AI score."
-                )
-            
-    async def delete_proposal_ai_score_by_proposal_id(
-        self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.AI_SCORE, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete AI score."
-                )
-            
-    async def delete_proposal_ai_score_by_proposal_and_id(
-        self, id: UUID = Path(...), proposal_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.AI_SCORE, id=id, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete AI score."
-                )
-
-    async def get_all_proposal_analysis(self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                analysis = await service.get_all_data(
-                    query_type=QueryType.ALL, proposal_id=proposal_id
-                )
-                return ProposalCompleteAnalysisResponse(
-                    status="success",
-                    data=[ProposalCompleteAnalysis(**analysis)],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve analysis."
-                )
-
-    async def create_proposal_analysis(
-        self, analysis: CreateAllProposalAnalysisRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                data = analysis.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                created = await service.create_data(
-                    query_type=QueryType.ALL,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=data,
-                )
-                return ProposalCompleteAnalysisResponse(
-                    status="success",
-                    data=[ProposalCompleteAnalysis(**created)],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create analysis."
-                )
-
-    async def update_proposal_analysis(
-        self, analysis: UpdateAllProposalAnalysisRequest, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)
-    ):
-        async with self.__service() as service:
-            try:
-                data = analysis.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                updated = await service.update_data(
-                    query_type=QueryType.ALL,
-                    create_or_update_type=CreateOrUpdateType.ALL,
-                    data=data,
-                )
-                return ProposalCompleteAnalysisResponse(
-                    status="success",
-                    data=[ProposalCompleteAnalysis(**updated)],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update analysis."
-                )
-
-    async def delete_proposal_analysis(self, proposal_id: UUID = Path(...), rfp_id: UUID = Path(...)):
-        async with self.__service() as service:
-            try:
-                result = await service.delete_data(
-                    query_type=QueryType.ALL, proposal_id=proposal_id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete analysis."
-                )

src/controllers/_proposal_controller.py

@@ -1,338 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel, field_validator
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.services import ProposalService
-from src.models import ProposalStatus, GateCriteria
-
-
-class Proposal(BaseModel):
-    id: UUID
-    rfp_id: UUID
-    name: str
-    tep: str
-    gate_criteria: GateCriteria
-    status: ProposalStatus
-    ai_score: Optional[float] = None
-    final_score: Optional[float] = None
-    created_at: datetime
-    updated_at: datetime
-
-    @field_validator("ai_score", "final_score")
-    @classmethod
-    def round_to_two_decimals(cls, v):
-        if v is not None:
-            return round(v, 2)
-        return v
-
-class ProposalRequest(BaseModel):
-    rfp_id: UUID
-    name: str
-    tep: str
-    gate_criteria: GateCriteria
-    status: ProposalStatus
-    ai_score: Optional[float] = None
-    final_score: Optional[float] = None
-
-
-class CreateProposalRequest(BaseModel):
-    name: str
-    tep: str
-    gate_criteria: GateCriteria
-    status: ProposalStatus
-    ai_score: Optional[float] = None
-    final_score: Optional[float] = None
-
-
-class ProposalUpdateRequest(BaseModel):
-    rfp_id: Optional[UUID] = None
-    name: Optional[str] = None
-    tep: Optional[str] = None
-    gate_criteria: Optional[GateCriteria] = None
-    status: Optional[ProposalStatus] = None
-    ai_score: Optional[float] = None
-    final_score: Optional[float] = None
-
-
-class UpdateProposalRequest(BaseModel):
-    name: Optional[str] = None
-    tep: Optional[str] = None
-    gate_criteria: Optional[GateCriteria] = None
-    status: Optional[ProposalStatus] = None
-    ai_score: Optional[float] = None
-    final_score: Optional[float] = None
-
-
-class ProposalDeleteResponse(BaseModel):
-    status: str
-
-
-class ResponseProposal(BaseModel):
-    status: str
-    data: Optional[List[Proposal]]
-
-
-class ProposalController:
-    def __init__(self):
-        self.__proposal_service = ProposalService
-        self.router = APIRouter()
-        # self.router.add_api_route(
-        #     "/proposals",
-        #     self.get_proposals,
-        #     methods=["GET"],
-        #     response_model=ResponseProposal,
-        #     tags=["Proposals"],
-        # )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}",
-        #     self.get_proposals_by_id,
-        #     methods=["GET"],
-        #     response_model=ResponseProposal,
-        #     tags=["Proposals by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals",
-            self.get_proposals_by_rfp_id,
-            methods=["GET"],
-            response_model=ResponseProposal,
-            tags=["Proposals by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}",
-            self.get_proposals_by_proposal_and_rfp_id,
-            methods=["GET"],
-            response_model=ResponseProposal,
-            tags=["Proposals by Proposal and RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/proposals",
-        #     self.create_proposal,
-        #     methods=["POST"],
-        #     response_model=ResponseProposal,
-        #     tags=["Proposals"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals",
-            self.create_proposal_by_rfp_id,
-            methods=["POST"],
-            response_model=ResponseProposal,
-            tags=["Proposals by RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}",
-        #     self.update_proposal,
-        #     methods=["PUT"],
-        #     response_model=ResponseProposal,
-        #     tags=["Proposals by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}",
-            self.update_proposal_by_proposal_and_rfp_id,
-            methods=["PUT"],
-            response_model=ResponseProposal,
-            tags=["Proposals by Proposal and RFP ID"],
-        )
-        # self.router.add_api_route(
-        #     "/proposals/{proposal_id}",
-        #     self.delete_proposal,
-        #     methods=["DELETE"],
-        #     response_model=ProposalDeleteResponse,
-        #     tags=["Proposals by ID"],
-        # )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals",
-            self.delete_proposals_by_rfp_id,
-            methods=["DeLETE"],
-            response_model=ProposalDeleteResponse,
-            tags=["Proposals by RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}",
-            self.delete_proposals_by_proposal_and_rfp_id,
-            methods=["DeLETE"],
-            response_model=ProposalDeleteResponse,
-            tags=["Proposals by Proposal and RFP ID"],
-        )
-
-    async def get_proposals(self):
-        async with self.__proposal_service() as service:
-            try:
-                proposals = await service.get_proposals()
-                return ResponseProposal(
-                    status="success", data=[Proposal(**p) for p in proposals]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve proposals."
-                )
-
-    async def get_proposals_by_id(
-        self,
-        proposal_id: str = Path(...),
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                proposals = await service.get_proposals(proposal_id=proposal_id)
-                return ResponseProposal(
-                    status="success", data=[Proposal(**p) for p in proposals]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve proposals."
-                )
-
-    async def get_proposals_by_rfp_id(
-        self,
-        rfp_id: str = Path(...),
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                proposals = await service.get_proposals(rfp_id=rfp_id)
-                return ResponseProposal(
-                    status="success", data=[Proposal(**p) for p in proposals]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve proposals."
-                )
-
-    async def get_proposals_by_proposal_and_rfp_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                proposals = await service.get_proposals(
-                    rfp_id=rfp_id, proposal_id=proposal_id
-                )
-                return ResponseProposal(
-                    status="success", data=[Proposal(**p) for p in proposals]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to retrieve proposals."
-                )
-
-    async def create_proposal(self, proposal: ProposalRequest):
-        async with self.__proposal_service() as service:
-            try:
-                new_proposal = await service.create_proposal(
-                    proposal.model_dump(mode="json")
-                )
-                return ResponseProposal(
-                    status="success", data=[Proposal(**new_proposal)]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create proposal."
-                )
-
-    async def create_proposal_by_rfp_id(
-        self, proposal: CreateProposalRequest, rfp_id: str = Path(...)
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                data = proposal.model_dump(exclude_unset=True, mode="json")
-                data["rfp_id"] = rfp_id
-                new_proposal = await service.create_proposal(proposal=data)
-                return ResponseProposal(
-                    status="success", data=[Proposal(**new_proposal)]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create proposal."
-                )
-
-    async def update_proposal(
-        self, proposal: ProposalUpdateRequest, proposal_id: str = Path(...)
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                updated_proposal = await service.update_proposal(
-                    proposal_id=proposal_id,
-                    proposal=proposal.model_dump(exclude_unset=True),
-                )
-                return ResponseProposal(
-                    status="success", data=[Proposal(**updated_proposal)]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update proposal."
-                )
-
-    async def update_proposal_by_proposal_and_rfp_id(
-        self,
-        proposal: UpdateProposalRequest,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                data = proposal.model_dump(exclude_unset=True, mode="json")
-                data["rfp_id"] = rfp_id
-                updated_proposal = await service.update_proposal(
-                    proposal_id=proposal_id,
-                    proposal=proposal.model_dump(exclude_unset=True),
-                )
-                return ResponseProposal(
-                    status="success", data=[Proposal(**updated_proposal)]
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update proposal."
-                )
-
-    async def delete_proposal(self, proposal_id: str = Path(...)):
-        async with self.__proposal_service() as service:
-            try:
-                status = await service.delete_proposal(proposal_id=proposal_id)
-                if not status:
-                    raise HTTPException(status_code=404, detail="Proposal not found.")
-                return ProposalDeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal."
-                )
-
-    async def delete_proposals_by_rfp_id(self, rfp_id: str = Path(...)):
-        async with self.__proposal_service() as service:
-            try:
-                status = await service.delete_proposal(rfp_id=rfp_id)
-                if not status:
-                    raise HTTPException(status_code=404, detail="Proposal not found.")
-                return ProposalDeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal."
-                )
-
-    async def delete_proposals_by_proposal_and_rfp_id(
-        self, rfp_id: str = Path(...), proposal_id: str = Path(...)
-    ):
-        async with self.__proposal_service() as service:
-            try:
-                status = await service.delete_proposal(
-                    rfp_id=rfp_id, proposal_id=proposal_id
-                )
-                if not status:
-                    raise HTTPException(status_code=404, detail="Proposal not found.")
-                return ProposalDeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal."
-                )

src/controllers/_proposal_detailed_analysis_controller.py

@@ -1,291 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-
-from src.models import OperationCriteria, ProposalDetailAnalysis
-
-from src.services import ProposalDetailedAnalysisService
-
-
-class ProposalDetailedAnalysis(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    ai_assessment_result: str
-    confidence: float
-    operation_criteria: OperationCriteria
-    created_at: datetime
-    updated_at: datetime
-
-
-class ProposalDetailedAnalysisResponse(BaseModel):
-    status: str
-    data: Optional[List[ProposalDetailedAnalysis]]
-
-
-class OperationCriteriaResult(BaseModel):
-    confidence: float
-    ai_assessment_result: str
-
-
-class ProposalCompleteDetailedAnalysis(BaseModel):
-    mission_alignment: Optional[OperationCriteriaResult] = None
-    technical_feasibility: Optional[OperationCriteriaResult] = None
-    cost_efficiency: Optional[OperationCriteriaResult] = None
-    risk_assessment: Optional[OperationCriteriaResult] = None
-
-
-class CreateProposalDetailedAnalysisRequest(BaseModel):
-    data: ProposalCompleteDetailedAnalysis
-
-
-class CompleteAnalysisResponse(BaseModel):
-    status: str
-    data: Optional[ProposalCompleteDetailedAnalysis]
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class CreateDetailedAnalysisRequest(BaseModel):
-    proposal_id: UUID
-    confidence: float
-    ai_assessment_result: str
-    operation_criteria: OperationCriteria
-
-
-class UpdateDetailedAnalysisRequest(BaseModel):
-    proposal_id: Optional[UUID] = None
-    confidence: Optional[float] = None
-    ai_assessment_result: Optional[str] = None
-    operation_criteria: Optional[OperationCriteria] = None
-
-
-class ProposalDetailedController:
-    def __init__(self):
-        self.service = ProposalDetailedAnalysisService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/proposal-detailed-analysis",
-            self.get_proposal_analysis,
-            methods=["GET"],
-            tags=["Proposal Detailed Analysis"],
-            response_model=ProposalDetailedAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposal-detailed-analysis/{id}",
-            self.get_proposal_analysis_by_id,
-            methods=["GET"],
-            tags=["Proposal Detailed Analysis by ID"],
-            response_model=ProposalDetailedAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/proposal-detailed-analysis",
-            self.get_proposal_analysis_by_proposal_id,
-            methods=["GET"],
-            tags=["Proposal Detailed Analysis by Proposal ID"],
-            response_model=CompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposal-detailed-analysis",
-            self.create_proposal_analysis,
-            methods=["POST"],
-            tags=["Proposal Detailed Analysis"],
-            response_model=ProposalDetailedAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/proposal-detailed-analysis",
-            self.create_complete_proposal_analysis,
-            methods=["POST"],
-            tags=["Proposal Detailed Analysis by Proposal ID"],
-            response_model=CompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposal-detailed-analysis/{id}",
-            self.update_proposal_analysis,
-            methods=["PUT"],
-            tags=["Proposal Detailed Analysis by ID"],
-            response_model=ProposalDetailedAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/proposal-detailed-analysis",
-            self.update_complete_proposal_analysis,
-            methods=["PUT"],
-            tags=["Proposal Detailed Analysis by Proposal ID"],
-            response_model=CompleteAnalysisResponse,
-        )
-        self.router.add_api_route(
-            "/proposal-detailed-analysis/{id}",
-            self.delete_proposal_analysis,
-            methods=["DELETE"],
-            tags=["Proposal Detailed Analysis by ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/proposal-detailed-analysis",
-            self.delete_proposal_analysis_by_proposal_id,
-            methods=["DELETE"],
-            tags=["Proposal Detailed Analysis by Proposal ID"],
-            response_model=DeleteResponse,
-        )
-        self.router.add_api_route(
-            "/proposals/{proposal_id}/proposal-detailed-analysis/{id}",
-            self.delete_proposal_analysis_by_proposal_and_id,
-            methods=["DELETE"],
-            tags=["Proposal Detailed Analysis by Proposal and ID"],
-            response_model=DeleteResponse,
-        )
-
-    async def get_proposal_analysis(self):
-        async with self.service() as service:
-            try:
-                result = await service.get_proposal_analysis()
-                if not result:
-                    return ProposalDetailedAnalysisResponse(status="success", data=[])
-                return ProposalDetailedAnalysisResponse(
-                    status="success",
-                    data=[ProposalDetailedAnalysis(**r) for r in result],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to get proposal analysis."
-                )
-
-    async def get_proposal_analysis_by_id(self, id: str = Path(...)):
-        async with self.service() as service:
-            try:
-                result = await service.get_proposal_analysis(id=id)
-                return ProposalDetailedAnalysisResponse(
-                    status="success",
-                    data=[ProposalDetailedAnalysis(**r) for r in result],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to get proposal analysis."
-                )
-
-    async def get_proposal_analysis_by_proposal_id(self, proposal_id: str = Path(...)):
-        async with self.service() as service:
-            try:
-                result = await service.get_proposal_analysis_by_proposal_id(
-                    proposal_id=proposal_id
-                )
-                return CompleteAnalysisResponse(status="success", data=result)
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to get proposal analysis."
-                )
-
-    async def create_proposal_analysis(self, analysis: CreateDetailedAnalysisRequest):
-        async with self.service() as service:
-            try:
-                result = await service.create_proposal_analysis(
-                    data=analysis.model_dump(mode="json", exclude_unset=True)
-                )
-                return ProposalDetailedAnalysisResponse(
-                    status="success",
-                    data=[ProposalDetailedAnalysis(**r) for r in result],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create proposal analysis."
-                )
-
-    async def create_complete_proposal_analysis(
-        self,
-        analysis: CreateProposalDetailedAnalysisRequest,
-        proposal_id: UUID = Path(...),
-    ):
-        async with self.service() as service:
-            try:
-                data = analysis.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                result = await service.create_complete_proposal_analysis(data=data)
-                return CompleteAnalysisResponse(status="success", data=result)
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to create proposal analysis."
-                )
-
-    async def update_proposal_analysis(
-        self, analysis: UpdateDetailedAnalysisRequest, id: UUID = Path(...)
-    ):
-        async with self.service() as service:
-            try:
-                data = analysis.model_dump(mode="json", exclude_unset=True)
-                data["id"] = id
-                result = await service.update_proposal_analysis(data=data)
-                return ProposalDetailedAnalysisResponse(
-                    status="success",
-                    data=[ProposalDetailedAnalysis(**r) for r in result],
-                )
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update proposal analysis."
-                )
-
-    async def update_complete_proposal_analysis(
-        self,
-        analysis: CreateProposalDetailedAnalysisRequest,
-        proposal_id: UUID = Path(...),
-    ):
-        async with self.service() as service:
-            try:
-                data = analysis.model_dump(mode="json", exclude_unset=True)
-                data["proposal_id"] = proposal_id
-                result = await service.update_complete_proposal_analysis(data=data)
-                return CompleteAnalysisResponse(status="success", data=result)
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to update proposal analysis."
-                )
-
-    async def delete_proposal_analysis(self, id: str = Path(...)):
-        async with self.service() as service:
-            try:
-                result = await service.delete_proposal_analysis(id=id)
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal analysis."
-                )
-
-    async def delete_proposal_analysis_by_proposal_id(
-        self, proposal_id: str = Path(...)
-    ):
-        async with self.service() as service:
-            try:
-                result = await service.delete_proposal_analysis(proposal_id=proposal_id)
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal analysis."
-                )
-
-    async def delete_proposal_analysis_by_proposal_and_id(
-        self, proposal_id: str = Path(...), id: str = Path(...)
-    ):
-        async with self.service() as service:
-            try:
-                result = await service.delete_proposal_analysis(
-                    proposal_id=proposal_id, id=id
-                )
-                return DeleteResponse(status="success")
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(
-                    status_code=500, detail="Failed to delete proposal analysis."
-                )

src/controllers/_proposal_evaluation_controller.py

@@ -1,209 +0,0 @@
-from fastapi import APIRouter, HTTPException, Query, Path
-from pydantic import BaseModel, field_validator
-from typing import List, Optional
-from uuid import UUID
-from datetime import datetime
-
-from src.config import logger
-from src.models import EvaluationType
-from src.services import ProposalEvaluationService
-
-
-class Evaluation(BaseModel):
-    id: UUID
-    proposal_id: UUID
-    evaluation_type: EvaluationType
-    ai_score: Optional[float] = None
-    adjusted_score: Optional[float] = None
-    created_at: datetime
-    updated_at: datetime
-
-    @field_validator("ai_score", "adjusted_score")
-    @classmethod
-    def round_to_two_decimals(cls, v):
-        if v is not None:
-            return round(v, 2)
-        return v
-
-
-class Response(BaseModel):
-    status: str
-    data: Optional[List[Evaluation]] = None
-
-
-class RequestEvaluation(BaseModel):
-    evaluation_type: Optional[EvaluationType] = None
-    ai_score: Optional[float] = None
-    adjusted_score: Optional[float] = None
-
-
-class DeleteResponse(BaseModel):
-    status: str
-
-
-class CreateEvaluation(BaseModel):
-    evaluation_type: EvaluationType
-    ai_score: Optional[float] = None
-    adjusted_score: Optional[float] = None
-
-
-class CreateEvaluationRequest(BaseModel):
-    data: List[CreateEvaluation]
-
-
-class UpdateEvaluation(BaseModel):
-    evaluation_type: Optional[EvaluationType] = None
-    ai_score: Optional[float] = None
-    adjusted_score: Optional[float] = None
-
-
-class ProposalEvaluationController:
-    def __init__(self):
-        self.service = ProposalEvaluationService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations",
-            self.get_evaluation_by_proposal_and_rfp_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Evaluations by Proposal and RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{id}",
-            self.get_evaluation_by_proposal_and_rfp_id_and_id,
-            methods=["GET"],
-            response_model=Response,
-            tags=["Evaluations by Proposal and RFP ID and ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations",
-            self.create_evaluation_by_proposal_and_rfp_id,
-            methods=["POST"],
-            response_model=Response,
-            tags=["Evaluations by Proposal and RFP ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{id}",
-            self.update_evaluation_by_proposal_and_rfp_id_and_id,
-            methods=["PUT"],
-            response_model=Response,
-            tags=["Evaluations by Proposal and RFP ID and ID"],
-        )
-
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations",
-            self.delete_evaluation_by_proposal_and_rfp_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Evaluations by Proposal and RFP ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}/proposals/{proposal_id}/evaluations/{id}",
-            self.delete_evaluation_by_proposal_and_rfp_id_and_id,
-            methods=["DELETE"],
-            response_model=DeleteResponse,
-            tags=["Evaluations by Proposal and RFP ID and ID"],
-        )
-
-    async def get_evaluation_by_proposal_and_rfp_id(
-        self,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        evaluation_type: Optional[EvaluationType] = Query(None),
-    ):
-        try:
-            async with self.service() as service:
-                results = await service.get_evaluations(
-                    proposal_id=proposal_id, evaluation_type=evaluation_type
-                )
-                return Response(
-                    status="success",
-                    data=[Evaluation(**result) for result in results],
-                )
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
-
-    async def get_evaluation_by_proposal_and_rfp_id_and_id(
-        self, rfp_id: str = Path(...), proposal_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.service() as service:
-                result = await service.get_evaluations(proposal_id=proposal_id, id=id)
-                return Response(
-                    status="success",
-                    data=[Evaluation(**result) for result in result],
-                )
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
-
-    async def create_evaluation_by_proposal_and_rfp_id(
-        self,
-        evaluation: CreateEvaluationRequest,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-    ):
-        try:
-            async with self.service() as service:
-                result = await service.create_evaluations(
-                    proposal_id=proposal_id,
-                    evaluations=evaluation.model_dump(mode="json", exclude_unset=True)[
-                        "data"
-                    ],
-                )
-                return Response(
-                    status="success",
-                    data=[Evaluation(**result) for result in result],
-                )
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
-
-    async def update_evaluation_by_proposal_and_rfp_id_and_id(
-        self,
-        evaluation: UpdateEvaluation,
-        rfp_id: str = Path(...),
-        proposal_id: str = Path(...),
-        id: str = Path(...),
-    ):
-        try:
-            async with self.service() as service:
-                result = await service.update_evaluations(
-                    proposal_id=proposal_id,
-                    id=id,
-                    evaluations=evaluation.model_dump(mode="json", exclude_unset=True),
-                )
-                return Response(
-                    status="success",
-                    data=[Evaluation(**result) for result in result],
-                )
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
-
-    async def delete_evaluation_by_proposal_and_rfp_id(
-        self, rfp_id: str = Path(...), proposal_id: str = Path(...)
-    ):
-        try:
-            async with self.service() as service:
-                result = await service.delete_evaluations(proposal_id=proposal_id)
-                return DeleteResponse(status="success")
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")
-
-    async def delete_evaluation_by_proposal_and_rfp_id_and_id(
-        self, rfp_id: str = Path(...), proposal_id: str = Path(...), id: str = Path(...)
-    ):
-        try:
-            async with self.service() as service:
-                result = await service.delete_evaluations(
-                    proposal_id=proposal_id, id=id
-                )
-                return DeleteResponse(status="success")
-        except Exception as e:
-            logger.exception(e)
-            raise HTTPException(status_code=500, detail="Failed to retrieve proposals.")

src/controllers/_rfp_controller.py

@@ -1,170 +0,0 @@
-from fastapi import Path
-from fastapi import APIRouter, HTTPException, Query
-from pydantic import BaseModel, Field, field_validator
-from typing import List, Optional
-from uuid import UUID
-
-from src.config import logger
-from src.services import RFPService
-from datetime import datetime
-
-from src.models import RFPStatus
-
-
-class RFP(BaseModel):
-    id: UUID
-    rfp_number: str
-    name: str
-    received_proposals: int
-    evaluated_count: int
-    awaiting_evaluation: int
-    target_award_date: Optional[datetime] = None
-    ko_name: Optional[str] = None
-    award_type: Optional[str] = None
-    google_drive_id: Optional[str] = None
-    status: RFPStatus
-    comparative_weights_locked: Optional[bool] = False
-    created_at: datetime
-    updated_at: datetime
-
-
-class ResponseRFP(BaseModel):
-    status: str
-    data: Optional[List[RFP]]
-
-
-class RFPRequest(BaseModel):
-    rfp_number: str
-    name: str
-    received_proposals: int
-    evaluated_count: int
-    target_award_date: Optional[datetime] = None
-    ko_name: Optional[str] = None
-    award_type: Optional[str] = None
-    google_drive_id: Optional[str] = None
-    status: RFPStatus
-    comparative_weights_locked: Optional[bool] = False
-    awaiting_evaluation: int
-
-
-class RFPUpdateRequest(BaseModel):
-    rfp_number: Optional[str] = None
-    name: Optional[str] = None
-    received_proposals: Optional[int] = None
-    evaluated_count: Optional[int] = None
-    target_award_date: Optional[datetime] = None
-    ko_name: Optional[str] = None
-    award_type: Optional[str] = None
-    google_drive_id: Optional[str] = None
-    status: Optional[RFPStatus] = None
-    comparative_weights_locked: Optional[bool] = None
-    awaiting_evaluation: Optional[int] = None
-
-
-class RFPDeleteResponse(BaseModel):
-    status: str
-
-
-class RFPController:
-    def __init__(self):
-        self.__rfp_service = RFPService
-        self.router = APIRouter()
-        self.router.add_api_route(
-            "/rfps",
-            self.get_rfps,
-            methods=["GET"],
-            response_model=ResponseRFP,
-            tags=["RFPs"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}",
-            self.get_rfps_by_id,
-            methods=["GET"],
-            response_model=ResponseRFP,
-            tags=["RFPs by ID"],
-        )
-        self.router.add_api_route(
-            "/rfps",
-            self.create_rfp,
-            methods=["POST"],
-            response_model=ResponseRFP,
-            tags=["RFPs"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}",
-            self.update_rfp,
-            methods=["PUT"],
-            response_model=ResponseRFP,
-            tags=["RFPs by ID"],
-        )
-        self.router.add_api_route(
-            "/rfps/{rfp_id}",
-            self.delete_rfp,
-            methods=["DELETE"],
-            response_model=RFPDeleteResponse,
-            tags=["RFPs by ID"],
-        )
-
-    async def get_rfps(self, status: Optional[RFPStatus] = Query(None)):
-        async with self.__rfp_service() as service:
-            try:
-                rfps = await service.get_rfps(status=status)
-                return ResponseRFP(status="success", data=[RFP(**rfp) for rfp in rfps])
-            except HTTPException as e:
-                logger.warning(e)
-                raise e
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(status_code=500, detail="Failed to retrieve RFPs.")
-
-    async def get_rfps_by_id(self, rfp_id: str = Path(...)):
-        async with self.__rfp_service() as service:
-            try:
-                rfps = await service.get_rfps(rfp_id=rfp_id)
-                return ResponseRFP(status="success", data=[RFP(**rfp) for rfp in rfps])
-            except HTTPException as e:
-                logger.warning(e)
-                raise e
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(status_code=500, detail="Failed to retrieve RFPs.")
-
-    async def create_rfp(self, rfp: RFPRequest):
-        async with self.__rfp_service() as service:
-            try:
-                rfp = await service.create_rfp(rfp.model_dump(exclude_unset=True))
-                return ResponseRFP(status="success", data=[RFP(**rfp)])
-            except HTTPException as e:
-                logger.warning(e)
-                raise e
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(status_code=500, detail="Failed to create RFP.")
-
-    async def update_rfp(self, rfp: RFPUpdateRequest, rfp_id: str = Path(...)):
-        async with self.__rfp_service() as service:
-            try:
-                rfp = await service.update_rfp(
-                    rfp_id=rfp_id, rfp=rfp.model_dump(exclude_unset=True)
-                )
-                return ResponseRFP(status="success", data=[RFP(**rfp)])
-            except HTTPException as e:
-                logger.warning(e)
-                raise e
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(status_code=500, detail="Failed to update RFP.")
-
-    async def delete_rfp(self, rfp_id: str = Path(...)):
-        async with self.__rfp_service() as service:
-            try:
-                status = await service.delete_rfp(rfp_id)
-                if not status:
-                    raise HTTPException(status_code=404, detail="RFP not found.")
-                return RFPDeleteResponse(status="success")
-            except HTTPException as e:
-                logger.warning(e)
-                raise e
-            except Exception as e:
-                logger.exception(e)
-                raise HTTPException(status_code=500, detail="Failed to delete RFP.")

src/models/__init__.py

@@ -1,50 +0,0 @@
-from ._base import Base
-from ._proposal import Proposal, ProposalStatus, GateCriteria
-from ._rfp import RFP, RFPStatus
-from ._proposal_ai_analysis import (
-    ProposalAIAnalysis,
-    ProposalStrength,
-    ProposalWeakness,
-    ProposalImprovement,
-    ProposalRejectionReason,
-    Category
-)
-from ._proposal_detailed_analysis import ProposalDetailAnalysis, OperationCriteria
-from ._proposal_query_models import QueryType, CreateOrUpdateType
-from ._letters import Letter, LetterType
-from ._evaluation import EvaluationCriteria, EvaluationCriteriaType
-from ._comparitive_weights import ComparativeWeights, Weights
-from ._proposal_evaluation import Evaluations, EvaluationType
-from ._analysis import Analysis, AnalysisType, AnalysisStatus
-
-__all__ = [
-    "Base",
-    "Proposal",
-    "RFP",
-    "ProposalAIAnalysis",
-    "ProposalStrength",
-    "ProposalWeakness",
-    "ProposalImprovement",
-    "ProposalRejectionReason",
-    "ProposalDetailAnalysis",
-    "ProposalStatus",
-    "QueryType",
-    "CreateOrUpdateType",
-    "OperationCriteria",
-    "GateCriteria",
-    "Letter",
-    "LetterType",
-    "EvaluationCriteria",
-    "EvaluationCriteriaType",
-    "RFPStatus",
-    "Category",
-    "ComparativeWeights",
-    "Weights",
-    "Evaluations",
-    "EvaluationType",
-    "Analysis",
-    "AnalysisType",
-    "AnalysisStatus",
-]
-__version__ = "0.1.0"
-__author__ = "Aryan Jain"

src/models/_analysis.py

@@ -1,42 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class AnalysisType(PyEnum):
-    STRENGTHS = "STRENGTHS"
-    WEAKNESSES = "WEAKNESSES"
-    DEFICIENCIES = "DEFICIENCIES"
-
-class AnalysisStatus(PyEnum):
-    ACCEPTED = "ACCEPTED"
-    REJECTED = "REJECTED"
-    PENDING = "PENDING"
-
-class Analysis(Base):
-    __tablename__ = "analysis"
-    id = Column(UUID(as_uuid=True), primary_key=True)
-    evaluation_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("evaluations.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    insights = Column(String, nullable=False)
-    analysis_type = Column(Enum(AnalysisType), nullable=False)
-    status = Column(Enum(AnalysisStatus, name="analysisstatus"), nullable=False, default=AnalysisStatus.PENDING)
-    created_at = Column(DateTime(), nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime(), nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_base.py

@@ -1,3 +0,0 @@
-from sqlalchemy.orm import declarative_base
-
-Base = declarative_base()

src/models/_comparitive_weights.py

@@ -1,47 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class Weights(PyEnum):
-    NONE = "NONE"
-    LOW = "LOW"
-    MEDIUM = "MEDIUM"
-    HIGH = "HIGH"
-
-
-class ComparativeWeights(Base):
-    __tablename__ = "comparative_weights"
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    rfp_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("rfps.id", ondelete="CASCADE"),
-        nullable=False,
-        unique=True,
-    )
-    technical_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
-    management_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
-    past_performance_weight = Column(
-        Enum(Weights, name="comparativeweights"), nullable=False
-    )
-    price_weight = Column(Enum(Weights, name="comparativeweights"), nullable=False)
-    strengths_weight = Column(Float, nullable=False, default=15)
-    weaknesses_weight = Column(Float, nullable=False, default=5)
-    flag = Column(Boolean(), nullable=True, default=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_evaluation.py

@@ -1,34 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class EvaluationCriteriaType(PyEnum):
-    EVALUATION = "EVALUATION"
-    GATE = "GATE"
-
-
-class EvaluationCriteria(Base):
-    __tablename__ = "evaluation_criteria_details"
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    rfp_id = Column(
-        UUID(as_uuid=True), ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False
-    )
-    evaluation_criteria = Column(String, nullable=True)
-    evaluation_criteria_type = Column(Enum(EvaluationCriteriaType), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_letters.py

@@ -1,36 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class LetterType(PyEnum):
-    UO = "UO"
-    DEBRIEF = "DEBRIEF"
-
-
-class Letter(Base):
-    __tablename__ = "letters"
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    letter = Column(String, nullable=True)
-    letter_type = Column(Enum(LetterType), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_proposal.py

@@ -1,46 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class ProposalStatus(PyEnum):
-    APPROVED = "APPROVED"
-    EVALUATED = "EVALUATED"
-    IN_REVIEW = "IN_REVIEW"
-
-
-class GateCriteria(PyEnum):
-    PASS = "PASS"
-    FAIL = "FAIL"
-    IN_REVIEW = "IN_REVIEW"
-
-
-class Proposal(Base):
-    __tablename__ = "proposals"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    rfp_id = Column(
-        UUID(as_uuid=True), ForeignKey("rfps.id", ondelete="CASCADE"), nullable=False
-    )
-    name = Column(String, nullable=False)
-    tep = Column(String, nullable=False)
-    gate_criteria = Column(Enum(GateCriteria), nullable=False)
-    status = Column(Enum(ProposalStatus), nullable=False)
-    ai_score = Column(Float, nullable=True)
-    final_score = Column(Float, nullable=True)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_proposal_ai_analysis.py

@@ -1,103 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from ._base import Base
-
-class Category(PyEnum):
-    TECHNICAL = "TECHNICAL"
-    MANAGEMENT = "MANAGEMENT"
-    PAST_PERFORMANCE = "PAST_PERFORMANCE"
-    PRICE = "PRICE"
-
-class ProposalAIAnalysis(Base):
-    __tablename__ = "proposal_ai_analyses"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    ai_score = Column(Float, nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )
-
-
-class ProposalStrength(Base):
-    __tablename__ = "proposal_strengths"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    strength_point = Column(String, nullable=False)
-    category = Column(Enum(Category, name="strengthcategory"), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )
-
-
-class ProposalRejectionReason(Base):
-    __tablename__ = "proposal_rejection_reasons"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    reason = Column(String, nullable=False)
-    category = Column(Enum(Category, name="rejectioncategory"), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )
-
-
-class ProposalWeakness(Base):
-    __tablename__ = "proposal_weaknesses"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    weakness_point = Column(String, nullable=False)
-    category = Column(Enum(Category, name="weaknesscategory"), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )
-
-
-class ProposalImprovement(Base):
-    __tablename__ = "proposal_improvements"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    improvement_point = Column(String, nullable=False)
-    category = Column(Enum(Category, name="improvementcategory"), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_proposal_detailed_analysis.py

@@ -1,39 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-class OperationCriteria(PyEnum):
-    MISSION_ALIGNMENT = "MISSION_ALIGNMENT"
-    TECHNICAL_FEASIBILITY = "TECHNICAL_FEASIBILITY"
-    COST_EFFICIENCY = "COST_EFFICIENCY"
-    RISK_ASSESSMENT = "RISK_ASSESSMENT"
-
-
-class ProposalDetailAnalysis(Base):
-    __tablename__ = "proposal_detail_analyses"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    ai_assessment_result = Column(String, nullable=False)
-    confidence = Column(Float, nullable=False)
-    operation_criteria = Column(Enum(OperationCriteria), nullable=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_proposal_evaluation.py

@@ -1,40 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class EvaluationType(PyEnum):
-    TECHNICAL = "TECHNICAL"
-    MANAGEMENT = "MANAGEMENT"
-    PAST_PERFORMANCE = "PAST_PERFORMANCE"
-    PRICE = "PRICE"
-
-
-class Evaluations(Base):
-    __tablename__ = "evaluations"
-
-    id = Column(UUID(as_uuid=True), primary_key=True)
-    proposal_id = Column(
-        UUID(as_uuid=True),
-        ForeignKey("proposals.id", ondelete="CASCADE"),
-        nullable=False,
-    )
-    evaluation_type = Column(Enum(EvaluationType), nullable=False)
-    ai_score = Column(Float(), nullable=True)
-    adjusted_score = Column(Float(), nullable=True)
-    created_at = Column(DateTime(), nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime(), nullable=False, default=func.now(), onupdate=func.now()
-    )

src/models/_proposal_query_models.py

@@ -1,13 +0,0 @@
-from enum import Enum as PyEnum
-
-class QueryType(PyEnum):
-    ALL = "ALL"
-    AI_SCORE = "AI_SCORE"
-    STRENGTHS = "STRENGTHS"
-    WEAKNESSES = "WEAKNESSES"
-    REJECTION_REASONS = "REJECTION_REASONS"
-    IMPROVEMENTS = "IMPROVEMENTS"
-
-class CreateOrUpdateType(PyEnum):
-    ALL = "ALL"
-    ID = "ID"

src/models/_rfp.py

@@ -1,47 +0,0 @@
-from enum import Enum as PyEnum
-
-from sqlalchemy import (
-    Boolean,
-    Column,
-    DateTime,
-    Enum,
-    Float,
-    ForeignKey,
-    Integer,
-    String,
-    func,
-)
-from sqlalchemy.dialects.postgresql import UUID
-from pydantic import BaseModel
-from ._base import Base
-
-
-class RFPStatus(PyEnum):
-    ACTIVE = "ACTIVE"
-    IN_PROGRESS = "IN_PROGRESS"
-    NOT_YET_STARTED = "NOT_YET_STARTED"
-    CUSTOMER_HOLD = "CUSTOMER_HOLD"
-    UNSOLVED_ISSUES = "UNSOLVED_ISSUES"
-    AWARDED = "AWARDED"
-    PROTESTED = "PROTESTED"
-
-
-class RFP(Base):
-    __tablename__ = "rfps"
-
-    id = Column(UUID(as_uuid=True), primary_key=True, nullable=False)
-    rfp_number = Column(String, nullable=False)
-    name = Column(String, nullable=False)
-    received_proposals = Column(Integer, nullable=False)
-    evaluated_count = Column(Integer, nullable=False)
-    awaiting_evaluation = Column(Integer, nullable=False)
-    target_award_date = Column(DateTime, nullable=True)
-    ko_name = Column(String, nullable=True)
-    award_type = Column(String, nullable=True)
-    google_drive_id = Column(String, nullable=True)
-    status = Column(Enum(RFPStatus), nullable=False)
-    comparative_weights_locked = Column(Boolean(), nullable=True, default=False)
-    created_at = Column(DateTime, nullable=False, default=func.now())
-    updated_at = Column(
-        DateTime, nullable=False, default=func.now(), onupdate=func.now()
-    )

src/repositories/__init__.py

@@ -1,23 +0,0 @@
-from ._base_repository import BaseRepository
-from ._rfp_repository import RFPRepository
-from ._proposal_repository import ProposalRepository
-from ._proposal_detailed_analysis_repository import ProposalDetailedAnalysisRepository
-from ._letter_repository import LetterRepository
-from ._evaluation_repository import EvaluationRepository
-from ._comparative_weight_repository import ComparativeWeightRepository
-from ._proposal_evaluation_repository import ProposalEvaluationRepository
-from ._analysis_repository import AnalysisRepository
-
-__all__ = [
-    "BaseRepository",
-    "RFPRepository",
-    "ProposalRepository",
-    "ProposalDetailedAnalysisRepository",
-    "LetterRepository",
-    "EvaluationRepository",
-    "ComparativeWeightRepository",
-    "ProposalEvaluationRepository",
-    "AnalysisRepository",
-]
-__version__ = "0.1.0"
-__author__ = "Aryan Jain"

src/repositories/_analysis_repository.py

@@ -1,99 +0,0 @@
-import uuid
-from sqlalchemy import select
-from ._base_repository import BaseRepository
-from src.models import AnalysisType, Analysis
-from src.utils import ScoreClient
-
-
-class AnalysisRepository(BaseRepository):
-    def __init__(self):
-        super().__init__(Analysis)
-        self.score_client = ScoreClient
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc_value, traceback):
-        pass
-
-    async def get_analysis(
-        self,
-        evaluation_id: str = None,
-        analysis_type: AnalysisType = None,
-        id: str = None,
-    ):
-        async with self.get_session() as session:
-            query = select(Analysis)
-            if evaluation_id is not None:
-                query = query.filter(Analysis.evaluation_id == evaluation_id)
-            if analysis_type is not None:
-                query = query.filter(Analysis.analysis_type == analysis_type)
-            if id is not None:
-                query = query.filter(Analysis.id == id)
-            result = await session.execute(query)
-            results = result.scalars().all()
-        return [
-            {k: v for k, v in result.__dict__.items() if not k.startswith("_")}
-            for result in results
-        ]
-
-    async def create_analysis(
-        self,
-        evaluation_id: str,
-        evaluation_analysis: dict,
-        analysis_score_type: str = None,
-    ):
-        async with self.get_session() as session:
-            for analysis in evaluation_analysis:
-                analysis["evaluation_id"] = evaluation_id
-                analysis["id"] = str(uuid.uuid4())
-                instance = Analysis(**analysis)
-                session.add(instance)
-                await session.commit()
-                await session.refresh(instance)
-        async with self.score_client() as score_client:
-            await score_client.update_ai_score(
-                evaluation_id=evaluation_id, analysis_score_type=analysis_score_type
-            )
-        return await self.get_analysis(evaluation_id=evaluation_id)
-
-    async def update_analysis(
-        self, evaluation_id: str = None, id: str = None, proposal_analysis: dict = None
-    ):
-        async with self.get_session() as session:
-            if id:
-                query = select(Analysis).where(Analysis.id == id)
-                result = await session.execute(query)
-                instance = result.scalars().one()
-                for k, v in proposal_analysis.items():
-                    setattr(instance, k, v)
-                await session.commit()
-                await session.refresh(instance)
-                async with self.score_client() as score_client:
-                    await score_client.update_ai_score(evaluation_id=evaluation_id)
-                return [
-                    {
-                        k: v
-                        for k, v in instance.__dict__.items()
-                        if not k.startswith("_")
-                    }
-                ]
-            else:
-                await self.delete_analysis(evaluation_id=evaluation_id)
-                return await self.create_analysis(
-                    evaluation_id=evaluation_id, evaluation_analysis=proposal_analysis
-                )
-
-    async def delete_analysis(self, evaluation_id: str = None, id: str = None):
-        async with self.get_session() as session:
-            query = select(Analysis)
-            if evaluation_id:
-                query = query.filter(Analysis.evaluation_id == evaluation_id)
-            if id:
-                query = query.filter(Analysis.id == id)
-            result = await session.execute(query)
-            instances = result.scalars().all()
-            for instance in instances:
-                await session.delete(instance)
-            await session.commit()
-            return True