7046a504a1
- 네이버/카페24/발주 파일명/반품 입고일을 KST로 고정 (컨테이너 UTC 대응) - 네이버 API timeout 추가, last-changed-statuses 'more' 페이지 이어서 조회, 주문번호 중복 제거 - 스마트스토어 발주확인을 엑셀 생성 이후로 이동 - 반품 신청/입고 목록 innerHTML 이스케이프 (XSS) - 카페24 OAuth 콜백: 반사형 XSS 차단, /corm 경로로 복귀 - 블로킹 async 엔드포인트를 sync로 전환 (코드표·반품·송장 업로드·자사몰 행사·밀크런·CS 가져오기) - DB 연결 closing 처리, 세트 목록 N+1 쿼리 제거 - 반품 일괄 입고 중복 송장 건너뛰기 및 안내 - 작업 결과 메모리 1시간 TTL, 401 로그인 next 경로 중복 수정 - 송장 '.0' 처리 수정 및 네이버/카페24 송장 파싱 공용화 - SortableJS 1.15.6 고정, 중복 코드·미사용 import 정리 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1440 lines
55 KiB
Python
1440 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)
|
|
today = datetime.datetime.now(datetime.timezone(datetime.timedelta(hours=9))).date()
|
|
filename = f"cs-records-{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")
|
|
def import_records(file: UploadFile = File(...)):
|
|
raw = file.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()
|