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

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

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

1336 lines
57 KiB
JavaScript

document.addEventListener('DOMContentLoaded', () => {
const tabLink = document.querySelector('[data-tab="cs-record-tab"]');
const calendarTitle = document.getElementById('cs-calendar-title');
const calendarGrid = document.getElementById('cs-calendar-grid');
const selectedDateTitle = document.getElementById('cs-selected-date-title');
const recordCount = document.getElementById('cs-record-count');
const recordList = document.getElementById('cs-record-list');
const recordInput = document.getElementById('cs-record-input');
const addButton = document.getElementById('cs-record-add');
const copyButton = document.getElementById('cs-copy-next');
const copySelectedButton = document.getElementById('cs-copy-selected');
const importInput = document.getElementById('cs-record-import');
const statusBox = document.getElementById('cs-record-status');
const permanentList = document.getElementById('cs-permanent-list');
const folderTabs = document.getElementById('cs-folder-tabs');
const memoModal = document.getElementById('cs-memo-modal');
const memoFolderSelect = document.getElementById('cs-memo-folder-select');
const memoContent = document.getElementById('cs-memo-content');
const memoSaveButton = document.getElementById('cs-memo-save');
const folderAddModal = document.getElementById('cs-folder-add-modal');
const folderNameInput = document.getElementById('cs-folder-name');
const folderAddColors = document.getElementById('cs-folder-add-colors');
const folderEditModal = document.getElementById('cs-folder-edit-modal');
const folderEditNameInput = document.getElementById('cs-folder-edit-name');
const folderEditColors = document.getElementById('cs-folder-edit-colors');
const folderDeleteModal = document.getElementById('cs-folder-delete-modal');
const folderDeleteSelect = document.getElementById('cs-folder-delete-select');
const memoDeleteModal = document.getElementById('cs-memo-delete-modal');
const memoDeletePreview = document.getElementById('cs-memo-delete-preview');
const scheduleList = document.getElementById('cs-schedule-list');
const scheduleCount = document.getElementById('cs-schedule-count');
const scheduleModal = document.getElementById('cs-schedule-modal');
const scheduleModalTitle = document.getElementById('cs-schedule-modal-title');
const scheduleDateInput = document.getElementById('cs-schedule-date');
const scheduleEndDateInput = document.getElementById('cs-schedule-end-date');
const scheduleAllDayInput = document.getElementById('cs-schedule-all-day');
const scheduleTimeRow = document.querySelector('.cs-schedule-time-row');
const scheduleStartTimeInputs = {
period: document.getElementById('cs-schedule-start-period'),
hour: document.getElementById('cs-schedule-start-hour'),
minute: document.getElementById('cs-schedule-start-minute')
};
const scheduleEndTimeInputs = {
period: document.getElementById('cs-schedule-end-period'),
hour: document.getElementById('cs-schedule-end-hour'),
minute: document.getElementById('cs-schedule-end-minute')
};
const scheduleTitleInput = document.getElementById('cs-schedule-title');
const scheduleSaveButton = document.getElementById('cs-schedule-save');
const scheduleDeleteModal = document.getElementById('cs-schedule-delete-modal');
const scheduleDeletePreview = document.getElementById('cs-schedule-delete-preview');
const dataModal = document.getElementById('cs-data-modal');
if (!tabLink || !calendarGrid || !recordList) return;
const pad = value => String(value).padStart(2, '0');
const toLocalISO = date => `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
const fromISO = value => {
const [year, month, day] = value.split('-').map(Number);
return new Date(year, month - 1, day);
};
const weekdays = ['일', '월', '화', '수', '목', '금', '토'];
const folderColorOptions = [
{ value: '#FDE68A', label: '노랑' },
{ value: '#FDA4AF', label: '분홍' },
{ value: '#FDBA74', label: '주황' },
{ value: '#86EFAC', label: '초록' },
{ value: '#93C5FD', label: '파랑' },
{ value: '#C4B5FD', label: '보라' },
{ value: '#CBD5E1', label: '회색' }
];
const defaultFolderColor = folderColorOptions[0].value;
const today = new Date();
let selectedDate = toLocalISO(today);
let visibleMonth = new Date(today.getFullYear(), today.getMonth(), 1);
let monthSummary = new Map();
let holidaySummary = new Map();
let scheduleSummary = new Map();
let initialized = false;
let records = [];
let schedules = [];
let permanentMemos = [];
let memoFolders = [];
let selectedFolderId = null;
let editingFolderId = null;
let pendingMemoDeleteId = null;
let editingScheduleId = null;
let pendingScheduleDeleteId = null;
const selectedRecordIds = new Set();
let statusTimer = null;
function showStatus(message, success = false) {
if (statusTimer) clearTimeout(statusTimer);
statusBox.textContent = message;
statusBox.classList.toggle('success', success);
statusBox.hidden = false;
requestAnimationFrame(() => statusBox.classList.add('visible'));
statusTimer = setTimeout(clearStatus, 1000);
}
function clearStatus() {
if (statusTimer) clearTimeout(statusTimer);
statusTimer = null;
statusBox.classList.remove('visible');
setTimeout(() => {
if (!statusBox.classList.contains('visible')) statusBox.hidden = true;
}, 160);
statusBox.textContent = '';
statusBox.classList.remove('success');
}
async function api(url, options = {}) {
const response = await fetch(url, { cache: 'no-store', ...options });
let data = {};
try {
data = await response.json();
} catch (_) {
data = {};
}
if (!response.ok) {
throw new Error(data.detail || '요청을 처리하지 못했습니다.');
}
return data;
}
function formatSelectedDate(value) {
const date = fromISO(value);
return `${date.getFullYear()}년 ${date.getMonth() + 1}월 ${date.getDate()}일 (${weekdays[date.getDay()]})`;
}
function renderCalendar() {
const year = visibleMonth.getFullYear();
const month = visibleMonth.getMonth();
const firstWeekday = new Date(year, month, 1).getDay();
const daysInMonth = new Date(year, month + 1, 0).getDate();
calendarTitle.textContent = `${year}년 ${month + 1}월`;
calendarGrid.replaceChildren();
for (let index = 0; index < firstWeekday; index += 1) {
const blank = document.createElement('span');
blank.className = 'cs-calendar-blank';
calendarGrid.appendChild(blank);
}
for (let day = 1; day <= daysInMonth; day += 1) {
const date = new Date(year, month, day);
const iso = toLocalISO(date);
const summary = monthSummary.get(iso);
const holidayName = holidaySummary.get(iso);
const daySchedules = scheduleSummary.get(iso) || [];
const button = document.createElement('button');
button.type = 'button';
button.className = 'cs-calendar-day';
button.textContent = String(day);
button.dataset.date = iso;
const accessibilityDetails = [];
if (holidayName) accessibilityDetails.push(holidayName);
if (summary) accessibilityDetails.push(`기록 ${summary.total_count}개`);
if (daySchedules.length) accessibilityDetails.push(`일정 ${daySchedules.length}개`);
button.setAttribute(
'aria-label',
`${formatSelectedDate(iso)}${accessibilityDetails.length ? ` ${accessibilityDetails.join(', ')}` : ''} 보기`
);
if (date.getDay() === 0) button.classList.add('sunday');
if (date.getDay() === 6) button.classList.add('saturday');
const titleParts = [];
if (holidayName) {
button.classList.add('holiday');
titleParts.push(holidayName);
}
if (iso === toLocalISO(today)) button.classList.add('today');
if (iso === selectedDate) button.classList.add('selected');
if (summary) {
button.classList.add('has-record');
if (summary.completed_count < summary.total_count) button.classList.add('has-incomplete');
titleParts.push(`${summary.total_count}개 기록 / ${summary.total_count - summary.completed_count}개 미완료`);
}
if (daySchedules.length) {
button.classList.add('has-schedule');
titleParts.push(daySchedules.map(schedule => schedule.title).join(', '));
const marker = document.createElement('span');
marker.className = 'cs-calendar-schedule-marker';
marker.setAttribute('aria-hidden', 'true');
button.appendChild(marker);
}
button.title = titleParts.join(' · ');
button.addEventListener('click', () => selectDate(iso));
calendarGrid.appendChild(button);
}
}
async function loadMonthSummary() {
const year = visibleMonth.getFullYear();
const month = visibleMonth.getMonth() + 1;
renderCalendar();
try {
const holidayRequest = year >= 2026 && year <= 2030
? api(`/api/cs-records/holidays?year=${year}`)
: Promise.resolve({ holidays: [] });
const [data, holidayData, scheduleData] = await Promise.all([
api(`/api/cs-records/month?year=${year}&month=${month}`),
holidayRequest,
api(`/api/cs-records/schedules?year=${year}&month=${month}`)
]);
monthSummary = new Map(data.days.map(day => [day.record_date, day]));
holidaySummary = new Map(holidayData.holidays.map(holiday => [holiday.date, holiday.name]));
schedules = scheduleData.schedules;
scheduleSummary = new Map();
schedules.forEach(schedule => {
const rangeEnd = schedule.end_date || schedule.schedule_date;
const cursor = fromISO(schedule.schedule_date);
const endDate = fromISO(rangeEnd);
while (cursor <= endDate) {
const dateKey = toLocalISO(cursor);
const daySchedules = scheduleSummary.get(dateKey) || [];
daySchedules.push(schedule);
scheduleSummary.set(dateKey, daySchedules);
cursor.setDate(cursor.getDate() + 1);
}
});
renderCalendar();
renderScheduleList();
} catch (error) {
monthSummary = new Map();
holidaySummary = new Map();
scheduleSummary = new Map();
schedules = [];
renderCalendar();
renderScheduleList();
showStatus(error.message);
}
}
function scheduleTimeLabel(startValue, endValue = null) {
const start = startValue ? startValue.slice(0, 5) : '';
const end = endValue ? endValue.slice(0, 5) : '';
if (start && end) return `${start} ~ ${end}`;
if (start) return start;
if (end) return `~ ${end}`;
return '종일';
}
function setTimeSelectValue(inputs, value) {
if (!value) {
inputs.period.value = '';
inputs.hour.value = '';
inputs.minute.value = '';
return;
}
const [hourText, minuteText = '00'] = value.slice(0, 5).split(':');
const hour24 = Number(hourText);
const hour12 = hour24 % 12 || 12;
const normalizedMinute = String(Math.min(50, Math.round(Number(minuteText) / 10) * 10)).padStart(2, '0');
inputs.period.value = hour24 >= 12 ? 'PM' : 'AM';
inputs.hour.value = String(hour12).padStart(2, '0');
inputs.minute.value = normalizedMinute;
}
function currentRoundedTime() {
const now = new Date();
now.setSeconds(0, 0);
now.setMinutes(Math.round(now.getMinutes() / 10) * 10);
return `${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}`;
}
function readTimeSelectValue(inputs, label) {
const values = [inputs.period.value, inputs.hour.value, inputs.minute.value];
if (values.every(value => !value)) return null;
if (values.some(value => !value)) {
const missingInput = !inputs.period.value ? inputs.period : (!inputs.hour.value ? inputs.hour : inputs.minute);
missingInput.focus();
throw new Error(`${label}의 오전·오후, 시, 분을 모두 선택해주세요.`);
}
let hour = Number(inputs.hour.value) % 12;
if (inputs.period.value === 'PM') hour += 12;
return `${String(hour).padStart(2, '0')}:${inputs.minute.value}`;
}
function setScheduleAllDay(isAllDay) {
scheduleAllDayInput.checked = isAllDay;
[...Object.values(scheduleStartTimeInputs), ...Object.values(scheduleEndTimeInputs)].forEach(input => {
input.disabled = isAllDay;
});
scheduleTimeRow.classList.toggle('is-all-day', isAllDay);
}
function scheduleRangeLabel(schedule) {
const start = fromISO(schedule.schedule_date);
const end = fromISO(schedule.end_date || schedule.schedule_date);
const startText = `${start.getMonth() + 1}월 ${start.getDate()}일 (${weekdays[start.getDay()]})`;
if (toLocalISO(start) === toLocalISO(end)) return startText;
return `${startText} ~ ${end.getMonth() + 1}월 ${end.getDate()}일 (${weekdays[end.getDay()]})`;
}
function isDateWithinSchedule(dateValue, schedule) {
const endDate = schedule.end_date || schedule.schedule_date;
return dateValue >= schedule.schedule_date && dateValue <= endDate;
}
function fillScheduleDateCard(card, schedule) {
const start = fromISO(schedule.schedule_date);
const end = fromISO(schedule.end_date || schedule.schedule_date);
const isSingleDay = toLocalISO(start) === toLocalISO(end);
const day = document.createElement('strong');
day.className = 'cs-schedule-card-day';
const weekday = document.createElement('span');
weekday.className = 'cs-schedule-card-weekday';
const toneClass = date => {
const key = toLocalISO(date);
if (date.getDay() === 0 || holidaySummary.has(key)) return 'holiday';
if (date.getDay() === 6) return 'saturday';
return 'weekday';
};
const appendEndpoint = (container, text, date) => {
const value = document.createElement('b');
value.className = toneClass(date);
value.textContent = text;
container.appendChild(value);
};
const appendSeparator = container => {
const separator = document.createElement('i');
separator.textContent = '~';
container.appendChild(separator);
};
if (isSingleDay) {
appendEndpoint(day, String(start.getDate()), start);
appendEndpoint(weekday, weekdays[start.getDay()], start);
} else {
appendEndpoint(day, String(start.getDate()), start);
appendSeparator(day);
appendEndpoint(day, String(end.getDate()), end);
appendEndpoint(weekday, weekdays[start.getDay()], start);
appendSeparator(weekday);
appendEndpoint(weekday, weekdays[end.getDay()], end);
}
card.append(day, weekday);
}
function renderScheduleList() {
scheduleList.replaceChildren();
scheduleCount.textContent = `${schedules.length}개`;
if (schedules.length === 0) {
const empty = document.createElement('div');
empty.className = 'cs-schedule-empty';
empty.innerHTML = '<span aria-hidden="true">🗓️</span><strong>등록된 일정이 없습니다.</strong><small>위 버튼을 눌러 일정을 추가해보세요.</small>';
scheduleList.appendChild(empty);
return;
}
schedules.forEach(schedule => {
const item = document.createElement('article');
item.className = `cs-schedule-row${isDateWithinSchedule(selectedDate, schedule) ? ' selected' : ''}`;
const dateButton = document.createElement('button');
dateButton.type = 'button';
dateButton.className = 'cs-schedule-date-card';
dateButton.setAttribute('aria-label', `${scheduleRangeLabel(schedule)} 기록 보기`);
fillScheduleDateCard(dateButton, schedule);
dateButton.addEventListener('click', () => selectDate(schedule.schedule_date));
const content = document.createElement('div');
content.className = 'cs-schedule-row-content';
const contentTop = document.createElement('div');
contentTop.className = 'cs-schedule-row-top';
const time = document.createElement('span');
time.className = `cs-schedule-time${schedule.start_time || schedule.end_time ? '' : ' all-day'}`;
time.textContent = scheduleTimeLabel(schedule.start_time, schedule.end_time);
contentTop.appendChild(time);
const titleButton = document.createElement('button');
titleButton.type = 'button';
titleButton.className = 'cs-schedule-title-button';
titleButton.textContent = schedule.title;
titleButton.title = '일정 수정';
titleButton.addEventListener('click', () => openScheduleEditor(schedule));
const actions = document.createElement('span');
actions.className = 'cs-schedule-item-actions';
const editButton = document.createElement('button');
editButton.type = 'button';
editButton.title = '일정 수정';
editButton.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 20h4l11-11a2.8 2.8 0 0 0-4-4L4 16v4Z"></path><path d="m13.5 6.5 4 4"></path></svg>';
editButton.setAttribute('aria-label', `${schedule.title} 일정 수정`);
editButton.addEventListener('click', () => openScheduleEditor(schedule));
const deleteButton = document.createElement('button');
deleteButton.type = 'button';
deleteButton.title = '일정 삭제';
deleteButton.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h16"></path><path d="M9 7V4h6v3"></path><path d="M6.5 7l1 13h9l1-13"></path><path d="M10 11v5M14 11v5"></path></svg>';
deleteButton.setAttribute('aria-label', `${schedule.title} 일정 삭제`);
deleteButton.addEventListener('click', () => openScheduleDelete(schedule));
actions.append(editButton, deleteButton);
content.append(contentTop, titleButton);
item.append(dateButton, content, actions);
scheduleList.appendChild(item);
});
}
function openScheduleEditor(schedule = null) {
editingScheduleId = schedule ? schedule.id : null;
scheduleModalTitle.textContent = schedule ? '일정 수정' : '일정 등록';
scheduleDateInput.value = schedule ? schedule.schedule_date : selectedDate;
scheduleEndDateInput.value = schedule ? (schedule.end_date || schedule.schedule_date) : selectedDate;
scheduleEndDateInput.min = scheduleDateInput.value;
const defaultTime = schedule ? null : currentRoundedTime();
setTimeSelectValue(scheduleStartTimeInputs, schedule?.start_time || defaultTime);
setTimeSelectValue(scheduleEndTimeInputs, schedule?.end_time || defaultTime);
setScheduleAllDay(Boolean(schedule && !schedule.start_time && !schedule.end_time));
scheduleTitleInput.value = schedule ? schedule.title : '';
scheduleSaveButton.textContent = schedule ? '변경 저장' : '일정 저장';
openModal(scheduleModal);
setTimeout(() => scheduleTitleInput.focus(), 0);
}
function openScheduleDelete(schedule) {
pendingScheduleDeleteId = schedule.id;
const timeText = scheduleTimeLabel(schedule.start_time, schedule.end_time);
scheduleDeletePreview.innerHTML = '';
const date = document.createElement('strong');
date.textContent = `${scheduleRangeLabel(schedule)} · ${timeText}`;
const title = document.createElement('span');
title.textContent = schedule.title;
scheduleDeletePreview.append(date, title);
openModal(scheduleDeleteModal);
}
async function saveSchedule() {
const scheduleDate = scheduleDateInput.value;
const scheduleEndDate = scheduleEndDateInput.value;
const title = scheduleTitleInput.value.trim();
let startTime;
let endTime;
try {
startTime = scheduleAllDayInput.checked ? null : readTimeSelectValue(scheduleStartTimeInputs, '시작 시간');
endTime = scheduleAllDayInput.checked ? null : readTimeSelectValue(scheduleEndTimeInputs, '종료 시간');
} catch (error) {
showStatus(error.message);
return;
}
if (!scheduleDate) {
scheduleDateInput.focus();
showStatus('일정 날짜를 선택해주세요.');
return;
}
if (!scheduleEndDate) {
scheduleEndDateInput.focus();
showStatus('일정 종료일을 선택해주세요.');
return;
}
if (scheduleEndDate < scheduleDate) {
scheduleEndDateInput.focus();
showStatus('종료일은 시작일보다 빠를 수 없습니다.');
return;
}
if (scheduleDate === scheduleEndDate && startTime && endTime && endTime < startTime) {
scheduleEndTimeInputs.hour.focus();
showStatus('같은 날짜의 종료 시간은 시작 시간보다 빠를 수 없습니다.');
return;
}
if (!title) {
scheduleTitleInput.focus();
showStatus('일정 내용을 입력해주세요.');
return;
}
scheduleSaveButton.disabled = true;
const wasEditing = Boolean(editingScheduleId);
try {
const data = await api(
wasEditing ? `/api/cs-records/schedules/${editingScheduleId}` : '/api/cs-records/schedules',
{
method: wasEditing ? 'PATCH' : 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
schedule_date: scheduleDate,
end_date: scheduleEndDate,
title,
start_time: startTime,
end_time: endTime
})
}
);
editingScheduleId = null;
selectedDate = data.schedule.schedule_date;
const savedDate = fromISO(selectedDate);
visibleMonth = new Date(savedDate.getFullYear(), savedDate.getMonth(), 1);
closeModal(scheduleModal);
await Promise.all([loadMonthSummary(), loadRecords()]);
showStatus(wasEditing ? '일정을 수정했습니다.' : '일정을 등록했습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
scheduleSaveButton.disabled = false;
}
}
async function deleteSchedule() {
const scheduleId = pendingScheduleDeleteId;
if (!scheduleId) return;
const button = document.getElementById('cs-schedule-delete-save');
button.disabled = true;
try {
await api(`/api/cs-records/schedules/${scheduleId}`, { method: 'DELETE' });
pendingScheduleDeleteId = null;
closeModal(scheduleDeleteModal);
await loadMonthSummary();
showStatus('일정을 삭제했습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
button.disabled = false;
}
}
function resizeTextarea(textarea) {
textarea.style.height = 'auto';
const minimumHeight = textarea.classList.contains('cs-record-text') ? 22 : 30;
textarea.style.height = `${Math.max(minimumHeight, textarea.scrollHeight)}px`;
}
function sourceLabel(source) {
if (source === 'new_cs') return 'New CS 자동';
if (source === 'copied') return '이월';
if (source === 'import') return '업로드';
return '';
}
function renderRecords() {
selectedDateTitle.textContent = formatSelectedDate(selectedDate);
const completed = records.filter(record => record.is_completed).length;
recordCount.textContent = `${records.length}개 기록 · ${records.length - completed}개 미완료`;
recordList.replaceChildren();
if (records.length === 0) {
const empty = document.createElement('div');
empty.className = 'cs-empty-state';
empty.textContent = '이 날짜에 작성된 기록이 없습니다.';
recordList.appendChild(empty);
updateSelectedCopyButton();
return;
}
records.forEach(record => {
const item = document.createElement('article');
item.className = `cs-record-item${record.is_completed ? ' completed' : ''}`;
const checkbox = document.createElement('input');
checkbox.type = 'checkbox';
checkbox.className = 'cs-record-checkbox';
checkbox.checked = selectedRecordIds.has(record.id);
checkbox.setAttribute('aria-label', '복사할 업무 선택');
const textarea = document.createElement('textarea');
textarea.className = 'cs-record-text';
textarea.rows = 1;
textarea.value = record.content;
textarea.maxLength = 10000;
textarea.setAttribute('aria-label', 'CS 기록 내용');
textarea.addEventListener('input', () => resizeTextarea(textarea));
setTimeout(() => resizeTextarea(textarea), 0);
const meta = document.createElement('div');
meta.className = 'cs-record-meta';
const label = sourceLabel(record.source);
if (label) {
const badge = document.createElement('span');
badge.className = 'cs-source-badge';
badge.textContent = label;
meta.appendChild(badge);
}
const deleteButton = document.createElement('button');
deleteButton.type = 'button';
deleteButton.className = 'cs-delete-button';
deleteButton.textContent = '삭제';
const completeButton = document.createElement('button');
completeButton.type = 'button';
completeButton.className = 'cs-complete-button';
completeButton.textContent = record.is_completed ? '완료 취소' : '완료';
meta.append(completeButton, deleteButton);
checkbox.addEventListener('change', () => {
if (checkbox.checked) selectedRecordIds.add(record.id);
else selectedRecordIds.delete(record.id);
updateSelectedCopyButton();
});
completeButton.addEventListener('click', async () => {
completeButton.disabled = true;
try {
const data = await api(`/api/cs-records/${record.id}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ is_completed: !record.is_completed })
});
Object.assign(record, data.record);
renderRecords();
await loadMonthSummary();
showStatus(record.is_completed ? '완료 처리했습니다.' : '미완료로 되돌렸습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
completeButton.disabled = false;
}
});
textarea.addEventListener('blur', async () => {
const content = textarea.value.trim();
if (!content) {
textarea.value = record.content;
resizeTextarea(textarea);
showStatus('내용은 비워둘 수 없습니다. 삭제 버튼을 이용해주세요.');
return;
}
if (content === record.content) return;
try {
const data = await api(`/api/cs-records/${record.id}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ content })
});
Object.assign(record, data.record);
showStatus('내용을 저장했습니다.', true);
} catch (error) {
textarea.value = record.content;
resizeTextarea(textarea);
showStatus(error.message);
}
});
deleteButton.addEventListener('click', async () => {
if (!confirm('이 CS 기록을 삭제할까요?')) return;
deleteButton.disabled = true;
try {
await api(`/api/cs-records/${record.id}`, { method: 'DELETE' });
selectedRecordIds.delete(record.id);
records = records.filter(itemRecord => itemRecord.id !== record.id);
renderRecords();
await loadMonthSummary();
showStatus('기록을 삭제했습니다.', true);
} catch (error) {
showStatus(error.message);
deleteButton.disabled = false;
}
});
item.append(checkbox, textarea, meta);
recordList.appendChild(item);
});
updateSelectedCopyButton();
}
function updateSelectedCopyButton() {
const count = selectedRecordIds.size;
copySelectedButton.textContent = count > 0 ? `체크내용 복사 (${count})` : '체크내용 복사';
}
function openModal(modal) {
modal.hidden = false;
requestAnimationFrame(() => modal.classList.add('open'));
}
function closeModal(modal) {
modal.classList.remove('open');
setTimeout(() => {
if (!modal.classList.contains('open')) modal.hidden = true;
}, 120);
}
function selectedFolder() {
return memoFolders.find(folder => folder.id === selectedFolderId) || null;
}
function renderColorPalette(container, groupName, selectedColor = defaultFolderColor) {
container.replaceChildren();
folderColorOptions.forEach(option => {
const label = document.createElement('label');
label.className = 'cs-color-choice';
label.title = option.label;
const input = document.createElement('input');
input.type = 'radio';
input.name = groupName;
input.value = option.value;
input.checked = option.value === selectedColor;
input.setAttribute('aria-label', option.label);
const swatch = document.createElement('span');
swatch.className = 'cs-color-swatch';
swatch.style.setProperty('--swatch-color', option.value);
label.append(input, swatch);
container.appendChild(label);
});
}
function selectedPaletteColor(container) {
return container.querySelector('input:checked')?.value || defaultFolderColor;
}
function openFolderSettings(folder) {
editingFolderId = folder.id;
folderEditNameInput.value = folder.name;
renderColorPalette(folderEditColors, 'cs-folder-edit-color', folder.color || defaultFolderColor);
openModal(folderEditModal);
setTimeout(() => {
folderEditNameInput.focus();
folderEditNameInput.select();
}, 0);
}
function fillFolderSelects() {
memoFolderSelect.replaceChildren();
folderDeleteSelect.replaceChildren();
memoFolders.forEach(folder => {
const option = document.createElement('option');
option.value = String(folder.id);
option.textContent = folder.name;
option.selected = folder.id === selectedFolderId;
memoFolderSelect.appendChild(option);
if (!folder.is_default) {
const deleteOption = document.createElement('option');
deleteOption.value = String(folder.id);
deleteOption.textContent = `${folder.name} (${folder.memo_count || 0}개)`;
folderDeleteSelect.appendChild(deleteOption);
}
});
}
function renderFolderTabs() {
folderTabs.replaceChildren();
memoFolders.forEach(folder => {
const button = document.createElement('button');
button.type = 'button';
button.className = `cs-folder-tab${folder.id === selectedFolderId ? ' active' : ''}`;
button.setAttribute('role', 'tab');
button.setAttribute('aria-selected', folder.id === selectedFolderId ? 'true' : 'false');
button.textContent = `${folder.name} ${folder.memo_count || 0}`;
button.title = '한 번 클릭: 폴더 열기 / 더블클릭: 폴더 설정';
button.style.setProperty('--folder-color', folder.color || defaultFolderColor);
button.addEventListener('click', async () => {
if (selectedFolderId === folder.id) return;
selectedFolderId = folder.id;
renderFolderTabs();
fillFolderSelects();
await loadPermanentMemos();
});
button.addEventListener('dblclick', event => {
event.preventDefault();
openFolderSettings(folder);
});
folderTabs.appendChild(button);
});
fillFolderSelects();
}
async function loadMemoFolders(preferredFolderId = null) {
const data = await api('/api/cs-records/memo-folders');
memoFolders = data.folders;
const preferred = Number(preferredFolderId);
const currentExists = memoFolders.some(folder => folder.id === selectedFolderId);
const preferredExists = memoFolders.some(folder => folder.id === preferred);
if (preferredExists) selectedFolderId = preferred;
else if (!currentExists) {
const defaultFolder = memoFolders.find(folder => folder.is_default);
selectedFolderId = defaultFolder ? defaultFolder.id : (memoFolders[0]?.id || null);
}
renderFolderTabs();
}
function renderPermanentMemos() {
permanentList.replaceChildren();
if (permanentMemos.length === 0) {
const empty = document.createElement('div');
empty.className = 'cs-empty-state';
empty.textContent = '항상 표시할 메모가 없습니다.';
permanentList.appendChild(empty);
return;
}
const memoColumns = [0, 1].map(() => {
const column = document.createElement('div');
column.className = 'cs-permanent-column';
return column;
});
permanentList.append(...memoColumns);
permanentMemos.forEach((memo, index) => {
const item = document.createElement('article');
item.className = 'cs-permanent-item';
item.style.setProperty('--memo-color', selectedFolder()?.color || defaultFolderColor);
const textarea = document.createElement('textarea');
textarea.className = 'cs-permanent-text';
textarea.value = memo.content;
textarea.maxLength = 10000;
textarea.setAttribute('aria-label', '항상 확인 메모 내용');
textarea.addEventListener('input', () => resizeTextarea(textarea));
setTimeout(() => resizeTextarea(textarea), 0);
const copyButton = document.createElement('button');
copyButton.type = 'button';
copyButton.className = 'cs-permanent-icon-button cs-permanent-copy';
copyButton.setAttribute('aria-label', '메모 내용 복사');
copyButton.title = '메모 내용 복사';
copyButton.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="8" y="8" width="11" height="11" rx="2"></rect><path d="M16 8V6a2 2 0 0 0-2-2H6a2 2 0 0 0-2 2v8a2 2 0 0 0 2 2h2"></path></svg>';
const deleteButton = document.createElement('button');
deleteButton.type = 'button';
deleteButton.className = 'cs-permanent-icon-button cs-permanent-delete';
deleteButton.setAttribute('aria-label', '메모 삭제');
deleteButton.title = '메모 삭제';
deleteButton.innerHTML = '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h16"></path><path d="M9 7V4h6v3"></path><path d="M6.5 7l1 13h9l1-13"></path><path d="M10 11v5M14 11v5"></path></svg>';
copyButton.addEventListener('click', async () => {
try {
const content = textarea.value;
const copied = typeof copyTextToClipboard === 'function'
? await copyTextToClipboard(content)
: false;
if (!copied) throw new Error('클립보드 복사에 실패했습니다.');
showStatus('메모 내용을 클립보드에 복사했습니다.', true);
} catch (error) {
showStatus(error.message);
}
});
textarea.addEventListener('blur', async () => {
const content = textarea.value.trim();
if (!content) {
textarea.value = memo.content;
resizeTextarea(textarea);
showStatus('내용은 비워둘 수 없습니다. 삭제 버튼을 이용해주세요.');
return;
}
if (content === memo.content) return;
try {
const data = await api(`/api/cs-records/permanent/${memo.id}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ content })
});
Object.assign(memo, data.memo);
showStatus('상시 메모를 수정했습니다.', true);
} catch (error) {
textarea.value = memo.content;
resizeTextarea(textarea);
showStatus(error.message);
}
});
deleteButton.addEventListener('click', () => {
pendingMemoDeleteId = memo.id;
memoDeletePreview.textContent = memo.content;
memoDeletePreview.style.setProperty('--memo-color', selectedFolder()?.color || defaultFolderColor);
openModal(memoDeleteModal);
});
item.append(copyButton, textarea, deleteButton);
memoColumns[index % 2].appendChild(item);
});
}
async function loadPermanentMemos() {
if (!selectedFolderId) {
permanentMemos = [];
renderPermanentMemos();
return;
}
permanentList.innerHTML = '<div class="cs-empty-state">불러오는 중...</div>';
try {
const data = await api(`/api/cs-records/permanent?folder_id=${selectedFolderId}`);
permanentMemos = data.memos;
renderPermanentMemos();
} catch (error) {
permanentMemos = [];
renderPermanentMemos();
showStatus(error.message);
}
}
async function deletePermanentMemo() {
const memoId = pendingMemoDeleteId;
if (!memoId) return;
const button = document.getElementById('cs-memo-delete-save');
button.disabled = true;
try {
await api(`/api/cs-records/permanent/${memoId}`, { method: 'DELETE' });
permanentMemos = permanentMemos.filter(memo => memo.id !== memoId);
pendingMemoDeleteId = null;
closeModal(memoDeleteModal);
renderPermanentMemos();
await loadMemoFolders(selectedFolderId);
showStatus('상시 메모를 삭제했습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
button.disabled = false;
}
}
async function addPermanentMemo() {
const content = memoContent.value.trim();
const folderId = Number(memoFolderSelect.value);
if (!content) {
memoContent.focus();
showStatus('상시 메모 내용을 입력해주세요.');
return;
}
memoSaveButton.disabled = true;
try {
await api('/api/cs-records/permanent', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ content, folder_id: folderId })
});
selectedFolderId = folderId;
memoContent.value = '';
closeModal(memoModal);
await loadMemoFolders(folderId);
await loadPermanentMemos();
showStatus('상시 메모를 추가했습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
memoSaveButton.disabled = false;
}
}
async function addMemoFolder() {
const name = folderNameInput.value.trim();
const color = selectedPaletteColor(folderAddColors);
if (!name) {
folderNameInput.focus();
showStatus('추가할 폴더 이름을 입력해주세요.');
return;
}
const button = document.getElementById('cs-folder-add-save');
button.disabled = true;
try {
const data = await api('/api/cs-records/memo-folders', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name, color })
});
folderNameInput.value = '';
closeModal(folderAddModal);
await loadMemoFolders(data.folder.id);
await loadPermanentMemos();
showStatus(`'${data.folder.name}' 폴더를 추가했습니다.`, true);
} catch (error) {
showStatus(error.message);
} finally {
button.disabled = false;
}
}
async function updateMemoFolder() {
const folderId = editingFolderId;
const name = folderEditNameInput.value.trim();
const color = selectedPaletteColor(folderEditColors);
if (!folderId) return;
if (!name) {
folderEditNameInput.focus();
showStatus('폴더 이름을 입력해주세요.');
return;
}
const button = document.getElementById('cs-folder-edit-save');
button.disabled = true;
try {
const data = await api(`/api/cs-records/memo-folders/${folderId}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ name, color })
});
editingFolderId = null;
closeModal(folderEditModal);
await loadMemoFolders(folderId);
await loadPermanentMemos();
showStatus(`'${data.folder.name}' 폴더 설정을 저장했습니다.`, true);
} catch (error) {
showStatus(error.message);
} finally {
button.disabled = false;
}
}
async function deleteMemoFolder() {
const folderId = Number(folderDeleteSelect.value);
if (!folderId) {
showStatus('삭제할 수 있는 폴더가 없습니다.');
return;
}
const folder = memoFolders.find(item => item.id === folderId);
if (!folder) return;
const button = document.getElementById('cs-folder-delete-save');
button.disabled = true;
try {
const data = await api(`/api/cs-records/memo-folders/${folderId}`, { method: 'DELETE' });
closeModal(folderDeleteModal);
await loadMemoFolders(data.default_folder_id);
await loadPermanentMemos();
showStatus(`폴더를 삭제하고 메모 ${data.moved_count}개를 기본 폴더로 이동했습니다.`, true);
} catch (error) {
showStatus(error.message);
} finally {
button.disabled = false;
}
}
async function loadRecords() {
selectedDateTitle.textContent = formatSelectedDate(selectedDate);
recordCount.textContent = '기록을 불러오는 중입니다.';
recordList.innerHTML = '<div class="cs-empty-state">불러오는 중...</div>';
try {
const data = await api(`/api/cs-records?record_date=${selectedDate}`);
records = data.records;
selectedRecordIds.clear();
clearStatus();
renderRecords();
} catch (error) {
records = [];
selectedRecordIds.clear();
renderRecords();
showStatus(error.message);
}
}
async function selectDate(iso) {
selectedDate = iso;
const date = fromISO(iso);
visibleMonth = new Date(date.getFullYear(), date.getMonth(), 1);
renderCalendar();
renderScheduleList();
await loadRecords();
}
async function addRecord() {
const content = recordInput.value.trim();
if (!content) {
recordInput.focus();
showStatus('메모 내용을 입력해주세요.');
return;
}
addButton.disabled = true;
try {
const data = await api('/api/cs-records', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ record_date: selectedDate, content })
});
records.push(data.record);
recordInput.value = '';
clearStatus();
renderRecords();
await loadMonthSummary();
showStatus('기록을 추가했습니다.', true);
} catch (error) {
showStatus(error.message);
} finally {
addButton.disabled = false;
}
}
addButton.addEventListener('click', addRecord);
recordInput.addEventListener('keydown', event => {
if (event.key === 'Enter' && (event.ctrlKey || event.metaKey)) {
event.preventDefault();
addRecord();
}
});
document.getElementById('cs-open-schedule-modal').addEventListener('click', () => {
openScheduleEditor();
});
document.getElementById('cs-open-data-modal').addEventListener('click', () => {
openModal(dataModal);
});
scheduleDateInput.addEventListener('change', () => {
scheduleEndDateInput.min = scheduleDateInput.value;
if (!scheduleEndDateInput.value || scheduleEndDateInput.value < scheduleDateInput.value) {
scheduleEndDateInput.value = scheduleDateInput.value;
}
});
scheduleAllDayInput.addEventListener('change', () => {
setScheduleAllDay(scheduleAllDayInput.checked);
});
scheduleSaveButton.addEventListener('click', saveSchedule);
scheduleTitleInput.addEventListener('keydown', event => {
if (event.key === 'Enter') {
event.preventDefault();
saveSchedule();
}
});
document.getElementById('cs-schedule-delete-save').addEventListener('click', deleteSchedule);
document.getElementById('cs-open-memo-modal').addEventListener('click', () => {
fillFolderSelects();
memoContent.value = '';
if (selectedFolderId) memoFolderSelect.value = String(selectedFolderId);
openModal(memoModal);
setTimeout(() => memoContent.focus(), 0);
});
memoSaveButton.addEventListener('click', addPermanentMemo);
memoContent.addEventListener('keydown', event => {
if (event.key === 'Enter' && (event.ctrlKey || event.metaKey)) {
event.preventDefault();
addPermanentMemo();
}
});
document.getElementById('cs-open-folder-add').addEventListener('click', () => {
folderNameInput.value = '';
renderColorPalette(folderAddColors, 'cs-folder-add-color', defaultFolderColor);
openModal(folderAddModal);
setTimeout(() => folderNameInput.focus(), 0);
});
document.getElementById('cs-folder-add-save').addEventListener('click', addMemoFolder);
folderNameInput.addEventListener('keydown', event => {
if (event.key === 'Enter') {
event.preventDefault();
addMemoFolder();
}
});
document.getElementById('cs-folder-edit-save').addEventListener('click', updateMemoFolder);
folderEditNameInput.addEventListener('keydown', event => {
if (event.key === 'Enter') {
event.preventDefault();
updateMemoFolder();
}
});
document.getElementById('cs-open-folder-delete').addEventListener('click', () => {
fillFolderSelects();
if (folderDeleteSelect.options.length === 0) {
showStatus('기본 폴더는 삭제할 수 없습니다. 삭제할 다른 폴더가 없습니다.');
return;
}
openModal(folderDeleteModal);
setTimeout(() => folderDeleteSelect.focus(), 0);
});
document.getElementById('cs-folder-delete-save').addEventListener('click', deleteMemoFolder);
document.getElementById('cs-memo-delete-save').addEventListener('click', deletePermanentMemo);
document.querySelectorAll('[data-cs-close]').forEach(button => {
button.addEventListener('click', () => {
const modal = document.getElementById(button.dataset.csClose);
if (modal) closeModal(modal);
});
});
[scheduleModal, scheduleDeleteModal, dataModal, memoModal, folderAddModal, folderEditModal, folderDeleteModal, memoDeleteModal].forEach(modal => {
modal.addEventListener('click', event => {
if (event.target === modal) closeModal(modal);
});
});
document.addEventListener('keydown', event => {
if (event.key !== 'Escape') return;
[scheduleModal, scheduleDeleteModal, dataModal, memoModal, folderAddModal, folderEditModal, folderDeleteModal, memoDeleteModal].forEach(modal => {
if (!modal.hidden) closeModal(modal);
});
});
document.getElementById('cs-calendar-prev').addEventListener('click', async () => {
visibleMonth = new Date(visibleMonth.getFullYear(), visibleMonth.getMonth() - 1, 1);
monthSummary = new Map();
holidaySummary = new Map();
scheduleSummary = new Map();
schedules = [];
await loadMonthSummary();
});
document.getElementById('cs-calendar-next').addEventListener('click', async () => {
visibleMonth = new Date(visibleMonth.getFullYear(), visibleMonth.getMonth() + 1, 1);
monthSummary = new Map();
holidaySummary = new Map();
scheduleSummary = new Map();
schedules = [];
await loadMonthSummary();
});
copyButton.addEventListener('click', async () => {
copyButton.disabled = true;
try {
const data = await api('/api/cs-records/copy-next', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ record_date: selectedDate })
});
const targetText = formatSelectedDate(data.target_date);
selectedDate = data.target_date;
const target = fromISO(selectedDate);
visibleMonth = new Date(target.getFullYear(), target.getMonth(), 1);
await Promise.all([loadMonthSummary(), loadRecords()]);
showStatus(`${data.copied_count}개 미완료 기록을 ${targetText}로 복사했습니다.`, true);
} catch (error) {
showStatus(error.message);
} finally {
copyButton.disabled = false;
}
});
function escapeClipboardHtml(value) {
return String(value)
.replace(/&/g, '&amp;')
.replace(/</g, '&lt;')
.replace(/>/g, '&gt;')
.replace(/"/g, '&quot;')
.replace(/'/g, '&#039;');
}
function buildSelectedRecordsClipboardData(selectedRecords) {
const contents = selectedRecords.map(record =>
String(record.content || '').replace(/\r\n?/g, '\n')
);
return {
text: contents.join('\r\n'),
html: contents.map(content => {
const lines = content.split('\n').map(escapeClipboardHtml);
return `<div>${lines.join('<br>')}</div>`;
}).join('')
};
}
function copyRichTextWithExecCommand(html) {
const selection = window.getSelection();
if (!selection) return false;
const savedRanges = [];
for (let index = 0; index < selection.rangeCount; index += 1) {
savedRanges.push(selection.getRangeAt(index).cloneRange());
}
const copyArea = document.createElement('div');
copyArea.contentEditable = 'true';
copyArea.setAttribute('aria-hidden', 'true');
copyArea.style.position = 'fixed';
copyArea.style.left = '-10000px';
copyArea.style.top = '0';
copyArea.innerHTML = html;
document.body.appendChild(copyArea);
const range = document.createRange();
range.selectNodeContents(copyArea);
selection.removeAllRanges();
selection.addRange(range);
let copied = false;
try {
copied = document.execCommand('copy');
} finally {
selection.removeAllRanges();
savedRanges.forEach(savedRange => selection.addRange(savedRange));
copyArea.remove();
}
return copied;
}
async function copySelectedRecordsToClipboard(selectedRecords) {
const { text, html } = buildSelectedRecordsClipboardData(selectedRecords);
if (navigator.clipboard && window.ClipboardItem && window.isSecureContext) {
try {
const clipboardItem = new ClipboardItem({
'text/plain': new Blob([text], { type: 'text/plain' }),
'text/html': new Blob([html], { type: 'text/html' })
});
await navigator.clipboard.write([clipboardItem]);
return true;
} catch (error) {
console.warn('서식이 있는 클립보드 복사 실패, 호환 방식으로 재시도합니다.', error);
}
}
if (copyRichTextWithExecCommand(html)) return true;
if (typeof copyTextToClipboard === 'function') {
return await copyTextToClipboard(text);
}
return false;
}
copySelectedButton.addEventListener('click', async () => {
const selectedRecords = records.filter(record => selectedRecordIds.has(record.id));
if (selectedRecords.length === 0) {
showStatus('복사할 업무 앞의 체크박스를 선택해주세요.');
return;
}
try {
const copied = await copySelectedRecordsToClipboard(selectedRecords);
if (!copied) throw new Error('클립보드 복사에 실패했습니다.');
showStatus(`${selectedRecords.length}개 업무 내용을 클립보드에 복사했습니다.`, true);
} catch (error) {
showStatus(error.message || '클립보드 복사에 실패했습니다.');
}
});
importInput.addEventListener('change', async () => {
const file = importInput.files && importInput.files[0];
if (!file) return;
const formData = new FormData();
formData.append('file', file);
showStatus('데이터를 업로드하는 중입니다.');
try {
const data = await api('/api/cs-records/import', { method: 'POST', body: formData });
await loadMemoFolders(selectedFolderId);
await Promise.all([loadMonthSummary(), loadRecords(), loadPermanentMemos()]);
const permanentText = data.permanent_added_count
? `, 상시 메모 ${data.permanent_added_count}개`
: '';
const scheduleText = data.schedule_added_count
? `, 일정 ${data.schedule_added_count}개`
: '';
showStatus(`날짜 메모 ${data.added_count}개${permanentText}${scheduleText}를 추가했습니다. ${data.skipped_count}개는 건너뛰었습니다.`, true);
} catch (error) {
showStatus(error.message);
} finally {
importInput.value = '';
}
});
tabLink.addEventListener('click', async () => {
if (!initialized) {
initialized = true;
}
try {
await loadMemoFolders(selectedFolderId);
await Promise.all([loadMonthSummary(), loadRecords(), loadPermanentMemos()]);
} catch (error) {
showStatus(error.message);
}
});
});