기능 추가 및 버그 수정 — 처리시간 지표, 대시보드 차트, UI 개선

## 처리시간 지표
- 업무시간 기준(09-18 평일) / 공휴일 제외 24h / 달력 기준 3가지 모드 선택
- 공휴일 DB 관리 (holidays 테이블, 수동 등록·삭제·일괄 추가)
- 2026년 공휴일 등록 지원
- 설정 페이지에서 라디오 버튼으로 모드 선택

## 대시보드 차트
- 월별 평균 처리시간 막대 차트 추가
- 월별 신고 접수 건수 누적 막대 차트 추가
- 월별 → 일별 드릴다운 (막대 클릭 시 해당 월의 일별 차트로 전환)
- 일별 막대 클릭 시 처리 완료/신고 접수 상세 내역 모달
- 충전기별 누적 고장 건수 Top 10 수평 막대 차트 추가

## 신고 목록
- # 컬럼을 DB PK 대신 현재 목록 순서(1, 2, 3…)로 표시
- 엑셀 export 접수번호도 순차번호로 변경

## 모바일 네비게이션 버그 수정
- 모바일에서 가로 오버플로우 시 nav가 body 넓이로 늘어나
  햄버거 버튼이 화면 밖으로 밀리는 문제 수정
- nav를 position:fixed + body padding-top:54px 로 변경 (전체 페이지 적용)
- 충전기 관리·신고 목록 페이지 지도 컨테이너에 isolation:isolate 적용

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
byun
2026-05-31 06:52:56 +09:00
parent 05b478372a
commit 2e8751ea6c
35 changed files with 5541 additions and 353 deletions

View File

@@ -1,9 +1,13 @@
from fastapi import FastAPI
from fastapi import FastAPI, HTTPException
from fastapi.middleware.cors import CORSMiddleware
from fastapi.staticfiles import StaticFiles
from datetime import datetime, timedelta
from collections import defaultdict
import calendar as cal_module
import os
from routers import auth_router, chargers, reports, repairs, costs, improvements, accounts, settings, export
from routers import auth_router, chargers, reports, repairs, costs, improvements, accounts, settings, export, manufacturers
from routers import holidays
app = FastAPI(title="EV 충전기 AS 관리 시스템", version="1.0.0")
@@ -25,6 +29,49 @@ app.include_router(improvements.router)
app.include_router(accounts.router)
app.include_router(settings.router)
app.include_router(export.router)
app.include_router(manufacturers.router)
app.include_router(holidays.router)
def _calc_business_hours(start: datetime, end: datetime, holiday_dates: set,
work_start: int = 9, work_end: int = 18) -> float:
"""업무시간(평일 09:00-18:00, 공휴일 제외) 기준 경과 시간 계산."""
if not start or not end or end <= start:
return 0.0
s = start.replace(tzinfo=None)
e = end.replace(tzinfo=None)
total = 0.0
cur_date = s.date()
end_date = e.date()
while cur_date <= end_date:
if cur_date.weekday() < 5 and cur_date not in holiday_dates:
day_ws = datetime(cur_date.year, cur_date.month, cur_date.day, work_start)
day_we = datetime(cur_date.year, cur_date.month, cur_date.day, work_end)
seg_start = max(s, day_ws)
seg_end = min(e, day_we)
if seg_end > seg_start:
total += (seg_end - seg_start).total_seconds() / 3600
cur_date += timedelta(days=1)
return round(total, 1)
def _calc_holiday_excluded_hours(start: datetime, end: datetime, holiday_dates: set) -> float:
"""공휴일을 제외하고 나머지 날(주말 포함)은 24시간 전체 카운트."""
if not start or not end or end <= start:
return 0.0
s = start.replace(tzinfo=None)
e = end.replace(tzinfo=None)
total = 0.0
cur_date = s.date()
end_date = e.date()
while cur_date <= end_date:
if cur_date not in holiday_dates:
day_s = datetime(cur_date.year, cur_date.month, cur_date.day)
day_e = day_s + timedelta(days=1)
seg_start = max(s, day_s)
seg_end = min(e, day_e)
if seg_end > seg_start:
total += (seg_end - seg_start).total_seconds() / 3600
cur_date += timedelta(days=1)
return round(total, 1)
@app.get("/api/health")
def health():
@@ -33,8 +80,8 @@ def health():
@app.get("/api/stats")
def stats(db=None):
from database import SessionLocal
from sqlalchemy import func
from models import Report, Repair, RepairCost, Improvement
from sqlalchemy import func, text
from models import Report, Repair, RepairCost, Improvement, SystemSetting, Holiday
db = SessionLocal()
try:
total = db.query(Report).count()
@@ -44,10 +91,452 @@ def stats(db=None):
cost_pend = db.query(RepairCost).filter(RepairCost.cost_status == "pending").count()
imp_open = db.query(Improvement).filter(
Improvement.status.in_(["registered","reviewing","developing"])).count()
# ── 설정 읽기 ──
def _setting(key, default):
r = db.query(SystemSetting).filter_by(key=key).first()
return r.value if r else default
_base = _setting("time_metric_base", "occurred")
# 구버전 "true"/"false" → 신버전 mode 문자열로 정규화
_raw_mode = _setting("time_metric_worktime", "off")
if _raw_mode == "true": _raw_mode = "worktime"
elif _raw_mode == "false": _raw_mode = "off"
_mode = _raw_mode # "off" | "holiday_24h" | "worktime"
if _base == "reported":
t_join = "rep.reported_at"
t_plain = "reported_at"
else:
t_join = "COALESCE(rep.occurred_at, rep.reported_at)"
t_plain = "COALESCE(occurred_at, reported_at)"
if _mode in ("worktime", "holiday_24h"):
# ── Python 기반 계산 (공휴일 테이블 활용) ──
holiday_dates = {r.holiday_date for r in db.query(Holiday).all()}
calc_fn = _calc_business_hours if _mode == "worktime" else _calc_holiday_excluded_hours
def _avg_py(interval_days):
rows = db.execute(text(f"""
SELECT {t_join} AS start_t, r.completed_at
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND r.completed_at >= NOW() - INTERVAL '{interval_days} days'
""")).fetchall()
h_list = [calc_fn(row[0], row[1], holiday_dates)
for row in rows if row[0] and row[1]]
return round(sum(h_list) / len(h_list), 1) if h_list else None
avg_30d = _avg_py(30)
avg_7d = _avg_py(7)
pending_rows = db.execute(text(f"""
SELECT {t_plain} AS start_t
FROM reports
WHERE status IN ('pending','pending_approval','in_progress','waiting','revisit')
AND {t_plain} IS NOT NULL
""")).fetchall()
now = datetime.now()
h_pending = [calc_fn(row[0], now, holiday_dates) for row in pending_rows if row[0]]
over_24h = sum(1 for h in h_pending if h > 24)
over_72h = sum(1 for h in h_pending if h > 72)
longest_h = max(h_pending, default=0.0)
else:
# ── 단순 경과시간 기준 계산 (SQL) ──
avg_30d = db.execute(text(f"""
SELECT ROUND(AVG(EXTRACT(EPOCH FROM (r.completed_at - {t_join}))/3600)::numeric, 1)
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND r.completed_at >= NOW() - INTERVAL '30 days'
""")).scalar()
avg_7d = db.execute(text(f"""
SELECT ROUND(AVG(EXTRACT(EPOCH FROM (r.completed_at - {t_join}))/3600)::numeric, 1)
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND r.completed_at >= NOW() - INTERVAL '7 days'
""")).scalar()
avg_30d = float(avg_30d) if avg_30d else None
avg_7d = float(avg_7d) if avg_7d else None
row = db.execute(text(f"""
SELECT
COUNT(*) FILTER (WHERE EXTRACT(EPOCH FROM (NOW()-{t_plain}))/3600 > 24) AS over_24h,
COUNT(*) FILTER (WHERE EXTRACT(EPOCH FROM (NOW()-{t_plain}))/3600 > 72) AS over_72h,
COALESCE(MAX(ROUND(EXTRACT(EPOCH FROM (NOW()-{t_plain}))/3600, 1)), 0) AS longest_h
FROM reports
WHERE status IN ('pending','pending_approval','in_progress','waiting','revisit')
""")).fetchone()
over_24h = int(row.over_24h)
over_72h = int(row.over_72h)
longest_h = float(row.longest_h)
return {
"total": total, "pending": pending,
"in_progress": in_prog, "done": done,
"cost_pending": cost_pend, "improvement_open": imp_open,
"time_metric_base": _base,
"time_metric_worktime": _mode,
"avg_resolution_hours_30d": avg_30d,
"avg_resolution_hours_7d": avg_7d,
"pending_over_24h": over_24h,
"pending_over_72h": over_72h,
"longest_pending_hours": longest_h,
}
finally:
db.close()
def _month_range(n: int = 13):
"""최근 n개월 목록 생성 (YYYY-MM 형식)."""
now = datetime.now()
result = []
for i in range(n - 1, -1, -1):
m = now.month - i
y = now.year
while m <= 0:
m += 12
y -= 1
result.append(f"{y:04d}-{m:02d}")
return result
@app.get("/api/stats/monthly")
def stats_monthly(months: int = 13):
from database import SessionLocal
from sqlalchemy import text
from models import SystemSetting, Holiday
db = SessionLocal()
try:
def _setting(key, default):
r = db.query(SystemSetting).filter_by(key=key).first()
return r.value if r else default
_base = _setting("time_metric_base", "occurred")
_raw = _setting("time_metric_worktime", "off")
if _raw == "true": _raw = "worktime"
elif _raw == "false": _raw = "off"
_mode = _raw
if _base == "reported":
t_join = "rep.reported_at"
else:
t_join = "COALESCE(rep.occurred_at, rep.reported_at)"
all_months = _month_range(months)
if _mode in ("worktime", "holiday_24h"):
holiday_dates = {r.holiday_date for r in db.query(Holiday).all()}
calc_fn = _calc_business_hours if _mode == "worktime" else _calc_holiday_excluded_hours
rows = db.execute(text(f"""
SELECT TO_CHAR(r.completed_at, 'YYYY-MM') AS month,
{t_join} AS start_t,
r.completed_at
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND r.completed_at >= NOW() - INTERVAL '{months} months'
""")).fetchall()
by_month = defaultdict(list)
for row in rows:
if row[1] and row[2]:
by_month[row[0]].append(calc_fn(row[1], row[2], holiday_dates))
data = {}
for m, vals in by_month.items():
data[m] = {"avg": round(sum(vals) / len(vals), 1), "count": len(vals)}
else:
rows = db.execute(text(f"""
SELECT TO_CHAR(r.completed_at, 'YYYY-MM') AS month,
ROUND(AVG(EXTRACT(EPOCH FROM (r.completed_at - {t_join}))/3600)::numeric, 1) AS avg_h,
COUNT(*) AS cnt
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND r.completed_at >= NOW() - INTERVAL '{months} months'
GROUP BY month
ORDER BY month
""")).fetchall()
data = {row[0]: {"avg": float(row[1]) if row[1] else None, "count": int(row[2])} for row in rows}
# ── 월별 신고 접수 건수 ──
rpt_rows = db.execute(text(f"""
SELECT TO_CHAR(reported_at, 'YYYY-MM') AS month,
COUNT(*) AS total,
COUNT(*) FILTER (WHERE status = 'done') AS done_cnt
FROM reports
WHERE reported_at >= NOW() - INTERVAL '{months} months'
GROUP BY month
ORDER BY month
""")).fetchall()
rpt_map = {row[0]: {"total": int(row[1]), "done": int(row[2])} for row in rpt_rows}
result = []
for m in all_months:
d = data.get(m)
r = rpt_map.get(m)
result.append({
"month": m,
"avg_hours": d["avg"] if d else None,
"count": d["count"] if d else 0,
"report_total": r["total"] if r else 0,
"report_done": r["done"] if r else 0,
})
return {"data": result, "time_metric_worktime": _mode, "time_metric_base": _base}
finally:
db.close()
@app.get("/api/stats/daily")
def stats_daily(month: str):
"""month: YYYY-MM. Returns day-by-day processing time and report counts."""
from database import SessionLocal
from sqlalchemy import text
from models import SystemSetting, Holiday
try:
year, mon = int(month[:4]), int(month[5:7])
except (ValueError, IndexError):
raise HTTPException(400, "month must be YYYY-MM format")
db = SessionLocal()
try:
def _setting(key, default):
r = db.query(SystemSetting).filter_by(key=key).first()
return r.value if r else default
_base = _setting("time_metric_base", "occurred")
_raw = _setting("time_metric_worktime", "off")
if _raw == "true": _raw = "worktime"
elif _raw == "false": _raw = "off"
_mode = _raw
if _base == "reported":
t_join = "rep.reported_at"
t_plain = "reported_at"
else:
t_join = "COALESCE(rep.occurred_at, rep.reported_at)"
t_plain = "COALESCE(occurred_at, reported_at)"
_, days_in_month = cal_module.monthrange(year, mon)
all_days = [f"{year:04d}-{mon:02d}-{d:02d}" for d in range(1, days_in_month + 1)]
if _mode in ("worktime", "holiday_24h"):
holiday_dates = {r.holiday_date for r in db.query(Holiday).all()}
calc_fn = _calc_business_hours if _mode == "worktime" else _calc_holiday_excluded_hours
rows = db.execute(text(f"""
SELECT TO_CHAR(r.completed_at, 'YYYY-MM-DD') AS day,
{t_join} AS start_t,
r.completed_at
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND TO_CHAR(r.completed_at, 'YYYY-MM') = :month
"""), {"month": month}).fetchall()
by_day = defaultdict(list)
for row in rows:
if row[1] and row[2]:
by_day[row[0]].append(calc_fn(row[1], row[2], holiday_dates))
data = {}
for d, vals in by_day.items():
data[d] = {"avg": round(sum(vals) / len(vals), 1), "count": len(vals)}
else:
rows = db.execute(text(f"""
SELECT TO_CHAR(r.completed_at, 'YYYY-MM-DD') AS day,
ROUND(AVG(EXTRACT(EPOCH FROM (r.completed_at - {t_join}))/3600)::numeric, 1) AS avg_h,
COUNT(*) AS cnt
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
WHERE r.completed_at IS NOT NULL
AND TO_CHAR(r.completed_at, 'YYYY-MM') = :month
GROUP BY day
ORDER BY day
"""), {"month": month}).fetchall()
data = {row[0]: {"avg": float(row[1]) if row[1] else None, "count": int(row[2])} for row in rows}
rpt_rows = db.execute(text(f"""
SELECT TO_CHAR(reported_at, 'YYYY-MM-DD') AS day,
COUNT(*) AS total,
COUNT(*) FILTER (WHERE status = 'done') AS done_cnt
FROM reports
WHERE TO_CHAR(reported_at, 'YYYY-MM') = :month
GROUP BY day
ORDER BY day
"""), {"month": month}).fetchall()
rpt_map = {row[0]: {"total": int(row[1]), "done": int(row[2])} for row in rpt_rows}
result = []
for day in all_days:
d = data.get(day)
r = rpt_map.get(day)
result.append({
"day": day,
"avg_hours": d["avg"] if d else None,
"count": d["count"] if d else 0,
"report_total": r["total"] if r else 0,
"report_done": r["done"] if r else 0,
})
return {"data": result, "time_metric_worktime": _mode, "time_metric_base": _base, "month": month}
finally:
db.close()
@app.get("/api/stats/daily/detail")
def stats_daily_detail(day: str):
"""day: YYYY-MM-DD. Returns per-repair and per-report detail for that day."""
import json as _json
from database import SessionLocal
from sqlalchemy import text
from models import SystemSetting, Holiday
try:
datetime.strptime(day, "%Y-%m-%d")
except ValueError:
raise HTTPException(400, "day must be YYYY-MM-DD format")
db = SessionLocal()
try:
def _setting(key, default):
r = db.query(SystemSetting).filter_by(key=key).first()
return r.value if r else default
_base = _setting("time_metric_base", "occurred")
_raw = _setting("time_metric_worktime", "off")
if _raw == "true": _raw = "worktime"
elif _raw == "false": _raw = "off"
_mode = _raw
if _base == "reported":
t_join = "rep.reported_at"
else:
t_join = "COALESCE(rep.occurred_at, rep.reported_at)"
if _mode in ("worktime", "holiday_24h"):
holiday_dates = {r.holiday_date for r in db.query(Holiday).all()}
calc_fn = _calc_business_hours if _mode == "worktime" else _calc_holiday_excluded_hours
# ── 처리 완료 내역 ──
repair_rows = db.execute(text(f"""
SELECT r.id AS repair_id,
rep.id AS report_id,
rep.charger_id,
c.station_name,
rep.issue_types,
{t_join} AS start_t,
r.completed_at,
u.name AS mechanic_name
FROM repairs r
JOIN repair_reports rr ON rr.repair_id = r.id
JOIN reports rep ON rep.id = rr.report_id
LEFT JOIN users u ON u.id = r.mechanic_id
LEFT JOIN chargers c ON c.id = rep.charger_id
WHERE r.completed_at IS NOT NULL
AND TO_CHAR(r.completed_at, 'YYYY-MM-DD') = :day
ORDER BY r.completed_at
"""), {"day": day}).fetchall()
repairs = []
for row in repair_rows:
start_t, completed = row[5], row[6]
if _mode in ("worktime", "holiday_24h") and start_t and completed:
h = calc_fn(start_t, completed, holiday_dates)
elif start_t and completed:
h = round((completed - start_t).total_seconds() / 3600, 1)
else:
h = None
try:
issues = _json.loads(row[4]) if row[4] else []
except Exception:
issues = []
repairs.append({
"repair_id": row[0],
"report_id": row[1],
"charger_id": row[2] or "",
"station_name": row[3] or "",
"issue_types": issues,
"start_t": start_t.isoformat() if start_t else None,
"completed_at": completed.isoformat() if completed else None,
"processing_hours": h,
"mechanic_name": row[7] or "",
})
# ── 신고 접수 내역 ──
rpt_rows = db.execute(text("""
SELECT rep.id, rep.charger_id, c.station_name,
rep.issue_types, rep.status, rep.reported_at
FROM reports rep
LEFT JOIN chargers c ON c.id = rep.charger_id
WHERE TO_CHAR(rep.reported_at, 'YYYY-MM-DD') = :day
ORDER BY rep.reported_at
"""), {"day": day}).fetchall()
reports = []
for row in rpt_rows:
try:
issues = _json.loads(row[3]) if row[3] else []
except Exception:
issues = []
reports.append({
"id": row[0],
"charger_id": row[1] or "",
"station_name": row[2] or "",
"issue_types": issues,
"status": row[4],
"reported_at": row[5].isoformat() if row[5] else None,
})
return {"day": day, "repairs": repairs, "reports": reports}
finally:
db.close()
@app.get("/api/stats/top-chargers")
def stats_top_chargers(limit: int = 10):
"""충전기별 누적 고장 신고 건수 Top N."""
from database import SessionLocal
from sqlalchemy import text
db = SessionLocal()
try:
rows = db.execute(text("""
SELECT rep.charger_id,
COALESCE(c.station_name, rep.charger_id) AS station_name,
COALESCE(c.name, '') AS charger_name,
COUNT(*) AS total,
COUNT(*) FILTER (WHERE rep.status = 'done') AS done_cnt,
COUNT(*) FILTER (WHERE rep.status != 'done') AS active_cnt
FROM reports rep
LEFT JOIN chargers c ON c.id = rep.charger_id
GROUP BY rep.charger_id, c.station_name, c.name
ORDER BY total DESC
LIMIT :lim
"""), {"lim": limit}).fetchall()
return [
{
"charger_id": row[0],
"station_name": row[1],
"charger_name": row[2],
"total": int(row[3]),
"done": int(row[4]),
"active": int(row[5]),
}
for row in rows
]
finally:
db.close()