Files
dbx-corm/routers/cs_records.py
T
king d2fdec5c43 feat: v9.1 업그레이드 — CS 기록 메뉴 + 반품 목록 검색 + 구글 연동 안정화
원본(CS 통합 프로그램 v9.1, 2026.09.03)을 서버판에 병합. 서버용 개조는 유지:
SSO(AuthGuard·SessionMiddleware), /corm 서브경로(root_path·APP_BASE_PATH),
X-Service-Token, /health/db, 환경변수 DB 설정, cafe24/naver 키 환경변수.

- CS 기록 메뉴(routers/cs_records.py, cs_records.js/css): 달력별 기록·완료·복사·
  다음 업무일 이월, 상시 메모(폴더·색), 일정, 엑셀 내려받기/업로드.
  표는 itemcode_db 에 자동 생성(CREATE TABLE IF NOT EXISTS). DB 설정은 원본의
  하드코딩 대신 CS_RECORD_DB_* → POSTGRES_*/ITEMCODE_DB 환경변수.
- New CS 누락·파손·불량·오배송 발주 → CS 기록 자동 저장.
- 반품 신청/입고 목록: 최근 3개월 기본, 전체 보기, 원송장번호 전체 검색.
- google_runtime.py: 구글 호출 시간 제한·전용 작업 슬롯, 설정 시트 스냅샷 캐시
  (예전 10분 인메모리 캐시와 /api/config/refresh 대체), 설정 저장 한 번에 원자적으로.
- 밀크런: 탭을 열 때만 구글 시트 조회.
- 자동발주 메뉴는 원본처럼 막지 않고 그대로 둠, 엑셀 내려받기 링크도 /corm 경로.
- requirements: holidays 추가. tests/test_google_resilience.py(서비스 토큰으로 SSO 통과).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 16:07:53 +09:00

1439 lines
55 KiB
Python

import datetime
import io
import os
import threading
from functools import lru_cache
from typing import List, Optional
import pandas as pd
import psycopg2
import psycopg2.extras
from fastapi import APIRouter, File, HTTPException, Query, UploadFile
from fastapi.responses import StreamingResponse
from openpyxl import Workbook
from openpyxl.styles import Alignment, Font, PatternFill
from pydantic import BaseModel
try:
import holidays as holidays_library
except ImportError: # 로컬 의존성 설치 전에도 주말 계산은 동작하도록 한다.
holidays_library = None
router = APIRouter(prefix="/api/cs-records", tags=["CS 기록"])
DB_CONFIG = {
# 서버(dbx-corm): CS 기록 표는 itemcode_db 에 둔다. CS_RECORD_DB_* 로 따로 지정 가능, 없으면 POSTGRES_* 공통 값.
"host": os.getenv("CS_RECORD_DB_HOST", os.getenv("POSTGRES_HOST", "postgres-db")),
"port": int(os.getenv("CS_RECORD_DB_PORT", os.getenv("POSTGRES_PORT", "5432"))),
"dbname": os.getenv("CS_RECORD_DB_NAME", os.getenv("ITEMCODE_DB", "itemcode_db")),
"user": os.getenv("CS_RECORD_DB_USER", os.getenv("POSTGRES_USER", "king")),
"password": os.getenv("CS_RECORD_DB_PASSWORD", os.getenv("POSTGRES_PASSWORD", "")),
}
_schema_ready = False
_schema_lock = threading.Lock()
MEMO_FOLDER_COLORS = {
"#FDE68A", # 노랑
"#FDA4AF", # 분홍
"#FDBA74", # 주황
"#86EFAC", # 초록
"#93C5FD", # 파랑
"#C4B5FD", # 보라
"#CBD5E1", # 회색
}
DEFAULT_MEMO_FOLDER_COLOR = "#FDE68A"
class CSRecordCreate(BaseModel):
record_date: datetime.date
content: str
class CSRecordUpdate(BaseModel):
content: Optional[str] = None
is_completed: Optional[bool] = None
class CSCopyRequest(BaseModel):
record_date: datetime.date
class PermanentMemoCreate(BaseModel):
content: str
folder_id: Optional[int] = None
class PermanentMemoUpdate(BaseModel):
content: Optional[str] = None
folder_id: Optional[int] = None
class MemoFolderCreate(BaseModel):
name: str
color: str = DEFAULT_MEMO_FOLDER_COLOR
class MemoFolderUpdate(BaseModel):
name: Optional[str] = None
color: Optional[str] = None
class CSScheduleCreate(BaseModel):
schedule_date: datetime.date
end_date: Optional[datetime.date] = None
title: str
start_time: Optional[datetime.time] = None
end_time: Optional[datetime.time] = None
class CSScheduleUpdate(BaseModel):
schedule_date: Optional[datetime.date] = None
end_date: Optional[datetime.date] = None
title: Optional[str] = None
start_time: Optional[datetime.time] = None
end_time: Optional[datetime.time] = None
def _connect():
return psycopg2.connect(
**DB_CONFIG,
cursor_factory=psycopg2.extras.RealDictCursor,
)
def _ensure_schema():
global _schema_ready
if _schema_ready:
return
with _schema_lock:
if _schema_ready:
return
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
CREATE TABLE IF NOT EXISTS cs_records (
id BIGSERIAL PRIMARY KEY,
record_date DATE NOT NULL,
content TEXT NOT NULL,
is_completed BOOLEAN NOT NULL DEFAULT FALSE,
source VARCHAR(30) NOT NULL DEFAULT 'manual',
source_key VARCHAR(255),
copied_from_id BIGINT REFERENCES cs_records(id) ON DELETE SET NULL,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)
"""
)
cur.execute(
"CREATE INDEX IF NOT EXISTS idx_cs_records_date ON cs_records(record_date, id)"
)
cur.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS ux_cs_records_source_key
ON cs_records(source_key) WHERE source_key IS NOT NULL
"""
)
cur.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS ux_cs_records_copied_item
ON cs_records(record_date, copied_from_id)
WHERE copied_from_id IS NOT NULL
"""
)
cur.execute(
"""
CREATE TABLE IF NOT EXISTS cs_memo_folders (
id BIGSERIAL PRIMARY KEY,
name VARCHAR(80) NOT NULL UNIQUE,
color VARCHAR(20) NOT NULL DEFAULT '#FDE68A',
is_default BOOLEAN NOT NULL DEFAULT FALSE,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)
"""
)
cur.execute(
"ALTER TABLE cs_memo_folders ADD COLUMN IF NOT EXISTS color VARCHAR(20) NOT NULL DEFAULT '#FDE68A'"
)
cur.execute(
"""
INSERT INTO cs_memo_folders (name, is_default)
VALUES ('기본', TRUE)
ON CONFLICT (name) DO UPDATE SET is_default = TRUE
"""
)
cur.execute(
"""
CREATE UNIQUE INDEX IF NOT EXISTS ux_cs_memo_folders_default
ON cs_memo_folders(is_default) WHERE is_default = TRUE
"""
)
cur.execute(
"""
CREATE TABLE IF NOT EXISTS cs_permanent_memos (
id BIGSERIAL PRIMARY KEY,
content TEXT NOT NULL,
folder_id BIGINT REFERENCES cs_memo_folders(id) ON DELETE RESTRICT,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)
"""
)
cur.execute(
"""
ALTER TABLE cs_permanent_memos
ADD COLUMN IF NOT EXISTS folder_id BIGINT REFERENCES cs_memo_folders(id) ON DELETE RESTRICT
"""
)
cur.execute(
"""
UPDATE cs_permanent_memos
SET folder_id = (SELECT id FROM cs_memo_folders WHERE is_default = TRUE LIMIT 1)
WHERE folder_id IS NULL
"""
)
cur.execute("ALTER TABLE cs_permanent_memos ALTER COLUMN folder_id SET NOT NULL")
cur.execute(
"CREATE INDEX IF NOT EXISTS idx_cs_permanent_memos_folder ON cs_permanent_memos(folder_id, id)"
)
cur.execute(
"""
CREATE TABLE IF NOT EXISTS cs_schedules (
id BIGSERIAL PRIMARY KEY,
schedule_date DATE NOT NULL,
end_date DATE NOT NULL,
title VARCHAR(300) NOT NULL,
start_time TIME,
end_time TIME,
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
)
"""
)
cur.execute("ALTER TABLE cs_schedules ADD COLUMN IF NOT EXISTS end_date DATE")
cur.execute("ALTER TABLE cs_schedules ADD COLUMN IF NOT EXISTS end_time TIME")
cur.execute("UPDATE cs_schedules SET end_date = schedule_date WHERE end_date IS NULL")
cur.execute("ALTER TABLE cs_schedules ALTER COLUMN end_date SET NOT NULL")
cur.execute(
"""
DO $$
BEGIN
IF NOT EXISTS (
SELECT 1 FROM pg_constraint
WHERE conname = 'ck_cs_schedules_date_range'
AND conrelid = 'cs_schedules'::regclass
) THEN
ALTER TABLE cs_schedules
ADD CONSTRAINT ck_cs_schedules_date_range CHECK (end_date >= schedule_date);
END IF;
END
$$
"""
)
cur.execute(
"CREATE INDEX IF NOT EXISTS idx_cs_schedules_date ON cs_schedules(schedule_date, start_time, id)"
)
conn.commit()
_schema_ready = True
finally:
conn.close()
def _service_unavailable(exc: Exception):
print(f"CS 기록 DB 연결 실패: {exc}")
raise HTTPException(
status_code=503,
detail="CS 기록 데이터베이스에 연결할 수 없습니다. 서버 배포 상태 또는 DB 연결 설정을 확인해주세요.",
)
def _clean_content(content: str) -> str:
content = (content or "").strip()
if not content:
raise HTTPException(status_code=400, detail="기록할 내용을 입력해주세요.")
if len(content) > 10000:
raise HTTPException(status_code=400, detail="한 기록은 10,000자까지 입력할 수 있습니다.")
return content
def _clean_folder_name(name: str) -> str:
name = (name or "").strip()
if not name:
raise HTTPException(status_code=400, detail="폴더 이름을 입력해주세요.")
if len(name) > 80:
raise HTTPException(status_code=400, detail="폴더 이름은 80자까지 입력할 수 있습니다.")
return name
def _clean_folder_color(color: str) -> str:
color = (color or "").strip().upper()
if color not in MEMO_FOLDER_COLORS:
raise HTTPException(status_code=400, detail="선택할 수 없는 폴더 색상입니다.")
return color
def _clean_schedule_title(title: str) -> str:
title = (title or "").strip()
if not title:
raise HTTPException(status_code=400, detail="일정 내용을 입력해주세요.")
if len(title) > 300:
raise HTTPException(status_code=400, detail="일정 내용은 300자까지 입력할 수 있습니다.")
return title
def _schedule_date_range(
schedule_date: datetime.date,
end_date: Optional[datetime.date],
):
normalized_end = end_date or schedule_date
if normalized_end < schedule_date:
raise HTTPException(status_code=400, detail="종료일은 시작일보다 빠를 수 없습니다.")
if (normalized_end - schedule_date).days > 366:
raise HTTPException(status_code=400, detail="일정 기간은 최대 1년까지 등록할 수 있습니다.")
return schedule_date, normalized_end
def _validate_schedule_times(
schedule_date: datetime.date,
end_date: datetime.date,
start_time: Optional[datetime.time],
end_time: Optional[datetime.time],
):
if schedule_date == end_date and start_time is not None and end_time is not None and end_time < start_time:
raise HTTPException(status_code=400, detail="같은 날짜의 종료 시간은 시작 시간보다 빠를 수 없습니다.")
def _serialize_record(row):
result = dict(row)
for key in ("record_date", "created_at", "updated_at"):
value = result.get(key)
if value is not None:
result[key] = value.isoformat()
return result
def _serialize_permanent_memo(row):
result = dict(row)
for key in ("created_at", "updated_at"):
value = result.get(key)
if value is not None:
result[key] = value.isoformat()
return result
def _serialize_schedule(row):
result = dict(row)
for key in ("schedule_date", "end_date"):
if result.get(key) is not None:
result[key] = result[key].isoformat()
for key in ("start_time", "end_time"):
if result.get(key) is not None:
result[key] = result[key].isoformat(timespec="minutes")
for key in ("created_at", "updated_at"):
value = result.get(key)
if value is not None:
result[key] = value.isoformat()
return result
@lru_cache(maxsize=16)
def _korean_holidays(year: int):
if holidays_library is None:
return frozenset()
return frozenset(holidays_library.country_holidays("KR", years=[year]).keys())
@lru_cache(maxsize=16)
def _korean_holiday_details(year: int):
if year < 2026 or year > 2030:
return tuple()
details = {}
if holidays_library is not None:
details.update(holidays_library.country_holidays("KR", years=[year], language="ko"))
# 제헌절은 국경일이므로 사용 중인 holidays 버전과 관계없이 표시한다.
details.setdefault(datetime.date(year, 7, 17), "제헌절")
return tuple(sorted(details.items()))
def _extra_holidays():
values = os.getenv("CS_RECORD_EXTRA_HOLIDAYS", "")
parsed = set()
for value in values.split(","):
value = value.strip()
if not value:
continue
try:
parsed.add(datetime.date.fromisoformat(value))
except ValueError:
continue
return parsed
def next_business_date(record_date: datetime.date) -> datetime.date:
candidate = record_date + datetime.timedelta(days=1)
extra = _extra_holidays()
for _ in range(370):
if (
candidate.weekday() < 5
and candidate not in _korean_holidays(candidate.year)
and candidate not in extra
):
return candidate
candidate += datetime.timedelta(days=1)
raise RuntimeError("다음 영업일을 계산하지 못했습니다.")
@router.get("/holidays")
def holiday_calendar(year: int = Query(..., ge=2026, le=2030)):
holidays = [
{"date": holiday_date.isoformat(), "name": name}
for holiday_date, name in _korean_holiday_details(year)
]
return {"status": "success", "year": year, "holidays": holidays}
@router.get("/memo-folders")
def list_memo_folders():
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT f.id, f.name, f.color, f.is_default, COUNT(m.id) AS memo_count
FROM cs_memo_folders f
LEFT JOIN cs_permanent_memos m ON m.folder_id = f.id
GROUP BY f.id, f.name, f.color, f.is_default, f.created_at
ORDER BY f.is_default DESC, f.created_at, f.id
"""
)
folders = [
{
"id": row["id"],
"name": row["name"],
"color": row["color"],
"is_default": row["is_default"],
"memo_count": int(row["memo_count"]),
}
for row in cur.fetchall()
]
return {"status": "success", "folders": folders}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.post("/memo-folders")
def create_memo_folder(payload: MemoFolderCreate):
name = _clean_folder_name(payload.name)
color = _clean_folder_color(payload.color)
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO cs_memo_folders (name, color)
VALUES (%s, %s)
RETURNING id, name, color, is_default
""",
(name, color),
)
row = cur.fetchone()
conn.commit()
return {
"status": "success",
"folder": {**dict(row), "memo_count": 0},
}
except psycopg2.IntegrityError:
conn.rollback()
raise HTTPException(status_code=409, detail="같은 이름의 메모 폴더가 이미 있습니다.")
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.patch("/memo-folders/{folder_id}")
def update_memo_folder(folder_id: int, payload: MemoFolderUpdate):
if payload.name is None and payload.color is None:
raise HTTPException(status_code=400, detail="변경할 폴더 설정이 없습니다.")
name = _clean_folder_name(payload.name) if payload.name is not None else None
color = _clean_folder_color(payload.color) if payload.color is not None else None
try:
_ensure_schema()
conn = _connect()
try:
updates = []
values = []
if name is not None:
updates.append("name = %s")
values.append(name)
if color is not None:
updates.append("color = %s")
values.append(color)
values.append(folder_id)
with conn.cursor() as cur:
cur.execute(
f"""
UPDATE cs_memo_folders
SET {', '.join(updates)}
WHERE id = %s
RETURNING id, name, color, is_default
""",
values,
)
row = cur.fetchone()
if row is None:
raise HTTPException(status_code=404, detail="메모 폴더를 찾을 수 없습니다.")
conn.commit()
return {"status": "success", "folder": {**dict(row), "memo_count": 0}}
except psycopg2.IntegrityError:
conn.rollback()
raise HTTPException(status_code=409, detail="같은 이름의 메모 폴더가 이미 있습니다.")
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.delete("/memo-folders/{folder_id}")
def delete_memo_folder(folder_id: int):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"SELECT id, name, is_default FROM cs_memo_folders WHERE id = %s",
(folder_id,),
)
folder = cur.fetchone()
if folder is None:
raise HTTPException(status_code=404, detail="메모 폴더를 찾을 수 없습니다.")
if folder["is_default"]:
raise HTTPException(status_code=400, detail="기본 폴더는 삭제할 수 없습니다.")
cur.execute("SELECT id FROM cs_memo_folders WHERE is_default = TRUE LIMIT 1")
default_folder = cur.fetchone()
cur.execute(
"UPDATE cs_permanent_memos SET folder_id = %s, updated_at = NOW() WHERE folder_id = %s",
(default_folder["id"], folder_id),
)
moved_count = cur.rowcount
cur.execute("DELETE FROM cs_memo_folders WHERE id = %s", (folder_id,))
conn.commit()
return {
"status": "success",
"deleted_folder": folder["name"],
"moved_count": moved_count,
"default_folder_id": default_folder["id"],
}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.get("/permanent")
def list_permanent_memos(folder_id: Optional[int] = Query(None)):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
if folder_id is None:
cur.execute(
"""
SELECT m.id, m.content, m.folder_id, f.name AS folder_name,
m.created_at, m.updated_at
FROM cs_permanent_memos m
JOIN cs_memo_folders f ON f.id = m.folder_id
ORDER BY m.id
"""
)
else:
cur.execute(
"""
SELECT m.id, m.content, m.folder_id, f.name AS folder_name,
m.created_at, m.updated_at
FROM cs_permanent_memos m
JOIN cs_memo_folders f ON f.id = m.folder_id
WHERE m.folder_id = %s
ORDER BY m.id
""",
(folder_id,),
)
memos = [_serialize_permanent_memo(row) for row in cur.fetchall()]
return {"status": "success", "memos": memos}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.post("/permanent")
def create_permanent_memo(payload: PermanentMemoCreate):
content = _clean_content(payload.content)
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
folder_id = payload.folder_id
if folder_id is None:
cur.execute("SELECT id FROM cs_memo_folders WHERE is_default = TRUE LIMIT 1")
folder_id = cur.fetchone()["id"]
else:
cur.execute("SELECT id FROM cs_memo_folders WHERE id = %s", (folder_id,))
if cur.fetchone() is None:
raise HTTPException(status_code=404, detail="메모 폴더를 찾을 수 없습니다.")
cur.execute(
"""
INSERT INTO cs_permanent_memos (content, folder_id)
VALUES (%s, %s)
RETURNING id, content, folder_id, created_at, updated_at
""",
(content, folder_id),
)
memo = _serialize_permanent_memo(cur.fetchone())
conn.commit()
return {"status": "success", "memo": memo}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.patch("/permanent/{memo_id}")
def update_permanent_memo(memo_id: int, payload: PermanentMemoUpdate):
if payload.content is None and payload.folder_id is None:
raise HTTPException(status_code=400, detail="변경할 내용이 없습니다.")
content = _clean_content(payload.content) if payload.content is not None else None
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
updates = []
values = []
if content is not None:
updates.append("content = %s")
values.append(content)
if payload.folder_id is not None:
cur.execute("SELECT id FROM cs_memo_folders WHERE id = %s", (payload.folder_id,))
if cur.fetchone() is None:
raise HTTPException(status_code=404, detail="메모 폴더를 찾을 수 없습니다.")
updates.append("folder_id = %s")
values.append(payload.folder_id)
updates.append("updated_at = NOW()")
values.append(memo_id)
cur.execute(
f"""
UPDATE cs_permanent_memos
SET {', '.join(updates)}
WHERE id = %s
RETURNING id, content, folder_id, created_at, updated_at
""",
values,
)
row = cur.fetchone()
if row is None:
raise HTTPException(status_code=404, detail="상시 메모를 찾을 수 없습니다.")
memo = _serialize_permanent_memo(row)
conn.commit()
return {"status": "success", "memo": memo}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.delete("/permanent/{memo_id}")
def delete_permanent_memo(memo_id: int):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute("DELETE FROM cs_permanent_memos WHERE id = %s RETURNING id", (memo_id,))
if cur.fetchone() is None:
raise HTTPException(status_code=404, detail="상시 메모를 찾을 수 없습니다.")
conn.commit()
return {"status": "success"}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.get("/schedules")
def list_schedules(
year: int = Query(..., ge=2000, le=2100),
month: int = Query(..., ge=1, le=12),
):
try:
_ensure_schema()
start = datetime.date(year, month, 1)
end = datetime.date(year + (month == 12), 1 if month == 12 else month + 1, 1)
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT id, schedule_date, end_date, title, start_time, end_time, created_at, updated_at
FROM cs_schedules
WHERE schedule_date < %s AND end_date >= %s
ORDER BY schedule_date, start_time NULLS FIRST, id
""",
(end, start),
)
schedules = [_serialize_schedule(row) for row in cur.fetchall()]
return {"status": "success", "year": year, "month": month, "schedules": schedules}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.post("/schedules")
def create_schedule(payload: CSScheduleCreate):
title = _clean_schedule_title(payload.title)
schedule_date, end_date = _schedule_date_range(payload.schedule_date, payload.end_date)
_validate_schedule_times(schedule_date, end_date, payload.start_time, payload.end_time)
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO cs_schedules (schedule_date, end_date, title, start_time, end_time)
VALUES (%s, %s, %s, %s, %s)
RETURNING id, schedule_date, end_date, title, start_time, end_time, created_at, updated_at
""",
(schedule_date, end_date, title, payload.start_time, payload.end_time),
)
schedule = _serialize_schedule(cur.fetchone())
conn.commit()
return {"status": "success", "schedule": schedule}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.patch("/schedules/{schedule_id}")
def update_schedule(schedule_id: int, payload: CSScheduleUpdate):
fields_set = getattr(payload, "model_fields_set", getattr(payload, "__fields_set__", set()))
if not fields_set:
raise HTTPException(status_code=400, detail="변경할 일정 내용이 없습니다.")
updates = []
values = []
if "schedule_date" in fields_set:
if payload.schedule_date is None:
raise HTTPException(status_code=400, detail="일정 날짜를 입력해주세요.")
updates.append("schedule_date = %s")
values.append(payload.schedule_date)
if "end_date" in fields_set:
if payload.end_date is None:
raise HTTPException(status_code=400, detail="일정 종료일을 입력해주세요.")
updates.append("end_date = %s")
values.append(payload.end_date)
if "title" in fields_set:
updates.append("title = %s")
values.append(_clean_schedule_title(payload.title or ""))
if "start_time" in fields_set:
updates.append("start_time = %s")
values.append(payload.start_time)
if "end_time" in fields_set:
updates.append("end_time = %s")
values.append(payload.end_time)
updates.append("updated_at = NOW()")
values.append(schedule_id)
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"SELECT schedule_date, end_date, start_time, end_time FROM cs_schedules WHERE id = %s",
(schedule_id,),
)
current = cur.fetchone()
if current is None:
raise HTTPException(status_code=404, detail="일정을 찾을 수 없습니다.")
candidate_start = payload.schedule_date if "schedule_date" in fields_set else current["schedule_date"]
candidate_end = payload.end_date if "end_date" in fields_set else current["end_date"]
_schedule_date_range(candidate_start, candidate_end)
candidate_start_time = payload.start_time if "start_time" in fields_set else current["start_time"]
candidate_end_time = payload.end_time if "end_time" in fields_set else current["end_time"]
_validate_schedule_times(candidate_start, candidate_end, candidate_start_time, candidate_end_time)
cur.execute(
f"""
UPDATE cs_schedules SET {', '.join(updates)}
WHERE id = %s
RETURNING id, schedule_date, end_date, title, start_time, end_time, created_at, updated_at
""",
values,
)
row = cur.fetchone()
if row is None:
raise HTTPException(status_code=404, detail="일정을 찾을 수 없습니다.")
schedule = _serialize_schedule(row)
conn.commit()
return {"status": "success", "schedule": schedule}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.delete("/schedules/{schedule_id}")
def delete_schedule(schedule_id: int):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute("DELETE FROM cs_schedules WHERE id = %s RETURNING id", (schedule_id,))
if cur.fetchone() is None:
raise HTTPException(status_code=404, detail="일정을 찾을 수 없습니다.")
conn.commit()
return {"status": "success"}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.get("")
def list_records(record_date: datetime.date = Query(...)):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT id, record_date, content, is_completed, source,
copied_from_id, created_at, updated_at
FROM cs_records
WHERE record_date = %s
ORDER BY id
""",
(record_date,),
)
records = [_serialize_record(row) for row in cur.fetchall()]
return {"status": "success", "record_date": record_date.isoformat(), "records": records}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.get("/month")
def month_summary(year: int = Query(..., ge=2000, le=2100), month: int = Query(..., ge=1, le=12)):
try:
_ensure_schema()
start = datetime.date(year, month, 1)
end = datetime.date(year + (month == 12), 1 if month == 12 else month + 1, 1)
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT record_date,
COUNT(*) AS total_count,
COUNT(*) FILTER (WHERE is_completed) AS completed_count
FROM cs_records
WHERE record_date >= %s AND record_date < %s
GROUP BY record_date
ORDER BY record_date
""",
(start, end),
)
days = [
{
"record_date": row["record_date"].isoformat(),
"total_count": int(row["total_count"]),
"completed_count": int(row["completed_count"]),
}
for row in cur.fetchall()
]
return {"status": "success", "year": year, "month": month, "days": days}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.post("")
def create_record(payload: CSRecordCreate):
content = _clean_content(payload.content)
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO cs_records (record_date, content)
VALUES (%s, %s)
RETURNING id, record_date, content, is_completed, source,
copied_from_id, created_at, updated_at
""",
(payload.record_date, content),
)
record = _serialize_record(cur.fetchone())
conn.commit()
return {"status": "success", "record": record}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.patch("/{record_id}")
def update_record(record_id: int, payload: CSRecordUpdate):
if payload.content is None and payload.is_completed is None:
raise HTTPException(status_code=400, detail="변경할 내용이 없습니다.")
content = _clean_content(payload.content) if payload.content is not None else None
try:
_ensure_schema()
conn = _connect()
try:
updates = []
values = []
if content is not None:
updates.append("content = %s")
values.append(content)
if payload.is_completed is not None:
updates.append("is_completed = %s")
values.append(payload.is_completed)
updates.append("updated_at = NOW()")
values.append(record_id)
with conn.cursor() as cur:
cur.execute(
f"""
UPDATE cs_records SET {', '.join(updates)}
WHERE id = %s
RETURNING id, record_date, content, is_completed, source,
copied_from_id, created_at, updated_at
""",
values,
)
row = cur.fetchone()
if row is None:
raise HTTPException(status_code=404, detail="기록을 찾을 수 없습니다.")
record = _serialize_record(row)
conn.commit()
return {"status": "success", "record": record}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.delete("/{record_id}")
def delete_record(record_id: int):
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute("DELETE FROM cs_records WHERE id = %s RETURNING id", (record_id,))
if cur.fetchone() is None:
raise HTTPException(status_code=404, detail="기록을 찾을 수 없습니다.")
conn.commit()
return {"status": "success"}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.post("/copy-next")
def copy_to_next_business_day(payload: CSCopyRequest):
try:
_ensure_schema()
target_date = next_business_date(payload.record_date)
conn = _connect()
copied_count = 0
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT id, content
FROM cs_records
WHERE record_date = %s AND is_completed = FALSE
ORDER BY id
""",
(payload.record_date,),
)
for row in cur.fetchall():
cur.execute(
"""
INSERT INTO cs_records
(record_date, content, is_completed, source, copied_from_id)
VALUES (%s, %s, FALSE, 'copied', %s)
ON CONFLICT DO NOTHING
RETURNING id
""",
(target_date, row["content"], row["id"]),
)
if cur.fetchone() is not None:
copied_count += 1
conn.commit()
return {
"status": "success",
"source_date": payload.record_date.isoformat(),
"target_date": target_date.isoformat(),
"copied_count": copied_count,
}
finally:
conn.close()
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
@router.get("/export")
def export_records():
try:
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
SELECT id, record_date, content, is_completed, source,
created_at, updated_at
FROM cs_records
ORDER BY record_date, id
"""
)
rows = cur.fetchall()
cur.execute(
"""
SELECT m.id, f.name AS folder_name, f.color AS folder_color,
m.content, m.created_at, m.updated_at
FROM cs_permanent_memos m
JOIN cs_memo_folders f ON f.id = m.folder_id
ORDER BY f.is_default DESC, f.created_at, m.id
"""
)
permanent_rows = cur.fetchall()
cur.execute(
"""
SELECT id, schedule_date, end_date, title, start_time, end_time, created_at, updated_at
FROM cs_schedules
ORDER BY schedule_date, start_time NULLS FIRST, id
"""
)
schedule_rows = cur.fetchall()
finally:
conn.close()
workbook = Workbook()
sheet = workbook.active
sheet.title = "CS 기록"
headers = ["ID", "날짜", "내용", "완료", "출처", "생성일", "수정일"]
sheet.append(headers)
for row in rows:
sheet.append(
[
row["id"],
row["record_date"].isoformat(),
row["content"],
"완료" if row["is_completed"] else "미완료",
row["source"],
row["created_at"].strftime("%Y-%m-%d %H:%M:%S"),
row["updated_at"].strftime("%Y-%m-%d %H:%M:%S"),
]
)
header_fill = PatternFill("solid", fgColor="2F5597")
for cell in sheet[1]:
cell.fill = header_fill
cell.font = Font(color="FFFFFF", bold=True)
cell.alignment = Alignment(horizontal="center")
sheet.freeze_panes = "A2"
sheet.auto_filter.ref = sheet.dimensions
widths = {"A": 10, "B": 14, "C": 80, "D": 12, "E": 14, "F": 22, "G": 22}
for column, width in widths.items():
sheet.column_dimensions[column].width = width
for row in sheet.iter_rows(min_row=2):
row[2].alignment = Alignment(wrap_text=True, vertical="top")
permanent_sheet = workbook.create_sheet("상시 메모")
permanent_sheet.append(["ID", "폴더", "폴더 색상", "내용", "생성일", "수정일"])
for row in permanent_rows:
permanent_sheet.append(
[
row["id"],
row["folder_name"],
row["folder_color"],
row["content"],
row["created_at"].strftime("%Y-%m-%d %H:%M:%S"),
row["updated_at"].strftime("%Y-%m-%d %H:%M:%S"),
]
)
for cell in permanent_sheet[1]:
cell.fill = header_fill
cell.font = Font(color="FFFFFF", bold=True)
cell.alignment = Alignment(horizontal="center")
permanent_sheet.freeze_panes = "A2"
permanent_sheet.auto_filter.ref = permanent_sheet.dimensions
permanent_sheet.column_dimensions["A"].width = 10
permanent_sheet.column_dimensions["B"].width = 18
permanent_sheet.column_dimensions["C"].width = 16
permanent_sheet.column_dimensions["D"].width = 80
permanent_sheet.column_dimensions["E"].width = 22
permanent_sheet.column_dimensions["F"].width = 22
for row in permanent_sheet.iter_rows(min_row=2):
row[3].alignment = Alignment(wrap_text=True, vertical="top")
schedule_sheet = workbook.create_sheet("일정")
schedule_sheet.append(["ID", "시작일", "종료일", "시작 시간", "종료 시간", "일정", "생성일", "수정일"])
for row in schedule_rows:
schedule_sheet.append(
[
row["id"],
row["schedule_date"].isoformat(),
row["end_date"].isoformat(),
row["start_time"].strftime("%H:%M") if row["start_time"] else "",
row["end_time"].strftime("%H:%M") if row["end_time"] else "",
row["title"],
row["created_at"].strftime("%Y-%m-%d %H:%M:%S"),
row["updated_at"].strftime("%Y-%m-%d %H:%M:%S"),
]
)
for cell in schedule_sheet[1]:
cell.fill = header_fill
cell.font = Font(color="FFFFFF", bold=True)
cell.alignment = Alignment(horizontal="center")
schedule_sheet.freeze_panes = "A2"
schedule_sheet.auto_filter.ref = schedule_sheet.dimensions
schedule_sheet.column_dimensions["A"].width = 10
schedule_sheet.column_dimensions["B"].width = 14
schedule_sheet.column_dimensions["C"].width = 14
schedule_sheet.column_dimensions["D"].width = 12
schedule_sheet.column_dimensions["E"].width = 12
schedule_sheet.column_dimensions["F"].width = 60
schedule_sheet.column_dimensions["G"].width = 22
schedule_sheet.column_dimensions["H"].width = 22
output = io.BytesIO()
workbook.save(output)
output.seek(0)
filename = f"cs-records-{datetime.date.today().isoformat()}.xlsx"
return StreamingResponse(
output,
media_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
)
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
def _read_import_file(filename: str, content: bytes):
suffix = os.path.splitext(filename or "")[1].lower()
if suffix in (".xlsx", ".xls"):
sheets = pd.read_excel(io.BytesIO(content), sheet_name=None)
if not sheets:
raise HTTPException(status_code=400, detail="업로드 파일에 시트가 없습니다.")
daily = sheets.get("CS 기록", next(iter(sheets.values())))
return daily, sheets.get("상시 메모"), sheets.get("일정")
if suffix == ".csv":
for encoding in ("utf-8-sig", "cp949"):
try:
return pd.read_csv(io.BytesIO(content), encoding=encoding), None, None
except UnicodeDecodeError:
continue
raise HTTPException(status_code=400, detail=".xlsx, .xls 또는 .csv 파일만 업로드할 수 있습니다.")
def _column(dataframe, *names):
normalized = {str(column).strip().lower(): column for column in dataframe.columns}
for name in names:
if name.lower() in normalized:
return normalized[name.lower()]
return None
def _completed_value(value) -> bool:
if pd.isna(value):
return False
if isinstance(value, bool):
return value
return str(value).strip().lower() in {"완료", "true", "1", "y", "yes", "done"}
@router.post("/import")
async def import_records(file: UploadFile = File(...)):
raw = await file.read()
if len(raw) > 15 * 1024 * 1024:
raise HTTPException(status_code=400, detail="업로드 파일은 15MB 이하여야 합니다.")
dataframe, permanent_dataframe, schedule_dataframe = _read_import_file(file.filename or "", raw)
date_column = _column(dataframe, "날짜", "record_date", "date")
content_column = _column(dataframe, "내용", "content", "memo")
completed_column = _column(dataframe, "완료", "is_completed", "completed")
source_column = _column(dataframe, "출처", "source")
if date_column is None or content_column is None:
raise HTTPException(status_code=400, detail="파일에 '날짜'와 '내용' 열이 필요합니다.")
prepared = []
permanent_prepared = []
schedule_prepared = []
skipped = 0
for _, row in dataframe.iterrows():
try:
parsed_date = pd.to_datetime(row[date_column], errors="raise").date()
content = str(row[content_column]).strip()
if not content or content.lower() == "nan" or len(content) > 10000:
raise ValueError
completed = _completed_value(row[completed_column]) if completed_column is not None else False
source = str(row[source_column]).strip() if source_column is not None else "import"
if not source or source.lower() == "nan":
source = "import"
prepared.append((parsed_date, content, completed, source[:30]))
except (ValueError, TypeError):
skipped += 1
if permanent_dataframe is not None:
permanent_content_column = _column(permanent_dataframe, "내용", "content", "memo")
permanent_folder_column = _column(permanent_dataframe, "폴더", "folder", "folder_name")
permanent_color_column = _column(permanent_dataframe, "폴더 색상", "folder_color", "color")
if permanent_content_column is not None:
for _, row in permanent_dataframe.iterrows():
content = str(row[permanent_content_column]).strip()
if content and content.lower() != "nan" and len(content) <= 10000:
folder_name = "기본"
folder_color = DEFAULT_MEMO_FOLDER_COLOR
if permanent_folder_column is not None:
imported_folder = str(row[permanent_folder_column]).strip()
if imported_folder and imported_folder.lower() != "nan":
folder_name = imported_folder[:80]
if permanent_color_column is not None:
imported_color = str(row[permanent_color_column]).strip().upper()
if imported_color in MEMO_FOLDER_COLORS:
folder_color = imported_color
permanent_prepared.append((folder_name, folder_color, content))
else:
skipped += 1
if schedule_dataframe is not None:
schedule_date_column = _column(schedule_dataframe, "시작일", "날짜", "schedule_date", "date")
schedule_end_date_column = _column(schedule_dataframe, "종료일", "end_date")
schedule_title_column = _column(schedule_dataframe, "일정", "title", "내용", "content")
schedule_time_column = _column(schedule_dataframe, "시작 시간", "시간", "start_time", "time")
schedule_end_time_column = _column(schedule_dataframe, "종료 시간", "end_time")
if schedule_date_column is not None and schedule_title_column is not None:
for _, row in schedule_dataframe.iterrows():
try:
schedule_date = pd.to_datetime(row[schedule_date_column], errors="raise").date()
end_date = schedule_date
if schedule_end_date_column is not None and not pd.isna(row[schedule_end_date_column]):
end_date = pd.to_datetime(row[schedule_end_date_column], errors="raise").date()
if end_date < schedule_date or (end_date - schedule_date).days > 366:
raise ValueError
title = str(row[schedule_title_column]).strip()
if not title or title.lower() == "nan" or len(title) > 300:
raise ValueError
start_time = None
end_time = None
if schedule_time_column is not None and not pd.isna(row[schedule_time_column]):
raw_time = row[schedule_time_column]
if isinstance(raw_time, datetime.time):
start_time = raw_time.replace(second=0, microsecond=0)
else:
time_text = str(raw_time).strip()
if time_text and time_text.lower() != "nan":
start_time = datetime.time.fromisoformat(time_text).replace(second=0, microsecond=0)
if schedule_end_time_column is not None and not pd.isna(row[schedule_end_time_column]):
raw_end_time = row[schedule_end_time_column]
if isinstance(raw_end_time, datetime.time):
end_time = raw_end_time.replace(second=0, microsecond=0)
else:
end_time_text = str(raw_end_time).strip()
if end_time_text and end_time_text.lower() != "nan":
end_time = datetime.time.fromisoformat(end_time_text).replace(second=0, microsecond=0)
_validate_schedule_times(schedule_date, end_date, start_time, end_time)
schedule_prepared.append((schedule_date, end_date, title, start_time, end_time))
except (ValueError, TypeError, HTTPException):
skipped += 1
try:
_ensure_schema()
conn = _connect()
added = 0
permanent_added = 0
schedule_added = 0
try:
with conn.cursor() as cur:
for parsed_date, content, completed, source in prepared:
cur.execute(
"""
INSERT INTO cs_records (record_date, content, is_completed, source)
SELECT %s, %s, %s, %s
WHERE NOT EXISTS (
SELECT 1 FROM cs_records
WHERE record_date = %s AND content = %s
)
RETURNING id
""",
(parsed_date, content, completed, source, parsed_date, content),
)
if cur.fetchone() is not None:
added += 1
else:
skipped += 1
for folder_name, folder_color, content in permanent_prepared:
cur.execute(
"""
INSERT INTO cs_memo_folders (name, color)
VALUES (%s, %s)
ON CONFLICT (name) DO NOTHING
""",
(folder_name, folder_color),
)
cur.execute("SELECT id FROM cs_memo_folders WHERE name = %s", (folder_name,))
folder_id = cur.fetchone()["id"]
cur.execute(
"""
INSERT INTO cs_permanent_memos (content, folder_id)
SELECT %s, %s
WHERE NOT EXISTS (
SELECT 1 FROM cs_permanent_memos WHERE folder_id = %s AND content = %s
)
RETURNING id
""",
(content, folder_id, folder_id, content),
)
if cur.fetchone() is not None:
permanent_added += 1
else:
skipped += 1
for schedule_date, end_date, title, start_time, end_time in schedule_prepared:
cur.execute(
"""
INSERT INTO cs_schedules (schedule_date, end_date, title, start_time, end_time)
SELECT %s, %s, %s, %s, %s
WHERE NOT EXISTS (
SELECT 1 FROM cs_schedules
WHERE schedule_date = %s
AND end_date = %s
AND title = %s
AND start_time IS NOT DISTINCT FROM %s
AND end_time IS NOT DISTINCT FROM %s
)
RETURNING id
""",
(
schedule_date, end_date, title, start_time, end_time,
schedule_date, end_date, title, start_time, end_time,
),
)
if cur.fetchone() is not None:
schedule_added += 1
else:
skipped += 1
conn.commit()
finally:
conn.close()
return {
"status": "success",
"added_count": added,
"permanent_added_count": permanent_added,
"schedule_added_count": schedule_added,
"skipped_count": skipped,
}
except HTTPException:
raise
except Exception as exc:
_service_unavailable(exc)
def add_special_order_records(
record_date: datetime.date,
contents: List[str],
event_key: str,
) -> int:
"""New CS 특수 발주의 클립보드 문장들을 CS 기록 한 건으로 추가한다."""
content = "\n".join(
cleaned
for raw_content in contents
if (cleaned := (raw_content or "").strip())
)
if not content:
return 0
_ensure_schema()
conn = _connect()
try:
with conn.cursor() as cur:
cur.execute(
"""
INSERT INTO cs_records
(record_date, content, is_completed, source, source_key)
VALUES (%s, %s, FALSE, 'new_cs', %s)
ON CONFLICT DO NOTHING
RETURNING id
""",
(record_date, content, f"new-cs:{event_key}"),
)
added = 1 if cur.fetchone() is not None else 0
conn.commit()
return added
finally:
conn.close()