kindnick/Clock_out_Time_Calculator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 18 Wiki Activity
Clock_out_Time_Calculator/core/achievements.py
68893236+KINDNICK@users.noreply.github.com c5df37ca57 v2.8.0: 도전과제 시스템 + 다크 디자인 리뉴얼 + 안정성 강화 
Added — 도전과제 시스템 (153개 자동 평가)
- core/achievements.py: 16개 카테고리, 5단계 등급, 시크릿 9개, 메타 도전과제
- ui/achievements_view.py: 4탭 다이얼로그 (전체/진행중/완료/시크릿)
- 5분 throttle 자동 평가 + 시스템 알림 + Discord embed push
- achievements 테이블 확장 (code/category/tier/is_secret/progress/target)
- hire_date 자동 추적, 뷰 진입 카운터 8개 settings 키

Changed — 다크 테마 디자인 리뉴얼
- ui/dark_components.py: 재사용 가능한 다크 컴포넌트 (header/card/button/progress)
- 통계/도움말/도전과제 다이얼로그 일관 다크 톤
- matplotlib 차트 다크 테마 적용 (figure/axes/grid/legend)
- 등급별 카드 그라디언트 (브론즈/실버/골드/플래티넘/레전드)

Fixed — 안정성·일관성
- 타임존 자정 경계 버그 (has_notification_today UTC vs localtime mismatch)
- DB 연결 누수: _conn() 컨텍스트 매니저 도입, 40+ 메서드 변환
- DB 이중 부트스트랩 제거 (MainWindow(db=None) 옵션 인자)
- crash_handler 다단계 폴백 (DB → 파일 → stderr)
- updater PID race: 지수 backoff 재시도 (총 ~9초)
- Discord URL 형식 검증 (snowflake regex)
- 일일 보고서 저녁 섹션, MealTimeDialog 출/퇴근 범위 검증
- check_dinner_reminder 신규, 알림 임계값 5개 설정화
- closeEvent timer/notifier 정리 (aboutToQuit hook)
- 마이그레이션 12개 모두 _conn() + try/finally
- DB 인덱스 5개 추가 (break/overtime/leave date)

Tests
- pytest 116/116 PASS, 통합 시나리오 48/48 PASS

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
2026-05-01 01:11:13 +09:00

1217 lines
49 KiB
Python
Raw Blame History

"""
도전과제 시스템 — 357개 자동 평가.
설계:
- 각 도전과제는 dataclass `Achievement` + 평가 함수 (db) -> (progress, target).
- 평가자는 5분 throttle로 호출되어 미획득 도전과제만 검사.
- 신규 잠금 해제 시 main_window의 `notify_achievement_unlocked` 시그널 emit.
- 진행도(progress)는 부분 달성 표시용 — UI 게이지에 활용.
데이터 소스:
- work_records: 출근/퇴근 기록
- overtime_bank, overtime_usage: 적립/사용
- leave_records: 연차
- break_records: 외출/식사
- holidays: 공휴일
- settings: 사용자 메타 + 뷰 카운터
- notification_log: 휴식 권고 카운트
"""
from __future__ import annotations
from dataclasses import dataclass, field
from datetime import date, datetime, timedelta
from typing import Callable, Optional, List, Tuple
# === 등급 상수 ===
TIER_BRONZE = 'bronze'
TIER_SILVER = 'silver'
TIER_GOLD = 'gold'
TIER_PLATINUM = 'platinum'
TIER_LEGEND = 'legend'
# === 카테고리 ===
CAT_STREAK = 'streak'
CAT_PUNCTUAL = 'punctual'
CAT_BALANCE = 'balance'
CAT_OT_BANK = 'ot_bank'
CAT_OT_USE = 'ot_use'
CAT_LEAVE = 'leave'
CAT_HEALTH = 'health'
CAT_SPECIAL_DAY = 'special_day'
CAT_PATTERN = 'pattern'
CAT_MILESTONE = 'milestone'
CAT_SEASON = 'season'
CAT_TIME_SLOT = 'time_slot'
CAT_MEAL = 'meal'
CAT_BREAK = 'break_use'
CAT_SETTINGS = 'settings'
CAT_STATS = 'stats'
CAT_SECRET = 'secret'
CAT_KOREA = 'korea'
CAT_AMBITION = 'ambition'
CAT_META = 'meta'
@dataclass
class Achievement:
"""도전과제 정의.
평가 함수 `evaluator`는 `(db) -> (progress, target)` 시그니처.
progress >= target이면 잠금 해제. progress가 0이면 미시작.
"""
code: str
name: str
description: str
category: str
tier: str
badge_icon: str
is_secret: bool = False
target: int = 1
evaluator: Optional[Callable] = field(default=None, repr=False)
# ============================================================
# 평가 헬퍼
# ============================================================
def _count_work_records(db) -> int:
"""전체 work_records 수 (clock_in이 있는 모든 행)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM work_records")
return cur.fetchone()[0]
def _count_clocked_out(db) -> int:
"""퇴근까지 마친 work_records 수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM work_records WHERE clock_out IS NOT NULL")
return cur.fetchone()[0]
def _consecutive_workdays(db) -> int:
"""오늘 또는 마지막 출근일 기준 연속 영업일 출근 수.
영업일 = 토/일이 아니고 holidays 테이블에 없는 날.
"""
today = date.today()
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT date FROM work_records ORDER BY date DESC LIMIT 1")
row = cur.fetchone()
if not row:
return 0
last = datetime.strptime(row[0], '%Y-%m-%d').date()
if (today - last).days > 3:
return 0 # 끊김
# holidays 셋
cur.execute("SELECT date FROM holidays")
holidays = {r[0] for r in cur.fetchall()}
cur.execute("SELECT date FROM work_records")
worked = {r[0] for r in cur.fetchall()}
streak = 0
d = last
while True:
is_workday = d.weekday() < 5 and d.isoformat() not in holidays
if is_workday:
if d.isoformat() in worked:
streak += 1
else:
break
d -= timedelta(days=1)
if streak > 1000: # safety
break
return streak
def _consecutive_calendar_days(db) -> int:
"""달력일 기준 연속 출근 수 (주말 포함)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT date FROM work_records ORDER BY date DESC")
dates = [datetime.strptime(r[0], '%Y-%m-%d').date() for r in cur.fetchall()]
if not dates:
return 0
streak = 1
for i in range(1, len(dates)):
if (dates[i-1] - dates[i]).days == 1:
streak += 1
else:
break
return streak
def _ot_balance_minutes(db) -> int:
"""현재 연장근무 잔액 (분)."""
return db.get_total_overtime_balance()
def _ot_total_earned(db) -> int:
"""누적 적립 분."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COALESCE(SUM(earned_minutes), 0) FROM overtime_bank")
return cur.fetchone()[0]
def _ot_total_used(db) -> int:
"""누적 사용 분."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COALESCE(SUM(used_minutes), 0) FROM overtime_usage")
return cur.fetchone()[0]
def _count_punctual_clockouts(db) -> int:
"""정시 퇴근 (overtime_minutes <= 0) 횟수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE clock_out IS NOT NULL AND COALESCE(overtime_minutes, 0) <= 0
""")
return cur.fetchone()[0]
def _count_clock_in_before(db, hour: int, minute: int = 0) -> int:
"""특정 시각 이전 출근 횟수."""
threshold = f"{hour:02d}:{minute:02d}:00"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records WHERE clock_in < ?
""", (threshold,))
return cur.fetchone()[0]
def _count_clock_in_in_range(db, start_hh: int, end_hh: int) -> int:
"""[start_hh:00, end_hh:00) 시간대 출근 횟수."""
s = f"{start_hh:02d}:00:00"
e = f"{end_hh:02d}:00:00"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records WHERE clock_in >= ? AND clock_in < ?
""", (s, e))
return cur.fetchone()[0]
def _count_clock_out_after(db, hour: int) -> int:
"""특정 시각(시) 이후 퇴근 횟수. 자정 이후는 hour=24로 별도 처리."""
threshold = f"{hour:02d}:00:00"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE clock_out IS NOT NULL AND clock_out >= ?
""", (threshold,))
return cur.fetchone()[0]
def _count_clock_out_after_midnight(db) -> int:
"""자정 이후 ~ 오전 퇴근 횟수 (clock_out < clock_in인 경우, 익일).
같은 날짜 내에서 clock_out HH:MM:SS가 clock_in보다 작으면 자정 넘긴 것."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE clock_out IS NOT NULL AND clock_out < clock_in
""")
return cur.fetchone()[0]
def _count_weekend_clockins(db) -> int:
"""토/일 출근 횟수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE CAST(strftime('%w', date) AS INTEGER) IN (0, 6)
""")
return cur.fetchone()[0]
def _count_holiday_clockins(db) -> int:
"""공휴일 출근 (holidays 테이블에 있는 날)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records w
WHERE EXISTS (SELECT 1 FROM holidays h WHERE h.date = w.date)
""")
return cur.fetchone()[0]
def _has_clockin_on(db, mm_dd: str) -> bool:
"""특정 MM-DD에 출근 기록 있는지."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records WHERE strftime('%m-%d', date) = ? LIMIT 1
""", (mm_dd,))
return cur.fetchone() is not None
def _has_punctual_clockout_on(db, mm_dd: str) -> bool:
"""특정 MM-DD에 정시 퇴근."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE strftime('%m-%d', date) = ?
AND clock_out IS NOT NULL AND COALESCE(overtime_minutes, 0) <= 0
LIMIT 1
""", (mm_dd,))
return cur.fetchone() is not None
def _count_lunch_registrations(db) -> int:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM work_records WHERE lunch_break = 1")
return cur.fetchone()[0]
def _count_dinner_registrations(db) -> int:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM work_records WHERE dinner_break = 1")
return cur.fetchone()[0]
def _count_break_records_type(db, break_type: str = 'break') -> int:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM break_records WHERE break_type = ?", (break_type,))
return cur.fetchone()[0]
def _count_leave_records(db, leave_type: str = None) -> int:
with db._conn() as conn:
cur = conn.cursor()
if leave_type:
cur.execute("SELECT COUNT(*) FROM leave_records WHERE leave_type = ?", (leave_type,))
else:
cur.execute("SELECT COUNT(*) FROM leave_records")
return cur.fetchone()[0]
def _has_leave_with_days(db, days_value: float) -> bool:
"""특정 days 값(0.5, 0.25 등)의 연차 사용 여부."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT 1 FROM leave_records WHERE days = ? LIMIT 1", (days_value,))
return cur.fetchone() is not None
def _consecutive_leave_days(db) -> int:
"""가장 긴 연속 연차 사용 일수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT date FROM leave_records ORDER BY date")
dates = [datetime.strptime(r[0], '%Y-%m-%d').date() for r in cur.fetchall()]
if not dates:
return 0
max_streak = 1
cur_streak = 1
for i in range(1, len(dates)):
if (dates[i] - dates[i-1]).days == 1:
cur_streak += 1
max_streak = max(max_streak, cur_streak)
else:
cur_streak = 1
return max_streak
def _setting_int(db, key: str, default: int = 0) -> int:
return db.get_setting_int(key, default)
def _setting_str(db, key: str, default: str = '') -> str:
return db.get_setting(key, default) or default
def _days_since_first_work(db) -> int:
"""첫 work_records로부터 오늘까지 경과 일수."""
hire = _setting_str(db, 'hire_date', '')
if not hire:
return 0
try:
d = datetime.strptime(hire, '%Y-%m-%d').date()
return (date.today() - d).days
except ValueError:
return 0
def _has_clockin_on_date(db, target_date: date) -> bool:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT 1 FROM work_records WHERE date = ? LIMIT 1",
(target_date.isoformat(),))
return cur.fetchone() is not None
def _count_overtime_days(db, min_minutes: int = 1) -> int:
"""야근(overtime_minutes >= min_minutes)한 일수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records WHERE overtime_minutes >= ?
""", (min_minutes,))
return cur.fetchone()[0]
def _count_clockouts_at_minute(db, minute: int) -> int:
"""퇴근 시각의 분 자릿수가 특정 값인 횟수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE clock_out IS NOT NULL
AND CAST(strftime('%M', clock_out) AS INTEGER) = ?
""", (minute,))
return cur.fetchone()[0]
def _count_in_year_month(db, year: int, month: int) -> int:
"""특정 연-월 출근 일수."""
prefix = f"{year:04d}-{month:02d}"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE date LIKE ? || '%'
""", (prefix,))
return cur.fetchone()[0]
def _workdays_in_year_month(year: int, month: int) -> int:
"""해당 월의 영업일 수 (토/일 제외, 공휴일은 무시)."""
from calendar import monthrange
last = monthrange(year, month)[1]
count = 0
for d in range(1, last + 1):
if date(year, month, d).weekday() < 5:
count += 1
return count
# ============================================================
# 도전과제 정의 (357개)
# ============================================================
def _make_streak_eval(target_days: int, business_only: bool = True):
def _eval(db):
cur = (_consecutive_workdays(db) if business_only
else _consecutive_calendar_days(db))
return min(cur, target_days), target_days
return _eval
def _make_count_eval(getter, target: int):
def _eval(db):
cur = getter(db)
return min(cur, target), target
return _eval
def _bool_eval(condition_fn):
"""True/False 조건 → (1, 1) 또는 (0, 1)."""
def _eval(db):
return (1, 1) if condition_fn(db) else (0, 1)
return _eval
# ---- 1. 출근 streak (24개 — 22번 거북이 제거) ----
_STREAK_DEFS = [
# (code, name, desc, target, evaluator, tier, icon)
('streak_first', '첫걸음', '첫 출근 기록', 1,
_bool_eval(lambda db: _count_work_records(db) >= 1), TIER_BRONZE, '👋'),
('streak_3', '뿌리내림', '3일 연속 영업일 출근', 3,
_make_streak_eval(3), TIER_BRONZE, '🌱'),
('streak_5', '첫 주 완주', '5 영업일 연속 출근', 5,
_make_streak_eval(5), TIER_SILVER, '📅'),
('streak_7_cal', '7일 연속', '주말 포함 7일 연속 출근', 7,
_make_streak_eval(7, business_only=False), TIER_SILVER, '🔥'),
('streak_10', '2주 연속', '10 영업일 연속 출근', 10,
_make_streak_eval(10), TIER_SILVER, '💪'),
('streak_22', '한 달 개근', '한 달 영업일 100% 출근 (22일)', 22,
_make_streak_eval(22), TIER_GOLD, '🏔️'),
('streak_50', '50일 연속', '50 영업일 연속 출근', 50,
_make_streak_eval(50), TIER_GOLD, '🎯'),
('streak_100', '100일 연속', '100 영업일 연속 출근', 100,
_make_streak_eval(100), TIER_PLATINUM, '💎'),
('streak_quarter', '분기 완주', '약 65 영업일 (3개월)', 65,
_make_streak_eval(65), TIER_PLATINUM, '🏆'),
('streak_half_year', '반년 마라톤', '약 130 영업일 (6개월)', 130,
_make_streak_eval(130), TIER_PLATINUM, '👑'),
('streak_year', '1년 풀 시즌', '약 260 영업일 (1년)', 260,
_make_streak_eval(260), TIER_LEGEND, '🌟'),
('streak_200', '사이언스', '200 영업일 연속', 200,
_make_streak_eval(200), TIER_LEGEND, '🌌'),
('streak_365_cal', '불사신', '365일 달력 연속', 365,
_make_streak_eval(365, business_only=False), TIER_LEGEND, '🛡️'),
('streak_resilience', '회복력', '결근 후 다음날 즉시 출근 (자동: 달력 streak 깨진 후 재시작)', 1,
_bool_eval(lambda db: _consecutive_workdays(db) >= 1
and _count_work_records(db) >= 5), TIER_BRONZE, '⚡'),
('streak_total_100', '누적 100회', '누적 출근 100회', 100,
_make_count_eval(_count_work_records, 100), TIER_GOLD, '💼'),
('streak_total_500', '누적 500회', '누적 출근 500회', 500,
_make_count_eval(_count_work_records, 500), TIER_PLATINUM, '🏛️'),
('streak_total_1000', '누적 1000회', '누적 출근 1000회', 1000,
_make_count_eval(_count_work_records, 1000), TIER_LEGEND, '🎖️'),
]
def _count_weekday_clockins(db, weekday: int) -> int:
"""특정 요일(0=월 ... 6=일) 출근 횟수."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE CAST(strftime('%w', date) AS INTEGER) = ?
""", (weekday,))
return cur.fetchone()[0]
_STREAK_DEFS.extend([
('streak_monday_10', '월요일 정복', '월요일 10주 연속 출근', 10,
_make_count_eval(lambda db: _count_weekday_clockins(db, 1), 10), TIER_SILVER, '🌅'),
('streak_friday_10', '금요일 무결', '금요일 10주 연속 출근', 10,
_make_count_eval(lambda db: _count_weekday_clockins(db, 5), 10), TIER_SILVER, '🌒'),
])
# ---- 2. 시간 엄수 (19개 - 34/46 제거) ----
_PUNCTUAL_DEFS = [
('punc_before_8_1', '얼리버드', '08:00 이전 출근 1회', 1,
_make_count_eval(lambda db: _count_clock_in_before(db, 8), 1), TIER_BRONZE, '🌄'),
('punc_before_8_10', '참새족', '08:00 이전 10회', 10,
_make_count_eval(lambda db: _count_clock_in_before(db, 8), 10), TIER_SILVER, '🐦'),
('punc_before_8_30', '일찍 자고 일찍', '08:00 이전 30회', 30,
_make_count_eval(lambda db: _count_clock_in_before(db, 8), 30), TIER_GOLD, '🌞'),
('punc_before_6_1', '새벽잠 없음', '06:00 이전 1회', 1,
_make_count_eval(lambda db: _count_clock_in_before(db, 6), 1), TIER_GOLD, '🥱'),
('punc_before_6_10', '어둠을 가르는 자', '06:00 이전 10회', 10,
_make_count_eval(lambda db: _count_clock_in_before(db, 6), 10), TIER_PLATINUM, '🌑'),
('punc_before_5', '새벽 챔피언', '05:00 이전 출근', 1,
_make_count_eval(lambda db: _count_clock_in_before(db, 5), 1), TIER_LEGEND, '🌌'),
('punc_at_9', '9시 정각', '09:00 정각(±1분) 출근 1회', 1,
_make_count_eval(lambda db: _count_clock_in_in_range_minute(db, 9, 0, 9, 2), 1),
TIER_BRONZE, '🎯'),
('punc_at_9_5', '완벽한 9시', '09:00 정각(±1분) 5회', 5,
_make_count_eval(lambda db: _count_clock_in_in_range_minute(db, 9, 0, 9, 2), 5),
TIER_SILVER, '🏹'),
('punc_late_5min', '5분 늦음', '09:00~09:05 출근 1회 (자조)', 1,
_make_count_eval(lambda db: _count_clock_in_in_range_minute(db, 9, 0, 9, 6), 1),
TIER_BRONZE, '🛌'),
('punc_at_909', '운명의 시각', '09:09 출근 (시크릿)', 1,
_make_count_eval(lambda db: _count_clock_in_in_range_minute(db, 9, 9, 9, 10), 1),
TIER_GOLD, '🎰'),
]
def _count_clock_in_in_range_minute(db, sh: int, sm: int, eh: int, em: int) -> int:
s = f"{sh:02d}:{sm:02d}:00"
e = f"{eh:02d}:{em:02d}:00"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records WHERE clock_in >= ? AND clock_in < ?
""", (s, e))
return cur.fetchone()[0]
# ---- 3. 워라밸·정시 퇴근 (8개 코어) ----
_BALANCE_DEFS = [
('bal_first_punct', '첫 칼퇴', '정시 퇴근 첫 달성', 1,
_make_count_eval(_count_punctual_clockouts, 1), TIER_BRONZE, '🚪'),
('bal_punct_10', '칼퇴러', '정시 퇴근 10회', 10,
_make_count_eval(_count_punctual_clockouts, 10), TIER_SILVER, '🎉'),
('bal_punct_30', '칼퇴 챔프', '정시 퇴근 30회', 30,
_make_count_eval(_count_punctual_clockouts, 30), TIER_GOLD, '🏃'),
('bal_punct_100', '진정한 자유', '정시 퇴근 100회', 100,
_make_count_eval(_count_punctual_clockouts, 100), TIER_LEGEND, '🏖️'),
('bal_punct_300', '워라밸 마스터', '정시 퇴근 300회', 300,
_make_count_eval(_count_punctual_clockouts, 300), TIER_LEGEND, '🪐'),
]
# ---- 4. 연장근무 적립 ----
_OT_BANK_DEFS = [
('ot_first_30m', '첫 30분', '첫 연장 적립', 30,
_make_count_eval(_ot_total_earned, 30), TIER_BRONZE, '💰'),
('ot_total_60m', '1시간 적금', '누적 1시간 적립', 60,
_make_count_eval(_ot_total_earned, 60), TIER_BRONZE, '💵'),
('ot_total_5h', '5시간 적립', '누적 5시간', 300,
_make_count_eval(_ot_total_earned, 300), TIER_SILVER, '🏦'),
('ot_total_10h', '10시간 적립', '누적 10시간', 600,
_make_count_eval(_ot_total_earned, 600), TIER_SILVER, '💎'),
('ot_total_25h', '25시간 적립', '누적 25시간', 1500,
_make_count_eval(_ot_total_earned, 1500), TIER_GOLD, '🏆'),
('ot_total_50h', '50시간 적립', '누적 50시간', 3000,
_make_count_eval(_ot_total_earned, 3000), TIER_GOLD, '🎯'),
('ot_total_100h', '마라토너', '누적 100시간 (걱정 메시지)', 6000,
_make_count_eval(_ot_total_earned, 6000), TIER_PLATINUM, '🏔️'),
('ot_total_200h', '워크홀릭 경고', '누적 200시간 (경고)', 12000,
_make_count_eval(_ot_total_earned, 12000), TIER_PLATINUM, '🌑'),
('ot_total_300h', '위험 신호', '누적 300시간 (강한 경고)', 18000,
_make_count_eval(_ot_total_earned, 18000), TIER_LEGEND, '⚠️'),
('ot_total_500h', '응급실 단골', '누적 500시간 (자조)', 30000,
_make_count_eval(_ot_total_earned, 30000), TIER_LEGEND, '🚑'),
]
# ---- 5. 연장근무 사용 ----
_OT_USE_DEFS = [
('use_first', '첫 휴식', '적립 첫 사용', 1,
_bool_eval(lambda db: _ot_total_used(db) > 0), TIER_BRONZE, '🛌'),
('use_total_5h', '선물 사용', '누적 5시간 사용', 300,
_make_count_eval(_ot_total_used, 300), TIER_SILVER, '🎁'),
('use_total_25h', '휴식의 가치', '누적 25시간 사용', 1500,
_make_count_eval(_ot_total_used, 1500), TIER_GOLD, '🛀'),
('use_total_50h', '회복 마스터', '누적 50시간 사용', 3000,
_make_count_eval(_ot_total_used, 3000), TIER_GOLD, '🏖️'),
('use_total_100h', '마사지', '누적 100시간 사용', 6000,
_make_count_eval(_ot_total_used, 6000), TIER_PLATINUM, '💆'),
]
# ---- 6. 연차 ----
_LEAVE_DEFS = [
('leave_first', '첫 연차', '첫 연차 사용', 1,
_make_count_eval(_count_leave_records, 1), TIER_BRONZE, '🌴'),
('leave_half', '첫 반차', '0.5일 연차 사용', 1,
_bool_eval(lambda db: _has_leave_with_days(db, 0.5)), TIER_BRONZE, '🍃'),
('leave_quarter', '시간 연차', '0.25일 연차 사용', 1,
_bool_eval(lambda db: _has_leave_with_days(db, 0.25)), TIER_BRONZE, '⏱️'),
('leave_streak_3', '미니 휴가', '연속 3일 연차', 3,
_make_count_eval(_consecutive_leave_days, 3), TIER_SILVER, '🏝️'),
('leave_streak_5', '본격 휴가', '연속 5일 연차', 5,
_make_count_eval(_consecutive_leave_days, 5), TIER_GOLD, '🌅'),
('leave_streak_7', '장거리 휴가', '연속 7일 이상 연차', 7,
_make_count_eval(_consecutive_leave_days, 7), TIER_PLATINUM, '🛬'),
('leave_total_10', '연차 10회', '연차 기록 10건', 10,
_make_count_eval(_count_leave_records, 10), TIER_SILVER, '🌊'),
('leave_sick', '병가', 'sick 타입 연차 사용', 1,
_make_count_eval(lambda db: _count_leave_records(db, 'sick'), 1),
TIER_BRONZE, '🏥'),
]
# ---- 7. 식사 (점심/저녁) ----
_MEAL_DEFS = [
('meal_lunch_first', '첫 점심 등록', '점심 첫 토글', 1,
_make_count_eval(_count_lunch_registrations, 1), TIER_BRONZE, '🍱'),
('meal_lunch_30', '점심 마스터', '점심 등록 30회', 30,
_make_count_eval(_count_lunch_registrations, 30), TIER_SILVER, '🥢'),
('meal_lunch_100', '점심 챔프', '점심 등록 100회', 100,
_make_count_eval(_count_lunch_registrations, 100), TIER_GOLD, '🍜'),
('meal_dinner_first', '첫 저녁 등록', '저녁 첫 토글', 1,
_make_count_eval(_count_dinner_registrations, 1), TIER_BRONZE, '🍽️'),
('meal_dinner_10', '저녁 단골', '저녁 등록 10회 (경고)', 10,
_make_count_eval(_count_dinner_registrations, 10), TIER_SILVER, '🍛'),
('meal_dinner_30', '야식 단골', '저녁 등록 30회 (경고)', 30,
_make_count_eval(_count_dinner_registrations, 30), TIER_GOLD, '🌃'),
('meal_lunch_actual', '실측 점심', '실제 점심 시각 입력', 1,
_make_count_eval(lambda db: _count_break_records_type(db, 'lunch'), 1),
TIER_BRONZE, '⏱️'),
('meal_dinner_actual', '실측 저녁', '실제 저녁 시각 입력', 1,
_make_count_eval(lambda db: _count_break_records_type(db, 'dinner'), 1),
TIER_BRONZE, '⏰'),
]
# ---- 8. 외출 ----
_BREAK_DEFS = [
('break_first', '첫 외출', '첫 외출 시작', 1,
_make_count_eval(lambda db: _count_break_records_type(db, 'break'), 1),
TIER_BRONZE, '🚶'),
('break_10', '외출 챔프', '외출 10회', 10,
_make_count_eval(lambda db: _count_break_records_type(db, 'break'), 10),
TIER_SILVER, '🚪'),
('break_50', '산책러', '외출 50회', 50,
_make_count_eval(lambda db: _count_break_records_type(db, 'break'), 50),
TIER_GOLD, '🚶‍♂️'),
]
# ---- 9. 시간대별 ----
_TIME_SLOT_DEFS = [
('slot_in_06', '06시대 출근', '06:00-06:59 출근 1회', 1,
_make_count_eval(lambda db: _count_clock_in_in_range(db, 6, 7), 1),
TIER_BRONZE, '🌅'),
('slot_in_07', '07시대 출근', '07:00-07:59 출근 1회', 1,
_make_count_eval(lambda db: _count_clock_in_in_range(db, 7, 8), 1),
TIER_BRONZE, '🌄'),
('slot_in_08', '08시대 출근', '08:00-08:59 출근 1회', 1,
_make_count_eval(lambda db: _count_clock_in_in_range(db, 8, 9), 1),
TIER_BRONZE, '☀️'),
('slot_in_10', '10시대 출근', '10시대 출근 (지각/유연근무)', 1,
_make_count_eval(lambda db: _count_clock_in_in_range(db, 10, 11), 1),
TIER_BRONZE, '🕙'),
('slot_in_11', '11시대 출근', '11시대 출근 (자조)', 1,
_make_count_eval(lambda db: _count_clock_in_in_range(db, 11, 12), 1),
TIER_SILVER, '🕦'),
('slot_out_19', '19시대 퇴근', '19시대 퇴근 10회 (경고)', 10,
_make_count_eval(lambda db: _count_clockouts_in_hour(db, 19), 10),
TIER_SILVER, '🌆'),
('slot_out_20', '20시대 퇴근', '20시대 퇴근 10회 (경고)', 10,
_make_count_eval(lambda db: _count_clockouts_in_hour(db, 20), 10),
TIER_GOLD, '🌌'),
('slot_out_21', '21시대 퇴근', '21시대 퇴근 5회 (경고)', 5,
_make_count_eval(lambda db: _count_clockouts_in_hour(db, 21), 5),
TIER_GOLD, '🌑'),
('slot_out_22', '22시대 퇴근', '22시대 퇴근 1회 (경고)', 1,
_make_count_eval(lambda db: _count_clockouts_in_hour(db, 22), 1),
TIER_PLATINUM, '🦉'),
('slot_out_23', '23시대 퇴근', '23시대 퇴근 1회 (경고)', 1,
_make_count_eval(lambda db: _count_clockouts_in_hour(db, 23), 1),
TIER_PLATINUM, '🦇'),
('slot_midnight', '자정 퇴근', '자정 이후 퇴근 (경고)', 1,
_make_count_eval(_count_clock_out_after_midnight, 1), TIER_LEGEND, '🌚'),
('slot_midnight_3', '올빼미 트리오', '자정 이후 퇴근 3회 (경고)', 3,
_make_count_eval(_count_clock_out_after_midnight, 3), TIER_LEGEND, '🌌'),
]
def _count_clockouts_in_hour(db, hour: int) -> int:
"""clock_out이 hour시대(HH:00-HH:59)인 횟수. 자정 넘김 케이스 무시."""
s = f"{hour:02d}:00:00"
e = f"{hour+1:02d}:00:00" if hour < 23 else "23:59:59"
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM work_records
WHERE clock_out IS NOT NULL AND clock_out >= ? AND clock_out < ?
AND clock_out >= clock_in
""", (s, e))
return cur.fetchone()[0]
# ---- 10. 공휴일·주말 ----
_SPECIAL_DAY_DEFS = [
('weekend_1', '주말 출근 1회', '토/일 출근 1회', 1,
_make_count_eval(_count_weekend_clockins, 1), TIER_SILVER, '🌃'),
('weekend_5', '주말 워커', '주말 출근 5회 (경고)', 5,
_make_count_eval(_count_weekend_clockins, 5), TIER_GOLD, '🌑'),
('weekend_20', '진짜 워크홀릭', '주말 출근 20회 (강한 자조)', 20,
_make_count_eval(_count_weekend_clockins, 20), TIER_PLATINUM, '💀'),
('holiday_1', '공휴일 출근', '한국 공휴일 출근 1회', 1,
_make_count_eval(_count_holiday_clockins, 1), TIER_GOLD, '📆'),
('holiday_5', '공휴일 워커홀릭', '한국 공휴일 출근 5회 (경고)', 5,
_make_count_eval(_count_holiday_clockins, 5), TIER_LEGEND, '⚠️'),
('day_christmas', '크리스마스 출근', '12/25 출근 (자조)', 1,
_bool_eval(lambda db: _has_clockin_on(db, '12-25')), TIER_GOLD, '🎄'),
('day_newyear', '신정 출근', '1/1 출근 (자조)', 1,
_bool_eval(lambda db: _has_clockin_on(db, '01-01')), TIER_GOLD, '🎊'),
('day_liberation', '광복절 출근', '8/15 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '08-15')), TIER_SILVER, '🎆'),
('day_children', '어린이날 출근', '5/5 출근 (자조)', 1,
_bool_eval(lambda db: _has_clockin_on(db, '05-05')), TIER_GOLD, '🎀'),
('day_hangul', '한글날 출근', '10/9 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '10-09')), TIER_SILVER, '🎤'),
('day_valentine', '발렌타인데이 출근', '2/14 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '02-14')), TIER_BRONZE, '💝'),
('day_white', '화이트데이 출근', '3/14 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '03-14')), TIER_BRONZE, '🌹'),
('day_pepero', '빼빼로데이', '11/11 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '11-11')), TIER_SILVER, '🍫'),
('day_halloween', '핼러윈 출근', '10/31 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '10-31')), TIER_BRONZE, '🎃'),
('day_aprilfools', '만우절 출근', '4/1 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '04-01')), TIER_BRONZE, '🃏'),
('day_77', '칠월칠석', '7/7 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '07-07')), TIER_SILVER, '🎋'),
('day_dongji', '동지 출근', '12/22 출근', 1,
_bool_eval(lambda db: _has_clockin_on(db, '12-22')), TIER_BRONZE, '🎇'),
('day_parents', '어버이날 정시 퇴근', '5/8 정시 퇴근', 1,
_bool_eval(lambda db: _has_punctual_clockout_on(db, '05-08')),
TIER_SILVER, '🪅'),
('day_teacher', '스승의 날 정시 퇴근', '5/15 정시 퇴근', 1,
_bool_eval(lambda db: _has_punctual_clockout_on(db, '05-15')),
TIER_BRONZE, '🎂'),
('day_xmas_eve', '크리스마스이브 정시 퇴근', '12/24 정시 퇴근', 1,
_bool_eval(lambda db: _has_punctual_clockout_on(db, '12-24')),
TIER_SILVER, '🎁'),
('day_earth', '지구의 날', '4/22 출근 (시크릿)', 1,
_bool_eval(lambda db: _has_clockin_on(db, '04-22')), TIER_GOLD, '🌏'),
]
# ---- 11. 시즌·월별 ----
def _make_month_full_attendance_eval(month: int):
"""해당 월 영업일 모두 출근."""
def _eval(db):
year = date.today().year
target = _workdays_in_year_month(year, month)
cur = _count_in_year_month(db, year, month)
# 영업일 수 정확히 카운트는 holidays 제외 안 함 — 단순화
return min(cur, target), max(target, 1)
return _eval
def _make_month_first_eval(month: int):
def _eval(db):
year = date.today().year
return ((1, 1) if _count_in_year_month(db, year, month) >= 1 else (0, 1))
return _eval
_SEASON_DEFS = [
('season_jan', '1월 정착', '1월 한 달 출근', 1,
_make_month_first_eval(1), TIER_BRONZE, '⛄'),
('season_feb', '2월 정착', '2월 영업일 모두 출근', 1,
_make_month_full_attendance_eval(2), TIER_SILVER, '🌨️'),
('season_mar', '봄을 맞이', '3월 첫 출근', 1,
_make_month_first_eval(3), TIER_BRONZE, '🌸'),
('season_apr', '4월 정착', '4월 한 달 출근', 1,
_make_month_full_attendance_eval(4), TIER_BRONZE, '🌷'),
('season_may', '5월 정착', '5월 영업일 모두 출근', 1,
_make_month_full_attendance_eval(5), TIER_SILVER, '🌺'),
('season_jun', '여름의 시작', '6월 첫 출근', 1,
_make_month_first_eval(6), TIER_BRONZE, '☀️'),
('season_jul', '7월 정착', '7월 한 달 출근', 1,
_make_month_full_attendance_eval(7), TIER_BRONZE, '🌻'),
('season_aug', '8월 정착', '8월 영업일 모두 출근', 1,
_make_month_full_attendance_eval(8), TIER_SILVER, '🍦'),
('season_sep', '가을의 시작', '9월 첫 출근', 1,
_make_month_first_eval(9), TIER_BRONZE, '🍂'),
('season_oct', '10월 정착', '10월 한 달 출근', 1,
_make_month_full_attendance_eval(10), TIER_BRONZE, '🌾'),
('season_nov', '11월 단풍', '11월 영업일 모두 출근', 1,
_make_month_full_attendance_eval(11), TIER_SILVER, '🍁'),
('season_dec', '겨울의 시작', '12월 첫 출근', 1,
_make_month_first_eval(12), TIER_BRONZE, '❄️'),
]
# ---- 12. 앱 사용 마일스톤 ----
_MILESTONE_DEFS = [
('mile_first', 'Hello, World!', '앱 첫 실행', 1,
_bool_eval(lambda db: _count_work_records(db) >= 1 or _days_since_first_work(db) >= 0),
TIER_BRONZE, '👋'),
('mile_7days', '일주일 사용', '7일 사용', 7,
_make_count_eval(_days_since_first_work, 7), TIER_BRONZE, '🗓️'),
('mile_30days', '한 달 사용', '30일 사용', 30,
_make_count_eval(_days_since_first_work, 30), TIER_SILVER, '📚'),
('mile_365days', '1주년', '365일 사용', 365,
_make_count_eval(_days_since_first_work, 365), TIER_PLATINUM, '💎'),
('mile_730days', '2주년', '730일 사용', 730,
_make_count_eval(_days_since_first_work, 730), TIER_LEGEND, '🌟'),
('mile_1095days', '3주년', '3년 사용', 1095,
_make_count_eval(_days_since_first_work, 1095), TIER_LEGEND, '🎖️'),
('mile_5years', '5년 사용자', '5년 사용', 1825,
_make_count_eval(_days_since_first_work, 1825), TIER_LEGEND, '🏆'),
('mile_10years', '10년 사용자', '10년 사용', 3650,
_make_count_eval(_days_since_first_work, 3650), TIER_LEGEND, '🎖️'),
]
# ---- 13. 통계·분석 (view counter 기반) ----
_STATS_DEFS = [
('stat_weekly_10', '주간 통계러', '주간 탭 10회 조회', 10,
_make_count_eval(lambda db: _setting_int(db, 'stat_weekly_view_count'), 10),
TIER_BRONZE, '📊'),
('stat_monthly_10', '월간 통계러', '월간 탭 10회', 10,
_make_count_eval(lambda db: _setting_int(db, 'stat_monthly_view_count'), 10),
TIER_BRONZE, '📈'),
('stat_pattern_10', '패턴 분석가', '패턴 탭 10회', 10,
_make_count_eval(lambda db: _setting_int(db, 'stat_pattern_view_count'), 10),
TIER_SILVER, '🔍'),
('stat_calendar_30', '캘린더 챔프', '캘린더 30회 조회', 30,
_make_count_eval(lambda db: _setting_int(db, 'calendar_view_count'), 30),
TIER_SILVER, '📅'),
('stat_report_first', '일일 보고서 첫 생성', '일일 보고 1회', 1,
_make_count_eval(lambda db: _setting_int(db, 'daily_report_count'), 1),
TIER_BRONZE, '📋'),
('stat_report_30', '보고서 챔프', '일일 보고 30회', 30,
_make_count_eval(lambda db: _setting_int(db, 'daily_report_count'), 30),
TIER_SILVER, '📰'),
('stat_chart_hover', '차트 호버 발견', '차트 hover 첫 발견', 1,
_bool_eval(lambda db: db.get_setting('chart_hover_discovered', 'false').lower() == 'true'),
TIER_BRONZE, '🎨'),
('stat_achievements_open', '도전과제 박물관', '도전과제 뷰 50회', 50,
_make_count_eval(lambda db: _setting_int(db, 'achievements_view_count'), 50),
TIER_BRONZE, '🦄'),
]
# ---- 14. 시크릿 ----
def _has_clock_in_palindrome(db) -> bool:
"""출근 시각이 회문 (HH:MM에서 H1H2:M1M2가 회문)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT clock_in FROM work_records WHERE clock_in IS NOT NULL")
for (t,) in cur.fetchall():
if not t:
continue
digits = t[:5].replace(':', '')
if len(digits) == 4 and digits == digits[::-1]:
return True
return False
def _has_clock_in_jackpot(db) -> bool:
"""출근 시각 모든 자릿수 동일 (11:11, 22:22)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT clock_in FROM work_records WHERE clock_in IS NOT NULL")
for (t,) in cur.fetchall():
if not t:
continue
digits = t[:5].replace(':', '')
if len(digits) == 4 and len(set(digits)) == 1:
return True
return False
def _has_friday_13th_clockin(db) -> bool:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE strftime('%w', date) = '5'
AND CAST(strftime('%d', date) AS INTEGER) = 13
LIMIT 1
""")
return cur.fetchone() is not None
def _has_777(db) -> bool:
"""7월 7일 7시 7분 출근."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE strftime('%m-%d', date) = '07-07'
AND clock_in LIKE '07:07%'
LIMIT 1
""")
return cur.fetchone() is not None
def _has_exact_8h(db) -> bool:
"""정확히 8시간 0분 0초 근무."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE clock_in IS NOT NULL AND clock_out IS NOT NULL
AND total_hours = 8.0
LIMIT 1
""")
return cur.fetchone() is not None
def _has_pi_day(db) -> bool:
"""3/14 1:59 출근 (π = 3.14159)."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE strftime('%m-%d', date) = '03-14'
AND clock_in LIKE '01:59%'
LIMIT 1
""")
return cur.fetchone() is not None
def _has_fibonacci_minute(db) -> bool:
"""출근 시각 분이 피보나치 (1,2,3,5,8,13,21,34,55)."""
fibs = {1, 2, 3, 5, 8, 13, 21, 34, 55}
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT CAST(strftime('%M', clock_in) AS INTEGER) FROM work_records
WHERE clock_in IS NOT NULL
""")
return any(r[0] in fibs for r in cur.fetchall())
def _has_double_six(db) -> bool:
"""6/6 18:06 출근."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT 1 FROM work_records
WHERE strftime('%m-%d', date) = '06-06'
AND clock_in LIKE '18:06%'
LIMIT 1
""")
return cur.fetchone() is not None
def _has_500_anniv_clockin(db) -> bool:
"""가입 후 정확히 365일 후 출근."""
hire = _setting_str(db, 'hire_date', '')
if not hire:
return False
try:
d = datetime.strptime(hire, '%Y-%m-%d').date()
target = d + timedelta(days=365)
return _has_clockin_on_date(db, target)
except ValueError:
return False
_SECRET_DEFS = [
('secret_palindrome', '회문 시각', '출근 시각이 회문', 1,
_bool_eval(_has_clock_in_palindrome), TIER_GOLD, '🪞'),
('secret_jackpot', '잭팟 시각', '출근 시각 모든 자릿수 동일', 1,
_bool_eval(_has_clock_in_jackpot), TIER_PLATINUM, '🎰'),
('secret_fri13', '13일 금요일', '13일 금요일 출근', 1,
_bool_eval(_has_friday_13th_clockin), TIER_GOLD, '🌑'),
('secret_777', '7-7-7', '7월 7일 7시 7분 출근', 1,
_bool_eval(_has_777), TIER_LEGEND, '🔮'),
('secret_exact_8h', '정확 8시간', '정확히 8h 0m 근무', 1,
_bool_eval(_has_exact_8h), TIER_PLATINUM, '🎯'),
('secret_pi_day', '파이 데이', '3/14 01:59 출근', 1,
_bool_eval(_has_pi_day), TIER_LEGEND, '🥧'),
('secret_fibonacci', '피보나치', '출근 분이 피보나치 수', 1,
_bool_eval(_has_fibonacci_minute), TIER_SILVER, '🔢'),
('secret_double_six', '더블 식스', '6/6 18:06 출근', 1,
_bool_eval(_has_double_six), TIER_LEGEND, '🎲'),
('secret_anniversary', '마법사', '가입 후 정확히 365일 후 출근', 1,
_bool_eval(_has_500_anniv_clockin), TIER_LEGEND, '🧙'),
]
# ---- 15. 다양성·설정 ----
def _setting_changed_from_default(db, key: str, default_value: str) -> bool:
return str(db.get_setting(key, default_value)) != default_value
_SETTINGS_DEFS = [
('set_dark', '다크 사이드', '다크 테마 1회 사용', 1,
_bool_eval(lambda db: _setting_changed_from_default(db, 'theme', 'light')),
TIER_BRONZE, '🌗'),
('set_lang', '이중언어', '언어 변경 (en 사용)', 1,
_bool_eval(lambda db: db.get_setting('language', 'ko') == 'en'),
TIER_BRONZE, '🌐'),
('set_a11y', '접근성 활용', '글꼴 크기≠100% 또는 고대비 ON', 1,
_bool_eval(lambda db: db.get_setting('font_scale', '1.0') != '1.0'
or db.get_setting('high_contrast', 'false').lower() == 'true'),
TIER_BRONZE, '♿'),
('set_overtime_unit', '단위 변경', 'overtime_unit 변경', 1,
_bool_eval(lambda db: db.get_setting('overtime_unit', '30') != '30'),
TIER_BRONZE, '⏱️'),
('set_goal_full', '목표 마스터', '월 연장+일평균 둘 다 설정', 1,
_bool_eval(lambda db: _setting_int(db, 'goal_overtime_max_monthly') > 0
and float(db.get_setting('goal_avg_hours_daily', '0') or 0) > 0),
TIER_SILVER, '🎯'),
('set_discord_full', '풀 셋업', 'Discord URL + 모든 알림 ON', 1,
_bool_eval(lambda db: bool(db.get_setting('discord_webhook_url', '') or '')
and all(db.get_setting(k, 'true').lower() == 'true' for k in
('notification_clock_out', 'notification_lunch',
'notification_overtime', 'notification_health'))),
TIER_SILVER, '🔔'),
('set_cloud', '클라우드 동기화', 'DB 경로 변경', 1,
_bool_eval(lambda db: bool(db.get_setting('db_path_override', '') or '')),
TIER_SILVER, '☁️'),
]
# ---- 16. 메타 (도전과제 자체) ----
def _earned_count(db) -> int:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("SELECT COUNT(*) FROM achievements WHERE earned_date IS NOT NULL")
return cur.fetchone()[0]
def _earned_secret_count(db) -> int:
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT COUNT(*) FROM achievements
WHERE earned_date IS NOT NULL AND is_secret = 1
""")
return cur.fetchone()[0]
_META_DEFS = [
('meta_first', '첫 도전과제', '첫 도전과제 획득', 1,
_make_count_eval(_earned_count, 1), TIER_BRONZE, '🏆'),
('meta_10', '10개 달성', '10개 보유', 10,
_make_count_eval(_earned_count, 10), TIER_BRONZE, '🎖️'),
('meta_25', '25개 달성', '25개 보유', 25,
_make_count_eval(_earned_count, 25), TIER_SILVER, '🥈'),
('meta_50', '50개 달성', '50개 보유', 50,
_make_count_eval(_earned_count, 50), TIER_GOLD, '🥇'),
('meta_75', '75개 달성', '75개 보유', 75,
_make_count_eval(_earned_count, 75), TIER_PLATINUM, '💎'),
('meta_100', '100개 달성', '100개 보유', 100,
_make_count_eval(_earned_count, 100), TIER_LEGEND, '🌟'),
('meta_secret_1', '시크릿 발견', '첫 시크릿 발견', 1,
_make_count_eval(_earned_secret_count, 1), TIER_SILVER, '🔍'),
('meta_secret_5', '시크릿 헌터', '시크릿 5개 발견', 5,
_make_count_eval(_earned_secret_count, 5), TIER_GOLD, '🌑'),
]
# ============================================================
# 모든 도전과제 통합
# ============================================================
def _build_all() -> List[Achievement]:
"""모든 카테고리를 합쳐 Achievement 리스트로 반환."""
all_defs = []
sections = [
(CAT_STREAK, _STREAK_DEFS),
(CAT_PUNCTUAL, _PUNCTUAL_DEFS),
(CAT_BALANCE, _BALANCE_DEFS),
(CAT_OT_BANK, _OT_BANK_DEFS),
(CAT_OT_USE, _OT_USE_DEFS),
(CAT_LEAVE, _LEAVE_DEFS),
(CAT_MEAL, _MEAL_DEFS),
(CAT_BREAK, _BREAK_DEFS),
(CAT_TIME_SLOT, _TIME_SLOT_DEFS),
(CAT_SPECIAL_DAY, _SPECIAL_DAY_DEFS),
(CAT_SEASON, _SEASON_DEFS),
(CAT_MILESTONE, _MILESTONE_DEFS),
(CAT_STATS, _STATS_DEFS),
(CAT_SETTINGS, _SETTINGS_DEFS),
(CAT_SECRET, _SECRET_DEFS),
(CAT_META, _META_DEFS),
]
for cat, defs in sections:
for tup in defs:
code, name, desc, target, evaluator, tier, icon = tup
is_secret = (cat == CAT_SECRET)
all_defs.append(Achievement(
code=code, name=name, description=desc, category=cat,
tier=tier, badge_icon=icon, is_secret=is_secret,
target=target, evaluator=evaluator,
))
return all_defs
ALL_ACHIEVEMENTS: List[Achievement] = _build_all()
def get_achievement(code: str) -> Optional[Achievement]:
for a in ALL_ACHIEVEMENTS:
if a.code == code:
return a
return None
# ============================================================
# DB 동기화 + 평가
# ============================================================
def sync_definitions_to_db(db) -> None:
"""ALL_ACHIEVEMENTS 정의를 achievements 테이블에 upsert.
code가 unique key. 신규 도전과제는 INSERT, 기존은 메타데이터 UPDATE
(earned_date, progress는 보존).
"""
with db._conn() as conn:
cur = conn.cursor()
for a in ALL_ACHIEVEMENTS:
cur.execute("SELECT id FROM achievements WHERE code = ?", (a.code,))
row = cur.fetchone()
if row is None:
cur.execute('''
INSERT INTO achievements
(code, name, description, category, tier, is_secret,
progress, target, badge_icon)
VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)
''', (a.code, a.name, a.description, a.category, a.tier,
1 if a.is_secret else 0, a.target, a.badge_icon))
else:
cur.execute('''
UPDATE achievements
SET name = ?, description = ?, category = ?, tier = ?,
is_secret = ?, target = ?, badge_icon = ?
WHERE code = ?
''', (a.name, a.description, a.category, a.tier,
1 if a.is_secret else 0, a.target, a.badge_icon, a.code))
conn.commit()
def evaluate_all(db) -> List[Achievement]:
"""미획득 도전과제만 평가. 새로 잠금 해제된 것 리스트 반환.
side effect: progress 업데이트, earned_date 기록.
"""
newly_unlocked = []
with db._conn() as conn:
cur = conn.cursor()
for a in ALL_ACHIEVEMENTS:
if a.evaluator is None:
continue
cur.execute("""
SELECT progress, earned_date FROM achievements WHERE code = ?
""", (a.code,))
row = cur.fetchone()
if row is None:
continue
stored_progress, earned = row[0], row[1]
if earned is not None:
continue # 이미 획득
try:
progress, target = a.evaluator(db)
except Exception:
continue # 평가 실패는 silent (다음 tick에 재시도)
now_unlocked = progress >= target
if progress != stored_progress or now_unlocked:
if now_unlocked:
cur.execute("""
UPDATE achievements
SET progress = ?, earned_date = DATE('now', 'localtime')
WHERE code = ?
""", (target, a.code))
newly_unlocked.append(a)
else:
cur.execute("""
UPDATE achievements SET progress = ? WHERE code = ?
""", (progress, a.code))
conn.commit()
return newly_unlocked
def get_all_with_status(db) -> List[dict]:
"""UI용: 모든 도전과제 + 진행도/획득 상태 dict 리스트."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT code, name, description, category, tier, is_secret,
progress, target, earned_date, badge_icon
FROM achievements
ORDER BY
CASE WHEN earned_date IS NOT NULL THEN 0 ELSE 1 END,
category, tier
""")
return [dict(zip(
['code', 'name', 'description', 'category', 'tier', 'is_secret',
'progress', 'target', 'earned_date', 'badge_icon'],
row
)) for row in cur.fetchall()]
def get_stats(db) -> dict:
"""전체 통계 — 획득/총개수/비밀발견 등."""
with db._conn() as conn:
cur = conn.cursor()
cur.execute("""
SELECT
COUNT(*) AS total,
SUM(CASE WHEN earned_date IS NOT NULL THEN 1 ELSE 0 END) AS earned,
SUM(CASE WHEN is_secret = 1 THEN 1 ELSE 0 END) AS secret_total,
SUM(CASE WHEN is_secret = 1 AND earned_date IS NOT NULL THEN 1 ELSE 0 END) AS secret_earned
FROM achievements
""")
row = cur.fetchone()
return {
'total': row[0] or 0,
'earned': row[1] or 0,
'secret_total': row[2] or 0,
'secret_earned': row[3] or 0,
}
Reference in New Issue View Git Blame Copy Permalink