項目

Flask

Django

フレームワークの特徴

軽量・シンプルな構成

機能が揃ったフルスタック

開発の自由度

高い（必要な機能を追加）

中程度（規約ベース）

学習コスト

低め

やや高め

向いている規模

小規模〜中規模

中規模〜大規模

標準搭載の機能

最小限

認証、管理画面、ORM、フォーム機能など

初期開発のスピード

早い

中〜早い（慣れれば高速）

拡張性

必要に応じて柔軟に追加

標準機能が多いため、拡張も容易

予約システムとの相性

MVP構築・単店舗などに最適

多店舗運用・権限管理が必要な場合に最適

#config.py

class Role(Enum):
CUSTOMER = auto()
ADMIN = auto()

@dataclass
class ReservationRule:
max_capacity_per_slot: int = 4 # 1枠の最大予約数
max_reservations_per_user: int = 3 # 1ユーザーの同時予約上限
cancel_limit: timedelta = timedelta(hours=24) # キャンセル締切（24時間前まで）

@dataclass
class NotificationRule:
send_on_reserved: bool = True # 予約確定時
send_reminder_before_hours: int = 24 # 何時間前にリマインドするか
send_on_cancel: bool = True # キャンセル時

RESERVATION_RULE = ReservationRule()
NOTIFICATION_RULE = NotificationRule()

# app.py

from flask import Flask, render_template, request, redirect, url_for, flash

from datetime import date

from models import db, Slot, Customer, Reservation, create_reservation_safely

app = Flask(__name__)

app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///reservation.db"

app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False

app.secret_key = "very-secret"  # 実運用では環境変数などで管理

db.init_app(app)

@app.route("/")

def index():

    # 当日の予約枠一覧を取得（本来は日付指定やカレンダー表示と組み合わせる）

    target_date = date.today()

    slots = Slot.query.filter(Slot.start_at >= target_date).order_by(Slot.start_at).all()

    return render_template("index.html", slots=slots)

@app.route("/reserve/<int:slot_id>", methods=["GET", "POST"])

def reserve(slot_id):

    slot = Slot.query.get_or_404(slot_id)

    if request.method == "POST":

        name = request.form.get("name")

        email = request.form.get("email")

        tel = request.form.get("tel")

        if not name or not email:

            flash("氏名とメールアドレスは必須です。")

            return redirect(request.url)

        # 顧客の取得 or 作成

        customer = Customer.query.filter_by(email=email).first()

        if customer is None:

            customer = Customer(name=name, email=email, tel=tel)

            db.session.add(customer)

            db.session.commit()

        # 二重予約を避けつつ、予約作成

        ok, msg = create_reservation_safely(db.session, customer.id, slot.id)

        if not ok:

            flash(msg)

            return redirect(url_for("index"))

        flash("予約を受け付けました。確認メールを送信します。")

        return redirect(url_for("index"))

    return render_template("reserve.html", slot=slot)

if name == "__main__":

    with app.app_context():

        db.create_all()

    app.run(debug=True)

# models.py

from flask_sqlalchemy import SQLAlchemy

from datetime import datetime

from sqlalchemy import CheckConstraint, func

from config import RESERVATION_RULE

db = SQLAlchemy()

class Customer(db.Model):

    tablename = "customers"

    id = db.Column(db.Integer, primary_key=True)

    name = db.Column(db.String(128), nullable=False)

    email = db.Column(db.String(256), nullable=False, unique=True)

    tel = db.Column(db.String(32))

    created_at = db.Column(db.DateTime, default=datetime.utcnow)

class Slot(db.Model):

    tablename = "slots"

    id = db.Column(db.Integer, primary_key=True)

    start_at = db.Column(db.DateTime, nullable=False)

    end_at = db.Column(db.DateTime, nullable=False)

    capacity = db.Column(db.Integer, nullable=False, default=RESERVATION_RULE.max_capacity_per_slot)

    resource = db.Column(db.String(128))  # 部屋名やスタッフ名など

    # その枠の現在の予約数を計算するプロパティ

    @property

    def reserved_count(self) -> int:

        return len([r for r in self.reservations if r.status == "CONFIRMED"])

class Reservation(db.Model):

    tablename = "reservations"

    id = db.Column(db.Integer, primary_key=True)

    customer_id = db.Column(db.Integer, db.ForeignKey("customers.id"), nullable=False)

    slot_id = db.Column(db.Integer, db.ForeignKey("slots.id"), nullable=False)

    status = db.Column(db.String(32), nullable=False, default="CONFIRMED")  # CONFIRMED / CANCELED など

    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    customer = db.relationship("Customer", backref="reservations")

    slot = db.relationship("Slot", backref="reservations")

    __table_args__ = (

        # 1つの枠に対し同一顧客が複数予約しないようにする（一例）

        db.UniqueConstraint("customer_id", "slot_id", name="uq_customer_slot"),

    )

def create_reservation_safely(session, customer_id: int, slot_id: int):

    """

    二重予約を防ぎつつ予約を作成するユーティリティ関数。

    """

    # 対象枠をSELECT ... FOR UPDATEでロック（SQLiteでは擬似的ですが、他のDBなら有効）

    slot = (

        session.query(Slot)

        .filter(Slot.id == slot_id)

        .with_for_update()  # SQLiteでは無視されますが、設計として記載

        .first()

    )

    if slot is None:

        return False, "対象の枠が見つかりません。"

    # 現在の予約数を確認

    current_count = (

        session.query(func.count(Reservation.id))

        .filter(Reservation.slot_id == slot_id, Reservation.status == "CONFIRMED")

        .scalar()

    )

    if current_count >= slot.capacity:

        return False, "この枠は満席になっています。"

    reservation = Reservation(customer_id=customer_id, slot_id=slot_id, status="CONFIRMED")

    session.add(reservation)

    session.commit()

    return True, "予約を確定しました。"

def cancel_reservation(session, reservation_id: int):

    """

    キャンセル時にステータスを変更し、枠の空きは自動的に復活させる（枠のcapacityは変えず、予約数で管理）。

    """

    reservation = session.query(Reservation).get(reservation_id)

    if reservation is None:

        return False, "対象の予約が見つかりません。"

    reservation.status = "CANCELED"

    session.commit()

    return True, "予約をキャンセルしました。"

# notify.py

import smtplib

from email.mime.text import MIMEText

import requests

from typing import Optional

from config import NOTIFICATION_RULE

SMTP_HOST = "smtp.example.com"

SMTP_PORT = 587

SMTP_USER = "noreply@example.com"

SMTP_PASS = "password"

LINE_NOTIFY_TOKEN = "YOUR_LINE_NOTIFY_TOKEN"

def send_email(to_email: str, subject: str, body: str):

    msg = MIMEText(body, "plain", "utf-8")

    msg["Subject"] = subject

    msg["From"] = SMTP_USER

    msg["To"] = to_email

    with smtplib.SMTP(SMTP_HOST, SMTP_PORT) as smtp:

        smtp.starttls()

        smtp.login(SMTP_USER, SMTP_PASS)

        smtp.send_message(msg)

def send_line_notify(message: str):

    headers = {"Authorization": f"Bearer {LINE_NOTIFY_TOKEN}"}

    data = {"message": message}

    requests.post("https://notify-api.line.me/api/notify", headers=headers, data=data)

def send_reservation_confirm(customer_email: str, slot_info: str):

    if NOTIFICATION_RULE.send_on_reserved:

        subject = "【予約確定】ご予約ありがとうございます"

        body = f"以下の内容で予約を受け付けました。\n\n{slot_info}"

        send_email(customer_email, subject, body)

def send_reservation_reminder(customer_email: str, slot_info: str):

    subject = "【リマインド】明日のご予約について"

    body = f"明日、以下の内容でご予約をいただいております。\n\n{slot_info}"

    send_email(customer_email, subject, body)

def notify_staff_new_reservation(slot_info: str):

    # スタッフへの通知（LINE / Slack などに拡張可能）

    message = f"新しい予約が入りました。\n{slot_info}"

    send_line_notify(message)

# test_reservation.py

from models import db, Slot, Customer, create_reservation_safely

from datetime import datetime, timedelta

def test_double_booking(app):

    """

    capacity=1 の枠に対して2回予約を試みた場合、2回目はエラーになることを確認するテスト例

    """

    with app.app_context():

        db.drop_all()

        db.create_all()

        slot = Slot(start_at=datetime.utcnow(), end_at=datetime.utcnow() + timedelta(hours=1), capacity=1)

        db.session.add(slot)

        db.session.commit()

        c1 = Customer(name="山田太郎", email="taro@example.com")

        c2 = Customer(name="佐藤花子", email="hanako@example.com")

        db.session.add_all([c1, c2])

        db.session.commit()

        ok1, = createreservation_safely(db.session, c1.id, slot.id)

        ok2, msg2 = create_reservation_safely(db.session, c2.id, slot.id)

        assert ok1 is True

        assert ok2 is False

        assert "満席" in msg2

開発体制

工数の目安

費用の目安

特徴

個人開発（1人）

1〜2ヶ月

人件費＋サーバー費（数百〜数千円/月）

小規模でスモールスタートしたい場合に最適

小規模チーム（2〜3名）

2〜3ヶ月

人件費（複数名）＋監視/環境費

中規模の予約システムや多店舗対応に向く

開発会社へ外注

3〜6ヶ月

数十万〜数百万円

完成度が高く、保守契約による安心感あり

言語・方法

特徴

向いているケース

PHP

開発が容易・低コストで導入できる

中小規模店舗に適している

JavaScript（Node.js）

リアルタイム処理に強く柔軟な拡張が可能

Webアプリやチャット連携に向いている

Java

高信頼・高性能で大規模開発に対応

医療機関や企業システムに最適

WordPress

プラグイン導入で短期間構築が可能

個人事業主やサロン向け

SaaS／ノーコード

コーディング不要ですぐに運用できる

小規模チームや検証段階での利用に最適