Files
king 07861dfe8c feat(performance): 자동 업데이트 일정 설정 — 매출·광고비 따로 간격·요일·시작/끝
- 실적 설정 "자동 업데이트" 카드(관리자): 매출 실적·광고비 각각 사용·요일([매일]·[평일])·
  시작/끝 시각(5분 단위)·간격(5~720분, 5분 단위, 기본 30분), PUT /api/auto-sync-schedule
- 마이그레이션 011 perf_settings(key auto_sync, JSONB). 미적용·값 없음 = 기본 일정(매일 9~19시 30분)
- auto_sync: 종류별 일정·Scheduler(1분마다 다시 읽어 바뀐 종류만 다시 계산, 종류마다 따로 스레드)
- 매출·광고비 탭 카운트다운이 각자 일정대로 다음 회차 계산(nextScheduleSlot)
- 테스트: 일정 계산·검증·Scheduler·저장 API·브라우저(설정 카드·카운트다운)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-26 18:01:00 +09:00

324 lines
15 KiB
Python

"""매출·광고비 자동 업데이트 — 웹 프로세스 안 데몬 스레드(프로젝트 마감 알림과 같은 방식).
일정(2026-10-26) — 실적 설정 "자동 업데이트" 카드에서 매출 실적·광고비를 **따로** 정한다(마이그레이션 011 perf_settings,
key 'auto_sync'). 종류마다 {enabled, interval(분, 5분 단위, 기본 30), days(0=월 … 6=일), start "HH:MM", end "HH:MM"}.
- 회차 = 고른 요일의 start, start+interval, … end 까지(end 와 딱 맞으면 end 도). 시각은 5분 단위, KST.
- 저장한 일정은 1분 안에 반영(스레드가 1분마다 다시 읽는다). 저장 값이 없으면(011 미적용 포함) 기본 일정 =
매일 env PERFORMANCE_AUTO_SYNC_HOURS(기본 9-19)시 정각 ~ 마지막 시 정각, 30분마다.
- 매출 = 진행 창 작업(jobs kind="sales") — 그동안 누가 [매출 업데이트] 를 누르면 새로 시작하지 않고 이 진행 상황을 본다.
- 광고비 = 설정된 광고 API(구글·메타) — 광고비 진행 창 작업(jobs kind="ads"). 광고비 탭 [광고비 업데이트]도 같은 진행 상황.
- 두 종류의 회차가 같은 시각이면 동시에 돈다(따로 스레드). 그 시각에 이미 같은 종류 업데이트가 돌고 있으면 그 종류는 그 회차를
건너뛴다. 한 회차가 간격을 넘기면 지나간 회차는 건너뛰고 다음 회차를 기다린다(밀린 회차를 몰아서 돌리지 않음).
- 서버를 켠 시각의 회차는 돌리지 않고 다음 회차부터.
환경변수(.env)
PERFORMANCE_AUTO_SYNC=false 끄기(기본 켜짐) — 끄면 설정 화면 일정과 상관없이 안 돈다
PERFORMANCE_AUTO_SYNC_DAYS=10 가져올 기간(오늘 포함 최근 N일, 1~90)
PERFORMANCE_AUTO_SYNC_HOURS=9-19 설정 화면에서 일정을 저장하기 전 기본 시간대(시작시-마지막시)
"""
from __future__ import annotations
import logging
import os
import re
import threading
import time
from datetime import datetime, timedelta
from typing import Any
from app.timezone import now_kst
logger = logging.getLogger("performance.auto_sync")
AUTO_USER = "자동 업데이트"
DEFAULT_DAYS = 10
DEFAULT_HOURS = (9, 19)
DEFAULT_INTERVAL = 30
INTERVAL_STEP = 5
INTERVAL_MAX = 720
SETTING_KEY = "auto_sync"
KINDS = ("sales", "ads")
KIND_NAMES = {"sales": "매출 실적", "ads": "광고비"}
WEEKDAYS = ("월", "화", "수", "목", "금", "토", "일")
_started = False
_start_lock = threading.Lock()
def _env(name: str) -> str:
return (os.getenv(name, "") or "").strip()
def enabled() -> bool:
return _env("PERFORMANCE_AUTO_SYNC").lower() not in ("0", "false", "no", "off")
def sync_days() -> int:
try:
return max(1, min(90, int(_env("PERFORMANCE_AUTO_SYNC_DAYS") or DEFAULT_DAYS)))
except ValueError:
return DEFAULT_DAYS
def hour_window() -> tuple[int, int]:
m = re.fullmatch(r"(\d{1,2})\s*-\s*(\d{1,2})", _env("PERFORMANCE_AUTO_SYNC_HOURS"))
if not m:
return DEFAULT_HOURS
first, last = int(m.group(1)), int(m.group(2))
if not (0 <= first <= last <= 23):
return DEFAULT_HOURS
return first, last
# ════════════════════════════════════════════════════════════
# 일정
# ════════════════════════════════════════════════════════════
def default_schedule() -> dict[str, Any]:
first, last = hour_window()
return {"enabled": True, "interval": DEFAULT_INTERVAL, "days": list(range(7)),
"start": f"{first:02d}:00", "end": f"{last:02d}:00"}
def _minutes(hhmm: str) -> int:
h, m = hhmm.split(":")
return int(h) * 60 + int(m)
def _time(raw: Any, label: str) -> str:
m = re.fullmatch(r"(\d{1,2}):(\d{2})", str(raw or "").strip())
if not m or not (0 <= int(m.group(1)) <= 23 and 0 <= int(m.group(2)) <= 59):
raise ValueError(f"{label}을 HH:MM 으로 넣어 주세요.")
if int(m.group(2)) % INTERVAL_STEP:
raise ValueError(f"{label}은 {INTERVAL_STEP}분 단위로 정할 수 있습니다.")
return f"{int(m.group(1)):02d}:{m.group(2)}"
def validate_schedule(raw: Any) -> dict[str, Any]:
"""설정 화면에서 받은 일정 하나 → 정리한 값. 잘못되면 ValueError(화면에 그대로 보여 줄 문구)."""
if not isinstance(raw, dict):
raise ValueError("일정 형식이 잘못되었습니다.")
on = bool(raw.get("enabled"))
try:
interval = int(raw.get("interval"))
except (TypeError, ValueError):
raise ValueError("간격(분)을 숫자로 넣어 주세요.") from None
if not (INTERVAL_STEP <= interval <= INTERVAL_MAX) or interval % INTERVAL_STEP:
raise ValueError(f"간격은 {INTERVAL_STEP}분 ~ {INTERVAL_MAX}분, {INTERVAL_STEP}분 단위로 정할 수 있습니다.")
days = raw.get("days")
if not isinstance(days, list) or any(not isinstance(d, int) or isinstance(d, bool) or not 0 <= d <= 6 for d in days):
raise ValueError("요일이 잘못되었습니다.")
days = sorted(set(days))
if on and not days:
raise ValueError("요일을 하나 이상 고르세요(자동 업데이트를 쓰지 않으려면 [사용]을 끄세요).")
start, end = _time(raw.get("start"), "시작 시각"), _time(raw.get("end"), "끝 시각")
if _minutes(end) < _minutes(start):
raise ValueError("끝 시각은 시작 시각과 같거나 뒤여야 합니다(밤을 넘기는 시간대는 안 됩니다).")
return {"enabled": on, "interval": interval, "days": days, "start": start, "end": end}
def normalize(raw: Any) -> dict[str, dict[str, Any]]:
"""DB 에 저장된 값 → 종류마다 일정. 없거나 잘못된 종류는 기본 일정."""
out = {}
for k in KINDS:
try:
out[k] = validate_schedule((raw or {}).get(k)) if isinstance(raw, dict) else default_schedule()
except ValueError:
out[k] = default_schedule()
return out
def load_schedules(store: Any) -> tuple[dict[str, dict[str, Any]], bool]:
"""(종류 → 일정, 011 적용 여부). DB 오류는 그대로 올린다(스레드는 직전 일정을 계속 쓴다)."""
from .db import SettingsMigrationNeeded # noqa: WPS433
getter = getattr(store, "get_setting", None)
if getter is None: # 테스트용 가짜 저장소 등
return normalize(None), True
try:
return normalize(getter(SETTING_KEY)), True
except SettingsMigrationNeeded:
return normalize(None), False
def describe(sched: dict[str, Any]) -> str:
"""'매일 09:00~19:00 · 30분마다' / '평일 …' / '월·수·금 …' / '꺼짐'."""
if not sched.get("enabled") or not sched.get("days"):
return "꺼짐"
days = sched["days"]
if days == list(range(7)):
when = "매일"
elif days == list(range(5)):
when = "평일"
elif days == [5, 6]:
when = "주말"
else:
when = "·".join(WEEKDAYS[d] for d in days)
span = sched["start"] if sched["start"] == sched["end"] else f"{sched['start']}~{sched['end']}"
every = sched["interval"]
every_txt = f"{every // 60}시간" + (f" {every % 60}분" if every % 60 else "") if every >= 60 else f"{every}분"
return f"{when} {span}" + ("" if sched["start"] == sched["end"] else f" · {every_txt}마다")
def is_slot(t: datetime, sched: dict[str, Any]) -> bool:
"""t(분 단위로 자른 KST 시각)가 회차인가."""
if not sched.get("enabled") or t.weekday() not in sched["days"]:
return False
m, start, end = t.hour * 60 + t.minute, _minutes(sched["start"]), _minutes(sched["end"])
return start <= m <= end and (m - start) % sched["interval"] == 0
def next_slot(after: datetime, sched: dict[str, Any]) -> datetime | None:
"""after 보다 뒤의 첫 회차 시각(KST). 꺼져 있거나 요일이 없으면 None."""
if not sched.get("enabled") or not sched.get("days"):
return None
start, end, step = _minutes(sched["start"]), _minutes(sched["end"]), sched["interval"]
day0 = after.replace(hour=0, minute=0, second=0, microsecond=0)
for d in range(8):
base = day0 + timedelta(days=d)
if base.weekday() not in sched["days"]:
continue
first = base + timedelta(minutes=start)
k = 0 if first > after else int((after - first).total_seconds() // (step * 60)) + 1
m = start + k * step
if m <= end:
return base + timedelta(minutes=m)
return None
# ════════════════════════════════════════════════════════════
# 회차 실행
# ════════════════════════════════════════════════════════════
def run_once(store: Any, app_state: Any, *, today: Any, days: int,
kinds: tuple[str, ...] = KINDS) -> dict[str, Any]:
"""한 회차 — 오늘 포함 최근 days 일. kinds 의 매출(진행 창 작업)·광고비(광고 진행 창 작업)를 동시에.
각각 이미 돌고 있으면 그 종류만 건너뜀."""
from . import common, jobs # noqa: WPS433
from .ad_sync import run_ad_job # noqa: WPS433
from .credentials import CredentialService # noqa: WPS433
from .sync import SyncService # noqa: WPS433
start, end = today - timedelta(days=days - 1), today
ads: list[dict[str, Any]] = []
ad_thread = None
ads_skipped = "ads" not in kinds or jobs.running_job("ads") is not None
if not ads_skipped:
ad_job = jobs.create_job(user=AUTO_USER, start=start, end=end, kind="ads")
def _ads() -> None:
ads.extend(run_ad_job(store, common.key_ring, ad_job, start, end, user=AUTO_USER))
ad_thread = threading.Thread(target=_ads, name=f"perf-auto-ads-{ad_job.id}", daemon=True)
ad_thread.start()
sales_skipped = "sales" not in kinds or jobs.running_job("sales") is not None
error = ""
results: list[dict[str, Any]] = []
if not sales_skipped:
job = jobs.create_job(user=AUTO_USER, start=start, end=end)
sync = SyncService(store, CredentialService(store, common.key_ring), app_state=app_state)
try:
results = sync.sync_all(start=start, end=end, trigger="schedule", user=AUTO_USER, job=job)
except Exception as exc: # noqa: BLE001 — 스레드가 죽지 않게
logger.exception("auto sync failed")
error = f"업데이트 중 오류: {type(exc).__name__}"
last = None
try:
last = store.last_update_at()
except Exception: # noqa: BLE001
pass
job.finish(error=error, last_update_at=last)
if ad_thread is not None:
ad_thread.join()
if sales_skipped and ads_skipped:
return {"skipped": True, "reason": "다른 업데이트 진행 중"}
ok = sum(1 for r in results if r.get("ok"))
return {"skipped": False, "sales_skipped": sales_skipped, "ads_skipped": ads_skipped,
"from": start.isoformat(), "to": end.isoformat(), "ok": ok,
"failed": [r.get("code") for r in results if not r.get("ok") and not r.get("skipped")], "error": error,
"ads": [{"code": a.get("code"), "ok": bool(a.get("ok"))} for a in ads]}
class Scheduler:
"""종류마다 다음 회차(due)를 들고 있다가 시각이 되면 그 종류만 따로 스레드로 돌린다.
tick(now) 이 1분마다 불리며 일정이 바뀐 종류는 지금부터 다시 계산(서버 시작·저장 직후 회차는 안 돌림)."""
def __init__(self, fire: Any):
self.fire = fire # fire(kind, due)
self.schedules: dict[str, dict[str, Any]] = {}
self.due: dict[str, datetime | None] = {}
def update(self, schedules: dict[str, dict[str, Any]], now: datetime) -> None:
for k in KINDS:
s = schedules.get(k) or default_schedule()
if self.schedules.get(k) != s:
self.schedules[k] = s
self.due[k] = next_slot(now, s)
def tick(self, now: datetime) -> None:
for k in KINDS:
due = self.due.get(k)
if due is not None and due <= now:
self.fire(k, due)
self.due[k] = next_slot(max(now, due), self.schedules[k])
def wait_seconds(self, now: datetime) -> float:
dues = [d for d in self.due.values() if d is not None]
if not dues:
return 60.0
return max(0.0, min(60.0, min((d - now).total_seconds() for d in dues)))
def start_auto_sync_thread(app_state: Any) -> bool:
"""웹 프로세스 시작 시 1번. 저장소가 없거나 꺼져 있거나 이미 돌고 있으면 False."""
global _started # noqa: PLW0603
store = getattr(app_state, "performance_store", None)
if store is not None and not _started:
try: # 지난 프로세스가 업데이트 도중 끝나 남은 '진행 중' 기록 정리(자동 업데이트를 꺼 둬도)
n = store.abandon_running_runs()
if n:
logger.warning("매출 업데이트 '진행 중' 기록 %d건 정리(서버 재시작으로 중단)", n)
except Exception: # noqa: BLE001 — DB 가 아직 안 붙었어도 앱은 뜬다
logger.exception("매출 업데이트 진행 기록 정리 실패")
if store is None or not enabled():
return False
with _start_lock:
if _started:
return False
_started = True
days = sync_days()
def _fire(kind: str, due: datetime) -> None:
def _run() -> None:
try:
res = run_once(store, app_state, today=due.date(), days=days, kinds=(kind,))
logger.info("%s 자동 업데이트 %s: %s", KIND_NAMES[kind], due.strftime("%H:%M"), res)
except Exception: # noqa: BLE001
logger.exception("%s 자동 업데이트 실패 — 다음 회차에 다시", KIND_NAMES[kind])
threading.Thread(target=_run, name=f"performance-auto-{kind}", daemon=True).start()
sched = Scheduler(_fire)
def _reload(now: datetime) -> None:
try:
schedules, _ = load_schedules(store)
except Exception: # noqa: BLE001 — DB 가 잠시 끊기면 직전 일정 그대로(처음이면 기본 일정)
logger.warning("자동 업데이트 일정 읽기 실패 — 직전 일정 사용", exc_info=True)
schedules = sched.schedules or normalize(None)
sched.update(schedules, now)
def _loop() -> None:
_reload(now_kst())
logger.info("실적 자동 업데이트 시작 — 최근 %d일, %s", days, ", ".join(
f"{KIND_NAMES[k]} {describe(sched.schedules[k])} 다음 "
f"{sched.due[k].strftime('%m-%d %H:%M') if sched.due[k] else '없음'}" for k in KINDS))
while True:
time.sleep(max(1.0, sched.wait_seconds(now_kst()))) # 시계 변경·절전·일정 저장에도 1분 안에 다시 확인
now = now_kst()
_reload(now)
sched.tick(now)
threading.Thread(target=_loop, name="performance-auto-sync", daemon=True).start()
return True