sophhub 0.4.35 → 0.4.37

package/skills/store-appointment/src/store_appointment_lib/cli.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from typing import Any, Dict, List, Optional
+
+from store_db.db import connect
+from store_db.ids import next_id
+from store_db.operation_log import commit_with_log, log_read, request_dict
+from store_db.response import emit_error, emit_need_confirm, emit_ok
+
+from store_appointment_lib.helpers import (  # noqa: E402
+    SettlementError,
+    appt_interval,
+    query_service_price_and_duration,
+    staff_list_for_skill,
+    staff_schedule_query,
+    suggest_available_slots,
+    validate_appt_create,
+    within_slots,
+)
+from store_appointment_lib.settlement import PAY_MODES, complete_appointment  # noqa: E402
+
+SKILL = "store-appointment"
+
+
+def cmd_appt_create(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    service = args.service
+    price, dur = query_service_price_and_duration(conn, service)
+    duration_min = int(args.duration) if args.duration else dur
+    ok, err = validate_appt_create(
+        conn,
+        technician_id=args.technician_id,
+        datetime_str=args.datetime,
+        duration_min=duration_min,
+    )
+    if not ok:
+        code = err.split(":", 1)[0] if err.startswith("schedule_conflict") else err
+        detail = {}
+        if ":" in err:
+            detail = {"conflict_id": err.split(":", 1)[1]}
+        emit_error(code, detail if detail else None)
+    aid = args.appt_id or next_id(conn, "A", "store_appointments")
+    conn.execute(
+        """INSERT INTO store_appointments
+           (id, member_id, service_name, technician_id, start_dt, duration_min, status, remark)
+           VALUES (?,?,?,?,?,?, 'scheduled', ?)""",
+        (
+            aid,
+            args.member_id,
+            service,
+            args.technician_id,
+            args.datetime,
+            duration_min,
+            args.remark or "",
+        ),
+    )
+    commit_with_log(
+        conn, args, skill=SKILL, command="appt-create", op="create", table_name="store_appointments",
+        entity_id=aid, duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"appt_id": aid, "duration_min": duration_min, "price": price})
+    return 0
+
+
+def cmd_appt_query(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    if args.appt_id:
+        row = conn.execute("SELECT * FROM store_appointments WHERE id=?", (args.appt_id,)).fetchone()
+        log_read(
+            conn, args, skill=SKILL, command="appt-query", table_name="store_appointments",
+            entity_id=args.appt_id, duration_ms=int((time.perf_counter() - t0) * 1000),
+        )
+        emit_ok({"appointments": [dict(row)] if row else [], "count": 1 if row else 0})
+        return 0
+
+    if args.date and (args.date_from or args.date_to):
+        emit_error("invalid_query", {"hint": "use --date or --date-from/--date-to, not both"})
+
+    clauses: List[str] = ["1=1"]
+    params: List[Any] = []
+    if args.member_id:
+        clauses.append("member_id=?")
+        params.append(args.member_id)
+    if args.technician_id:
+        clauses.append("technician_id=?")
+        params.append(args.technician_id)
+    if args.date:
+        clauses.append("substr(start_dt,1,10)=?")
+        params.append(args.date)
+    elif args.date_from:
+        clauses.append("substr(start_dt,1,10)>=?")
+        params.append(args.date_from)
+    if args.date_to:
+        clauses.append("substr(start_dt,1,10)<=?")
+        params.append(args.date_to)
+    if args.status:
+        clauses.append("status=?")
+        params.append(args.status)
+
+    q = f"SELECT * FROM store_appointments WHERE {' AND '.join(clauses)} ORDER BY start_dt"
+    if args.limit:
+        q += " LIMIT ?"
+        params.append(args.limit)
+    elif not args.date and not args.date_from and not args.member_id:
+        q += " LIMIT ?"
+        params.append(200)
+    rows = [dict(r) for r in conn.execute(q, params)]
+    log_read(
+        conn, args, skill=SKILL, command="appt-query", table_name="store_appointments",
+        duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"appointments": rows, "count": len(rows)})
+    return 0
+
+
+def cmd_appt_update(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    row = conn.execute("SELECT * FROM store_appointments WHERE id=?", (args.appt_id,)).fetchone()
+    if not row or row["status"] != "scheduled":
+        emit_error("invalid_appt", {"appt_id": args.appt_id})
+
+    new_dt = args.datetime or row["start_dt"]
+    new_tech = args.technician_id or row["technician_id"]
+    new_service = args.service or row["service_name"]
+
+    if not args.datetime and not args.technician_id and not args.service:
+        emit_error("invalid_query", {"hint": "provide at least one of --datetime, --technician-id, --service"})
+
+    if args.service and args.service != row["service_name"]:
+        svc = conn.execute(
+            "SELECT name FROM catalog_services WHERE name=? AND status='active'",
+            (args.service,),
+        ).fetchone()
+        if not svc:
+            emit_error("service_not_found", {"name": args.service})
+
+    _, dur = query_service_price_and_duration(conn, new_service)
+    duration_min = int(args.duration) if args.duration else int(row["duration_min"] or dur)
+
+    ok, err = validate_appt_create(
+        conn,
+        technician_id=new_tech,
+        datetime_str=new_dt,
+        duration_min=duration_min,
+        exclude_appt_id=args.appt_id,
+    )
+    if not ok:
+        code = err.split(":", 1)[0] if err.startswith("schedule_conflict") else err
+        detail = {}
+        if ":" in err:
+            detail = {"conflict_id": err.split(":", 1)[1]}
+        emit_error(code, detail if detail else None)
+
+    conn.execute(
+        """UPDATE store_appointments SET start_dt=?, technician_id=?, service_name=?,
+           duration_min=?, updated_at=datetime('now','localtime') WHERE id=?""",
+        (new_dt, new_tech, new_service, duration_min, args.appt_id),
+    )
+    commit_with_log(
+        conn, args, skill=SKILL, command="appt-update", op="update", table_name="store_appointments",
+        entity_id=args.appt_id, duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"appt_id": args.appt_id})
+    return 0
+
+
+def cmd_appt_cancel(args: argparse.Namespace) -> int:
+    if not args.yes:
+        emit_need_confirm({"action": "appt-cancel", "appt_id": args.appt_id})
+        return 0
+    t0 = time.perf_counter()
+    conn = connect()
+    row = conn.execute("SELECT status FROM store_appointments WHERE id=?", (args.appt_id,)).fetchone()
+    if not row:
+        emit_error("not_found", {"appt_id": args.appt_id})
+    conn.execute(
+        """UPDATE store_appointments SET status='cancelled', updated_at=datetime('now','localtime')
+           WHERE id=?""",
+        (args.appt_id,),
+    )
+    commit_with_log(
+        conn, args, skill=SKILL, command="appt-cancel", op="update", table_name="store_appointments",
+        entity_id=args.appt_id, duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"appt_id": args.appt_id, "status": "cancelled"})
+    return 0
+
+
+def cmd_appt_complete(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    row = conn.execute("SELECT * FROM store_appointments WHERE id=?", (args.appt_id,)).fetchone()
+    if not row:
+        emit_error("not_found", {"appt_id": args.appt_id})
+    price, _ = query_service_price_and_duration(conn, row["service_name"])
+    if not args.yes:
+        emit_need_confirm(
+            {
+                "action": "appt-complete",
+                "appt_id": args.appt_id,
+                "member_id": row["member_id"],
+                "service": row["service_name"],
+                "pay": args.pay,
+                "total_amount": price,
+            }
+        )
+        return 0
+    audit = {
+        "session_id": getattr(args, "session_id", None),
+        "skill": SKILL,
+        "command": "appt-complete",
+        "request_json": request_dict(args),
+        "duration_ms": int((time.perf_counter() - t0) * 1000),
+    }
+    try:
+        summary = complete_appointment(
+            conn,
+            appt_id=args.appt_id,
+            pay=args.pay,
+            lines_json=args.lines_json,
+            staff_lines_json=args.staff_lines_json,
+            card_name=args.card_name,
+            cash_amount=args.cash_amount,
+            audit=audit,
+        )
+    except SettlementError as e:
+        emit_error(e.code, e.detail if e.detail else None)
+    emit_ok(summary)
+    return 0
+
+
+def cmd_tech_recommend(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    _, dur = query_service_price_and_duration(conn, args.service)
+    candidates = staff_list_for_skill(conn, args.service)
+    date_part = args.datetime[:10]
+    good: List[Dict[str, Any]] = []
+    for st in candidates:
+        sid = st["id"]
+        sch = staff_schedule_query(conn, sid, date_part)
+        if sch.get("status") == "off":
+            continue
+        if not within_slots(args.datetime, sch.get("slots")):
+            continue
+        clash = appt_interval(conn, sid, args.datetime, dur)
+        if clash:
+            continue
+        good.append({"staff_id": sid, "name": st.get("name"), "fields": st.get("fields")})
+    log_read(
+        conn, args, skill=SKILL, command="tech-recommend", table_name="staff_staff",
+        duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"technicians": good, "count": len(good)})
+    return 0
+
+
+def cmd_tech_auto_assign(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    _, dur = query_service_price_and_duration(conn, args.service)
+    candidates = staff_list_for_skill(conn, args.service)
+    date_part = args.datetime[:10]
+    for st in candidates:
+        sid = st["id"]
+        sch = staff_schedule_query(conn, sid, date_part)
+        if sch.get("status") == "off":
+            continue
+        if not within_slots(args.datetime, sch.get("slots")):
+            continue
+        clash = appt_interval(conn, sid, args.datetime, dur)
+        if clash:
+            continue
+        log_read(
+            conn, args, skill=SKILL, command="tech-auto-assign", table_name="staff_staff",
+            entity_id=sid, duration_ms=int((time.perf_counter() - t0) * 1000),
+        )
+        emit_ok({"assigned": {"staff_id": sid, "name": st.get("name")}})
+        return 0
+    emit_error("no_technician_available")
+    return 0
+
+
+def cmd_appt_suggest_slots(args: argparse.Namespace) -> int:
+    t0 = time.perf_counter()
+    conn = connect()
+    slots = suggest_available_slots(
+        conn,
+        service=args.service,
+        date_yyyy_mm_dd=args.date,
+        technician_id=args.technician_id,
+        limit=int(args.limit or 5),
+    )
+    log_read(
+        conn, args, skill=SKILL, command="appt-suggest-slots", table_name="store_appointments",
+        duration_ms=int((time.perf_counter() - t0) * 1000),
+    )
+    emit_ok({"slots": slots, "count": len(slots)})
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(description="Store appointment CLI")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    s = sub.add_parser("appt-create")
+    s.add_argument("--member-id", required=True)
+    s.add_argument("--service", "--project", dest="service", required=True)
+    s.add_argument("--technician-id", required=True)
+    s.add_argument("--datetime", required=True)
+    s.add_argument("--duration", type=int)
+    s.add_argument("--appt-id")
+    s.add_argument("--remark", default="")
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_create)
+
+    s = sub.add_parser("appt-query")
+    s.add_argument("--appt-id")
+    s.add_argument("--member-id")
+    s.add_argument("--date")
+    s.add_argument("--date-from")
+    s.add_argument("--date-to")
+    s.add_argument("--technician-id")
+    s.add_argument("--status")
+    s.add_argument("--limit", type=int)
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_query)
+
+    s = sub.add_parser("appt-update")
+    s.add_argument("--appt-id", required=True)
+    s.add_argument("--datetime")
+    s.add_argument("--technician-id")
+    s.add_argument("--service")
+    s.add_argument("--duration", type=int)
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_update)
+
+    s = sub.add_parser("appt-cancel")
+    s.add_argument("--appt-id", required=True)
+    s.add_argument("--yes", action="store_true")
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_cancel)
+
+    s = sub.add_parser("appt-complete")
+    s.add_argument("--appt-id", required=True)
+    s.add_argument("--pay", default="stored_value", choices=list(PAY_MODES))
+    s.add_argument("--lines-json")
+    s.add_argument("--staff-lines-json")
+    s.add_argument("--card-name")
+    s.add_argument("--cash-amount", type=float)
+    s.add_argument("--yes", action="store_true")
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_complete)
+
+    s = sub.add_parser("tech-recommend")
+    s.add_argument("--service", "--project", dest="service", required=True)
+    s.add_argument("--datetime", required=True)
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_tech_recommend)
+
+    s = sub.add_parser("tech-auto-assign")
+    s.add_argument("--service", "--project", dest="service", required=True)
+    s.add_argument("--datetime", required=True)
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_tech_auto_assign)
+
+    s = sub.add_parser("appt-suggest-slots")
+    s.add_argument("--service", "--project", dest="service", required=True)
+    s.add_argument("--date", required=True, help="YYYY-MM-DD")
+    s.add_argument("--technician-id")
+    s.add_argument("--limit", type=int, default=5)
+    s.add_argument("--session-id")
+    s.set_defaults(func=cmd_appt_suggest_slots)
+
+    return p
+
+
+def main() -> int:
+    args = build_parser().parse_args()
+    try:
+        return int(args.func(args))
+    except SettlementError as e:
+        emit_error(e.code, e.detail if e.detail else None)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/store-appointment/src/store_appointment_lib/helpers.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Tuple
+
+from store_settlement.catalog import query_service_price_and_duration  # noqa: F401
+from store_settlement.errors import SettlementError  # noqa: F401
+
+DT_FMT = "%Y-%m-%d %H:%M"
+DATE_FMT = "%Y-%m-%d"
+
+
+def parse_dt(s: str) -> datetime:
+    return datetime.strptime(s.strip(), DT_FMT)
+
+
+def staff_schedule_query(conn: sqlite3.Connection, staff_id: str, date_yyyy_mm_dd: str) -> Dict[str, Any]:
+    row = conn.execute(
+        "SELECT status, slots_json FROM staff_schedules WHERE staff_id=? AND date=?",
+        (staff_id, date_yyyy_mm_dd),
+    ).fetchone()
+    if not row:
+        return {"status": "work", "slots": None}
+    try:
+        slots = json.loads(row["slots_json"] or "null")
+    except json.JSONDecodeError:
+        slots = None
+    return {"status": row["status"], "slots": slots}
+
+
+def staff_list_for_skill(conn: sqlite3.Connection, skill_keyword: str) -> List[Dict[str, Any]]:
+    needle = skill_keyword or ""
+    out: List[Dict[str, Any]] = []
+    for r in conn.execute("SELECT * FROM staff_staff WHERE status='active' ORDER BY id").fetchall():
+        d = dict(r)
+        try:
+            fj = json.loads(d.get("fields_json") or "{}")
+        except json.JSONDecodeError:
+            fj = {}
+        blob = json.dumps(fj, ensure_ascii=False)
+        if needle in blob or needle in (d.get("name") or ""):
+            d["fields"] = fj
+            out.append(d)
+    return out
+
+
+def within_slots(start_dt: str, slots: Optional[List]) -> bool:
+    if not slots:
+        return True
+    t = start_dt.split()[1][:5]
+    for slot in slots:
+        if "-" not in slot:
+            continue
+        a, b = slot.split("-", 1)
+        a, b = a.strip()[:5], b.strip()[:5]
+        if a <= t <= b:
+            return True
+    return False
+
+
+def appt_interval(
+    conn: sqlite3.Connection,
+    technician_id: str,
+    start_dt: str,
+    duration_min: int,
+    exclude_appt_id: Optional[str] = None,
+) -> Optional[str]:
+    s = parse_dt(start_dt)
+    e = s + timedelta(minutes=duration_min)
+    q = """SELECT id, start_dt, duration_min FROM store_appointments
+           WHERE technician_id=? AND status='scheduled'"""
+    params: List[Any] = [technician_id]
+    if exclude_appt_id:
+        q += " AND id!=?"
+        params.append(exclude_appt_id)
+    for row in conn.execute(q, params):
+        os = parse_dt(row["start_dt"])
+        oe = os + timedelta(minutes=int(row["duration_min"]))
+        if s < oe and os < e:
+            return str(row["id"])
+    return None
+
+
+def validate_appt_create(
+    conn: sqlite3.Connection,
+    *,
+    technician_id: str,
+    datetime_str: str,
+    duration_min: int,
+    exclude_appt_id: Optional[str] = None,
+) -> Tuple[bool, str]:
+    date_part = datetime_str[:10]
+    sch = staff_schedule_query(conn, technician_id, date_part)
+    if sch.get("status") == "off":
+        return False, "technician_off"
+    if not within_slots(datetime_str, sch.get("slots")):
+        return False, "outside_work_slots"
+    clash = appt_interval(
+        conn, technician_id, datetime_str, duration_min, exclude_appt_id=exclude_appt_id
+    )
+    if clash:
+        return False, f"schedule_conflict:{clash}"
+    return True, ""
+
+
+def _slot_datetimes(date_yyyy_mm_dd: str, slots: Optional[List], duration_min: int) -> List[str]:
+    out: List[str] = []
+    if not slots:
+        for hour in range(9, 19):
+            for minute in (0, 30):
+                out.append(f"{date_yyyy_mm_dd} {hour:02d}:{minute:02d}")
+        return out
+    for slot in slots:
+        if "-" not in slot:
+            continue
+        a, b = slot.split("-", 1)
+        a, b = a.strip()[:5], b.strip()[:5]
+        cur = datetime.strptime(f"{date_yyyy_mm_dd} {a}", DT_FMT)
+        end = datetime.strptime(f"{date_yyyy_mm_dd} {b}", DT_FMT)
+        step = timedelta(minutes=30)
+        while cur + timedelta(minutes=duration_min) <= end:
+            out.append(cur.strftime(DT_FMT))
+            cur += step
+    return out
+
+
+def suggest_available_slots(
+    conn: sqlite3.Connection,
+    *,
+    service: str,
+    date_yyyy_mm_dd: str,
+    technician_id: Optional[str] = None,
+    limit: int = 5,
+) -> List[Dict[str, Any]]:
+    _, dur = query_service_price_and_duration(conn, service)
+    duration_min = int(dur or 60)
+    if technician_id:
+        staff_ids = [technician_id]
+    else:
+        staff_ids = [s["id"] for s in staff_list_for_skill(conn, service)]
+    suggestions: List[Dict[str, Any]] = []
+    for sid in staff_ids:
+        sch = staff_schedule_query(conn, sid, date_yyyy_mm_dd)
+        if sch.get("status") == "off":
+            continue
+        name_row = conn.execute("SELECT name FROM staff_staff WHERE id=?", (sid,)).fetchone()
+        staff_name = name_row["name"] if name_row else sid
+        for dt in _slot_datetimes(date_yyyy_mm_dd, sch.get("slots"), duration_min):
+            if not within_slots(dt, sch.get("slots")):
+                continue
+            if appt_interval(conn, sid, dt, duration_min):
+                continue
+            suggestions.append(
+                {"datetime": dt, "technician_id": sid, "technician_name": staff_name, "service": service}
+            )
+            if len(suggestions) >= limit:
+                return suggestions
+    return suggestions