【Docker × Flask】コンテナでFlask製のREST APIを実装する~実践~

Copy
.
|-- .env
|-- .gitignore
|-- .vscode
|   |-- launch.json
|   `-- tasks.json
|-- Dockerfile
|-- app
|   |-- __init__.py
|   |-- api.py
|   |-- config.py
|   |-- database.py
|   |-- database_model.py
|   |-- endpoints.py
|   |-- error_handling.py
|   |-- exceptions.py
|   |-- logger.py
|   |-- response_helper.py
|   |-- schemas.py
|   |-- user_service.py
|   `-- wsgi.py
|-- docker-compose.yml
|-- gunicorn_config.py
|-- log
|   |-- api.log
|   |-- gunicorn_access.log
|   `-- gunicorn_error.log
|-- mongo
|   |-- db
|   `-- init
|       `-- init-db.js
|-- requirements.txt
`-- vscode_ex_install.sh

Copy
**/mongo/**
**/__pycache__/**
**/log/**

Copy
# flask-REST APIコンテナ用
# Flaskがどのアプリケーションを実行するか指定(pyファイル:インスタンス)
FLASK_APP=app.wsgi:api

# Flaskがどの環境で動作するか指定
FLASK_ENV=development

#デバッグモードの指定
FLASK_DEBUG=true

# MongoDBコンテナ用
# MongoDBの管理者のユーザー名
MONGO_INITDB_ROOT_USERNAME=admin

# MongoDBの管理者のパスワード
MONGO_INITDB_ROOT_PASSWORD=admin123

# 初期DBの作成
MONGO_INITDB_DATABASE=mongodb 

# MongoDB接続用URL
MONGO_URI=mongodb://admin:admin123@172.25.2.3:27017/

# Mongo Expressコンテナ用
# Mongo Expressが接続するMongoDBのサーバーを指定(MongoDBのサービス名)
ME_CONFIG_MONGODB_SERVER=mongodb

# MongoDBの管理者（rootユーザー）のユーザー名(Mongo ExpressがMongoDBに接続する際に使用)
ME_CONFIG_MONGODB_ADMINUSERNAME=admin

# MongoDBの管理者（rootユーザー）のパスワード(Mongo ExpressがMongoDBに接続する際に使用)
ME_CONFIG_MONGODB_ADMINPASSWORD=admin123

# Mongo Expressへの基本認証のユーザー名
ME_CONFIG_BASICAUTH_USERNAME=admin

# Mongo Expressへの基本認証のパスワード
ME_CONFIG_BASICAUTH_PASSWORD=password

Copy
Flask==3.0.2
pymongo==4.8.0
pydantic==2.8.2
gunicorn==21.2.0

Copy
FROM python:3.12

# workspaceディレクトリ作成、移動
WORKDIR /workspace

# プロジェクトディレクトリにコピー
COPY requirements.txt /workspace

# 必要モジュールのインストール
RUN pip install --upgrade pip
RUN pip install -r requirements.txt

Copy
version: "3"
services:
  flask-api:
    container_name: "flask-api"
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    volumes:
      # バインドマウント
      - .:/workspace
    # 環境変数読み込み
    env_file:
      - .env
    tty: true
    networks:
      flaskmongo_network:
        ipv4_address: 172.25.2.2

  # MongoDBコンテナ
  mongodb:
    container_name: "mongodb"
    restart: always
    image: mongo:6.0.13
    ports:
      - "27017:27017"
    volumes:
      - ./mongo/init:/docker-entrypoint-initdb.d # 初期化スクリプト
      - mongoDataStore:/data/db # MongoDBのデータファイル
      # - ./mongo/db:/data/db
    env_file:
      - .env
    networks:
      flaskmongo_network:
        ipv4_address: 172.25.2.3

  # mongo_expressコンテナ
  mongo_express:
    container_name: "mongo_express"
    image: mongo-express:1.0.2
    restart: always
    ports:
      - "8081:8081"
    env_file:
      - .env
    depends_on:
      mongodb:
        condition: service_started # mongoコンテナが起動してから起動させる
    networks:
      flaskmongo_network:
        ipv4_address: 172.25.2.4

# ネットワーク設定
networks:
  # ネットワーク名（ファイル内での使う名称）
  flaskmongo_network:
    # ネットワークドライバーを指定
    driver: bridge

    #ネットワークの名前を指定（dockerネットワークとしての名称）
    name: flaskmongo_network

    # IPアドレス管理（IPAM）の設定
    ipam:
      # IPAMドライバーを指定
      driver: default

      # ネットワークのサブネット設定
      config:
        - subnet: 172.25.2.0/24

# 名前付きボリューム
volumes:
  mongoDataStore:
    name: mongoDataStore

Copy
# MongoDBコンテナ
  mongodb:
    container_name: "mongodb"
    restart: always
    image: mongo:6.0.13
    ports:
      - "27017:27017"
    volumes:
      - ./mongo/init:/docker-entrypoint-initdb.d # 初期化スクリプト
      - mongoDataStore:/data/db # MongoDBのデータファイル
      # - ./mongo/db:/data/db
    env_file:
      - .env
    networks:
      flaskmongo_network:
        ipv4_address: 172.25.2.3

~~省略~~
# ネットワーク設定
networks:
  # ネットワーク名（ファイル内での使う名称）
  flaskmongo_network:
    # ネットワークドライバーを指定
    driver: bridge

    #ネットワークの名前を指定（dockerネットワークとしての名称）
    name: flaskmongo_network

    # IPアドレス管理（IPAM）の設定
    ipam:
      # IPAMドライバーを指定
      driver: default

      # ネットワークのサブネット設定
      config:
        - subnet: 172.25.2.0/24

Copy
# MongoDBコンテナ
  mongodb:
    container_name: "mongodb"
    restart: always
    image: mongo:6.0.13
    ports:
      - "27017:27017"
    volumes:
      - ./mongo/init:/docker-entrypoint-initdb.d # 初期化スクリプト
      - mongoDataStore:/data/db # MongoDBのデータファイル
      # - ./mongo/db:/data/db
    env_file:
      - .env
    networks:
      flaskmongo_network:
        ipv4_address: 172.25.2.3

~~省略~~
# 名前付きボリューム
volumes:
  mongoDataStore:
    name: mongoDataStore

Copy
// init-db.js

// 管理者ユーザーでログイン
db = db.getSiblingDB("admin");
db.auth("admin", "admin123");

// mongotable データベースに接続する
db = db.getSiblingDB("SAMPLE_DB");
// コレクションを作成する
db.createCollection("USERS_COLLECTION");
// サンプルドキュメントを挿入する
db.USERS_COLLECTION.insertOne({
  user_id: "id",
  name: "Name",
  age: 0,
});

print("Initialization completed.");

Copy
#!/bin/bash

# 拡張機能のIDリスト
extensions=(
    "ms-python.python"
    "ms-python.vscode-pylance"
    "ms-python.debugpy"
    "mhutchie.git-graph"
    "ms-vscode-remote.vscode-remote-extensionpack"
    "ms-azuretools.vscode-docker"
)

# 各拡張機能をインストール
for extension in "${extensions[@]}"; do
    code --install-extension $extension
done

Copy
from flask import Flask
import logging

from app.database import Database
from app.endpoints import configure_endpoints
from app.error_handling import init_error_handling
from app.logger import logger_init

def create_app() -> Flask:
    # ロガーの設定
    logger_init()

    # ロガー取得
    logger = logging.getLogger('apiLogger')
    logger.info('api starting')

    # アプリケーションインスタンスの作成
    app = Flask(__name__)

    # 日本語文字化け対応
    app.json.ensure_ascii = False

    # データベース接続
    Database.init_db()

    # エラーハンドラ関数登録
    init_error_handling(app)

    # ルーティング設定
    configure_endpoints(app)

    return app

Copy
from app.api import create_app

api = create_app()

Copy
import logging
import logging.config

# ロギングの設定を辞書形式で定義
logging_config = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'exampleFormatter': {
            'format': '%(asctime)s - %(levelname)s - %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S'
        }
    },
    'handlers': {
        'consoleHandler': {
            'class': 'logging.StreamHandler',
            'level': 'DEBUG',
            'formatter': 'exampleFormatter',
            'stream': 'ext://sys.stdout'
        },
        'fileHandler': {
            'class': 'logging.FileHandler',
            'level': 'INFO',
            'formatter': 'exampleFormatter',
            'filename': '/workspace/log/api.log',
            'encoding': 'utf-8'
        }
    },
    'loggers': {
        '': {  # ルートロガーの設定
            'level': 'DEBUG',
            'handlers': ['consoleHandler', 'fileHandler']
        },
        'apiLogger': {  # 特定のロガー設定
            'level': 'DEBUG',
            'handlers': ['consoleHandler', 'fileHandler'],
            'propagate': False
        }
    }
}

# ロギングの設定を適用
def logger_init():
    logging.config.dictConfig(logging_config)

Copy
import os

class Config:
    # コンテナ環境変数よりmongodb接続情報取得
    MONGO_URI = os.environ.get('MONGO_URI')

Copy
from flask import Flask
from pymongo import MongoClient
import logging

from app.config import Config

logger = logging.getLogger('apiLogger')

class Database:

    # db接続クライアント
    client = None

    @classmethod
    def init_db(cls):
        # mogogoDBサーバーに接続
        try:
            cls.client = MongoClient(Config.MONGO_URI)
        except Exception as e:
            # logging
            logger.error(f'An error occurred while inithializing the database: {e}')
            raise

Copy
from flask import Flask, jsonify, make_response
import logging
from pydantic import ValidationError, BaseModel
from typing import Type
from pymongo.errors import PyMongoError

from app.exceptions import CustomException
from app.response_helper import ResponseHelper

logger = logging.getLogger('apiLogger')

# バリデーションチェック
def validation_check(data: dict, model: Type[BaseModel],target: str):
    # レスポンスのバリデーションチェック
    try:
        validated_data = model(**data)  # 引数で渡されたモデルを使用してバリデーション
        return validated_data.model_dump()
    except ValidationError as e:
        if target == 'request':
            e.context = 'request'  # エラーオブジェクトにコンテキスト情報を追加
        else:
            e.context = 'response'  # エラーオブジェクトにコンテキスト情報を追加
        raise e # eを再スロー
    except Exception as e:
        logger.error(f"An unexpected error occurred: {str(e)}")
        raise

# バリデーションエラーハンドラー
def handle_validation_error(error: ValidationError):    
    # カスタム属性 `context` でリクエストかレスポンスのエラーかを区別
    if hasattr(error, 'context') and error.context == 'request':
        logger.error(f'Request validation error:\n{str(error.errors())} ', exc_info=True)    
        response = ResponseHelper.error(status_code=422, message="Request validation error", detail=str(error.errors()))
        return make_response(jsonify(response), 422)
    elif hasattr(error, 'context') and error.context == 'response':
        logger.error(f'Response validation error:\n{str(error.errors())} ', exc_info=True)    
        response = ResponseHelper.error(status_code=422, message="Response validation error", detail=str(error.errors()))
        return make_response(jsonify(response), 422)

# カスタムエクセプションハンドラー
def handle_custom_exception(error: CustomException):
    logger.error(
        f'HTTP status code: {error.status_code}\n ' 
        f'Error message: {error.error_message}\n ', 
        exc_info=True
    )
    response = ResponseHelper.error(status_code=error.status_code, message=error.error_message)
    return make_response(jsonify(response), error.status_code)

# PyMongoエラーハンドラー
def handle_pymongo_error(error: PyMongoError):
    logger.error(
        f'HTTP status code: {500}\n' 
        'Error message: Internal Server Error\n'
        f'detail: {error.detail}', 
        exc_info=True
    )
    response = ResponseHelper.error(status_code=500, detail=error.detail, message='Internal Server Error')
    return make_response(jsonify(response), 500)

# dbアクセスエラー用ラッパー
def pymongo_error_wrapper(func):
    def wrapper(self, collection_name, *args, **kwargs):
        try:
            return func(self, collection_name, *args, **kwargs)
        except PyMongoError as e:
            e.detail = f"Failed to find documents in database '{self.db_name}', collection '{collection_name}'"
            raise e
        except Exception as e:
            logger.error(f"An unexpected error occurred: {str(e)}")
            raise
    return wrapper

# エラーハンドリング初期化関数
def init_error_handling(app: Flask):
    app.register_error_handler(ValidationError, handle_validation_error)    
    app.register_error_handler(CustomException, handle_custom_exception) 
    app.register_error_handler(PyMongoError, handle_pymongo_error)

Copy
# バリデーションチェック
def validation_check(data: dict, model: Type[BaseModel],target: str):
    # レスポンスのバリデーションチェック
    try:
        validated_data = model(**data)  # 引数で渡されたモデルを使用してバリデーション
        return validated_data.model_dump()　# データモデルクラスオブジェクトから辞書形式に変換
    except ValidationError as e:
        if target == 'request':
            e.context = 'request'  # エラーオブジェクトにコンテキスト情報を追加
        else:
            e.context = 'response'  # エラーオブジェクトにコンテキスト情報を追加
        raise e # eを再スロー
    except Exception as e:
        logger.error(f"An unexpected error occurred: {str(e)}")
        raise

Copy
# バリデーションエラーハンドラー
def handle_validation_error(error: ValidationError):    
    # カスタム属性 `context` でリクエストかレスポンスのエラーかを区別
    if hasattr(error, 'context') and error.context == 'request':
        logger.error(f'Request validation error:\n{str(error.errors())} ', exc_info=True)    
        response = ResponseHelper.error(status_code=422, message="Request validation error", detail=str(error.errors()))
        return make_response(jsonify(response), 422)
    elif hasattr(error, 'context') and error.context == 'response':
        logger.error(f'Response validation error:\n{str(error.errors())} ', exc_info=True)    
        response = ResponseHelper.error(status_code=422, message="Response validation error", detail=str(error.errors()))
        return make_response(jsonify(response), 422)

Copy
# カスタムエクセプションハンドラー
def handle_custom_exception(error: CustomException):
    logger.error(
        f'HTTP status code: {error.status_code}\n ' 
        f'Error message: {error.error_message}\n ', 
        exc_info=True
    )
    response = ResponseHelper.error(status_code=error.status_code, message=error.error_message)
    return make_response(jsonify(response), error.status_code)

Copy
# PyMongoエラーハンドラー
def handle_pymongo_error(error: PyMongoError):
    logger.error(
        f'HTTP status code: {500}\n' 
        'Error message: Internal Server Error\n'
        f'detail: {error.detail}', 
        exc_info=True
    )
    response = ResponseHelper.error(status_code=500, detail=error.detail, message='Internal Server Error')
    return make_response(jsonify(response), 500)

Copy
# エラーハンドリング初期化関数
def init_error_handling(app: Flask):
    app.register_error_handler(ValidationError, handle_validation_error)    
    app.register_error_handler(CustomException, handle_custom_exception) 
    app.register_error_handler(PyMongoError, handle_pymongo_error)

Copy
# dbアクセスエラー用ラッパー
def pymongo_error_wrapper(func):
    def wrapper(self, collection_name, *args, **kwargs):
        try:
            return func(self, collection_name, *args, **kwargs)
        except PyMongoError as e:
            e.detail = f"Failed to find documents in database '{self.db_name}', collection '{collection_name}'"
            raise e
        except Exception as e:
            logger.error(f"An unexpected error occurred: {str(e)}")
            raise
    return wrapper

Copy
class CustomException(Exception):
    status_code: int
    error_message: str
    detail: str

    def __init__(self, error_message: str):
        self.error_message = error_message

class CustomBadRequestException(CustomException):
    status_code = 400  # override field

class CustomNotFoundException(CustomException):
    status_code = 404  # override field

class CustomInternalServerErrorException(CustomException):
    status_code = 500  # override field

Copy
import logging
from flask import Flask, jsonify, make_response, request
from pydantic import BaseModel, ValidationError

from app.schemas import Users
from app.user_service import UserService
from app.error_handling import validation_check

logger = logging.getLogger('apiLogger')

# アクセスログ出力用デコレーター
def access_log(func):
    def log_wrapper(*args, **kwargs):
        http_method = request.method
        route = request.path
        logger.info(f'Received {http_method} request for "{route}"')

        # 関数を実行してレスポンスを取得
        response, make_response = func(*args, **kwargs)

        # レスポンスの詳細を辞書形式でログに記録
        logger.info(f'Sending {http_method} response for \"{route}\" result: {response}"')

        return make_response
    return log_wrapper

class Endpoints:
    def __init__(self, app: Flask):
        self.app = app
        self.user_service = UserService()
        self.configure_routes()

    def configure_routes(self):
        # 全件取得
        @self.app.route('/', methods=['GET'], endpoint='get_users')
        @access_log
        def get_users():
            response = self.user_service.list_users()
            return response, make_response(jsonify(response), 200)

        # 指定取得
        @self.app.route('/<user_id>', methods=['GET'], endpoint='get_user_by_id')
        @access_log
        def get_user_by_id(user_id):
            response = self.user_service.get_user_by_id(user_id)
            return response, make_response(jsonify(response), 200)

        # 登録
        @self.app.route('/register', methods=['POST'], endpoint='register_user')
        @access_log
        def register_user():

            # リクエストボディをdictで取得
            request_data = request.get_json()

            # リクエストバリデーション実行
            validated_data = validation_check(data=request_data, model=Users, target='request')

            response = self.user_service.register_user(validated_data)
            print(response)
            return response, make_response(jsonify(response), 201)

        # 更新
        @self.app.route('/<user_id>', methods=['PUT'], endpoint='update_user')
        @access_log
        def update_user(user_id):

            # リクエストボディをdictで取得
            update_data = request.get_json()

            # リクエストバリデーション実行
            validated_data = validation_check(data=update_data, model=Users, target='request')

            response = self.user_service.update_user(user_id, validated_data)
            return response, make_response(jsonify(response), 200)

        # 削除
        @self.app.route('/<user_id>', methods=['DELETE'], endpoint='delete_user')
        @access_log
        def delete_user(user_id):
            response = self.user_service.delete_user(user_id)
            return response, make_response(jsonify(response), 200)

# エンドポイントの初期化処理を行うファクトリ関数
def configure_endpoints(app: Flask):
    Endpoints(app)

Copy
# アクセスログ出力用デコレーター
def access_log(func):
    def log_wrapper(*args, **kwargs):
        http_method = request.method
        route = request.path
        logger.info(f'Received {http_method} request for "{route}"')

        # 関数を実行してレスポンスを取得
        response, make_response = func(*args, **kwargs)

        # レスポンスの詳細を辞書形式でログに記録
        logger.info(f'Sending {http_method} response for \"{route}\" result: {response}"')

        return make_response
    return log_wrapper

Copy
class Endpoints:
    def __init__(self, app: Flask):
        self.app = app
        self.user_service = UserService()
        self.configure_routes()

    def configure_routes(self):
        # 全件取得
        @self.app.route('/', methods=['GET'], endpoint='get_users')
        @access_log
        def get_users():
            response = self.user_service.list_users()
            return response, make_response(jsonify(response), 200)

        # 指定取得
        @self.app.route('/<user_id>', methods=['GET'], endpoint='get_user_by_id')
        @access_log
        def get_user_by_id(user_id):
            response = self.user_service.get_user_by_id(user_id)
            return response, make_response(jsonify(response), 200)

        # 登録
        @self.app.route('/register', methods=['POST'], endpoint='register_user')
        @access_log
        def register_user():

            # リクエストボディをdictで取得
            request_data = request.get_json()

            # リクエストバリデーション実行
            validated_data = validation_check(data=request_data, model=Users, target='request')

            response = self.user_service.register_user(validated_data)
            print(response)
            return response, make_response(jsonify(response), 201)

        # 更新
        @self.app.route('/<user_id>', methods=['PUT'], endpoint='update_user')
        @access_log
        def update_user(user_id):

            # リクエストボディをdictで取得
            update_data = request.get_json()

            # リクエストバリデーション実行
            validated_data = validation_check(data=update_data, model=Users, target='request')

            response = self.user_service.update_user(user_id, validated_data)
            return response, make_response(jsonify(response), 200)

        # 削除
        @self.app.route('/<user_id>', methods=['DELETE'], endpoint='delete_user')
        @access_log
        def delete_user(user_id):
            response = self.user_service.delete_user(user_id)
            return response, make_response(jsonify(response), 200)

Copy
# エンドポイントの初期化処理を行うファクトリ関数
def configure_endpoints(app: Flask):
    Endpoints(app)

Copy
from pydantic import BaseModel, Field, field_validator
from typing import Optional, List

# データモデル定義
class Users(BaseModel):
    user_id: str
    name: str = Field(..., min_length=1, max_length=50)
    age: Optional[int] = Field(None, ge=0, le=120)

    # カスタムバリデーション
    @field_validator('name')
    def name_must_be_capitalized(cls, v):
        if not v.istitle():
            raise ValueError('名前は大文字で始める必要があります')
        return v

# データモデルリストの定義
class UsersList(BaseModel):
    users: Optional[List[Users]] = []

Copy
from app.database_model import DatabaseModel
from app.response_helper import ResponseHelper
from app.error_handling import validation_check
from app.schemas import Users, UsersList
from app.exceptions import CustomNotFoundException

class UserService:
    def __init__(self):
        self.model = DatabaseModel('SAMPLE_DB')  # データベース名を指定してインスタンス化

    # 全件取得
    def list_users(self):
        user_list = self.model.find_documents('USERS_COLLECTION')
        # レスポンスバリデーション
        # データモデルリストのバリデーション
        validated_data = validation_check(data={"users": user_list}, model=UsersList, target='response')

        return ResponseHelper.success(status_code=200, data=validated_data)

    # 指定取得
    def get_user_by_id(self, user_id):
        user_detail = self.model.find_document_by_id('USERS_COLLECTION', user_id)

        if not user_detail:
            raise CustomNotFoundException(error_message="ユーザーが見つかりません")

        # レスポンスバリデーション
        validated_data = validation_check(data=user_detail, model=Users, target='response')

        return ResponseHelper.success(status_code=200, data=validated_data)

    # 登録
    def register_user(self, user_data):
        self.model.insert_document('USERS_COLLECTION', user_data)
        # `_id` フィールドを削除
        user_data.pop('_id', None)

        # レスポンスバリデーション
        validated_data = validation_check(data=user_data, model=Users, target='response')

        return ResponseHelper.success(status_code=201,message=f"ユーザー登録が成功しました。user_id: {user_data['user_id']}", data=validated_data)

    # 更新
    def update_user(self, user_id, update_data):
        result = self.model.update_document('USERS_COLLECTION', user_id, update_data)

        if result.matched_count == 0:
            raise CustomNotFoundException(error_message="ユーザーが見つかりません")

        return ResponseHelper.success(status_code=200,message=f"ユーザー情報が更新されました。user_id: {user_id}", data={'update_cnt':result.matched_count})

    # 削除
    def delete_user(self, user_id):
        result = self.model.delete_document('USERS_COLLECTION', user_id)

        if result.deleted_count == 0:
            raise CustomNotFoundException(error_message="ユーザーが見つかりません")

        return ResponseHelper.success(status_code=200,message=f"ユーザーが削除されました。user_id: {user_id}", data={'delete_cnt':result.deleted_count})

Copy
class UserService:
    def __init__(self):
        self.model = DatabaseModel('SAMPLE_DB')  # データベース名を指定してインスタンス化

Copy
# 指定取得
    def get_user_by_id(self, user_id):
        user_detail = self.model.find_document_by_id('USERS_COLLECTION', user_id)

        if not user_detail:
            raise CustomNotFoundException(error_message="ユーザーが見つかりません")

        # レスポンスバリデーション
        validated_data = validation_check(data=user_detail, model=Users, target='response')

        return ResponseHelper.success(status_code=200, data=validated_data)

Copy
# 指定取得
    def get_user_by_id(self, user_id):
        user_detail = self.model.find_document_by_id('USERS_COLLECTION', user_id)

        if not user_detail:
            raise CustomNotFoundException(error_message="ユーザーが見つかりません")

        # レスポンスバリデーション
        validated_data = validation_check(data=user_detail, model=Users, target='response')

        return ResponseHelper.success(status_code=200, data=validated_data)

Copy
from pydantic import BaseModel

# データモデルとして定義
class Response(BaseModel):
    status_code: int
    message: str | None = None
    data: dict | None = None
    detail: str | None = None

class ResponseHelper:
    @staticmethod
    def success(status_code:int, message="Operation successful", data=None, detail=None):
        return Response(status_code=status_code, message=message, data=data, detail=detail).model_dump()

    @staticmethod
    def error(status_code:int, message="An error occurred", data=None, detail=None):
        return Response(status_code=status_code, message=message, data=data, detail=detail).model_dump()

Copy
from app.database import Database
from app.error_handling import pymongo_error_wrapper

class DatabaseModel:
    # dbごとにインスタンスを作成
    def __init__(self, db_name):
        self.db = Database.client[db_name]
        self.db_name = db_name

    # 全件取得
    @pymongo_error_wrapper
    def find_documents(self, collection_name, query={}, projection={'_id': 0}):
        collection = self.db[collection_name]
        return list(collection.find(query, projection))

    # 指定取得
    @pymongo_error_wrapper
    def find_document_by_id(self, collection_name, document_id, projection={'_id': 0}):
        collection = self.db[collection_name]
        return collection.find_one({"user_id": document_id}, projection)

    # 登録
    @pymongo_error_wrapper
    def insert_document(self, collection_name, document):
        collection = self.db[collection_name]
        return collection.insert_one(document)

    # 削除
    @pymongo_error_wrapper
    def delete_document(self, collection_name, document_id):
        collection = self.db[collection_name]
        return collection.delete_one({"user_id": document_id})

    # 更新
    @pymongo_error_wrapper
    def update_document(self, collection_name, document_id, update_data):
        collection = self.db[collection_name]
        return collection.update_one(
            {"user_id": document_id},
            {"$set": update_data}
        )

Copy
# 全件取得
    @pymongo_error_wrapper
    def find_documents(self, collection_name, query={}, projection={'_id': 0}):
        collection = self.db[collection_name]
        return list(collection.find(query, projection))

Copy
# 年齢が30歳以上のユーザーの `name` と `email` フィールドを取得
documents = database_model.find_documents(
    collection_name="users",
    query={"age": {"$gte": 30}},  # 年齢が30以上の条件
    projection={"name": 1, "email": 1, "_id": 0}
)

Copy
# 指定取得
    @pymongo_error_wrapper
    def find_document_by_id(self, collection_name, document_id, projection={'_id': 0}):
        collection = self.db[collection_name]
        return collection.find_one({"user_id": document_id}, projection)

Copy
# 登録
    @pymongo_error_wrapper
    def insert_document(self, collection_name, document):
        collection = self.db[collection_name]
        return collection.insert_one(document)

Copy
# 削除
    @pymongo_error_wrapper
    def delete_document(self, collection_name, document_id):
        collection = self.db[collection_name]
        return collection.delete_one({"user_id": document_id})

Copy
# 更新
    @pymongo_error_wrapper
    def update_document(self, collection_name, document_id, update_data):
        collection = self.db[collection_name]
        return collection.update_one(
            {"user_id": document_id},
            {"$set": update_data}
        )