07861dfe8c
- 실적 설정 "자동 업데이트" 카드(관리자): 매출 실적·광고비 각각 사용·요일([매일]·[평일])· 시작/끝 시각(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>
324 lines
15 KiB
Python
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
|