mono/events/bp/slot/routes.py

from __future__ import annotations

from quart import (
    request, render_template, 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.browser.app.utils.htmx import is_htmx_request
from shared.sx.helpers import sx_response


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

    @bp.get("/")
    @require_admin
    async def get(slot_id: int, **kwargs):
        slot = await svc_get_slot(g.s, slot_id)
        if not slot:
            return await make_response("Not found", 404)
        
        if not is_htmx_request():
          # Normal browser request: full page with layout
          html = await render_template(
            "_types/slot/index.html",
            slot=slot,
            )
        else:
            
            html = await render_template(
              "_types/slot/_oob_elements.html",
              slot=slot,
            )
        
        return await make_response(html)


    @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)
        html = await render_template(
            "_types/slot/_edit.html",
            slot=slot,
            #post=g.post_data['post'],
            #calendar=g.calendar,
        )
        return await make_response(html)

    @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