rose-ash/events/bp/slot/routes.py

from __future__ import annotations

from quart import (
    request, make_response, Blueprint, g, jsonify
)
from sqlalchemy.exc import IntegrityError


from shared.browser.app.authz import require_admin
from shared.browser.app.redis_cacher import clear_cache

from .services.slot import (
  update_slot as svc_update_slot,
  soft_delete_slot as svc_delete_slot,
  get_slot as svc_get_slot,
)

from ..slots.services.slots import (
  list_slots as svc_list_slots,
)

from shared.browser.app.utils import (
    parse_time,
    parse_cost
)
from shared.sx.helpers import sx_response


def register():
    bp = Blueprint("slot", __name__, url_prefix='/<int:slot_id>')

    @bp.before_request
    async def _prepare_page_data():
        if "defpage_" not in (request.endpoint or ""):
            return
        slot_id = (request.view_args or {}).get("slot_id")
        slot = await svc_get_slot(g.s, slot_id) if slot_id else None
        if not slot:
            from quart import abort
            abort(404)
        g.slot = slot
        calendar = getattr(g, "calendar", None)
        from sx.sx_components import render_slot_main_panel
        g.slot_content = render_slot_main_panel(slot, calendar)

    @bp.context_processor
    async def _inject_slot():
        return {"slot": getattr(g, "slot", None)}

    from shared.sx.pages import mount_pages
    mount_pages(bp, "events", names=["slot-detail"])

    @bp.get("/edit/")
    @require_admin
    async def get_edit(slot_id: int, **kwargs):
        slot = await svc_get_slot(g.s, slot_id)
        if not slot:
            return await make_response("Not found", 404)
        from sx.sx_components import render_slot_edit_form
        return sx_response(render_slot_edit_form(slot, g.calendar))

    @bp.get("/view/")
    @require_admin
    async def get_view(slot_id: int, **kwargs):
        slot = await svc_get_slot(g.s, slot_id)
        if not slot:
            return await make_response("Not found", 404)
        from sx.sx_components import render_slot_main_panel
        return sx_response(render_slot_main_panel(slot, g.calendar))

    @bp.delete("/")
    @require_admin
    @clear_cache(tag="calendars", tag_scope="all")
    async def slot_delete(slot_id: int, **kwargs):
        await svc_delete_slot(g.s, slot_id)
        slots = await svc_list_slots(g.s, g.calendar.id)
        from sx.sx_components import render_slots_table
        return sx_response(render_slots_table(slots, g.calendar))

    @bp.put("/")
    @require_admin
    @clear_cache(tag="calendars", tag_scope="all")
    async def put(slot_id: int, **kwargs):
        form = await request.form

        name = (form.get("name") or "").strip()
        description = (form.get("description") or "").strip() or None
        days = {k: form.get(k) for k in ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]}
        time_start = parse_time(form.get("time_start"))
        time_end = parse_time(form.get("time_end"))
        cost = parse_cost(form.get("cost"))

        # NEW
        flexible = bool(form.get("flexible"))

        field_errors: dict[str, list[str]] = {}

        # Basic validation...
        if not name:
            field_errors.setdefault("name", []).append("Please enter a name for the slot.")

        if not time_start:
            field_errors.setdefault("time_start", []).append("Please select a start time.")

        if not time_end:
            field_errors.setdefault("time_end", []).append("Please select an end time.")

        if time_start and time_end and time_end <= time_start:
            field_errors.setdefault("time_end", []).append(
                "End time must be after the start time."
            )

        if not any(form.get(d) for d in ["mon", "tue", "wed", "thu", "fri", "sat", "sun"]):
            field_errors.setdefault("days", []).append(
                "Please select at least one day."
            )

        if field_errors:
            return jsonify(
                {
                    "message": "Please fix the highlighted fields.",
                    "errors": field_errors,
                }
            ), 422

        # DB update + friendly duplicate handling
        try:
            slot = await svc_update_slot(
                g.s,
                slot_id,
                name=name,
                description=description,
                days=days,
                time_start=time_start,
                time_end=time_end,
                cost=cost,
                flexible=flexible,    # <--- NEW
            )
        except IntegrityError as e:
            msg = str(e.orig) if getattr(e, "orig", None) else str(e)
            if "uq_calendar_slots_unique_band" in msg or "duplicate key value" in msg:
                field_errors = {
                    "name": [f'A slot called “{name}” already exists on this calendar.']
                }
                return jsonify(
                    {
                        "message": "That slot name is already in use.",
                        "errors": field_errors,
                    }
                ), 422

            return jsonify(
                {
                    "message": "An unexpected error occurred while updating the slot.",
                    "errors": {"__all__": [msg]},
                }
            ), 422

        from sx.sx_components import render_slot_main_panel
        return sx_response(render_slot_main_panel(slot, g.calendar, oob=True))

    

    return bp