Files
dbx-main/app/static/project.js
T
king 84113d1fd7 feat(project): silence web alert popup while PC notifier is running
If the user has a non-revoked notifier token seen in the last 3 minutes,
/api/notifications/alerts returns only the baseline with desktop=true;
the web marks it seen so alerts resume on the web after the app stops.
A failing check keeps the web popup.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-08 11:35:14 +09:00

11003 lines
582 KiB
JavaScript
Raw Blame History

This file contains invisible Unicode characters
This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/* 프로젝트 관리(아사나식) 모듈 — 프론트엔드.
* 두 페이지에서 공용:
* - index.html (홈): 새 프로젝트 모달
* - project.html: 달력/타임라인/보드/리스트 뷰 + 업무 CRUD + 서브/멤버 관리
* 의존: FullCalendar(전역), vis(전역). 둘 다 project.html 에서만 로드.
*/
(function () {
"use strict";
// ── 공용 fetch ─────────────────────────────────────────────
const navigationSavers = [];
let navigationWrites = 0;
// 오른쪽 회의록을 바꾸기 전에 입력 칸 저장을 끝낸다. 실패하면 기존 화면을 유지한다.
window.PJFlushForNavigation = async function () {
if (document.activeElement && document.activeElement.blur) document.activeElement.blur();
await Promise.all(navigationSavers.map(function (flush) { return flush(); }));
if (navigationWrites) throw new Error("저장 중입니다. 저장이 끝난 뒤 다시 이동해 주세요.");
};
// extra.keepalive — 페이지를 떠나는 중에도 요청을 보내 달라고 브라우저에 부탁(보장은 아님, createFieldSaver 참고)
async function api(method, url, body, extra) {
const writing = method !== "GET";
if (writing) navigationWrites++;
try {
const opts = { method, headers: { "Content-Type": "application/json" } };
if (body !== undefined) opts.body = JSON.stringify(body);
if (extra && extra.keepalive) opts.keepalive = true;
const res = await fetch(url, opts);
if (!res.ok) {
let msg = res.statusText, detail = null;
try { detail = (await res.json()).detail; } catch (_) {}
if (typeof detail === "string") msg = detail;
else if (detail && detail.message) msg = detail.message;
const err = new Error(msg);
err.status = res.status; // 403(권한 없음)·404 를 일시 오류와 구분하려고
err.detail = detail;
throw err;
}
if (res.status === 204) return null;
return await res.json();
} finally { if (writing) navigationWrites--; }
}
function el(id) { return document.getElementById(id); }
// 한글 등 입력기 조합 중의 Enter(조합 확정)인지 — 이때는 전송·추가를 하지 않는다. 크롬·엣지는
// isComposing, 사파리·예전 브라우저는 keyCode 229 로 알려 준다. 조합이 끝난 뒤의 Enter 만 제출.
function isImeEnter(e) {
return !!(e && (e.isComposing || e.keyCode === 229));
}
// 댓글 한 건을 가리키는 임시 번호 — 같은 댓글을 다시 보내도(응답 유실·연타) 서버가 한 번만 만든다.
function newClientToken() {
try { if (window.crypto && crypto.randomUUID) return crypto.randomUUID(); } catch (_) {}
return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 12);
}
// ── 확인/알림/입력 창 — 브라우저 기본 창 대신 공용 창(erp-dialog.js). 프로젝트
// 관리 화면의 창 제목은 전부 "KSN 프로그램". 이 파일 안의 alert/confirm/prompt 는
// 아래 함수가 가린다 — confirm/prompt 는 Promise 라서 쓰는 곳은 await 한다.
window.ERP_DIALOG_TITLE = "KSN 프로그램";
function alert(msg) {
if (window.erpAlert) window.erpAlert(msg); else window.alert(msg);
}
function confirm(msg, opts) {
return window.erpConfirm ? window.erpConfirm(msg, opts) : Promise.resolve(window.confirm(msg));
}
function prompt(msg, def) {
return window.erpPrompt ? window.erpPrompt(msg, def) : Promise.resolve(window.prompt(msg, def));
}
// 화면 배율 토글(_help_btn.html, html.pj-ui-scale) — 켜면 .erp-app 을 0.75 로 줄여
// 2880×1620·200%(CSS 화면 1440px 폭)에서도 1920×1080 기준 화면처럼 보이게 한다.
// 팝업은 body 에 붙어 배율 밖이라 좌표를 그대로 쓰면 되고, 배율 안에서 마우스
// 거리로 크기를 바꾸는 곳(작업 창 너비)만 이 값으로 나눈다. CSS --pj-z 와 같은 값.
const UI_ZOOM = 0.75;
function uiZoom() { return document.documentElement.classList.contains("pj-ui-scale") ? UI_ZOOM : 1; }
function openModal(m) { if (m) m.hidden = false; }
function closeModal(m) { if (m) m.hidden = true; }
// 업무 편집 팝업 전용 — 아사나처럼 오른쪽에서 슬라이드로 열고 닫는다.
// hidden 을 먼저 풀고 reflow 를 강제한 뒤 .pj-panel-open 을 붙여야
// transform 트랜지션이 (display:none 상태에서 곧장) 걸린다. 닫을 때는
// transitionend 를 기다렸다가 hidden 을 다시 세운다(이벤트가 안 오는
// 경우를 대비해 타임아웃도 같이 건다).
function openSlidePanel(m) {
if (!m) return;
m.hidden = false;
void m.offsetWidth;
m.classList.add("pj-panel-open");
}
function closeSlidePanel(m) {
if (!m || m.hidden) return;
m.classList.remove("pj-panel-open");
const card = m.querySelector(".pj-task-modal-card");
let done = false;
function finish() { if (done) return; done = true; m.hidden = true; }
if (card) {
card.addEventListener("transitionend", function onEnd(e) {
if (e.target !== card || e.propertyName !== "transform") return;
card.removeEventListener("transitionend", onEnd);
finish();
});
setTimeout(finish, 320);
} else finish();
}
function wireModalClose(modal) {
if (!modal) return;
modal.addEventListener("click", function (e) {
if (e.target === modal || e.target.closest("[data-close]")) closeModal(modal);
});
}
// ── 토스트 알림 — alert() 대신 쓰는 비차단 피드백 ──
let toastEl = null, toastTimer = null;
function showToast(msg, type) {
if (!toastEl) {
toastEl = document.createElement("div");
toastEl.className = "erp-toast";
toastEl.setAttribute("role", "status");
toastEl.setAttribute("aria-live", "polite");
document.body.appendChild(toastEl);
}
toastEl.textContent = msg;
toastEl.dataset.type = type || "info";
toastEl.dataset.visible = "true";
clearTimeout(toastTimer);
toastTimer = setTimeout(function () { toastEl.dataset.visible = "false"; }, 2400);
}
// ── 우클릭 컨텍스트 메뉴 — 하나만 열리는 공용 컴포넌트.
// openDayPopover(아래)의 위치잡기/외부클릭 닫기 방식을 그대로 따르되, 앵커
// 엘리먼트 대신 클릭 좌표(clientX/Y) 기준으로 뷰포트에 클램프한다.
let ctxMenuEl = null, ctxMenuOpts = null;
function closeContextMenu(opts) {
if (!ctxMenuEl) return;
const menu = ctxMenuEl, o = ctxMenuOpts || {};
// 메뉴 안에 포커스가 있었으면(키보드로 다루던 중) 연 버튼으로 포커스를 돌려준다
const hadFocus = menu.contains(document.activeElement);
menu.remove();
ctxMenuEl = null;
ctxMenuOpts = null;
document.removeEventListener("mousedown", onCtxDocDown, true);
document.removeEventListener("keydown", onCtxKeyDown, true);
window.removeEventListener("scroll", onCtxScroll, true);
window.removeEventListener("resize", onCtxScroll, true);
if (o.onClose) o.onClose(opts || {});
if (o.returnFocus && (hadFocus || (opts && opts.focus)) && document.contains(o.returnFocus)) {
try { o.returnFocus.focus({ preventScroll: true }); } catch (_) { o.returnFocus.focus(); }
}
}
function onCtxScroll() { closeContextMenu(); }
function onCtxDocDown(e) {
if (ctxMenuEl && !ctxMenuEl.contains(e.target)) closeContextMenu({ target: e.target });
}
function onCtxKeyDown(e) {
if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); closeContextMenu({ focus: true }); }
}
// items: [{label, danger?, onClick} | null(구분선)]
// opts(선택): returnFocus = 닫으면 포커스를 돌려줄 요소(메뉴 버튼), focusFirst = 열자마자 첫 항목에 포커스(키보드로 연 경우),
// onClose = 닫힐 때(메뉴 버튼 aria-expanded 되돌리기). 메뉴 안: ↑↓·Home·End 이동, Esc 닫기, Tab 닫기.
// 우클릭 메뉴 왼쪽 아이콘(Material Symbols) — item.icon 에 넣는다
function menuIcon(name) { return '<span class="material-symbols-outlined pj-ctxmenu-mi">' + name + "</span>"; }
function showContextMenu(x, y, items, opts) {
closeContextMenu();
opts = opts || {};
const menu = document.createElement("div");
menu.className = "pj-ctxmenu";
menu.setAttribute("role", "menu");
if (opts.label) menu.setAttribute("aria-label", opts.label);
menu.tabIndex = -1;
items.forEach(function (item) {
if (!item) {
const sep = document.createElement("div");
sep.className = "pj-ctxmenu-sep";
menu.appendChild(sep);
return;
}
const b = document.createElement("button");
b.type = "button";
b.className = "pj-ctxmenu-item" + (item.danger ? " is-danger" : "") + (item.checked ? " is-checked" : "");
// item.icon(HTML) — 담당자 메뉴의 아바타 등. item.checked — 현재 값 표시(오른쪽 ✓).
if (item.icon || item.checked) {
b.innerHTML = (item.icon ? '<span class="pj-ctxmenu-ic">' + item.icon + "</span>" : "") +
'<span class="pj-ctxmenu-label"></span>' +
(item.checked ? '<span class="material-symbols-outlined pj-ctxmenu-check">check</span>' : "");
b.querySelector(".pj-ctxmenu-label").textContent = item.label;
} else {
b.textContent = item.label;
}
b.setAttribute("role", item.checked !== undefined ? "menuitemcheckbox" : "menuitem");
if (item.checked !== undefined) b.setAttribute("aria-checked", item.checked ? "true" : "false");
b.tabIndex = -1;
b.addEventListener("click", function () { closeContextMenu({ focus: true }); item.onClick(); });
menu.appendChild(b);
});
menu.addEventListener("keydown", function (e) {
const list = Array.from(menu.querySelectorAll(".pj-ctxmenu-item"));
const i = list.indexOf(document.activeElement);
let j = -1;
if (e.key === "ArrowDown") j = i < 0 ? 0 : (i + 1) % list.length;
else if (e.key === "ArrowUp") j = i <= 0 ? list.length - 1 : i - 1;
else if (e.key === "Home") j = 0;
else if (e.key === "End") j = list.length - 1;
else if (e.key === "Tab") { e.preventDefault(); closeContextMenu({ focus: true }); return; }
if (j < 0 || !list.length) return;
e.preventDefault();
list[j].focus();
});
document.body.appendChild(menu);
ctxMenuEl = menu;
ctxMenuOpts = opts;
let left = window.scrollX + x;
let top = window.scrollY + y;
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - menu.offsetWidth - 8);
top = Math.min(top, window.scrollY + document.documentElement.clientHeight - menu.offsetHeight - 8);
menu.style.left = Math.max(8, left) + "px";
menu.style.top = Math.max(8, top) + "px";
if (opts.returnFocus) {
// 메뉴 버튼으로 연 메뉴 — 첫 항목(키보드) 또는 메뉴 자체(마우스·터치)에 포커스를 줘 ↑↓·Esc 가 바로 먹게
const first = menu.querySelector(".pj-ctxmenu-item");
if (opts.focusFirst && first) first.focus(); else menu.focus();
}
setTimeout(function () {
if (ctxMenuEl !== menu) return; // 그 사이 닫혔으면 문서 리스너를 남기지 않는다
document.addEventListener("mousedown", onCtxDocDown, true);
document.addEventListener("keydown", onCtxKeyDown, true);
window.addEventListener("scroll", onCtxScroll, true);
window.addEventListener("resize", onCtxScroll, true);
}, 0);
}
// ── 칸별 자동 저장(목표 표·주간 회의록 공용) ─────────────────────────────
// · 저장 완료 기준(saved)은 "성공한 요청에 실어 보낸 값"만이다 — 응답이 올 때 바뀌어 있는 화면 값을 저장됐다고 보지 않는다.
// · 같은 칸의 요청은 한 줄로 세운다(앞 요청이 끝나야 다음 요청을 보냄) — 서버에 닿는 순서 = 보낸 순서라, 늦게 끝난 옛 요청이
// 최신 값을 덮지 않는다(응답만 무시하는 게 아니라 쓰기 자체를 차례대로). 다음 요청은 보낼 때의 최신 초안을 읽어서,
// 진행 중에 새로 입력한 글·숫자도 뒤이어 저장된다.
// · 실패하면 초안과 dirty 를 그대로 두고 칸에 실패 표시(cfg.onFail) — 다음 입력·칸 떠남·Enter·flushAll 이 다시 보낸다.
// · flushAll() 은 대기 타이머뿐 아니라 진행 중 요청까지 기다리고, 하나라도 실패하면 reject(구조 변경·표 교체를 멈추게).
// · 초안 백업(cfg.draftKey) — 입력할 때마다 localStorage 에 {base(서버에 저장된 값), draft}, 저장되면 지운다. 다음에 열 때
// 서버 값이 base 그대로면 초안을 되살려 다시 저장하고, 서버 값이 바뀌었으면 되살리지 않는다(다른 곳의 수정을 덮지 않게).
// · 페이지 떠남(onBeforeUnload): 진행 중 요청이 없는 dirty 칸은 keepalive 로 한 번 더 보낸다 — 브라우저가 끝까지 보낸다는
// 보장은 없어서 초안 백업이 함께 남는다. 실패했던 칸·진행 중 요청이 있는 칸·cfg.unload === "warn"(숫자 칸) 이 남아 있으면
// 브라우저 이탈 경고를 띄운다.
const DRAFT_PREFIX = "pj_draft:";
const DRAFT_TTL_MS = 14 * 24 * 3600 * 1000;
(function purgeOldDrafts() {
try {
const now = Date.now(), old = [];
for (let i = 0; i < localStorage.length; i++) {
const k = localStorage.key(i);
if (!k || k.indexOf(DRAFT_PREFIX) !== 0) continue;
let d = null;
try { d = JSON.parse(localStorage.getItem(k)); } catch (_) {}
if (!d || now - (d.at || 0) > DRAFT_TTL_MS) old.push(k);
}
old.forEach(function (k) { localStorage.removeItem(k); });
} catch (_) {}
})();
function createFieldSaver(cfg) {
const delay = cfg.delay == null ? 800 : cfg.delay;
const states = new Map(); // 칸 → {saved, chain, busy, timer, failed}
const alive = cfg.alive || function (f) { return document.contains(f); };
function noop() {}
function writeDraft(f, s) {
const k = cfg.draftKey && cfg.draftKey(f);
if (!k) return;
try {
const v = cfg.read(f);
if (v === s.saved) localStorage.removeItem(DRAFT_PREFIX + k);
else localStorage.setItem(DRAFT_PREFIX + k, JSON.stringify({ base: s.saved, draft: v, at: Date.now() }));
} catch (_) {}
}
// 칸 등록 — initial = 서버가 그려 준 값. 남은 초안이 있으면 되살린다: "restored" | "conflict" | null
function track(f, initial) {
const s = { saved: initial, chain: Promise.resolve(), busy: 0, timer: null, failed: false };
states.set(f, s);
const k = cfg.draftKey && cfg.draftKey(f);
if (!k) return null;
let d = null;
try { d = JSON.parse(localStorage.getItem(DRAFT_PREFIX + k) || "null"); } catch (_) {}
if (!d || typeof d.draft !== "string") return null;
if (d.draft === initial) { try { localStorage.removeItem(DRAFT_PREFIX + k); } catch (_) {} return null; }
if (d.base !== initial) { try { localStorage.removeItem(DRAFT_PREFIX + k); } catch (_) {} return "conflict"; }
if (cfg.write) cfg.write(f, d.draft);
queue(f);
return "restored";
}
function queue(f) {
const s = states.get(f);
if (!s) return;
clearTimeout(s.timer);
s.timer = setTimeout(function () { s.timer = null; flush(f).catch(noop); }, delay);
writeDraft(f, s);
}
function flush(f, opts) {
const s = states.get(f);
if (!s) return Promise.resolve(true);
clearTimeout(s.timer);
s.timer = null;
const run = async function () {
const v = cfg.read(f);
if (v === s.saved) {
if (s.failed) { s.failed = false; if (cfg.onClear) cfg.onClear(f); }
writeDraft(f, s);
return true;
}
let res;
try {
res = await cfg.send(f, v, opts || {});
} catch (err) {
s.failed = true;
writeDraft(f, s);
if (cfg.onFail) cfg.onFail(f, err);
throw err;
}
s.saved = v; // 이 요청에 실어 보낸 값만 저장됨으로
s.failed = false;
if (cfg.onSaved) {
const ns = cfg.onSaved(f, v, res, cfg.read(f) === v); // 마지막 인자: 요청 뒤 초안이 그대로인가
if (typeof ns === "string") s.saved = ns; // 서버 표기(쉼표 등)로 칸을 바꿨으면 그 값이 기준
}
writeDraft(f, s);
return true;
};
s.busy++;
// 앞 요청이 없으면 지금 바로(동기적으로 fetch 까지) — 페이지 떠날 때 keepalive 가 그 자리에서 나가게
const p = s.busy === 1 ? run() : s.chain.then(run, run);
s.chain = p.then(noop, noop).then(function () { s.busy--; });
return p;
}
function isDirty(f) {
const s = states.get(f);
return !!s && (s.busy > 0 || !!s.timer || cfg.read(f) !== s.saved);
}
function each(fn) { states.forEach(function (s, f) { if (alive(f)) fn(s, f); }); }
function anyDirty() { let d = false; each(function (s, f) { if (isDirty(f)) d = true; }); return d; }
function flushAll() {
const list = [];
each(function (s, f) { if (isDirty(f)) list.push(flush(f)); });
return Promise.allSettled(list).then(function (rs) {
const bad = rs.filter(function (r) { return r.status === "rejected"; });
if (!bad.length) return true;
const err = new Error("저장하지 못한 칸이 " + bad.length + "개 있어 멈췄습니다(입력한 내용은 그대로) — " +
((bad[0].reason && bad[0].reason.message) || "저장 실패"));
err.cause = bad[0].reason;
throw err;
});
}
function prune() { states.forEach(function (s, f) { if (!alive(f)) { clearTimeout(s.timer); states.delete(f); } }); }
function onBeforeUnload(e) {
let warn = false;
each(function (s, f) {
const dirty = cfg.read(f) !== s.saved;
if (!dirty && !s.busy) return;
writeDraft(f, s);
if (cfg.unload === "warn" || s.busy > 0 || s.failed) warn = true;
if (dirty && s.busy === 0 && cfg.unload !== "warn") flush(f, { keepalive: true }).catch(noop);
});
if (warn && e) { e.preventDefault(); e.returnValue = ""; }
return warn;
}
navigationSavers.push(flushAll);
return {
track: track, queue: queue, flush: flush, flushAll: flushAll, isDirty: isDirty, anyDirty: anyDirty,
prune: prune, onBeforeUnload: onBeforeUnload,
savedOf: function (f) { const s = states.get(f); return s ? s.saved : undefined; },
failedOf: function (f) { const s = states.get(f); return !!(s && s.failed); },
acceptSaved: function (f, value) {
const s = states.get(f);
if (!s) return;
clearTimeout(s.timer); s.timer = null; s.saved = value; s.failed = false;
writeDraft(f, s);
if (cfg.onClear) cfg.onClear(f);
},
};
}
// 저장 실패 표시 — 칸 빨간 테두리 + 안내(입력한 내용은 지우지 않는다)
function markSaveFailed(node, err) {
if (node) {
node.classList.remove("is-saved");
node.classList.add("is-save-failed");
node.dataset.tip = "저장 실패 — 입력한 내용은 그대로 있습니다. 다시 입력하거나 칸을 떠나면(Enter) 다시 저장합니다.";
}
showToast("저장 실패(입력한 내용은 그대로, 칸을 떠나면 다시 시도): " + (err && err.message || ""), "error");
}
function clearSaveFailed(node) {
if (!node || !node.classList.contains("is-save-failed")) return;
node.classList.remove("is-save-failed");
delete node.dataset.tip;
}
// ── 클립보드 복사 ── navigator.clipboard 는 https(보안 컨텍스트)에서만
// 동작한다 — 사내 IP로 http 접속하는 경우를 위해 임시 textarea 로 한 번 더
// 시도한다. 둘 다 실패하면 false 를 돌려 호출 쪽이 주소를 직접 보여준다.
async function copyToClipboard(text) {
try {
if (navigator.clipboard && window.isSecureContext) {
await navigator.clipboard.writeText(text);
return true;
}
} catch (_) { /* 아래 폴백으로 */ }
try {
const ta = document.createElement("textarea");
ta.value = text;
ta.setAttribute("readonly", "");
ta.style.position = "fixed";
ta.style.top = "-1000px";
document.body.appendChild(ta);
ta.select();
const ok = document.execCommand("copy");
ta.remove();
return ok;
} catch (_) { return false; }
}
// 업무 퍼머링크(/project/t/{id})를 클립보드로. 우클릭 메뉴/공유 버튼 공용.
async function shareTaskLink(taskId) {
const url = location.origin + "/project/t/" + taskId;
if (await copyToClipboard(url)) showToast("작업 링크를 복사했습니다.");
else prompt("아래 주소를 복사하세요.", url);
}
// ── 날짜 표기 'YYYY-MM-DD' → 'mm/dd(요일)' — 서버 _fmt_date_kr 과 동일 규칙 ──
function fmtDateKr(dstr) {
if (!dstr) return "";
const d = new Date(String(dstr).slice(0, 10) + "T00:00:00");
if (isNaN(d.getTime())) return dstr;
const mm = String(d.getMonth() + 1).padStart(2, "0");
const dd = String(d.getDate()).padStart(2, "0");
const wd = ["월", "화", "수", "목", "금", "토", "일"][(d.getDay() + 6) % 7];
return mm + "/" + dd + "(" + wd + ")";
}
// ── 마감일 표기(아사나처럼) — 어제(빨강) / 오늘·내일(초록) / 그 밖엔 mm/dd(요일),
// 지난 날짜는 빨강. 완료된 작업은 오늘·내일 초록만 빼고, 지난 마감일 빨강은 그대로. 반환 {text, cls}.
function isoOf(d) {
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
// 업무 기준 "오늘" = 한국시간(Asia/Seoul, 서머타임 없음 → UTC+9 고정) 날짜. 브라우저가 해외
// 시간대여도, 한국 오전(UTC 로는 전날)이어도 서버(today_kst)·마감 알림과 같은 날짜를 쓴다.
// 예전 대시보드는 toISOString()(UTC) 날짜라 한국 00~09시에 지연 수가 달랐다.
function kstTodayIso(nowMs) {
const ms = (nowMs == null ? Date.now() : nowMs) + 9 * 3600000;
return new Date(ms).toISOString().slice(0, 10);
}
function isoToday() { return kstTodayIso(); }
function dayDiff(iso, baseIso) {
const a = new Date(String(iso).slice(0, 10) + "T00:00:00"), b = new Date(baseIso + "T00:00:00");
return Math.round((a - b) / 86400000);
}
function dueInfo(iso, done) {
if (!iso) return null;
const diff = dayDiff(iso, isoToday());
let text, cls = "";
if (diff === 0) { text = "오늘"; cls = "is-soon"; }
else if (diff === 1) { text = "내일"; cls = "is-soon"; }
else if (diff === -1) { text = "어제"; cls = "is-overdue"; }
else { text = fmtDateKr(iso); if (diff < 0) cls = "is-overdue"; }
if (done && cls !== "is-overdue") cls = "";
return { text: text, cls: cls };
}
// 마감일 칸 말풍선 — 지난 날짜(빨강)면 "마감일 지남", 아니면 "마감일 변경".
function dueTip(di) { return di && di.cls === "is-overdue" ? "마감일 지남" : "마감일 변경"; }
// ── 아사나식 날짜 팝업 — 마감일(과 선택적으로 시작일)을 월 달력에서 고른다.
// opts: { start, due, allowStart, onChange(patch) }. 날짜를 누를 때마다
// onChange({due_date[, start_date]}) 로 바로 저장하고, 마감일을 고르면 팝업을
// 닫는다(시작일을 고른 땐 마감일을 이어서 고르게 열어 둠). 바깥 클릭·Esc 로 닫힘. "지우기" = 둘 다 비우고 닫기. 앵커 아래(자리가
// 없으면 위)에 뜨고 꼬리가 앵커를 가리킨다. 한 번에 하나만.
let datePopEl = null, datePopCleanup = null;
function closeDatePopover() {
if (datePopCleanup) datePopCleanup();
datePopCleanup = null;
if (datePopEl) { datePopEl.remove(); datePopEl = null; }
}
// 직접 입력 해석 — 2026-09-30 / 2026.9.30 / 9/30 / 9월 30일 / 0930.
// 빈 값 = "" (지우기), 해석 불가 = null.
function parseTypedDate(text, baseIso) {
const v = String(text || "").trim().replace(/\s+/g, "");
if (!v) return "";
let m = v.match(/^(\d{4})[-./년](\d{1,2})[-./월](\d{1,2})[.일]?$/);
let y, mo, d;
if (m) { y = +m[1]; mo = +m[2]; d = +m[3]; }
else if ((m = v.match(/^(\d{1,2})[-./월](\d{1,2})[.일]?$/))) { y = +baseIso.slice(0, 4); mo = +m[1]; d = +m[2]; }
else if ((m = v.match(/^(\d{2})(\d{2})$/))) { y = +baseIso.slice(0, 4); mo = +m[1]; d = +m[2]; }
else return null;
const dt = new Date(y, mo - 1, d);
if (dt.getFullYear() !== y || dt.getMonth() !== mo - 1 || dt.getDate() !== d) return null;
return isoOf(dt);
}
function fmtFieldDate(iso) {
if (!iso) return "";
const d = new Date(iso + "T00:00:00");
const same = d.getFullYear() === new Date().getFullYear();
return (same ? "" : d.getFullYear() + "년 ") + (d.getMonth() + 1) + "월 " + d.getDate() + "일";
}
const HOLIDAY_SHORT = { "부처님오신날": "석가탄신일", "추석·개천절": "추석" };
function pageHolidays() {
try { return JSON.parse((el("pj-data") || {}).textContent || "{}").holidays || {}; } catch (_) { return {}; }
}
function openDatePopover(anchor, opts) {
closeDatePopover();
const today = isoToday();
let start = opts.start ? String(opts.start).slice(0, 10) : "";
let due = opts.due ? String(opts.due).slice(0, 10) : "";
let showStart = !!(opts.allowStart && start);
let active = "due";
const base = new Date((due || start || today) + "T00:00:00");
let viewY = base.getFullYear(), viewM = base.getMonth();
// 공휴일 표 — 공용 사이드바가 넘긴 것(모든 프로젝트 화면), 없으면 프로젝트 화면 데이터.
const holidays = window.PJ_HOLIDAYS || pageHolidays();
const pop = document.createElement("div");
pop.className = "pj-datepop";
document.body.appendChild(pop);
datePopEl = pop;
function emit() {
const patch = { due_date: due || null };
if (opts.allowStart) patch.start_date = start || null;
if (opts.onChange) opts.onChange(patch);
}
function field(kind, val, ph) {
return '<input type="text" class="pj-dp-field' + (active === kind ? " is-active" : "") +
'" data-kind="' + kind + '" placeholder="' + ph + '" value="' + escapeHtml(fmtFieldDate(val)) + '" autocomplete="off" />';
}
function render() {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
// 일요일·공휴일(국경일·대체공휴일 포함) = 빨강, 토요일 = 파랑. 공휴일 이름은 말풍선.
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
if (iso === due || (showStart && iso === start)) cls.push("is-selected");
if (showStart && start && due && iso > start && iso < due) cls.push("is-inrange");
// 공휴일은 숫자 밑에 이름. 칸이 좁아 5글자 안쪽으로 줄인다(전체 이름은 말풍선).
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '<button type="button" class="' + cls.join(" ") + '" data-iso="' + iso + '"' +
(holName ? ' data-tip="' + escapeHtml(holName) + '"' : "") + ">" +
'<span class="pj-dp-num">' + d.getDate() + "</span>" +
(holName ? '<span class="pj-dp-hol">' + escapeHtml(holShort) + "</span>" : "") +
"</button>";
}
pop.innerHTML =
'<div class="pj-dp-fields">' +
(opts.allowStart
? (showStart ? field("start", start, "시작일") : '<button type="button" class="pj-dp-addstart">+ 시작일</button>')
: "") +
field("due", due, "마감일") +
"</div>" +
'<div class="pj-dp-nav">' +
'<button type="button" class="pj-dp-navbtn" data-nav="-1" title="이전 달"><span class="material-symbols-outlined">chevron_left</span></button>' +
'<span class="pj-dp-title">' + viewY + "년 " + (viewM + 1) + "월</span>" +
'<button type="button" class="pj-dp-navbtn" data-nav="1" title="다음 달"><span class="material-symbols-outlined">chevron_right</span></button>' +
"</div>" +
'<div class="pj-dp-grid">' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '<span class="pj-dp-wd' + (i === 0 ? " is-sun" : i === 6 ? " is-sat" : "") + '">' + w + "</span>";
}).join("") +
days +
"</div>" +
'<div class="pj-dp-foot">' +
'<button type="button" class="pj-dp-link pj-dp-today">오늘</button>' +
'<button type="button" class="pj-dp-link pj-dp-clear">지우기</button>' +
"</div>";
wire();
}
// 날짜 하나 고르기 — 시작일 칸이 활성이면 시작일(그 뒤 마감일로 넘어감),
// 아니면 마감일. 시작일 > 마감일이 되지 않게 맞춘다.
// 마감일을 고르면 저장하고 팝업을 닫는다. 시작일을 고른 때는 이어서
// 마감일을 고르도록 열어 둔다.
function pick(iso) {
if (active === "start") {
start = iso;
if (due && due < iso) due = iso;
active = "due";
render();
emit();
return;
}
due = iso;
if (start && start > iso) start = iso;
emit();
closeDatePopover();
}
function wire() {
pop.querySelectorAll(".pj-dp-day").forEach(function (b) {
b.addEventListener("click", function () { pick(b.dataset.iso); });
});
pop.querySelectorAll(".pj-dp-navbtn").forEach(function (b) {
b.addEventListener("click", function () {
viewM += +b.dataset.nav;
if (viewM < 0) { viewM = 11; viewY--; } else if (viewM > 11) { viewM = 0; viewY++; }
render();
});
});
const add = pop.querySelector(".pj-dp-addstart");
if (add) add.addEventListener("click", function () {
showStart = true; active = "start"; render(); focusActive();
});
pop.querySelectorAll(".pj-dp-field").forEach(function (inp) {
inp.addEventListener("focus", function () {
active = inp.dataset.kind;
pop.querySelectorAll(".pj-dp-field").forEach(function (x) { x.classList.toggle("is-active", x === inp); });
});
function commit() {
const kind = inp.dataset.kind;
const cur = kind === "start" ? start : due;
const parsed = parseTypedDate(inp.value, today);
if (parsed === null || parsed === cur) { inp.value = fmtFieldDate(cur); return; }
if (!parsed) {
if (kind === "start") { start = ""; showStart = false; } else due = "";
render(); emit(); return;
}
active = kind;
const d = new Date(parsed + "T00:00:00");
viewY = d.getFullYear(); viewM = d.getMonth();
pick(parsed);
}
inp.addEventListener("keydown", function (e) {
if (e.isComposing) return;
if (e.key === "Enter") { e.preventDefault(); commit(); }
});
inp.addEventListener("change", commit);
});
pop.querySelector(".pj-dp-today").addEventListener("click", function () {
const d = new Date(); viewY = d.getFullYear(); viewM = d.getMonth();
pick(today);
});
pop.querySelector(".pj-dp-clear").addEventListener("click", function () {
start = ""; due = ""; emit(); closeDatePopover();
});
}
function focusActive() {
const f = pop.querySelector('.pj-dp-field[data-kind="' + active + '"]');
if (f) f.focus();
}
function place() {
const r = anchor.getBoundingClientRect();
const vw = document.documentElement.clientWidth, vh = document.documentElement.clientHeight;
const w = pop.offsetWidth, h = pop.offsetHeight;
const ax = r.left + r.width / 2;
const left = Math.min(Math.max(8, ax - w / 2), vw - w - 8);
const below = r.bottom + 10 + h <= vh - 8 || r.top - 10 - h < 8;
pop.classList.toggle("is-above", !below);
pop.style.left = left + "px";
pop.style.top = (below ? r.bottom + 10 : r.top - 10 - h) + "px";
pop.style.setProperty("--pj-dp-tail", Math.min(Math.max(ax - left, 16), w - 16) + "px");
}
function onDown(e) {
if (pop.contains(e.target) || anchor.contains(e.target)) return;
closeDatePopover();
}
function onKey(e) { if (e.key === "Escape") { e.stopPropagation(); closeDatePopover(); } }
render();
place();
setTimeout(function () {
// 그 사이에 이미 닫혔으면 걸지 않는다 — 안 그러면 닫힌 팝업의 Esc 처리가
// 문서에 남아 이후 모든 Esc 를 삼킨다(정리 함수는 이미 지나갔으므로).
if (datePopEl !== pop) return;
document.addEventListener("mousedown", onDown, true);
document.addEventListener("keydown", onKey, true);
}, 0);
window.addEventListener("resize", closeDatePopover);
datePopCleanup = function () {
document.removeEventListener("mousedown", onDown, true);
document.removeEventListener("keydown", onKey, true);
window.removeEventListener("resize", closeDatePopover);
};
focusActive();
}
// ── <input type="date"> 를 아사나식 날짜 버튼으로 — 브라우저 기본 달력 대신
// 위 openDatePopover 를 연다. input 은 숨겨 값 저장소로 그대로 두므로 기존
// 코드의 input.value 읽기/쓰기와 change 이벤트가 그대로 동작한다(value 쓰기를
// 가로채 버튼 글자도 따라 바뀐다 — enhanceAssigneeSelect 와 같은 방식).
// opts.startInput 을 주면 시작일·마감일을 버튼 하나로(팝업의 "+ 시작일").
function enhanceDateInput(input, opts) {
if (!input || input.dataset.pjDate) return;
opts = opts || {};
const startInput = opts.startInput || null;
const inputs = startInput ? [startInput, input] : [input];
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-date-btn";
input.after(btn);
const desc = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value");
inputs.forEach(function (inp) {
inp.dataset.pjDate = "1";
inp.style.display = "none";
Object.defineProperty(inp, "value", {
configurable: true,
get: function () { return desc.get.call(this); },
set: function (v) { desc.set.call(this, v); sync(); },
});
});
function label(iso) { const di = dueInfo(iso, false); return di ? di.text : ""; }
function sync() {
const due = input.value, start = startInput ? startInput.value : "";
const text = start && due ? label(start) + " – " + label(due)
: start ? label(start) + " –" : label(due);
const di = dueInfo(due, false);
// opts.iconOnly — 날짜가 없으면 글자 없이 점선 원 달력 아이콘만(아사나), 있으면 아이콘 + 날짜.
if (opts.iconOnly && !text) {
btn.innerHTML = DUE_EMPTY_ICON_SVG;
} else {
btn.innerHTML = '<span class="material-symbols-outlined">calendar_month</span>' +
'<span class="pj-date-btn-text"></span>';
btn.querySelector(".pj-date-btn-text").textContent = text || (opts.placeholder || "날짜 선택");
}
btn.classList.toggle("is-icon-only", !!opts.iconOnly && !text);
btn.classList.toggle("is-empty", !text);
btn.classList.toggle("is-overdue", !!di && di.cls === "is-overdue");
btn.title = text ? "날짜 변경" : "날짜 지정";
}
function set(inp, v) {
if ((inp.value || "") === (v || "")) return;
inp.value = v || "";
inp.dispatchEvent(new Event("input", { bubbles: true }));
inp.dispatchEvent(new Event("change", { bubbles: true }));
}
btn.addEventListener("click", function (e) {
e.preventDefault();
e.stopPropagation();
openDatePopover(btn, {
start: startInput ? startInput.value : "", due: input.value, allowStart: !!startInput,
onChange: function (patch) {
if (startInput) set(startInput, patch.start_date);
set(input, patch.due_date);
},
});
});
sync();
}
// ── 탭 그룹(뷰 탭/스코프 토글, 둘 다 .pj-view-tabs 마크업 공유)에 슬라이드
// 하이라이트를 붙인다 — is-active 를 단순 배경색 대신, 실제 위치가 움직이는
// 절대배치 요소 하나로 표현한다. 탭 클릭·초기 렌더·리사이즈마다 위치 재계산.
function initTabSlider(container) {
if (!container || container.dataset.pjSlider) return null;
container.dataset.pjSlider = "1";
const hl = document.createElement("div");
hl.className = "pj-tab-highlight";
container.insertBefore(hl, container.firstChild);
function move(animate) {
const active = container.querySelector(".pj-tab.is-active");
if (!active) { hl.style.opacity = "0"; return; }
hl.style.opacity = "1";
if (!animate) hl.classList.add("pj-no-anim");
hl.style.width = active.offsetWidth + "px";
hl.style.height = active.offsetHeight + "px";
hl.style.transform = "translateX(" + active.offsetLeft + "px)";
if (!animate) {
// 강제 리플로우로 즉시 반영시킨 뒤 트랜지션을 다시 켠다(다음 클릭부터 애니메이션).
void hl.offsetWidth;
hl.classList.remove("pj-no-anim");
}
}
move(false);
container.addEventListener("click", function (e) {
if (e.target.closest(".pj-tab")) requestAnimationFrame(function () { move(true); });
});
window.addEventListener("resize", function () { move(false); });
return move;
}
// "#RRGGBB" → "rgba(r,g,b,alpha)" — 세션 헤더 배경처럼 색은 유지한 채
// 투명도만 입혀야 할 때 쓴다.
function hexToRgba(hex, alpha) {
const h = String(hex || "").replace("#", "");
const full = h.length === 3 ? h.split("").map(function (c) { return c + c; }).join("") : h;
const r = parseInt(full.substr(0, 2), 16);
const g = parseInt(full.substr(2, 2), 16);
const b = parseInt(full.substr(4, 2), 16);
if (isNaN(r) || isNaN(g) || isNaN(b)) return hex;
return "rgba(" + r + "," + g + "," + b + "," + alpha + ")";
}
// 밝은 색인지 — 아사나 16색에는 연노랑·하늘·연분홍처럼 흰 글자가 안 보이는 색이 있어
// 그 위에서는 글자·아이콘을 어둡게 쓴다. alpha/바탕색을 주면 비쳐 보이는 실제 색으로 판단.
function isLightColor(hex, alpha, overHex) {
function rgb(h) {
h = String(h || "").replace("#", "");
if (h.length === 3) h = h.split("").map(function (c) { return c + c; }).join("");
return [parseInt(h.substr(0, 2), 16), parseInt(h.substr(2, 2), 16), parseInt(h.substr(4, 2), 16)];
}
const c = rgb(hex);
if (c.some(isNaN)) return false;
const a = alpha == null ? 1 : alpha, o = rgb(overHex || "#ffffff");
const m = c.map(function (v, i) { return v * a + o[i] * (1 - a); });
return (0.299 * m[0] + 0.587 * m[1] + 0.114 * m[2]) / 255 > 0.72;
}
// 멤버 선택 후보 카드(아이콘 위 / 이름 가운데 / 체크박스 아래) — 새 프로젝트
// 모달(홈·프로젝트 페이지)과 멤버 배정 모달 3곳이 전부 이 함수 하나를 쓴다.
// /api/assignable-users 응답의 avatar 필드를 그대로 쓰므로 페이지별
// avatars 맵(홈 페이지엔 없음)에 기대지 않는다.
function memberPickHtml(u) {
const icon = u.avatar
? '<img class="pj-avatar pj-member-pick-icon" src="' + escapeHtml(u.avatar) + '" alt="" referrerpolicy="no-referrer" />'
: '<span class="material-symbols-outlined pj-gicon pj-member-pick-icon">account_circle</span>';
return '<label class="pj-member-pick pj-member-pick-stacked">' +
'<span class="pj-member-pick-avatar">' + icon + "</span>" +
'<span class="pj-member-pick-name">' + escapeHtml(capName(u.id)) + "</span>" +
'<input type="checkbox" value="' + u.email + '" data-name="' + escapeHtml(u.name) + '" />' +
"</label>";
}
// 페이지 공용 아바타 맵 — 채팅/멤버 팝업은 여러 화면 공용 코드라 화면별
// init 안의 avatarHtml 을 못 본다. 페이지 데이터(#pj-data 또는
// #pj-mytasks-data)의 avatars 를 한 번 읽고, 전체 멤버 목록을 받으면 거기
// 들어있는 사진도 보탠다(수신함처럼 페이지 데이터가 없는 화면용).
let pageAvatars = null;
function pageAvatarUrl(email) {
if (pageAvatars === null) {
pageAvatars = {};
["pj-data", "pj-mytasks-data"].forEach(function (id) {
try {
const d = el(id);
if (d) Object.assign(pageAvatars, JSON.parse(d.textContent).avatars || {});
} catch (_) {}
});
}
return email ? pageAvatars[String(email).toLowerCase()] || "" : "";
}
function rememberAvatars(users) {
pageAvatarUrl(""); // 맵 초기화 보장
(users || []).forEach(function (u) {
if (u.avatar && !pageAvatars[u.email.toLowerCase()]) pageAvatars[u.email.toLowerCase()] = u.avatar;
});
}
// ── 업무 삭제 — 확인 창 + 요청을 한 곳에서. 하위 업무가 있으면 "하위 업무 N개까지
// 함께 삭제"를 분명히 묻는다. 지운 업무는 휴지통(3개월 보관, 관리자만 복구)으로
// 간다(project_db 010 — 미적용이면 서버가 예전처럼 영구 삭제, 토스트로 구분).
// subCount 를 모르면(null) 서버에서 하위 업무 수를 받아 확인한다.
async function confirmTaskDelete(taskId, title, subCount) {
let n = subCount;
if (n == null) {
try {
const res = await api("GET", "/project/api/tasks/" + taskId);
n = ((res && res.task && res.task.subtasks) || []).length;
if (!title && res && res.task) title = res.task.title;
} catch (_) { n = 0; }
}
const name = title ? "'" + title + "' " : "이 ";
const tail = "\n\n삭제한 작업은 휴지통에 3개월 보관되며, 관리자가 복구할 수 있습니다.";
const msg = n > 0
? name + "작업에 하위 작업이 " + n + "개 있습니다.\n하위 작업까지 모두 삭제할까요?" + tail
: name + "작업을 삭제할까요?" + tail;
const opts = { okText: n > 0 ? "하위 작업까지 삭제" : "삭제", cancelText: "취소" };
return await confirm(msg, opts);
}
async function deleteTaskRequest(taskId) {
const res = await api("DELETE", "/project/api/tasks/" + taskId);
showToast(res && res.trash ? "휴지통으로 옮겼습니다 (3개월 보관)" : "삭제했습니다");
return res;
}
// ── 담당자 고르기 — 어디서 배정하든 항상 "아이콘 + 이름" 메뉴(아사나처럼).
// 미지정 = 점선 원 사람 아이콘.
const EMPTY_PERSON_SVG =
'<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="1.4" aria-hidden="true">' +
'<circle cx="12" cy="12" r="10.3" stroke-dasharray="2.6 2.2"/>' +
'<circle cx="12" cy="9.6" r="3.1"/>' +
'<path d="M6.8 17.2c1.1-2.2 3-3.3 5.2-3.3s4.1 1.1 5.2 3.3" stroke-linecap="round"/>' +
"</svg>";
// 마감일 미지정 아이콘(아사나 모양: 점선 원 안의 달력) — 보드 카드·하위 작업 줄 공용.
const DUE_EMPTY_ICON_SVG =
'<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="1.4" aria-hidden="true">' +
'<circle cx="12" cy="12" r="10.3" stroke-dasharray="2.6 2.2"/>' +
'<rect x="7.3" y="8.2" width="9.4" height="8.6" rx="1.6"/>' +
'<path d="M7.3 11.2h9.4M9.8 6.8v2.4M14.2 6.8v2.4" stroke-linecap="round"/>' +
"</svg>";
// 아사나의 하위 업무 아이콘(위 노드 하나에서 두 갈래로 뻗은 노드) — 보드 카드·
// 타임라인·작업 창 하위 작업 줄 공용.
const SUBTASK_ICON_SVG =
'<svg class="pj-card-subtoggle-ic" viewBox="0 0 16 16" width="15" height="15" fill="none" ' +
'stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">' +
'<circle cx="4" cy="3" r="1.7"/>' +
'<path d="M4 4.7v6.3a1.5 1.5 0 0 0 1.5 1.5h3.8"/>' +
'<path d="M4 7.5h5.3"/>' +
'<circle cx="11.2" cy="7.5" r="1.7"/>' +
'<circle cx="11.2" cy="12.5" r="1.7"/>' +
"</svg>";
// 하위 작업 줄에 붙는 "N ⑂" — 그 하위 작업에도 하위 작업이 있을 때만(아사나).
function nestedSubsHtml(sub, cls) {
const n = (sub && sub.subtask_total) || 0;
if (!n) return "";
return '<span class="' + cls + '" data-tip="하위 작업 ' + n + '개">' + n + SUBTASK_ICON_SVG + "</span>";
}
// 하위 작업 줄의 댓글(말풍선 + 개수)·설명(줄글) 아이콘 — "N ⑂" 와 같은 모양.
const COMMENT_ICON_SVG =
'<svg viewBox="0 0 16 16" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.4" ' +
'stroke-linejoin="round" aria-hidden="true">' +
'<path d="M2.5 3.8A1.5 1.5 0 0 1 4 2.3h8a1.5 1.5 0 0 1 1.5 1.5v5.6A1.5 1.5 0 0 1 12 10.9H7.2L4.4 13.4v-2.5H4a1.5 1.5 0 0 1-1.5-1.5z"/>' +
"</svg>";
const DESC_ICON_SVG =
'<svg viewBox="0 0 16 16" width="15" height="15" fill="none" stroke="currentColor" stroke-width="1.4" ' +
'stroke-linecap="round" aria-hidden="true">' +
'<path d="M3 4h10M3 7h10M3 10h10M3 13h6"/>' +
"</svg>";
// 설명이 비어 있지 않은지 — 태그·&nbsp;·공백만 있으면 없음, 이미지만 있어도 있음.
// 보드 카드 표지 — 설명 HTML 의 첫 이미지 주소(template 로 읽어 이미지를 불러오지 않음). 같은 설명은 캐시.
// 우리 첨부 주소(/project/…)·http(s)·data:image 만.
const coverCache = new Map();
function cardCoverSrc(html) {
const s = String(html || "");
if (!/<img\b/i.test(s)) return "";
if (coverCache.has(s)) return coverCache.get(s);
let src = "";
try {
const tpl = document.createElement("template");
tpl.innerHTML = s;
const img = tpl.content.querySelector("img[src]");
const v = img ? img.getAttribute("src").trim() : "";
if (/^(\/project\/|https?:\/\/|data:image\/)/i.test(v)) src = v;
} catch (_) { src = ""; }
if (coverCache.size > 500) coverCache.clear();
coverCache.set(s, src);
return src;
}
function hasDescription(html) {
const s = String(html || "");
if (/<img\b/i.test(s)) return true;
return !!s.replace(/<[^>]*>/g, "").replace(/&nbsp;| /g, " ").trim();
}
// 하위 작업 줄 제목 옆 아이콘 묶음 — 하위 작업 "N ⑂" · 댓글 "N 💬" · 설명(있을 때만).
function subMetaHtml(sub, cls) {
let h = nestedSubsHtml(sub, cls);
const nc = (sub && sub.comment_count) || 0;
if (nc) h += '<span class="' + cls + '" data-tip="댓글 ' + nc + '개">' + nc + COMMENT_ICON_SVG + "</span>";
if (sub && hasDescription(sub.description)) {
h += '<span class="' + cls + ' is-desc" data-tip="설명 있음">' + DESC_ICON_SVG + "</span>";
}
return h;
}
function personIconHtml(email) {
if (!email) return '<span class="pj-person-ic is-empty">' + EMPTY_PERSON_SVG + "</span>";
const url = pageAvatarUrl(email);
return url
? '<img class="pj-avatar pj-person-ic" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="material-symbols-outlined pj-gicon pj-person-ic">account_circle</span>';
}
// emails 후보 중 하나를 고르는 메뉴 항목들(맨 앞 "(미지정)"). cur = 현재 담당자.
function assigneeMenuItems(emails, cur, onPick) {
const c = String(cur || "").toLowerCase();
const items = [{ label: "담당자 없음", icon: personIconHtml(""), checked: !c, onClick: function () { onPick(""); } }];
emails.forEach(function (e) {
items.push({
label: idOf(e), icon: personIconHtml(e), checked: String(e).toLowerCase() === c,
onClick: function () { onPick(e); },
});
});
return items;
}
// <select> 담당자 칸을 "아이콘 + 이름" 버튼으로 바꿔 보여준다. select 는 숨겨
// 값 저장소로 그대로 둔다 — 기존 코드의 sel.value 읽기/쓰기, change 이벤트,
// selectedOptions 가 그대로 동작. 코드가 sel.value 를 바꾸거나 옵션을 다시
// 채워도 버튼이 따라 바뀐다(value setter 가로채기 + MutationObserver).
function enhanceAssigneeSelect(sel) {
if (!sel || sel.dataset.pjEnhanced) return;
sel.dataset.pjEnhanced = "1";
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-assignee-btn " + (sel.className || "");
if (sel.id) btn.dataset.for = sel.id;
sel.after(btn);
sel.hidden = true;
sel.style.display = "none";
function sync() {
const v = sel.value;
const opt = sel.selectedOptions && sel.selectedOptions[0];
btn.innerHTML = personIconHtml(v) + '<span class="pj-assignee-btn-name"></span>';
btn.querySelector(".pj-assignee-btn-name").textContent = v ? (opt ? opt.textContent : idOf(v)) : "담당자 없음";
btn.classList.toggle("is-empty", !v);
btn.disabled = sel.disabled;
btn.dataset.tip = v ? "담당자 변경" : "이 작업 배정";
}
const desc = Object.getOwnPropertyDescriptor(HTMLSelectElement.prototype, "value");
Object.defineProperty(sel, "value", {
configurable: true,
get: function () { return desc.get.call(this); },
set: function (v) { desc.set.call(this, v); sync(); },
});
new MutationObserver(sync).observe(sel, { childList: true, subtree: true, attributes: true, attributeFilter: ["disabled"] });
sel.addEventListener("change", sync);
btn.addEventListener("click", function (e) {
e.stopPropagation();
const emails = Array.prototype.map.call(sel.options, function (o) { return o.value; })
.filter(function (v) { return v; });
const r = btn.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, assigneeMenuItems(emails, sel.value, function (v) {
if (v === sel.value) return;
sel.value = v;
sel.dispatchEvent(new Event("change", { bubbles: true }));
}));
});
sync();
}
function chatAvatarHtml(email) {
const url = pageAvatarUrl(email);
if (url) return '<img class="pj-avatar pj-chat-avatar" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer">';
return '<span class="material-symbols-outlined pj-gicon pj-chat-avatar">account_circle</span>';
}
// ── 멤버 업무 팝업(#pj-modal-member-tasks) — 그 사람이 담당자인 업무를
// 프로젝트/세션/마감일과 함께 나열. 좌측 "전체 멤버"(관리자 전용, 모든
// 화면)와 프로젝트 화면의 "프로젝트 멤버" 칩이 함께 쓴다. 페이지당 하나라
// 싱글턴으로 둔다 — 프로젝트 화면(initProject)이 먼저 openTask(그 자리 편집
// 팝업)를 넘겨 만들고, 다른 화면은 기본값(그 업무의 프로젝트 화면으로 이동)을
// 쓴다. 반환값 = openMemberTasksModal(email, name, opts).
let memberTasksOpener = null;
function initMemberTasks(cfg) {
if (memberTasksOpener) return memberTasksOpener;
cfg = cfg || {};
const memberTasksModal = el("pj-modal-member-tasks");
if (!memberTasksModal) { memberTasksOpener = function () {}; return memberTasksOpener; }
wireModalClose(memberTasksModal);
const openTask = cfg.openTask || function (t) {
location.href = "/project/p/" + t.project_id + "?task=" + t.id;
};
const taskModal = cfg.taskModal || null;
let mtItems = [];
let mtSort = { key: null, dir: 1 };
// 더블클릭으로 업무 편집 팝업을 열 때 이 팝업을 완전히 닫지 않고 잠깐
// 숨겨두는 용도의 컨텍스트 — 업무 편집을 마치고 닫으면(taskModal 의
// hidden 이 다시 true 로 바뀌면) 같은 조건으로 다시 열어 목록을 최신
// 상태로 되살린다(taskModal 이 있는 프로젝트 화면에서만).
let mtCurrentCtx = null;
let mtReopenCtx = null;
function mtSortValue(t, key) {
if (key === "project") return (t.project_name || "").toLowerCase();
if (key === "stage") return (t.stage_name || "").toLowerCase();
if (key === "title") return (t.title || "").toLowerCase();
if (key === "due") return t.due_date || "9999-99-99";
return "";
}
function mtRowHtml(t) {
return '<li class="pj-mt-row' + (t.completed_at ? " is-done" : "") + '" data-task-id="' + t.id + '">' +
'<span class="pj-mt-proj" style="color:' + (t.project_color || "#4573d2") + '">' + escapeHtml(t.project_name || "-") + "</span>" +
'<span class="pj-mt-stage">' + escapeHtml(t.stage_name || "미지정") + "</span>" +
'<span class="pj-mt-title2">' + escapeHtml(t.title || "") + "</span>" +
'<span class="pj-mt-due">' + (t.due_date ? fmtDateKr(t.due_date) : "-") + "</span>" +
"</li>";
}
const mtHead = el("pj-mt-head");
function updateMtSortIcons() {
if (!mtHead) return;
mtHead.querySelectorAll(".pj-mt-h").forEach(function (h) {
const icon = h.querySelector(".pj-mt-sort-icon");
if (!icon) return;
icon.textContent = h.dataset.sort === mtSort.key ? (mtSort.dir === 1 ? "▲" : "▼") : "";
});
}
function renderMtList() {
const list = el("pj-mt-list");
if (!mtItems.length) { list.innerHTML = "<li class='pj-empty-sm'>배정된 작업이 없습니다.</li>"; return; }
const sorted = mtItems.slice();
if (mtSort.key) {
sorted.sort(function (a, b) {
const va = mtSortValue(a, mtSort.key), vb = mtSortValue(b, mtSort.key);
if (va < vb) return -1 * mtSort.dir;
if (va > vb) return 1 * mtSort.dir;
return 0;
});
}
list.innerHTML = sorted.map(mtRowHtml).join("");
list.querySelectorAll("li[data-task-id]").forEach(function (li) {
li.addEventListener("dblclick", function () {
const t = mtItems.find(function (x) { return String(x.id) === li.dataset.taskId; });
if (!t) return;
if (taskModal) mtReopenCtx = mtCurrentCtx;
closeModal(memberTasksModal);
openTask(t);
});
});
}
if (mtHead) mtHead.addEventListener("click", function (e) {
const h = e.target.closest(".pj-mt-h");
if (!h) return;
const key = h.dataset.sort;
if (mtSort.key === key) mtSort.dir *= -1; else { mtSort.key = key; mtSort.dir = 1; }
updateMtSortIcons();
renderMtList();
});
// 제목 앞에 붙는 아이콘 — 아바타 있으면 사진, 없으면 기본 사람 아이콘.
function mtTitleAvatarHtml(email) {
const url = pageAvatarUrl(email);
return url
? '<img class="pj-avatar pj-mt-title-avatar" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer" />'
: '<span class="material-symbols-outlined pj-gicon pj-mt-title-avatar" style="font-size:22px;">account_circle</span>';
}
// opts.projectId 를 주면 "이 프로젝트 안에서" 담당하는 업무만, 제목도
// "[프로젝트 이름]의 [사용자]님의 업무" 형식으로. 안 주면(전체 멤버)
// 전체 프로젝트 대상 + "[사용자]님의 업무".
async function openMemberTasksModal(email, name, opts) {
opts = opts || {};
mtCurrentCtx = { email: email, name: name, opts: opts };
const prefix = opts.projectName ? escapeHtml(opts.projectName) + "의 " : "";
el("pj-mt-title").innerHTML = prefix + mtTitleAvatarHtml(email) + escapeHtml(name || email) + "님의 작업";
mtItems = [];
mtSort = { key: null, dir: 1 };
updateMtSortIcons();
const list = el("pj-mt-list");
list.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
openModal(memberTasksModal);
try {
const url = "/project/api/users/tasks?email=" + encodeURIComponent(email) +
(opts.projectId ? "&project_id=" + opts.projectId : "");
const res = await api("GET", url);
mtItems = res.tasks || [];
renderMtList();
} catch (e) {
list.innerHTML = "<li class='pj-empty-sm'>불러오기 실패: " + escapeHtml(e.message) + "</li>";
}
}
// 업무 편집 팝업이 닫히면(hidden 이 다시 true) 대기 중인 컨텍스트가
// 있을 때만 멤버 업무 팝업을 그 자리에 다시 연다.
if (taskModal) {
new MutationObserver(function () {
if (taskModal.hidden && mtReopenCtx) {
const ctx = mtReopenCtx;
mtReopenCtx = null;
openMemberTasksModal(ctx.email, ctx.name, ctx.opts);
}
}).observe(taskModal, { attributes: true, attributeFilter: ["hidden"] });
}
memberTasksOpener = openMemberTasksModal;
return memberTasksOpener;
}
// ── 좌측 "전체 멤버"(관리자 전용 — 서버가 관리자에게만 그리드를 렌더하고
// /api/all-users 도 관리자만 허용). 아이콘 클릭 = 그 사람의 업무 팝업.
function initAllMembers() {
const grid = el("pj-allmembers-grid");
if (!grid) return;
const openMemberTasksModal = initMemberTasks();
api("GET", "/project/api/all-users").then(function (res) {
const users = res.users || [];
rememberAvatars(users);
grid.innerHTML = users.length
? users.map(function (u) {
const icon = u.avatar
? '<img class="pj-avatar pj-member-pick-icon" src="' + escapeHtml(u.avatar) + '" alt="" referrerpolicy="no-referrer" />'
: '<span class="material-symbols-outlined pj-gicon pj-member-pick-icon">account_circle</span>';
return '<button type="button" class="pj-allmember-item" data-email="' + escapeHtml(u.email) + '" data-name="' + escapeHtml(capName(u.id)) + '">' +
icon + '<span class="pj-allmember-name">' + escapeHtml(capName(u.id)) + "</span></button>";
}).join("")
: "<span class='pj-empty-sm'>없음</span>";
grid.querySelectorAll(".pj-allmember-item").forEach(function (btn) {
btn.addEventListener("click", function () { openMemberTasksModal(btn.dataset.email, btn.dataset.name); });
});
}).catch(function (e) {
grid.innerHTML = "<span class='pj-empty-sm'>불러오기 실패: " + escapeHtml(e.message) + "</span>";
});
}
// ── 색상 팔레트 렌더 ───────────────────────────────────────
// 색의 밝기(0~1). 해석 못 하면 1(밝음).
function colorLuma(hex) {
let h = String(hex || "").replace("#", "");
if (h.length === 3) h = h.split("").map(function (c) { return c + c; }).join("");
const r = parseInt(h.substr(0, 2), 16), g = parseInt(h.substr(2, 2), 16), b = parseInt(h.substr(4, 2), 16);
if ([r, g, b].some(isNaN)) return 1;
return (0.299 * r + 0.587 * g + 0.114 * b) / 255;
}
// palette 를 생략하면 프로젝트 색(window.PJ_COLORS) — 세션 색상 선택은
// window.PJ_STAGE_COLORS(아사나 10색)를 넘겨 같은 UI를 재사용한다.
function renderColorPalette(container, onPick, initial, palette) {
const colors = palette || window.PJ_COLORS || ["#4573d2"];
// 목록에 없는 현재 색(예전 팔레트로 만든 프로젝트)은 고르기 전까지 그대로 둔다 —
// 첫 칸으로 바꿔 버리면 수정 팝업에서 저장만 해도 색이 바뀐다.
let selected = initial || colors[0];
container.innerHTML = "";
colors.forEach(function (c) {
const b = document.createElement("button");
b.type = "button";
b.className = "pj-color-swatch";
b.style.background = c;
// 진한 색(남색·먹색 등) 위에서는 체크를 흰색으로 — 기존 16색은 그대로 진회색 체크.
if (colorLuma(c) < 0.42) b.classList.add("is-dark");
if (c === selected) b.classList.add("is-active");
b.addEventListener("click", function () {
selected = c;
container.querySelectorAll(".pj-color-swatch").forEach(function (x) {
x.classList.remove("is-active");
});
b.classList.add("is-active");
if (onPick) onPick(c);
});
container.appendChild(b);
});
return function () { return selected; };
}
// ── 프로젝트 아이콘(아사나식) — window.PJ_ICONS(Material Symbols 이름) 격자.
// 첫 칸 "Aa" = 아이콘 없음(프로젝트 색 + 이름 첫 글자). 반환 = 지금 고른 이름("" = 없음).
function renderIconPalette(container, initial) {
if (!container) return function () { return ""; };
const icons = window.PJ_ICONS || [];
let selected = initial && icons.indexOf(initial) >= 0 ? initial : "";
container.innerHTML = [""].concat(icons).map(function (ic) {
return '<button type="button" class="pj-icon-pick' + (ic === selected ? " is-active" : "") +
'" data-icon="' + ic + '" title="' + (ic ? "아이콘" : "아이콘 없음(첫 글자)") + '">' +
(ic ? '<span class="material-symbols-outlined">' + ic + "</span>" : '<span class="pj-icon-pick-aa">Aa</span>') +
"</button>";
}).join("");
container.querySelectorAll(".pj-icon-pick").forEach(function (b) {
b.addEventListener("click", function () {
selected = b.dataset.icon;
container.querySelectorAll(".pj-icon-pick").forEach(function (x) { x.classList.toggle("is-active", x === b); });
});
});
return function () { return selected; };
}
// 프로젝트 배지 안쪽 — 아이콘이 있으면 흰 아이콘, 없으면 이름 첫 글자(사이드바 목록·제목 공용).
function projBadgeInner(p) {
if (p && p.icon) return '<span class="material-symbols-outlined pj-proj-ic">' + escapeHtml(p.icon) + "</span>";
return escapeHtml(((p && p.name) || "?").trim().charAt(0).toUpperCase() || "?");
}
// ════════════════════════════════════════════════════════════
// 댓글만 보는 채팅형 팝업(#pj-modal-comments) — 홈 카드/내 업무, 프로젝트
// 화면 우측 "내 업무" 패널 전부 공용(마크업 id 는 두 페이지가 같은 걸 씀).
// 페이지당 한 번 initCommentsChat() 으로 활성화하고, 이후 동적으로 새로
// 만들어지는 말풍선 배지는 반환된 wireBadge() 로 개별 등록한다(안 하면
// patch 로 새로 그려진 배지는 안 읽음 표시가 빠진다). 여는 건 한 번 클릭(문서 캡처).
// getTaskTitle(taskId) — 채팅창 제목에 쓸 업무 제목을 페이지별 데이터에서
// 찾아 돌려주는 콜백(각 화면이 이미 들고 있는 업무 목록에서 찾는다).
// ── 새 프로젝트 모달 (#pj-modal-project) — 좌측 사이드바 "+" 버튼 ──
// 내 업무 화면과 프로젝트 화면이 같은 마크업/동작을 쓴다. 만들어진 뒤
// 화면마다 할 일(트리 갱신 등)만 onCreated 로 받는다.
function initNewProjectModal(isAdmin, onCreated) {
const btn = el("pj-new-project-side");
const modal = el("pj-modal-project");
if (!btn || !modal) return;
wireModalClose(modal);
let getColor = renderColorPalette(el("pj-f-colors"), null, "#4573d2");
let getIcon = renderIconPalette(el("pj-f-icons"), "");
const membersBox = el("pj-f-members");
btn.addEventListener("click", async function () {
openModal(modal);
if (!membersBox) return;
// 멤버 배정은 관리자 전용 API — 관리자가 아니면 시도하지 않고 안내만.
if (!isAdmin) {
membersBox.innerHTML = "<span class='pj-empty-sm'>멤버 배정은 관리자가 나중에 할 수 있습니다.</span>";
return;
}
membersBox.innerHTML = "불러오는 중…";
try {
const res = await api("GET", "/project/api/assignable-users");
const users = res.users || [];
membersBox.innerHTML = users.length
? users.map(memberPickHtml).join("")
: "<span class='pj-empty-sm'>배정 가능한 직원이 없습니다.</span>";
} catch (_) {
membersBox.innerHTML = "<span class='pj-empty-sm'>불러오기 실패</span>";
}
});
el("pj-save-project").addEventListener("click", async function () {
const name = el("pj-f-name").value.trim();
if (!name) { alert("이름을 입력하세요."); return; }
const memberEmails = membersBox
? Array.from(membersBox.querySelectorAll("input[type=checkbox]:checked")).map(function (c) { return c.value; })
: [];
try {
const res = await api("POST", "/project/api/projects", {
name: name,
description: el("pj-f-desc").value.trim(),
due_date: el("pj-f-due").value || null,
color: getColor(),
icon: getIcon() || undefined,
});
const pid = res.project.id;
for (const email of memberEmails) {
try { await api("POST", "/project/api/projects/" + pid + "/members", { user_email: email }); }
catch (_) {}
}
closeModal(modal);
el("pj-f-name").value = ""; el("pj-f-desc").value = "";
el("pj-f-due").value = "";
getColor = renderColorPalette(el("pj-f-colors"), null, "#4573d2");
getIcon = renderIconPalette(el("pj-f-icons"), "");
if (onCreated) onCreated(res.project);
} catch (e) { showToast("생성 실패: " + e.message, "error"); }
});
}
// ── 좌측 프로젝트 목록(project/_side.html) — 수신함·내 업무·휴지통·프로젝트
// 네 화면이 모두 이 구현 하나를 쓴다(예전엔 프로젝트 화면에만 있어서 다른
// 화면에선 ✎/×·드래그 순서 변경이 없었다). 관리자에게만 손잡이(⣿)·✎·×·
// 우클릭 메뉴를 붙이고, 수정/새 프로젝트 모달은 project/_side_modals.html.
// cfg:
// projects 프로젝트 배열 — 주면 제자리에서 고친다(프로젝트 화면이 뷰와
// 같은 배열을 공유). 없으면 서버가 그린 li 의 data-* 에서 읽는다.
// currentId 지금 보고 있는 프로젝트 id(없으면 0) — 지우면 /project/ 로
// onSaved(p) / onCreated(p) / onDeleted(id) — 화면별 후처리
function initSideTree(cfg) {
cfg = cfg || {};
const side = document.querySelector(".pj-side");
const noop = { render: function () {}, merge: function () {} };
if (!side) return noop;
const isAdmin = side.dataset.isAdmin === "true";
const isSuper = side.dataset.isSuper === "true";
const me = (side.dataset.me || "").toLowerCase();
const currentId = cfg.currentId || 0;
const DELETE_DENIED = "삭제는 만든 사람만 할 수 있습니다.";
function canDelete(createdBy) {
if (isSuper) return true;
const cb = (createdBy || "").toLowerCase();
return !!cb && cb === me;
}
const projects = cfg.projects || Array.prototype.map.call(
side.querySelectorAll(".pj-tree-li"),
function (li) {
const d = li.dataset;
return {
id: parseInt(d.id, 10), name: d.name || "", description: d.desc || "",
start_date: d.start || null, due_date: d.due || null,
color: d.color || "#4573d2", status: d.status || "active", created_by: d.creator || "",
icon: d.icon || "",
};
}
);
function treeProjLi(p) {
let acts = "";
if (isAdmin) {
acts = '<span class="pj-tree-acts">' +
'<button type="button" class="pj-icon-btn pj-tree-edit" data-id="' + p.id +
'" data-name="' + escapeHtml(p.name) + '" data-desc="' + escapeHtml(p.description || "") +
'" data-start="' + (p.start_date || "") + '" data-due="' + (p.due_date || "") +
'" data-color="' + (p.color || "#4573d2") + '" data-status="' + (p.status || "active") +
'" title="프로젝트 수정">✎</button>' +
'<button type="button" class="pj-icon-btn pj-tree-del" data-id="' + p.id +
'" data-name="' + escapeHtml(p.name) + '" data-creator="' + escapeHtml(p.created_by || "") + '" title="프로젝트 삭제">×</button>' +
"</span>";
}
// 드래그로 순서 변경 가능함을 알려주는 손잡이(⣿) — 관리자에게만 보인다.
const handle = isAdmin ? '<span class="pj-tree-handle" title="드래그로 순서 변경">⣿</span>' : "";
return '<li class="pj-tree-li"' + (isAdmin ? ' draggable="true"' : "") + ' data-id="' + p.id + '"><div class="pj-tree-row ' +
(p.id === currentId ? "is-active" : "") + '">' +
handle +
'<a class="pj-tree-link" href="/project/p/' + p.id + '">' +
'<span class="pj-tree-avatar' + (p.icon ? " has-icon" : "") + (isLightColor(p.color) ? " is-light" : "") +
'" style="background:' + (p.color || "#4573d2") + '">' +
projBadgeInner(p) + "</span>" +
'<span class="pj-tree-name">' + escapeHtml(p.name) + "</span></a>" + acts + "</div></li>";
}
async function deleteTreeProject(id, name, createdBy) {
if (!canDelete(createdBy)) { alert(DELETE_DENIED); return; }
const ok = await window.erpConfirm(
"'" + (name || "") + "' 프로젝트를 삭제할까요? 안의 작업도 모두 삭제됩니다.",
{ okText: "삭제", cancelText: "취소" }
);
if (!ok) return;
try {
await api("DELETE", "/project/api/projects/" + id);
if (String(id) === String(currentId)) { location.href = "/project/"; return; }
const i = projects.findIndex(function (x) { return String(x.id) === String(id); });
if (i >= 0) projects.splice(i, 1);
render();
if (cfg.onDeleted) cfg.onDeleted(id);
else if (softSyncProjectRef) softSyncProjectRef(); // 내 업무 목록 등 다시 받기
} catch (err) { showToast("삭제 실패: " + err.message, "error"); }
}
function wireTreeHandlers(rootUl) {
// <a> 는 기본 draggable="true" — 그대로 두면 li 대신 링크(URL) 드래그가
// 시작돼 아래 wireTreeDrag 의 dragstart 핸들러가 무력화된다.
if (isAdmin) rootUl.querySelectorAll(".pj-tree-link").forEach(function (a) { a.draggable = false; });
rootUl.querySelectorAll(".pj-tree-del").forEach(function (b) {
b.addEventListener("click", function (e) {
e.preventDefault(); e.stopPropagation();
deleteTreeProject(b.dataset.id, b.dataset.name, b.dataset.creator);
});
});
rootUl.querySelectorAll(".pj-tree-edit").forEach(function (b) {
b.addEventListener("click", function (e) {
e.preventDefault(); e.stopPropagation();
openProjectEditModal(b.dataset);
});
});
if (isAdmin) rootUl.querySelectorAll(".pj-tree-li").forEach(function (li) {
li.addEventListener("contextmenu", function (e) {
e.preventDefault();
const editBtn = li.querySelector(".pj-tree-edit");
const delBtn = li.querySelector(".pj-tree-del");
showContextMenu(e.clientX, e.clientY, [
{ label: "열기", onClick: function () { location.href = "/project/p/" + li.dataset.id; } },
{ label: "수정", onClick: function () { if (editBtn) openProjectEditModal(editBtn.dataset); } },
null,
{
label: "삭제", danger: true,
onClick: function () {
if (delBtn) deleteTreeProject(delBtn.dataset.id, delBtn.dataset.name, delBtn.dataset.creator);
},
},
]);
});
});
}
function render() {
let rootUl = el("pj-tree-root");
const active = projects.filter(function (p) { return p.status !== "completed"; });
const done = projects.filter(function (p) { return p.status === "completed"; });
const block = side.querySelector(".pj-tree-block");
// 처음에 프로젝트가 하나도 없었으면 서버가 "프로젝트 없음" 만 그렸다 —
// 새로 만들면 그때 목록(ul)을 만든다.
if (!rootUl && active.length && block) {
const empty = block.querySelector(".pj-empty-sm");
rootUl = document.createElement("ul");
rootUl.className = "pj-tree";
rootUl.id = "pj-tree-root";
if (empty) empty.replaceWith(rootUl);
else block.insertBefore(rootUl, block.querySelector(".pj-side-head-done"));
wireTreeDrag(rootUl);
}
if (rootUl) {
rootUl.innerHTML = active.map(treeProjLi).join("");
wireTreeHandlers(rootUl);
}
// "완료 프로젝트" 섹션 — 처음 페이지를 열었을 때 완료 프로젝트가
// 하나도 없었으면 서버가 아예 안 그려서 DOM에 없다. 완료로 바뀌는
// 순간 필요해지면 그때 만든다(반대로 마지막 하나가 해제/삭제되면 통째로 치운다).
let doneUl = el("pj-tree-root-done");
if (done.length && block) {
if (!doneUl) {
const head = document.createElement("div");
head.className = "pj-side-head pj-side-head-done";
head.innerHTML = "<span>완료 프로젝트</span>";
doneUl = document.createElement("ul");
doneUl.className = "pj-tree";
doneUl.id = "pj-tree-root-done";
block.appendChild(head);
block.appendChild(doneUl);
wireTreeDrag(doneUl);
}
doneUl.innerHTML = done.map(treeProjLi).join("");
wireTreeHandlers(doneUl);
} else if (doneUl) {
const head = doneUl.previousElementSibling;
if (head && head.classList.contains("pj-side-head-done")) head.remove();
doneUl.remove();
}
}
// 드래그 순서 변경 — 관리자 전용, 최상위 프로젝트만. rootUl 자체는
// render() 가 innerHTML 만 바꾸고 element 를 갈아치우지 않으므로 리스너는
// 한 번만 붙이면 된다.
function wireTreeDrag(rootUl) {
if (!isAdmin || !rootUl) return;
let dragLi = null;
rootUl.addEventListener("dragstart", function (e) {
const li = e.target.closest(".pj-tree-li");
if (!li) return;
dragLi = li;
e.dataTransfer.setData("application/x-pj-tree", String(li.dataset.id));
e.dataTransfer.effectAllowed = "move";
li.classList.add("is-dragging");
});
rootUl.addEventListener("dragend", function () {
if (dragLi) dragLi.classList.remove("is-dragging");
dragLi = null;
});
rootUl.addEventListener("dragover", function (e) {
if (!dragLi) return;
const li = e.target.closest(".pj-tree-li");
if (!li || li === dragLi) { e.preventDefault(); return; }
e.preventDefault();
const r = li.getBoundingClientRect();
const before = (e.clientY - r.top) < r.height / 2;
rootUl.insertBefore(dragLi, before ? li : li.nextSibling);
});
rootUl.addEventListener("drop", async function (e) {
if (!dragLi) return;
e.preventDefault();
const ids = Array.prototype.slice.call(rootUl.querySelectorAll(".pj-tree-li"))
.map(function (li) { return parseInt(li.dataset.id, 10); });
try {
await api("PUT", "/project/api/projects/order", { ordered_ids: ids });
projects.sort(function (a, b) { return ids.indexOf(a.id) - ids.indexOf(b.id); });
} catch (err) {
showToast("순서 변경 실패: " + err.message, "error");
render();
}
});
}
function merge(p) {
const i = projects.findIndex(function (x) { return String(x.id) === String(p.id); });
if (i >= 0) projects[i] = Object.assign({}, projects[i], p);
else projects.push(p);
render();
}
// ── ✎ 버튼 — 프로젝트 수정 모달. 트리는 render() 로 매번 다시 그려지므로
// 열기 로직을 함수로 두고 wireTreeHandlers 에서 매번 다시 건다.
const editModal = el("pj-modal-edit");
let getEditColor = null, getEditIcon = null, editOrigIcon = "";
function openProjectEditModal(data) {
if (!editModal) return;
el("pj-e-id").value = data.id;
el("pj-e-name").value = data.name || "";
el("pj-e-desc").value = data.desc || "";
el("pj-e-start").value = data.start || "";
el("pj-e-due").value = data.due || "";
el("pj-e-done").checked = data.status === "completed";
getEditColor = renderColorPalette(el("pj-e-colors"), null, data.color);
const cur = projects.find(function (x) { return String(x.id) === String(data.id); });
editOrigIcon = (cur && cur.icon) || "";
getEditIcon = renderIconPalette(el("pj-e-icons"), editOrigIcon);
openModal(editModal);
}
if (editModal) {
wireModalClose(editModal);
el("pj-save-edit").addEventListener("click", async function () {
const id = el("pj-e-id").value;
const name = el("pj-e-name").value.trim();
if (!name) { alert("이름을 입력하세요."); return; }
try {
const res = await api("PUT", "/project/api/projects/" + id, {
name: name,
description: el("pj-e-desc").value.trim(),
start_date: el("pj-e-start").value || null,
due_date: el("pj-e-due").value || null,
color: getEditColor ? getEditColor() : undefined,
// 아이콘은 바뀐 경우에만 — 안 바꾼 저장이 마이그레이션 011 전에도 되게.
icon: getEditIcon && getEditIcon() !== editOrigIcon ? (getEditIcon() || null) : undefined,
status: el("pj-e-done").checked ? "completed" : "active",
});
merge(res.project);
if (cfg.onSaved) cfg.onSaved(res.project);
closeModal(editModal);
} catch (e) { showToast("저장 실패: " + e.message, "error"); }
});
el("pj-delete-project").addEventListener("click", function () {
const id = el("pj-e-id").value;
const p = projects.find(function (x) { return String(x.id) === String(id); });
closeModal(editModal);
deleteTreeProject(id, p && p.name, p && p.created_by);
});
}
// 프로젝트 모달의 날짜 칸 — 브라우저 기본 달력 대신 아사나식 날짜 팝업.
enhanceDateInput(el("pj-f-due"), { iconOnly: true });
enhanceDateInput(el("pj-e-due"), { startInput: el("pj-e-start"), iconOnly: true });
// "+" — 새 최상위 프로젝트. 기본은 만든 프로젝트 화면으로 이동한다.
initNewProjectModal(isAdmin, cfg.onCreated || function (project) {
location.href = "/project/p/" + project.id;
});
// 서버가 그려 둔 ul 에 먼저 드래그를 건다(render 가 새로 만드는 ul 은
// 거기서 직접 건다 — 순서를 바꾸면 리스너가 두 번 붙을 수 있다).
wireTreeDrag(el("pj-tree-root"));
wireTreeDrag(el("pj-tree-root-done"));
render();
return { render: render, merge: merge };
}
let cmtChat = null;
// 확장자 → 이모지 아이콘(파일 종류 표시용). 이미지는 썸네일로 따로 보여주므로
// 여기 없음.
function chatFileIcon(filename) {
const ext = String(filename || "").split(".").pop().toLowerCase();
const map = {
pdf: "📕", doc: "📄", docx: "📄", hwp: "📄", txt: "📃",
xls: "📊", xlsx: "📊", csv: "📊",
ppt: "📙", pptx: "📙",
zip: "🗜️", rar: "🗜️", "7z": "🗜️",
mp4: "🎬", mov: "🎬", avi: "🎬",
mp3: "🎵", wav: "🎵",
};
return map[ext] || "📎";
}
// 작업 창 댓글 목록의 댓글별 첨부(댓글 대화창과 같은 모양) — 이미지는 작은 미리보기(inline,
// 서버가 안전한 이미지 형식만 그대로 보낸다), 그 밖엔 아이콘 + 파일명(다운로드). 파일명은 이스케이프.
// 다운로드·미리보기 주소는 서버가 매번 작업 권한을 다시 검사한다.
function commentAttachmentsHtml(atts) {
if (!atts || !atts.length) return "";
return '<div class="pj-comment-atts">' + atts.map(function (a) {
const isImg = (a.content_type || "").indexOf("image/") === 0;
const name = escapeHtml(a.filename || "파일");
if (isImg) {
return '<a class="pj-comment-att pj-comment-att-img" href="/project/api/attachments/' + a.id +
'/download" target="_blank" rel="noopener" title="' + name + '">' +
'<img src="/project/api/attachments/' + a.id + '/inline" alt="' + name + '" loading="lazy" /></a>';
}
return '<a class="pj-comment-att pj-comment-att-file" href="/project/api/attachments/' + a.id + '/download">' +
'<span class="pj-chat-att-icon">' + chatFileIcon(a.filename) + "</span>" +
'<span class="pj-chat-att-name">' + name + "</span></a>";
}).join("") + "</div>";
}
function initCommentsChat(getTaskTitle) {
const modal = el("pj-modal-comments");
if (!modal) return null;
if (cmtChat) return cmtChat;
wireModalClose(modal);
function loadSeenComments() {
try { return JSON.parse(localStorage.getItem("pj_seen_comments") || "{}"); }
catch (_) { return {}; }
}
function markSeen(taskId, count) {
const m = loadSeenComments();
m[taskId] = count;
try { localStorage.setItem("pj_seen_comments", JSON.stringify(m)); } catch (_) {}
}
function currentUserEmail() {
const wrap = document.querySelector(".pj-wrap");
return ((wrap && wrap.dataset.me) || "").toLowerCase();
}
// ── 보내기 전 대기 중인 파일(파일 선택/붙여넣기로 담은 것들) ──
let pendingFiles = [];
let pendingErrors = new WeakMap(); // 파일 → 보낼 수 없었던 이유(빨간 표시)
function renderPending() {
const box = el("pj-cm-pending");
if (!box) return;
if (!pendingFiles.length) { box.hidden = true; box.innerHTML = ""; return; }
box.hidden = false;
box.innerHTML = pendingFiles.map(function (f, i) {
const icon = f.type && f.type.indexOf("image/") === 0 ? "🖼️" : chatFileIcon(f.name);
const err = pendingErrors.get(f);
return '<span class="pj-chat-pending-chip' + (err ? " is-failed" : "") + '"' +
(err ? ' title="보낼 수 없음: ' + escapeHtml(err) + '"' : "") + ">" +
'<span class="pj-chat-att-icon">' + icon + "</span>" +
'<span>' + escapeHtml(f.name) + (err ? " (" + escapeHtml(err) + ")" : "") + "</span>" +
'<button type="button" data-idx="' + i + '" title="빼기">×</button></span>';
}).join("");
box.querySelectorAll("button[data-idx]").forEach(function (btn) {
btn.addEventListener("click", function () {
pendingFiles.splice(parseInt(btn.dataset.idx, 10), 1);
chatToken = null;
renderPending();
});
});
}
const fileInput = el("pj-cm-file-input");
if (fileInput) fileInput.addEventListener("change", function () {
Array.prototype.slice.call(fileInput.files).forEach(function (f) { pendingFiles.push(f); });
fileInput.value = "";
chatToken = null;
renderPending();
});
const cmInput = el("pj-cm-input");
attachMentionInput(cmInput);
attachEmojiPicker(cmInput);
attachMentionButton(cmInput);
if (cmInput) cmInput.addEventListener("paste", function (e) {
const cd = e.clipboardData || window.clipboardData || {};
// 글자(웹페이지 주소 등)가 있으면 글자 붙여넣기가 먼저 — 일부 프로그램은 복사할 때
// 글자와 함께 그림도 넣어서, 예전엔 그림으로 가로채 주소가 안 붙었다.
if (cd.getData && cd.getData("text/plain")) return;
const items = cd.items || [];
let handled = false;
for (let i = 0; i < items.length; i++) {
if (items[i].type && items[i].type.indexOf("image/") === 0) {
const file = items[i].getAsFile();
if (file) { pendingFiles.push(file); handled = true; }
}
}
if (handled) { e.preventDefault(); chatToken = null; renderPending(); }
});
// ── 댓글에 딸린 첨부(이미지/파일) 렌더 — 이미지는 썸네일, 그 외는 아이콘+파일명 ──
function attachmentHtml(a, me) {
const mine = (a.uploaded_by || "").toLowerCase() === me;
const isImg = (a.content_type || "").indexOf("image/") === 0;
const delBtn = mine
? '<button type="button" class="pj-chat-att-del" data-id="' + a.id + '" title="삭제">' +
'<span class="material-symbols-outlined">close</span></button>'
: "";
if (isImg) {
return '<div class="pj-chat-att pj-chat-att-img" data-id="' + a.id + '">' +
'<a href="/project/api/attachments/' + a.id + '/download" target="_blank" rel="noopener">' +
'<img src="/project/api/attachments/' + a.id + '/inline" alt="' + escapeHtml(a.filename) + '" /></a>' +
delBtn + "</div>";
}
return '<span class="pj-chat-att pj-chat-att-file" data-id="' + a.id + '">' +
'<a href="/project/api/attachments/' + a.id + '/download">' +
'<span class="pj-chat-att-icon">' + chatFileIcon(a.filename) + '</span>' +
'<span class="pj-chat-att-name">' + escapeHtml(a.filename) + "</span></a>" +
delBtn + "</span>";
}
// 답글 대상 — 말풍선의 "답글"을 누르면 입력칸 위에 "OO 님에게 답글" 줄이 뜬다.
let replyTo = null;
function setReplyTo(c) {
replyTo = c;
let bar = el("pj-cm-replying");
if (!bar) {
bar = document.createElement("div");
bar.id = "pj-cm-replying";
bar.className = "pj-chat-replying";
const form = modal.querySelector(".pj-comment-form");
form.parentNode.insertBefore(bar, form);
}
if (!c) { bar.hidden = true; bar.innerHTML = ""; return; }
bar.hidden = false;
bar.innerHTML = '<span class="material-symbols-outlined">reply</span>' +
"<span><b>" + escapeHtml(idOf(c.author_email)) + "</b> 님에게 답글 · " +
escapeHtml(String(c.body || "첨부").slice(0, 40)) + "</span>" +
'<button type="button" class="pj-icon-btn" title="답글 취소"><span class="material-symbols-outlined">close</span></button>';
bar.querySelector("button").addEventListener("click", function () { setReplyTo(null); });
const inp = el("pj-cm-input");
if (inp) inp.focus();
}
async function renderChat(taskId) {
const me = currentUserEmail();
const list = el("pj-chat-list");
list.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
try {
const [cRes, aRes] = await Promise.all([
api("GET", "/project/api/tasks/" + taskId + "/comments"),
api("GET", "/project/api/tasks/" + taskId + "/attachments"),
ensureMentionTokens(),
]);
const comments = cRes.comments || [];
const feats = cRes.features || {};
// 읽기 전용(연결된 프로젝트에서 본 작업) — 입력칸·답글·반응·삭제를 감춘다(서버도 거절).
const readOnly = cRes.access === "read";
const form = modal.querySelector(".pj-comment-form");
if (form) form.hidden = readOnly;
if (readOnly) feats.reactions = false;
let roNote = el("pj-cm-readonly");
if (!roNote && form) {
roNote = document.createElement("div");
roNote.id = "pj-cm-readonly";
roNote.className = "pj-readonly-note";
roNote.textContent = "다른 프로젝트에서 연결된 작업이라 댓글은 읽기만 할 수 있습니다.";
form.parentNode.insertBefore(roNote, form);
}
if (roNote) roNote.hidden = !readOnly;
const byId = {};
comments.forEach(function (c) { byId[c.id] = c; });
// 완료 이력은 가운데 정렬 안내 줄로, 댓글과 시간순으로 섞는다.
const events = (cRes.events || []).slice();
// 댓글에 딸린 첨부만 채팅 말풍선에 표시(comment_id NULL = 설명란
// 이미지/"첨부파일" 패널 전용이라 여기선 무시).
const attByComment = {};
(aRes.attachments || []).forEach(function (a) {
if (a.comment_id == null) return;
(attByComment[a.comment_id] = attByComment[a.comment_id] || []).push(a);
});
if (!comments.length && !events.length) {
list.innerHTML = "<li class='pj-empty-sm'>댓글 없음</li>";
} else {
list.innerHTML = "";
function flushEvents(untilT) {
while (events.length && (untilT == null || (events[0].created_at || "") <= untilT)) {
const ev = events.shift();
const eli = document.createElement("li");
eli.className = "pj-chat-event";
eli.innerHTML = completionEventHtml(ev);
list.appendChild(eli);
}
}
comments.forEach(function (c) {
flushEvents(c.created_at || "");
const mine = (c.author_email || "").toLowerCase() === me;
const li = document.createElement("li");
li.className = "pj-chat-msg" + (mine ? " mine" : " other");
const atts = attByComment[c.id] || [];
const attsHtml = atts.length
? '<div class="pj-chat-atts">' + atts.map(function (a) { return attachmentHtml(a, readOnly ? "" : me); }).join("") + "</div>"
: "";
const parent = c.parent_id ? byId[c.parent_id] : null;
const quoteHtml = parent
? '<div class="pj-chat-quote"><span class="material-symbols-outlined">subdirectory_arrow_right</span>' +
"<b>" + escapeHtml(idOf(parent.author_email)) + "</b> " +
escapeHtml(String(parent.body || "첨부").slice(0, 50)) + "</div>"
: "";
const inner =
quoteHtml +
'<div class="pj-chat-bubble-wrap">' +
(c.body ? '<div class="pj-chat-bubble"></div>' : "") +
commentHoverBarHtml(feats, { reply: !readOnly }) +
"</div>" +
attsHtml +
'<div class="pj-react-slot">' + reactionRowHtml(c, me, feats.reactions) + "</div>" +
'<span class="pj-chat-meta">' +
(mine && !readOnly ? '<button type="button" class="pj-icon-btn pj-chat-del" title="삭제"><span class="material-symbols-outlined">close</span></button>' : "") +
'<span class="pj-chat-time">' + (c.created_at || "").slice(0, 16).replace("T", " ") + "</span>" +
"</span>";
// 상대방 댓글 — 카톡처럼 왼쪽에 프로필 아이콘, 그 옆에 이름 + 말풍선.
li.innerHTML = mine
? inner
: '<span class="pj-chat-av">' + chatAvatarHtml(c.author_email) + "</span>" +
'<div class="pj-chat-body">' +
'<span class="pj-chat-name">' + escapeHtml(idOf(c.author_email)) + "</span>" +
inner +
"</div>";
const bubble = li.querySelector(".pj-chat-bubble");
if (bubble) bubble.innerHTML = commentBodyHtml(c.body); // 주소 → 링크, @태그 → 칩(나머지는 이스케이프)
wireCommentReactions(li, c, function () {
li.querySelector(".pj-react-slot").innerHTML = reactionRowHtml(c, me, feats.reactions);
});
const replyBtn = li.querySelector("[data-reply]");
if (replyBtn) replyBtn.addEventListener("click", function () { setReplyTo(c); });
if (mine && !readOnly) {
li.querySelector(".pj-chat-del").addEventListener("click", async function () {
if (!(await confirm("이 댓글을 삭제할까요? 첨부된 파일도 함께 삭제됩니다."))) return;
try {
await api("DELETE", "/project/api/comments/" + c.id);
const n = await renderChat(taskId);
if (n !== null) { markSeen(taskId, n); syncBadge(taskId, n); }
} catch (e) { alert("삭제 실패: " + e.message); }
});
}
li.querySelectorAll(".pj-chat-att-del").forEach(function (btn) {
btn.addEventListener("click", async function (e) {
e.preventDefault(); e.stopPropagation();
if (!(await confirm("이 파일을 삭제할까요?"))) return;
try {
await api("DELETE", "/project/api/attachments/" + btn.dataset.id);
await renderChat(taskId);
} catch (err) { alert("삭제 실패: " + err.message); }
});
});
list.appendChild(li);
});
flushEvents(null);
list.scrollTop = list.scrollHeight;
}
return comments.length;
} catch (e) {
console.error("댓글 불러오기 실패", e);
list.innerHTML = "<li class='pj-empty-sm'>불러오기 실패: " + escapeHtml(e.message || "") + "</li>";
return null;
}
}
function syncBadge(taskId, n) {
const badge = document.querySelector('.pj-cmt-badge[data-task-id="' + taskId + '"]');
if (!badge) return;
badge.dataset.count = n;
badge.title = "댓글 " + n + "개";
const numEl = badge.querySelector(".pj-cmt-n");
if (numEl) numEl.textContent = n;
badge.classList.remove("is-unread");
}
async function open(taskId) {
el("pj-cm-task-id").value = taskId;
el("pj-cm-title").textContent = (getTaskTitle && getTaskTitle(taskId)) || "댓글";
pendingFiles = [];
pendingErrors = new WeakMap();
chatToken = null;
renderPending();
setReplyTo(null);
openModal(modal);
const n = await renderChat(taskId);
if (n !== null) { markSeen(taskId, n); syncBadge(taskId, n); }
}
function wireBadge(b) {
if (!b || b.dataset.pjCmtWired) return;
b.dataset.pjCmtWired = "1";
const n = parseInt(b.dataset.count, 10) || 0;
const seenN = loadSeenComments()[b.dataset.taskId] || 0;
if (n > seenN) b.classList.add("is-unread");
}
document.querySelectorAll(".pj-cmt-badge").forEach(wireBadge);
// 말풍선은 한 번 클릭으로 댓글 대화창(예전엔 더블클릭). 문서 전체에서 캡처
// 단계로 받아 카드·행·캘린더 막대의 클릭(작업 열기)보다 먼저 처리하고 막는다
// — 나중에 다시 그려진 말풍선도 따로 연결할 필요가 없다.
document.addEventListener("click", function (e) {
const b = e.target.closest && e.target.closest(".pj-cmt-badge[data-task-id]");
if (!b) return;
e.preventDefault(); e.stopPropagation();
open(b.dataset.taskId);
}, true);
// 빠르게 두 번 눌러도 밑의 카드/막대 더블클릭(작업 열기)이 같이 돌지 않게.
document.addEventListener("dblclick", function (e) {
if (e.target.closest && e.target.closest(".pj-cmt-badge[data-task-id]")) { e.preventDefault(); e.stopPropagation(); }
}, true);
// 보내기 — 파일이 있으면 본문·파일을 한 요청(/comments/files)으로 보내 서버가 한 트랜잭션에 만든다.
// 한 파일이라도 문제면(빈 파일·20MB 초과) 댓글을 만들지 않고 그 파일만 빨갛게 표시한다 — 빼고 다시
// 보내면 된다. 네트워크 오류·서버 오류면 입력·파일이 그대로 남아 다시 보낼 수 있고, 같은 client_token
// 이라 응답만 못 받은 경우에도 두 번 만들어지지 않는다. 예전엔 댓글을 먼저 만들고 파일을 따로 올려,
// 업로드가 실패하면 빈 댓글이 남고 고른 파일도 사라졌다.
let chatSending = false;
let chatToken = null;
el("pj-cm-send").addEventListener("click", async function () {
const taskId = el("pj-cm-task-id").value;
const inp = el("pj-cm-input");
const bodyText = inp.value.trim();
if (!taskId || (!bodyText && !pendingFiles.length) || chatSending) return;
const filesToSend = pendingFiles.slice();
chatSending = true;
chatToken = chatToken || newClientToken();
const sendBtn = el("pj-cm-send");
sendBtn.disabled = true;
try {
let res;
if (filesToSend.length) {
const fd = new FormData();
fd.append("body", bodyText);
fd.append("mentions", JSON.stringify(takeMentions(inp)));
fd.append("client_token", chatToken);
if (replyTo) fd.append("parent_id", String(replyTo.id));
filesToSend.forEach(function (f) { fd.append("files", f, f.name || "file"); });
const r = await fetch("/project/api/tasks/" + taskId + "/comments/files", { method: "POST", body: fd });
let data = null;
try { data = await r.json(); } catch (_) {}
if (!r.ok) {
const d = data && data.detail;
const err = new Error(typeof d === "string" ? d : (d && d.message) || ("요청 실패 (" + r.status + ")"));
err.status = r.status;
err.failed = (d && d.failed) || [];
throw err;
}
res = data;
} else {
res = await api("POST", "/project/api/tasks/" + taskId + "/comments", {
body: bodyText, mentions: takeMentions(inp), client_token: chatToken,
parent_id: replyTo ? replyTo.id : undefined,
});
}
chatToken = null;
setReplyTo(null);
pendingFiles = [];
pendingErrors = new WeakMap();
renderPending();
inp.value = "";
fitComposer(inp);
clearMentions(inp);
if (res && res.mention_skipped && res.mention_skipped.length) {
showToast("태그하지 못한 사람(이 작업을 볼 수 없음): " + res.mention_skipped.map(idOf).join(", "), "error");
}
const n = await renderChat(taskId);
if (n !== null) { markSeen(taskId, n); syncBadge(taskId, n); }
} catch (e) {
if (e.failed && e.failed.length) {
// 문제 파일만 표시 — 나머지는 그대로 두고, 빼거나 바꾼 뒤 다시 보낸다.
e.failed.forEach(function (f) {
const file = filesToSend[parseInt(f.index, 10)];
if (file) pendingErrors.set(file, f.reason || "실패");
});
renderPending();
}
if (e.status && e.status < 500) chatToken = null; // 거절된 요청은 다음에 새로 보낸다
showToast("등록 실패: " + e.message + " — 입력과 파일은 그대로 남아 있습니다.", "error");
} finally {
chatSending = false;
sendBtn.disabled = false;
}
});
el("pj-cm-input").addEventListener("input", function () { chatToken = null; });
el("pj-cm-input").addEventListener("keydown", function (e) {
if (isImeEnter(e)) return; // 한글 조합 확정 Enter 는 전송하지 않는다
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); el("pj-cm-send").click(); } // Shift+Enter = 줄바꿈
});
cmtChat = { open: open, wireBadge: wireBadge };
if (window.__PJ_TEST__) window.__pjChat = cmtChat; // 자동 테스트 전용
return cmtChat;
}
// ════════════════════════════════════════════════════════════
// 멘션(@태그) — 설명란(contenteditable)과 댓글 입력(평문 input) 공용
//
// @를 누르면 등록된 전체 프로젝트 멤버가 뜨고, 고르면
// · 설명란: <span class="pj-mention" data-email="...">@아이디</span> 칩
// · 댓글 : "@아이디 " 평문 + 이메일을 따로 기억(전송 시 함께 보냄)
// 으로 들어간다. 태그된 사람은 수신함(/project/inbox)에서 그 업무를 본다.
// ════════════════════════════════════════════════════════════
// 전체 등록 사용자(댓글 속 "@아이디" 를 칩으로 그릴 때) — 한 번만 받는다.
let allUsersCache = null;
async function allUsers() {
if (allUsersCache) return allUsersCache;
try {
const res = await api("GET", "/project/api/all-users");
allUsersCache = res.users || [];
} catch (_) { return []; } // 실패는 기억하지 않는다(다음에 다시)
return allUsersCache;
}
// @태그 후보 — 지금 쓰는 작업(댓글 대화창 또는 작업 창)을 볼 수 있는 사람만(서버가 거른다).
// 태그해도 볼 수 없는 사람에게 작업 정보가 가거나 권한이 생기지 않게(서버도 저장 때 다시 거른다).
const mentionUsersCache = {};
function mentionTaskId() {
const cm = el("pj-modal-comments");
if (cm && !cm.hidden && el("pj-cm-task-id") && el("pj-cm-task-id").value) return el("pj-cm-task-id").value;
const t = el("pj-t-id");
return t && t.value ? t.value : "";
}
async function mentionUsers() {
const tid = mentionTaskId();
if (!tid) return allUsers();
if (mentionUsersCache[tid]) return mentionUsersCache[tid];
try {
const res = await api("GET", "/project/api/all-users?task_id=" + encodeURIComponent(tid));
mentionUsersCache[tid] = res.users || [];
} catch (_) { return []; }
return mentionUsersCache[tid];
}
// 메뉴는 화면에 하나만 띄운다(설명란/댓글/채팅이 번갈아 쓴다).
let mentionMenuEl = null;
let mentionMenuState = null;
function closeMentionMenu() {
if (mentionMenuEl) mentionMenuEl.hidden = true;
mentionMenuState = null;
}
function mentionMenuOpen() { return !!mentionMenuState; }
function ensureMentionMenu() {
if (mentionMenuEl) return mentionMenuEl;
mentionMenuEl = document.createElement("div");
mentionMenuEl.className = "pj-mention-menu";
mentionMenuEl.hidden = true;
document.body.appendChild(mentionMenuEl);
// mousedown 은 막는다 — 안 그러면 목록을 누르는 순간 입력칸이 포커스를
// 잃어 커서 위치(=치환할 자리)가 사라진다.
mentionMenuEl.addEventListener("mousedown", function (e) { e.preventDefault(); });
document.addEventListener("mousedown", function (e) {
if (mentionMenuEl && !mentionMenuEl.contains(e.target)) closeMentionMenu();
}, true);
window.addEventListener("resize", closeMentionMenu);
return mentionMenuEl;
}
// opts.above — 기준(rect) 위쪽에 우선 띄우고 오른쪽 끝을 기준에 맞춘다(댓글칸 @ 버튼).
function renderMentionMenu(users, rect, onPick, opts) {
const menu = ensureMentionMenu();
menu.innerHTML = "";
if (!users.length) {
menu.innerHTML = '<div class="pj-mention-empty">일치하는 멤버 없음</div>';
} else {
users.forEach(function (u, i) {
const b = document.createElement("button");
b.type = "button";
b.className = "pj-mention-opt" + (i === 0 ? " is-active" : "");
b.innerHTML =
(u.avatar
? '<img class="pj-avatar pj-gicon-sm" src="' + escapeHtml(u.avatar) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="material-symbols-outlined pj-gicon pj-gicon-sm">account_circle</span>') +
"<span>" + escapeHtml(capName(u.id || u.name || u.email)) + "</span>";
b.addEventListener("click", function () { onPick(u); });
menu.appendChild(b);
});
}
menu.hidden = false;
// 기본: 커서/입력칸 바로 아래, 화면 밖으로 나가면 위쪽으로 뒤집는다.
// opts.above: 기준 위쪽(아이콘 윗부분), 위 공간이 없으면 아래로.
const above = !!(opts && opts.above);
let top = window.scrollY + rect.bottom + 4;
let left = window.scrollX + (above ? rect.right - menu.offsetWidth : rect.left);
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - menu.offsetWidth - 8);
if (above
? rect.top - menu.offsetHeight - 6 >= 8
: rect.bottom + menu.offsetHeight + 8 > document.documentElement.clientHeight) {
top = window.scrollY + rect.top - menu.offsetHeight - (above ? 6 : 4);
}
menu.style.left = Math.max(8, left) + "px";
menu.style.top = Math.max(8, top) + "px";
mentionMenuState = { users: users, index: 0, onPick: onPick };
}
function moveMentionActive(delta) {
if (!mentionMenuState) return;
const opts = mentionMenuEl.querySelectorAll(".pj-mention-opt");
if (!opts.length) return;
opts[mentionMenuState.index].classList.remove("is-active");
mentionMenuState.index = (mentionMenuState.index + delta + opts.length) % opts.length;
const act = opts[mentionMenuState.index];
act.classList.add("is-active");
act.scrollIntoView({ block: "nearest" });
}
function chooseMentionActive() {
if (!mentionMenuState) return false;
const u = mentionMenuState.users[mentionMenuState.index];
if (!u) { closeMentionMenu(); return false; }
mentionMenuState.onPick(u);
return true;
}
function filterMentionUsers(users, query) {
const q = (query || "").toLowerCase();
if (!q) return users.slice(0, 12);
return users.filter(function (u) {
return (u.id || "").toLowerCase().indexOf(q) >= 0 ||
(u.name || "").toLowerCase().indexOf(q) >= 0 ||
(u.email || "").toLowerCase().indexOf(q) >= 0;
}).slice(0, 12);
}
// 메뉴가 떠 있을 때 위/아래/엔터/탭/ESC 를 가로챈다(입력칸 공용).
function mentionKeydown(e) {
if (!mentionMenuOpen()) return false;
if (e.key === "ArrowDown") { e.preventDefault(); moveMentionActive(1); return true; }
if (e.key === "ArrowUp") { e.preventDefault(); moveMentionActive(-1); return true; }
// stopImmediatePropagation 이어야 한다 — 같은 입력칸에 걸린 "Enter=전송"
// 핸들러는 stopPropagation 으로는 안 막힌다(같은 노드의 다른 리스너).
// 그래서 이 멘션 리스너를 항상 먼저 등록한다(attachMentionInput 호출 위치).
if (e.key === "Enter" || e.key === "Tab") {
e.preventDefault(); e.stopImmediatePropagation();
chooseMentionActive();
return true;
}
if (e.key === "Escape") { e.preventDefault(); closeMentionMenu(); return true; }
return false;
}
// ── 이미지 보기 창 — 설명란 이미지를 더블클릭하면 별도 브라우저 창(팝업 창, 페이지 안 팝업 아님)으로 연다.
// 창 크기 = 이미지 원본 크기(+ 여백·도구 막대), 화면보다 크면 화면 95% 까지. 처음엔 원본(100%), 창보다 크면 창에 맞춤.
// 창 안: 휠 = 마우스 위치 기준 확대·축소, 끌기 = 이동, 아래 막대 − / % / + · 1:1(원본) · 맞춤,
// 더블클릭 = 원본 ↔ 맞춤, 키보드 + − 0(맞춤) 1(원본). 이미지는 같은 서버 첨부 주소라 로그인 쿠키로 그대로 열린다.
function openImageWindow(img) {
const src = new URL(img.getAttribute("src") || img.src, location.href).href;
const nw = img.naturalWidth || 1200, nh = img.naturalHeight || 800;
const sw = (window.screen && screen.availWidth) || 1600, sh = (window.screen && screen.availHeight) || 900;
const w = Math.round(Math.min(Math.max(nw + 48, 480), sw * 0.95));
const h = Math.round(Math.min(Math.max(nh + 110, 360), sh * 0.95));
const left = Math.round(((window.screenX || 0) + Math.max(0, (window.outerWidth - w) / 2)));
const top = Math.round(((window.screenY || 0) + Math.max(0, (window.outerHeight - h) / 2)));
const win = window.open("", "pj-img-" + Date.now(),
"popup=yes,width=" + w + ",height=" + h + ",left=" + left + ",top=" + top + ",resizable=yes,scrollbars=no");
if (!win) { showToast("팝업이 막혀 있습니다. 브라우저 주소창 오른쪽에서 이 사이트의 팝업을 허용해 주세요.", "error"); return; }
const title = (img.getAttribute("alt") || "").trim() || decodeURIComponent((src.split("?")[0].split("/").pop() || "이미지"));
const ICON = function (d) {
return '<svg viewBox="0 0 20 20" width="18" height="18" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round">' + d + "</svg>";
};
const html = '<!doctype html><html lang="ko"><head><meta charset="utf-8"><title>이미지</title>' +
'<meta name="viewport" content="width=device-width, initial-scale=1"><style>' +
'html,body{margin:0;height:100%;overflow:hidden;background:#202226;color:#fff;font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,"Helvetica Neue",Helvetica,Arial,"Apple SD Gothic Neo","Malgun Gothic",sans-serif}' +
'#stage{position:fixed;inset:0;cursor:grab;touch-action:none}#stage.drag{cursor:grabbing}' +
'#img{position:absolute;left:0;top:0;transform-origin:0 0;user-select:none;-webkit-user-drag:none;box-shadow:0 6px 28px rgba(0,0,0,.45);background:#fff;max-width:none}' +
'#bar{position:fixed;left:50%;bottom:14px;transform:translateX(-50%);display:flex;align-items:center;gap:2px;padding:4px;' +
'background:rgba(40,42,47,.92);border:1px solid rgba(255,255,255,.08);border-radius:10px;box-shadow:0 6px 18px rgba(0,0,0,.35);z-index:2}' +
'#bar button{height:30px;min-width:34px;padding:0 8px;border:0;border-radius:7px;background:transparent;color:#fff;cursor:pointer;' +
'display:inline-flex;align-items:center;justify-content:center;font-family:inherit;font-weight:600;font-size:12.5px}' +
'#bar button:hover{background:rgba(255,255,255,.14)}#bar button:focus-visible{outline:2px solid #9d8cff;outline-offset:1px}' +
'#pct{min-width:56px;text-align:center;font-size:13px;font-variant-numeric:tabular-nums}' +
'.sep{width:1px;height:18px;background:rgba(255,255,255,.18);margin:0 4px}' +
'#err{position:fixed;inset:0;display:none;align-items:center;justify-content:center;color:#cfd3da;font-size:14px}' +
'</style></head><body><div id="stage"><img id="img" alt="" draggable="false"></div><div id="err">이미지를 불러오지 못했습니다.</div>' +
'<div id="bar">' +
'<button id="out" title="축소 (−)" aria-label="축소">' + ICON('<path d="M5 10h10"/>') + "</button>" +
'<span id="pct">100%</span>' +
'<button id="in" title="확대 (+)" aria-label="확대">' + ICON('<path d="M5 10h10M10 5v10"/>') + "</button>" +
'<span class="sep"></span><button id="one" title="원본 크기 (1)">1:1</button><button id="fit" title="창에 맞춤 (0)">맞춤</button></div>' +
"<script>(function(){" +
"var SRC=" + JSON.stringify(src) + ",TITLE=" + JSON.stringify(title) + ";document.title=TITLE;" +
"var img=document.getElementById('img'),stage=document.getElementById('stage'),pct=document.getElementById('pct');" +
"var s=1,x=0,y=0,MIN=0.05,MAX=16,BAR=60;" +
"function apply(){img.style.transform='translate('+x+'px,'+y+'px) scale('+s+')';pct.textContent=Math.round(s*100)+'%';}" +
"function zoomAt(n,cx,cy){n=Math.min(MAX,Math.max(MIN,n));x=cx-(cx-x)*n/s;y=cy-(cy-y)*n/s;s=n;apply();}" +
"function centerAt(n){s=n;x=(innerWidth-img.naturalWidth*s)/2;y=(innerHeight-BAR-img.naturalHeight*s)/2+4;if(y<8)y=8;apply();}" +
"function fitScale(){return Math.min((innerWidth-32)/img.naturalWidth,(innerHeight-BAR-24)/img.naturalHeight);}" +
"img.onload=function(){var f=fitScale();centerAt(f<1?f:1);};" +
"img.onerror=function(){document.getElementById('err').style.display='flex';};img.src=SRC;" +
"stage.addEventListener('wheel',function(e){e.preventDefault();zoomAt(s*Math.exp(-e.deltaY*0.0015),e.clientX,e.clientY);},{passive:false});" +
"var drag=null;stage.addEventListener('pointerdown',function(e){if(e.button!==0)return;drag={x:e.clientX,y:e.clientY,ox:x,oy:y};stage.setPointerCapture(e.pointerId);stage.classList.add('drag');});" +
"stage.addEventListener('pointermove',function(e){if(!drag)return;x=drag.ox+e.clientX-drag.x;y=drag.oy+e.clientY-drag.y;apply();});" +
"function end(){drag=null;stage.classList.remove('drag');}stage.addEventListener('pointerup',end);stage.addEventListener('pointercancel',end);" +
"stage.addEventListener('dblclick',function(e){if(Math.abs(s-1)<0.01){centerAt(fitScale());}else{zoomAt(1,e.clientX,e.clientY);}});" +
"function mid(){return [innerWidth/2,(innerHeight-BAR)/2];}" +
"document.getElementById('in').onclick=function(){var m=mid();zoomAt(s*1.25,m[0],m[1]);};" +
"document.getElementById('out').onclick=function(){var m=mid();zoomAt(s/1.25,m[0],m[1]);};" +
"document.getElementById('one').onclick=function(){centerAt(1);};" +
"document.getElementById('fit').onclick=function(){centerAt(fitScale());};" +
"addEventListener('keydown',function(e){var m=mid();if(e.key==='+'||e.key==='='){zoomAt(s*1.25,m[0],m[1]);}else if(e.key==='-'||e.key==='_'){zoomAt(s/1.25,m[0],m[1]);}" +
"else if(e.key==='0'){centerAt(fitScale());}else if(e.key==='1'){centerAt(1);}else if(e.key==='Escape'){window.close();}});" +
"})();<\/script></body></html>";
win.document.open();
win.document.write(html);
win.document.close();
const fontCSS = win.document.createElement("link"); fontCSS.rel = "stylesheet";
fontCSS.href = new URL("/static/project-fonts.css?v=20261002g", location.href).href; win.document.head.appendChild(fontCSS);
win.document.body.style.fontFamily = getComputedStyle(document.body).fontFamily;
try { win.focus(); } catch (_) {}
}
// ── 댓글·답글 입력칸 — 전송·붙여넣기 뒤에도 70px 고정, 긴 글은 내부 스크롤.
function fitComposer(ta) {
if (!ta || ta.tagName !== "TEXTAREA") return;
ta.style.height = "70px";
ta.style.overflowY = "auto";
}
document.addEventListener("input", function (e) {
if (e.target && e.target.classList && e.target.classList.contains("pj-composer-ta")) fitComposer(e.target);
});
// ── 평문 input 용 (#pj-comment-input, #pj-cm-input) ──
// 고른 사람을 input 에 기억해두고(_pjMentions), 전송 직전에 "@아이디" 가
// 아직 본문에 남아 있는 사람만 서버로 보낸다.
function attachMentionInput(input) {
if (!input || input.dataset.pjMention) return;
input.dataset.pjMention = "1";
input._pjMentions = {}; // "@아이디" → 이메일
function caretQuery() {
const pos = input.selectionStart == null ? input.value.length : input.selectionStart;
const before = input.value.slice(0, pos);
const m = before.match(/(?:^|\s)@([^\s@]*)$/);
return m === null ? null : { query: m[1], start: pos - m[1].length - 1, end: pos };
}
async function maybeOpen() {
const ctx = caretQuery();
if (!ctx) { closeMentionMenu(); return; }
const users = filterMentionUsers(await mentionUsers(), ctx.query);
// 옆에 @ 버튼이 있는 댓글칸이면 멤버 목록은 그 아이콘 윗부분에 띄운다.
const atBtn = input.parentNode && input.parentNode.querySelector(".pj-mention-btn");
const anchorRect = atBtn ? atBtn.getBoundingClientRect() : input.getBoundingClientRect();
renderMentionMenu(users, anchorRect, function (u) {
const token = "@" + capName(u.id || u.email.split("@")[0]);
input.value = input.value.slice(0, ctx.start) + token + " " + input.value.slice(ctx.end);
input._pjMentions[token] = u.email;
const caret = ctx.start + token.length + 1;
input.focus();
input.setSelectionRange(caret, caret);
closeMentionMenu();
}, { above: !!atBtn });
}
input.addEventListener("input", maybeOpen);
input.addEventListener("blur", function () { setTimeout(closeMentionMenu, 120); });
// keydown 은 capture 로 먼저 받는다 — 이 입력칸들은 Enter 에 "전송"이
// 걸려 있어서, 메뉴가 떠 있을 때 Enter 가 전송으로 새 나가면 안 된다.
input.addEventListener("keydown", function (e) { mentionKeydown(e); }, true);
}
// 전송 시 실제로 본문에 남아 있는 태그만 추린다.
function takeMentions(input) {
if (!input || !input._pjMentions) return [];
const text = input.value || "";
const out = [];
Object.keys(input._pjMentions).forEach(function (token) {
if (text.indexOf(token) >= 0) {
const email = input._pjMentions[token];
if (out.indexOf(email) < 0) out.push(email);
}
});
return out;
}
function clearMentions(input) { if (input) input._pjMentions = {}; }
// ════════════════════════════════════════════════════════════
// 이모티콘 선택기 — 댓글 입력칸(평문 input) 옆 😊 버튼
//
// 이모티콘은 유니코드 글자 그대로 본문에 들어가므로 서버/DB 변경은 없다.
// Windows 10(Segoe UI Emoji)에서 깨지지 않게 Emoji 12 이하만 넣었다.
// "자주 사용"은 브라우저별(localStorage)로 기억한다.
// ════════════════════════════════════════════════════════════
const EMOJI_CATS = [
{ key: "smile", icon: "sentiment_satisfied", label: "이모티콘 및 감정", list:
"😀 웃음 기쁨 smile|😃 웃음 기쁨|😄 웃음 기쁨|😁 웃음 이빨|😆 웃음 깔깔|😅 땀 웃음 민망|😂 눈물 웃음 ㅋㅋ|🤣 폭소 ㅋㅋ|😭 울음 엉엉 슬픔|" +
"😉 윙크|😗 뽀뽀|😙 뽀뽀|😚 뽀뽀|😘 키스 뽀뽀 사랑|🥰 사랑 하트|😍 하트 눈 사랑|🤩 별 눈 감동|🥳 파티 축하|" +
"🙂 미소|🙃 거꾸로|😊 미소 수줍|☺️ 미소|😌 안도 편안|😏 능글|😋 맛있 냠|😛 메롱|😜 메롱 윙크|😝 메롱|🤪 장난|" +
"🤗 포옹 안아|🤭 쉿 웃음|🤫 쉿 조용|🤔 생각 고민 음|🤐 입꾹|🤨 의심|😐 무표정|😑 무표정|😶 할말없음|😬 어색 긴장|🙄 눈굴림|" +
"😯 놀람|😮 놀람 헉|😲 놀람 충격|😳 당황 부끄|🥺 부탁 애원 글썽|😢 눈물 슬픔|😥 실망 땀|😓 식은땀|😞 실망|😔 슬픔 시무룩|" +
"😟 걱정|😕 혼란|🙁 슬픔|☹️ 슬픔|😣 괴로움|😖 괴로움|😫 지침 피곤|😩 지침 피곤|🥱 하품 졸림|😴 잠 졸림 zzz|😪 졸림|" +
"😤 씩씩 콧김|😠 화남|😡 화남 분노|🤬 욕 분노|😱 공포 비명|😨 무서움|😰 걱정 땀|🤯 멘붕 폭발|🥵 더움|🥶 추움|" +
"😷 마스크 아픔|🤒 열 아픔|🤕 부상|🤢 메스꺼움|🤮 구토|🤧 재채기 감기|😇 천사|🤠 카우보이|🤓 공부 안경|😎 선글라스 멋짐|" +
"🧐 관찰 돋보기|🤡 광대|👻 유령|💀 해골|👽 외계인|🤖 로봇|💩 똥|😺 고양이|😸 고양이|😹 고양이|😻 고양이 하트|🙈 안봐 원숭이|🙉 안들려|🙊 말안해" },
{ key: "people", icon: "emoji_people", label: "사람 및 손동작", list:
"👍 좋아요 최고 따봉 ok|👎 싫어요 별로|👌 오케이 ok|✌️ 브이 승리|🤞 행운 기원|🤟 사랑해|🤘 락|🤙 전화|👈 왼쪽|👉 오른쪽|" +
"👆 위|👇 아래|☝️ 하나 위|✋ 손 멈춤|🤚 손|🖐️ 손바닥|🖖 벌칸|👋 안녕 인사 바이|🤏 조금|✊ 주먹|👊 주먹 펀치|🤛 주먹|🤜 주먹|" +
"👏 박수 짝짝|🙌 만세 환호|👐 손|🤲 손|🤝 악수 협력 계약|🙏 감사 부탁 기도|✍️ 작성 쓰기|💪 힘 화이팅 파이팅|" +
"👀 눈 확인 봄|👁️ 눈|🧠 뇌 생각|👂 귀 듣기|👃 코|👄 입|🙋 손들기 질문|🙆 오케이|🙅 안돼 금지|💁 안내|🤷 모르겠음 글쎄|🤦 한숨 에휴|" +
"🙇 사과 죄송 인사|🏃 달리기 급함|🚶 걷기|💃 춤|🕺 춤|👨‍💻 개발자 코딩|👩‍💻 개발자 코딩|🧑‍🤝‍🧑 함께 팀|👪 가족|👶 아기|🧑 사람|👨 남자|👩 여자" },
{ key: "nature", icon: "emoji_nature", label: "동물 및 자연", list:
"🐶 강아지 개|🐱 고양이|🐭 쥐|🐹 햄스터|🐰 토끼|🦊 여우|🐻 곰|🐼 판다|🐨 코알라|🐯 호랑이|🦁 사자|🐮 소|🐷 돼지|🐸 개구리|" +
"🐵 원숭이|🐔 닭|🐧 펭귄|🐦 새|🐤 병아리|🦆 오리|🦉 부엉이|🐺 늑대|🐴 말|🦄 유니콘|🐝 벌|🐛 벌레|🦋 나비|🐌 달팽이 느림|🐢 거북이 느림|" +
"🐍 뱀|🐙 문어|🦀 게|🐠 물고기|🐬 돌고래|🐳 고래|🦈 상어|🐘 코끼리|🦒 기린|🐿️ 다람쥐|🌵 선인장|🎄 트리|🌲 나무|🌳 나무|🌴 야자수|" +
"🌱 새싹 시작|🌿 잎|🍀 네잎클로버 행운|🍁 단풍|🍂 낙엽|🌷 튤립 꽃|🌹 장미 꽃|🌻 해바라기|🌸 벚꽃|💐 꽃다발 축하|" +
"🌞 해 맑음|🌝 달|🌙 달 밤|⭐ 별|🌟 별 반짝|✨ 반짝 반짝이|⚡ 번개 빠름|🔥 불 핫 대박|🌈 무지개|☀️ 해 맑음|⛅ 구름|☁️ 구름 흐림|" +
"🌧️ 비|⛈️ 뇌우|❄️ 눈 겨울|☃️ 눈사람|💧 물방울|🌊 파도|🌍 지구 세계" },
{ key: "food", icon: "emoji_food_beverage", label: "음식", list:
"🍎 사과|🍊 귤|🍋 레몬|🍌 바나나|🍉 수박|🍇 포도|🍓 딸기|🍒 체리|🍑 복숭아|🥭 망고|🍍 파인애플|🥝 키위|🍅 토마토|🥑 아보카도|" +
"🌽 옥수수|🥕 당근|🥔 감자|🍞 빵|🥐 크루아상|🧀 치즈|🍳 계란|🥓 베이컨|🍔 햄버거|🍟 감자튀김|🍕 피자|🌭 핫도그|🥪 샌드위치|" +
"🌮 타코|🍝 파스타|🍜 라면 국수|🍲 찌개 전골|🍛 카레|🍣 초밥|🍱 도시락|🥟 만두|🍤 새우튀김|🍙 주먹밥|🍚 밥|🍗 치킨|🍖 고기|🥩 고기 스테이크|" +
"🍦 아이스크림|🍩 도넛|🍪 쿠키|🎂 케이크 생일|🍰 케이크|🧁 컵케이크|🍫 초콜릿|🍬 사탕|🍭 사탕|🍯 꿀|" +
"☕ 커피|🍵 차|🧃 주스|🥤 음료|🧋 버블티|🍺 맥주|🍻 건배 맥주|🥂 건배 샴페인|🍷 와인|🍶 술|🥃 위스키|🍴 식사 밥|🥢 젓가락" },
{ key: "activity", icon: "emoji_events", label: "활동", list:
"🎉 축하 파티 짝짝|🎊 축하|🎈 풍선|🎁 선물|🎀 리본|🏆 트로피 우승|🥇 금메달 1등|🥈 은메달 2등|🥉 동메달 3등|🏅 메달|🎖️ 훈장|" +
"⚽ 축구|⚾ 야구|🏀 농구|🏐 배구|🏈 미식축구|🎾 테니스|🏓 탁구|🏸 배드민턴|⛳ 골프|🎳 볼링|🎯 목표 과녁|🎮 게임|🎲 주사위|🧩 퍼즐|" +
"🎨 그림 디자인|🎬 영화|🎤 마이크 발표|🎧 음악|🎵 음악|🎶 음악|🎹 피아노|🎸 기타|🏋️ 운동|🚴 자전거|🏊 수영|⛷️ 스키|🧘 요가 명상" },
{ key: "travel", icon: "emoji_transportation", label: "여행 및 장소", list:
"🚗 자동차|🚕 택시|🚌 버스|🚚 트럭 배송 택배|🚛 트럭 배송|🚜 트랙터|🏍️ 오토바이|🚲 자전거|🚀 로켓 출시 배포|✈️ 비행기 출장|🛫 출발|🛬 도착|" +
"🚢 배 선박|⛵ 요트|🚆 기차|🚇 지하철|🚉 역|🚦 신호등|🚧 공사중 작업중|⛽ 주유|🗺️ 지도|🧭 나침반|🏠 집|🏢 회사 빌딩|🏭 공장|🏬 백화점|" +
"🏪 편의점|🏥 병원|🏦 은행|🏫 학교|🏨 호텔|⛪ 교회|🗼 타워|🏖️ 해변 휴가|🏝️ 섬 휴가|⛰️ 산|🏕️ 캠핑|🌃 야경|🌅 일출" },
{ key: "objects", icon: "emoji_objects", label: "사물", list:
"💡 아이디어 전구|📌 고정 핀|📍 위치 핀|📎 클립 첨부|✂️ 가위|📝 메모 작성|✏️ 연필 수정|🖊️ 펜|📒 노트|📚 책|📖 책|📅 달력 일정|📆 달력|" +
"🗓️ 일정|⏰ 알람 마감|⏱️ 타이머|⌛ 모래시계 대기|⏳ 대기 진행중|🕐 시간|📊 차트 통계|📈 상승 증가|📉 하락 감소|📋 클립보드 목록|📁 폴더|📂 폴더|" +
"🗂️ 분류|📦 박스 상자 택배|📮 우체통|📧 이메일 메일|✉️ 편지 메일|📨 메일|📤 보내기|📥 받기|📞 전화|📱 휴대폰|💻 노트북 컴퓨터|🖥️ 모니터|" +
"⌨️ 키보드|🖱️ 마우스|🖨️ 프린터|💾 저장|📷 카메라 사진|🎥 동영상|🔍 검색 찾기|🔎 검색|🔒 잠금 보안|🔓 해제|🔑 열쇠|🔨 망치|🔧 수리 설정|" +
"⚙️ 설정 톱니|🧰 공구|🧲 자석|🛒 장바구니 쇼핑|💰 돈 매출|💵 돈 달러|💳 카드 결제|🧾 영수증|💎 보석|🔔 알림 종|📢 공지 확성기|📣 공지|🏷️ 태그 라벨|🎫 티켓" },
{ key: "symbols", icon: "emoji_symbols", label: "기호", list:
"✅ 완료 체크 확인|☑️ 체크|✔️ 체크|❌ 취소 아니오 x|❎ 취소|⭕ 동그라미 정답|🚫 금지|⛔ 금지|⚠️ 경고 주의|❗ 느낌표 중요|❓ 물음표 질문|" +
"‼️ 강조|⁉️ 놀람|💯 백점 완벽|🆗 ok|🆕 새로운 new|🆙 업|🔝 top|❤️ 하트 사랑|🧡 하트|💛 하트|💚 하트|💙 하트|💜 하트|🖤 하트|" +
"🤍 하트|💔 상심|💕 하트|💖 하트 반짝|💗 하트|💘 하트|💝 하트 선물|💢 화남|💥 쾅 충돌|💫 어지러움|💦 땀 물|💨 휙 빠름|💬 말풍선 댓글|💭 생각|" +
"🗯️ 외침|💤 잠 zzz|🔴 빨강|🟠 주황|🟡 노랑|🟢 초록|🔵 파랑|🟣 보라|⚫ 검정|⚪ 흰색|🔺 위 삼각형|🔻 아래 삼각형|➡️ 오른쪽 화살표|⬅️ 왼쪽 화살표|" +
"⬆️ 위 화살표|⬇️ 아래 화살표|🔄 새로고침 반복|🔁 반복|➕ 더하기 추가|➖ 빼기|✖️ 곱하기|➗ 나누기|♻️ 재활용|🔰 초보|🆘 도움 sos|🏁 완주 끝|🚩 깃발 표시|🇰🇷 한국 태극기|🇲🇾 말레이시아" },
];
EMOJI_CATS.forEach(function (c) {
c.items = c.list.split("|").map(function (s) {
const sp = s.indexOf(" ");
return { e: s.slice(0, sp), k: s.slice(sp + 1).toLowerCase() };
});
});
const EMOJI_RECENT_KEY = "pj.emoji.recent";
const EMOJI_DEFAULT_RECENT = ["✅", "👍", "🙏", "😊", "🎉"];
function emojiRecent() {
try {
const v = JSON.parse(localStorage.getItem(EMOJI_RECENT_KEY) || "null");
if (Array.isArray(v) && v.length) return v;
} catch (_) {}
return EMOJI_DEFAULT_RECENT.slice();
}
function pushEmojiRecent(e) {
const list = emojiRecent().filter(function (x) { return x !== e; });
list.unshift(e);
try { localStorage.setItem(EMOJI_RECENT_KEY, JSON.stringify(list.slice(0, 16))); } catch (_) {}
}
let emojiPickerEl = null;
let emojiTarget = null;
function closeEmojiPicker() {
if (!emojiPickerEl || emojiPickerEl.hidden) return;
emojiPickerEl.hidden = true;
emojiTarget = null;
}
function ensureEmojiPicker() {
if (emojiPickerEl) return emojiPickerEl;
const p = document.createElement("div");
p.className = "pj-emoji-picker";
p.hidden = true;
p.innerHTML =
'<div class="pj-emoji-top"><label class="pj-emoji-search">' +
'<span class="material-symbols-outlined">search</span>' +
'<input type="search" placeholder="검색" autocomplete="off" /></label></div>' +
'<div class="pj-emoji-tabs"><button type="button" data-cat="recent" title="자주 사용하는 이모티콘">' +
'<span class="material-symbols-outlined">schedule</span></button>' +
EMOJI_CATS.map(function (c) {
return '<button type="button" data-cat="' + c.key + '" title="' + escapeHtml(c.label) + '">' +
'<span class="material-symbols-outlined">' + c.icon + "</span></button>";
}).join("") + "</div>" +
'<div class="pj-emoji-body"></div>';
document.body.appendChild(p);
emojiPickerEl = p;
const search = p.querySelector("input");
const body = p.querySelector(".pj-emoji-body");
function gridHtml(list) {
return '<div class="pj-emoji-grid">' + list.map(function (e) {
return '<button type="button" class="pj-emoji-opt" data-e="' + escapeHtml(e) + '">' + e + "</button>";
}).join("") + "</div>";
}
p._render = function () {
const q = search.value.trim().toLowerCase();
if (q) {
const hits = [];
EMOJI_CATS.forEach(function (c) {
c.items.forEach(function (it) { if (it.k.indexOf(q) >= 0 && hits.indexOf(it.e) < 0) hits.push(it.e); });
});
body.innerHTML = hits.length
? '<div class="pj-emoji-sec">검색 결과</div>' + gridHtml(hits)
: '<div class="pj-emoji-empty">일치하는 이모티콘이 없습니다.</div>';
return;
}
body.innerHTML =
'<div class="pj-emoji-sec" data-sec="recent">자주 사용하는 이모티콘</div>' + gridHtml(emojiRecent()) +
EMOJI_CATS.map(function (c) {
return '<div class="pj-emoji-sec" data-sec="' + c.key + '">' + escapeHtml(c.label) + "</div>" +
gridHtml(c.items.map(function (it) { return it.e; }));
}).join("");
};
search.addEventListener("input", function () { p._render(); body.scrollTop = 0; });
search.addEventListener("keydown", function (e) {
if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); closeEmojiPicker(); }
else if (e.key === "Enter") {
e.preventDefault();
const first = body.querySelector(".pj-emoji-opt");
if (first) first.click();
}
});
p.querySelector(".pj-emoji-tabs").addEventListener("click", function (e) {
const b = e.target.closest("button[data-cat]");
if (!b) return;
if (search.value) { search.value = ""; p._render(); }
const sec = body.querySelector('[data-sec="' + b.dataset.cat + '"]');
if (sec) body.scrollTop = sec.offsetTop;
});
body.addEventListener("click", function (e) {
const b = e.target.closest(".pj-emoji-opt");
if (!b || !emojiTarget) return;
const input = emojiTarget;
const emo = b.dataset.e;
// 댓글 반응처럼 "고른 이모티콘을 받는 함수"를 넘긴 경우.
if (typeof input === "function") {
pushEmojiRecent(emo);
closeEmojiPicker();
input(emo);
return;
}
const s = input.selectionStart == null ? input.value.length : input.selectionStart;
const en = input.selectionEnd == null ? s : input.selectionEnd;
input.value = input.value.slice(0, s) + emo + input.value.slice(en);
pushEmojiRecent(emo);
closeEmojiPicker();
input.focus();
input.setSelectionRange(s + emo.length, s + emo.length);
});
document.addEventListener("mousedown", function (e) {
if (p.hidden || p.contains(e.target) || e.target.closest(".pj-emoji-btn")) return;
closeEmojiPicker();
}, true);
// 모달의 ESC(닫기)보다 먼저 받아 선택기만 닫는다.
document.addEventListener("keydown", function (e) {
if (e.key === "Escape" && !p.hidden) { e.preventDefault(); e.stopImmediatePropagation(); closeEmojiPicker(); }
}, true);
window.addEventListener("resize", closeEmojiPicker);
return p;
}
function openEmojiPicker(input, anchor) {
const p = ensureEmojiPicker();
emojiTarget = input;
p.querySelector("input").value = "";
p._render();
p.hidden = false;
const body = p.querySelector(".pj-emoji-body");
body.scrollTop = 0;
// 버튼 위쪽에 띄우고, 공간이 없으면 아래로.
const r = anchor.getBoundingClientRect();
const vw = document.documentElement.clientWidth;
const vh = document.documentElement.clientHeight;
let top = r.top - p.offsetHeight - 6;
if (top < 8) top = Math.min(r.bottom + 6, vh - p.offsetHeight - 8);
let left = r.right - p.offsetWidth;
left = Math.max(8, Math.min(left, vw - p.offsetWidth - 8));
p.style.left = left + "px";
p.style.top = Math.max(8, top) + "px";
p.querySelector("input").focus();
}
function attachEmojiPicker(input) {
if (!input || input.dataset.pjEmoji) return;
input.dataset.pjEmoji = "1";
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-emoji-btn";
btn.title = "이모티콘";
btn.innerHTML = '<span class="material-symbols-outlined">add_reaction</span>';
btn.addEventListener("click", function () {
if (emojiPickerEl && !emojiPickerEl.hidden && emojiTarget === input) { closeEmojiPicker(); return; }
openEmojiPicker(input, btn);
});
input.insertAdjacentElement("afterend", btn);
}
// @ 버튼 — 이모티콘 버튼 오른쪽. 누르면 커서 자리에 "@"를 넣고 멤버 메뉴를 연다
// (attachMentionInput 의 input 이벤트가 메뉴를 띄운다). mousedown 을 막아 입력칸
// 포커스를 유지한다 — 안 막으면 blur 로 메뉴 닫기 타이머가 돌아 방금 연 메뉴가 닫힌다.
function attachMentionButton(input) {
if (!input || input.dataset.pjMentionBtn) return;
input.dataset.pjMentionBtn = "1";
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-emoji-btn pj-mention-btn";
btn.title = "멤버 태그(@)";
btn.innerHTML = '<span class="material-symbols-outlined">alternate_email</span>';
btn.addEventListener("mousedown", function (e) { e.preventDefault(); });
btn.addEventListener("click", function () {
if (document.activeElement !== input) input.focus();
const start = input.selectionStart == null ? input.value.length : input.selectionStart;
const end = input.selectionEnd == null ? start : input.selectionEnd;
const before = input.value.slice(0, start);
const ins = (before && !/\s$/.test(before) ? " " : "") + "@";
input.value = before + ins + input.value.slice(end);
const caret = start + ins.length;
input.setSelectionRange(caret, caret);
input.dispatchEvent(new Event("input", { bubbles: true }));
});
const after = input.nextElementSibling && input.nextElementSibling.classList.contains("pj-emoji-btn")
? input.nextElementSibling : input;
after.insertAdjacentElement("afterend", btn);
}
// ════════════════════════════════════════════════════════════
// 댓글 공용 — 작업 창 댓글 목록과 채팅형 댓글 팝업이 같이 쓴다
// · 본문의 "@아이디" → 아이콘+이름 칩(아사나식)
// · 이모티콘 반응 줄(누른 사람 수, 내가 누른 건 강조)과 마우스 올림 도구 모음
// · "OO 님이 이 작업을 완료했습니다" 이력 줄
// ════════════════════════════════════════════════════════════
const QUICK_REACTIONS = ["👍", "👀", "🙌", "✅"];
let mentionTokenMap = null;
async function ensureMentionTokens() {
if (mentionTokenMap) return mentionTokenMap;
const users = await allUsers();
const map = {};
users.forEach(function (u) {
const token = "@" + capName(u.id || String(u.email || "").split("@")[0]);
map[token.toLowerCase()] = u;
});
mentionTokenMap = map;
return map;
}
function mentionChipHtml(u) {
const url = u.avatar || pageAvatarUrl(u.email);
return '<span class="pj-mention-chip" data-tip="' + escapeHtml(u.email || "") + '">' +
(url
? '<img class="pj-avatar" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="material-symbols-outlined pj-gicon">account_circle</span>') +
escapeHtml(capName(u.id || String(u.email || "").split("@")[0])) + "</span>";
}
// ensureMentionTokens() 를 먼저 기다린 뒤 부른다(안 불렀으면 칩 없이 글자 그대로).
function commentBodyHtml(text) {
const src = String(text == null ? "" : text);
const map = mentionTokenMap || {};
const re = /(^|\s)(@[^\s@]+)/g;
let out = "";
let last = 0;
let m;
while ((m = re.exec(src)) !== null) {
const tokenStart = m.index + m[1].length;
// 태그 뒤에 붙은 문장부호("@Roar,")도 알아본다.
const raw = m[2];
const trail = (raw.match(/[).,!?;:]+$/) || [""])[0];
const token = raw.slice(0, raw.length - trail.length);
const u = map[token.toLowerCase()];
if (!u) continue;
out += linkifyToHtml(src.slice(last, tokenStart)) + mentionChipHtml(u);
last = tokenStart + token.length;
}
return out + linkifyToHtml(src.slice(last));
}
function reactionNames(users) {
return users.map(idOf).join(", ");
}
function reactionRowHtml(c, me, enabled) {
const list = c.reactions || [];
if (!enabled || !list.length) return "";
return '<div class="pj-react-row">' + list.map(function (r) {
const mine = r.users.map(function (x) { return String(x).toLowerCase(); }).indexOf(me) >= 0;
return '<button type="button" class="pj-react-pill' + (mine ? " is-mine" : "") + '" data-react="' +
escapeHtml(r.emoji) + '" data-tip="' + escapeHtml(reactionNames(r.users)) + '">' +
'<span class="pj-react-emo">' + r.emoji + "</span>" + r.users.length + "</button>";
}).join("") +
'<button type="button" class="pj-react-add" data-react-pick title="반응 추가">' +
'<span class="material-symbols-outlined">add_reaction</span></button></div>';
}
// 마우스를 올렸을 때 댓글 오른쪽 위에 뜨는 도구 모음(아사나식).
function commentHoverBarHtml(feats, opts) {
let h = "";
if (feats.reactions) {
h += QUICK_REACTIONS.map(function (e) {
return '<button type="button" data-react="' + e + '" title="' + e + ' 반응">' + e + "</button>";
}).join("") +
'<button type="button" data-react-pick title="반응 추가"><span class="material-symbols-outlined">add_reaction</span></button>';
}
if (feats.replies && opts.reply) {
h += '<button type="button" data-reply title="답글"><span class="material-symbols-outlined">reply</span></button>';
}
if (opts.edit) h += '<button type="button" data-edit title="수정"><span class="material-symbols-outlined">edit</span></button>';
if (opts.del) h += '<button type="button" data-del title="삭제"><span class="material-symbols-outlined">delete</span></button>';
return h ? '<div class="pj-cmt-hoverbar">' + h + "</div>" : "";
}
async function toggleReaction(c, emoji) {
try {
const res = await api("POST", "/project/api/comments/" + c.id + "/reactions", { emoji: emoji });
c.reactions = res.reactions || [];
return true;
} catch (e) {
showToast("반응 실패: " + e.message, "error");
return false;
}
}
// 댓글 한 개(li)의 반응 버튼들을 연결한다. rerender 는 반응 줄만 다시 그리는 함수.
function wireCommentReactions(li, c, rerender) {
li.addEventListener("click", async function (e) {
const pick = e.target.closest("[data-react-pick]");
if (pick && li.contains(pick)) {
e.stopPropagation();
openEmojiPicker(async function (emo) {
const has = (c.reactions || []).some(function (r) {
return r.emoji === emo && r.users.map(function (x) { return String(x).toLowerCase(); }).indexOf(currentMe()) >= 0;
});
if (has) return; // 이미 누른 이모티콘을 창에서 또 고르면 그대로 둔다
if (await toggleReaction(c, emo)) rerender();
}, pick);
return;
}
const b = e.target.closest("[data-react]");
if (!b || !li.contains(b)) return;
e.stopPropagation();
if (await toggleReaction(c, b.dataset.react)) rerender();
});
}
function currentMe() {
const wrap = document.querySelector(".pj-wrap");
return ((wrap && wrap.dataset.me) || "").toLowerCase();
}
function fmtCommentTime(s) {
return String(s || "").slice(0, 16).replace("T", " ");
}
function completionEventHtml(ev) {
return '<span class="material-symbols-outlined pj-cmt-event-ic">check_circle</span>' +
"<span><b>" + escapeHtml(idOf(ev.actor_email)) + "</b> 님이 이 작업을 완료했습니다" +
' <span class="pj-comment-time">· ' + escapeHtml(fmtCommentTime(ev.created_at)) + "</span></span>";
}
// ── contenteditable 용 (설명란) — 멘션 칩을 끼워 넣는다 ──
function attachMentionEditor(box) {
if (!box || box.dataset.pjMention) return;
box.dataset.pjMention = "1";
function caretContext() {
const sel = window.getSelection();
if (!sel || !sel.rangeCount) return null;
const r = sel.getRangeAt(0);
if (!r.collapsed || !box.contains(r.startContainer)) return null;
const node = r.startContainer;
if (node.nodeType !== 3) return null; // 텍스트 노드 안에서만
const before = node.textContent.slice(0, r.startOffset);
const m = before.match(/(?:^|[\s\u00a0])@([^\s@\u00a0]*)$/);
if (m === null) return null;
return { node: node, query: m[1], start: r.startOffset - m[1].length - 1, end: r.startOffset };
}
async function maybeOpen() {
const ctx = caretContext();
if (!ctx) { closeMentionMenu(); return; }
const sel = window.getSelection();
let rect = sel.rangeCount ? sel.getRangeAt(0).getBoundingClientRect() : null;
if (!rect || (!rect.width && !rect.height)) rect = box.getBoundingClientRect();
const users = filterMentionUsers(await mentionUsers(), ctx.query);
renderMentionMenu(users, rect, function (u) {
const range = document.createRange();
range.setStart(ctx.node, ctx.start);
range.setEnd(ctx.node, ctx.end);
range.deleteContents();
const chip = document.createElement("span");
chip.className = "pj-mention";
chip.setAttribute("data-email", u.email);
chip.setAttribute("contenteditable", "false");
chip.textContent = "@" + capName(u.id || u.email.split("@")[0]);
const space = document.createTextNode("\u00a0");
range.insertNode(space);
range.insertNode(chip);
// 커서를 칩 뒤 공백 다음으로
const after = document.createRange();
after.setStartAfter(space);
after.collapse(true);
const s2 = window.getSelection();
s2.removeAllRanges();
s2.addRange(after);
box.focus();
closeMentionMenu();
});
}
box.addEventListener("input", maybeOpen);
box.addEventListener("keydown", function (e) { mentionKeydown(e); }, true);
box.addEventListener("blur", function () { setTimeout(closeMentionMenu, 120); });
}
// ════════════════════════════════════════════════════════════
// 설명란 링크 — 주소를 붙여넣으면 <a> 로 바꾸고, 클릭하면 새 탭으로 연다
// ════════════════════════════════════════════════════════════
const PJ_URL_RE = /(https?:\/\/[^\s<>"']+|www\.[^\s<>"']+)/g;
function linkifyToHtml(text) {
const src = String(text == null ? "" : text);
let out = "";
let last = 0;
let m;
PJ_URL_RE.lastIndex = 0;
while ((m = PJ_URL_RE.exec(src)) !== null) {
out += escapeHtml(src.slice(last, m.index));
// 주소 끝에 붙은 문장부호는 링크에서 뺀다(".", ",", ")" 등).
let url = m[0];
let tail = "";
const trailing = url.match(/[).,!?;:'"]+$/);
if (trailing) { tail = trailing[0]; url = url.slice(0, url.length - tail.length); }
const href = /^https?:\/\//i.test(url) ? url : "http://" + url;
out += '<a href="' + escapeHtml(href) + '" target="_blank" rel="noopener noreferrer">' +
escapeHtml(url) + "</a>" + escapeHtml(tail);
last = m.index + m[0].length;
}
out += escapeHtml(src.slice(last));
return out.replace(/\n/g, "<br>");
}
// 에디터 안의 모든 <a> 가 새 탭으로 열리게 맞춘다(서식바 링크 버튼 포함).
function normalizeEditorLinks(box) {
if (!box) return;
box.querySelectorAll("a").forEach(function (a) {
a.setAttribute("target", "_blank");
a.setAttribute("rel", "noopener noreferrer");
});
}
// ════════════════════════════════════════════════════════════
// 가로 스크롤 막대 — 보드(세션이 오른쪽으로 계속 늘어난다)용.
// 세로 막대(attachScrollIndicator)와 같은 이유로 직접 그린다.
// ════════════════════════════════════════════════════════════
function attachHScrollIndicator(scroller, bar) {
if (!scroller || !bar) return null;
const thumb = bar.querySelector(".pj-hbar-thumb");
if (!thumb) return null;
let thumbW = 0;
function update() {
const sw = scroller.scrollWidth, cw = scroller.clientWidth;
if (cw <= 0 || sw <= cw + 1) { bar.hidden = true; return; }
bar.hidden = false;
const trackW = bar.clientWidth;
thumbW = Math.max(32, Math.round(trackW * cw / sw));
const left = Math.round((trackW - thumbW) * scroller.scrollLeft / (sw - cw));
thumb.style.width = thumbW + "px";
thumb.style.transform = "translateX(" + left + "px)";
}
if (bar.dataset.pjHbar) return update;
bar.dataset.pjHbar = "1";
scroller.addEventListener("scroll", update, { passive: true });
window.addEventListener("resize", update);
if (window.ResizeObserver) new ResizeObserver(update).observe(scroller);
let dragging = false, startX = 0, startLeft = 0;
thumb.addEventListener("mousedown", function (e) {
e.preventDefault();
dragging = true; startX = e.clientX; startLeft = scroller.scrollLeft;
thumb.classList.add("is-dragging");
});
document.addEventListener("mousemove", function (e) {
if (!dragging) return;
const sw = scroller.scrollWidth, cw = scroller.clientWidth;
const room = bar.clientWidth - thumbW;
if (room <= 0) return;
scroller.scrollLeft = startLeft + (e.clientX - startX) * (sw - cw) / room;
});
document.addEventListener("mouseup", function () {
if (dragging) { dragging = false; thumb.classList.remove("is-dragging"); }
});
bar.addEventListener("mousedown", function (e) {
if (e.target !== bar) return;
e.preventDefault();
const x = e.clientX - bar.getBoundingClientRect().left;
const thumbLeft = thumb.getBoundingClientRect().left - bar.getBoundingClientRect().left;
scroller.scrollLeft += (x < thumbLeft ? -1 : 1) * scroller.clientWidth * 0.9;
});
update();
return update;
}
// ════════════════════════════════════════════════════════════
// 내 업무 화면 (/project/) — 프로젝트 모듈의 첫 화면.
// 예전 프로젝트 홈(카드 그리드)을 대체한다. 내가 담당자인 업무를 한 표에
// 모아 보여주고, 완료 체크·정렬·필터를 그 자리에서 처리한다. 업무를
// 누르면 그 프로젝트 화면이 열리면서 편집 팝업이 뜬다(?task=).
// ════════════════════════════════════════════════════════════
function initMyTasks() {
const root = document.querySelector(".pj-mytasks-view");
if (!root) return;
const dataEl = el("pj-mytasks-data");
const data = JSON.parse(dataEl.textContent);
let tasks = data.tasks || [];
const priorityLabels = data.priorityLabels || {};
// 오늘 = 한국시간 날짜를 그때그때(화면을 밤새 열어 두어도 자정이 지나면 바뀐다).
const todayNow = kstTodayIso;
const me = (root.dataset.me || "").toLowerCase();
const table = el("pj-mytasks-table");
const emptyEl = el("pj-mytasks-empty");
const summaryEl = el("pj-mytasks-summary");
const filterTabs = el("pj-mt-filter");
const moveFilterHighlight = initTabSlider(filterTabs);
let filter = "open";
let sort = { key: "due", dir: 1 };
const cmt = initCommentsChat(function (taskId) {
const t = tasks.find(function (x) { return String(x.id) === String(taskId); });
return t && t.title;
});
// 표 컬럼 — text() 는 셀 내용(HTML), sort() 는 정렬 기준값.
const COLS = [
{
key: "title", label: "작업", cls: "pj-mtk-title",
html: function (t) {
return '<span class="pj-mtk-name">' + escapeHtml(t.title || "") + "</span>" +
(t.comment_count
? ' <span class="pj-cmt-badge" data-task-id="' + t.id + '" data-count="' + t.comment_count +
'" title="댓글 ' + t.comment_count + '개"><span class="pj-cmt-ic">💬</span>' +
'<span class="pj-cmt-n">' + t.comment_count + "</span></span>"
: "");
},
sort: function (t) { return (t.title || "").toLowerCase(); },
},
{
key: "project", label: "프로젝트", cls: "pj-mtk-proj",
html: function (t) {
return '<span style="color:' + (t.project_color || "#4573d2") + '">●</span> ' +
escapeHtml(t.project_name || "-");
},
sort: function (t) { return (t.project_name || "").toLowerCase(); },
},
{
key: "stage", label: "섹션", cls: "pj-mtk-stage",
html: function (t) { return escapeHtml(t.stage_name || "미지정"); },
sort: function (t) { return (t.stage_name || "").toLowerCase(); },
},
{
key: "priority", label: "우선순위", cls: "pj-mtk-pri",
html: function (t) {
if (!t.priority || t.priority === "normal") return '<span class="pj-muted">보통</span>';
return '<span class="pj-pri pj-pri-' + t.priority + '">' +
escapeHtml(priorityLabels[t.priority] || t.priority) + "</span>";
},
sort: function (t) { return ({ low: 0, normal: 1, high: 2 })[t.priority] || 1; },
},
{
key: "start", label: "시작", cls: "pj-mtk-date",
html: function (t) { return t.start_date ? fmtDateKr(t.start_date) : "-"; },
sort: function (t) { return t.start_date || "9999-99-99"; },
},
{
key: "due", label: "마감", cls: "pj-mtk-date",
html: function (t) {
if (!t.due_date) return "-";
const di = dueInfo(t.due_date, !!t.completed_at);
return '<span class="pj-due-label ' + di.cls + (di.cls === "is-overdue" ? " pj-mtk-overdue" : "") + '">' +
escapeHtml(di.text) + "</span>";
},
sort: function (t) { return t.due_date || "9999-99-99"; },
},
];
// 검색어·마감·우선순위(필터 바) — 상태(진행 중/완료/전체)는 위 탭이 맡는다.
const mtFilter = Object.assign({}, TASK_FILTER_DEFAULT);
const mtQ = el("pj-mt-q"), mtDue = el("pj-mt-due"), mtPri = el("pj-mt-priority");
try {
const saved = JSON.parse(localStorage.getItem("pj_mt_filter") || "{}");
["q", "due", "priority"].forEach(function (k) { if (saved[k]) mtFilter[k] = saved[k]; });
} catch (_) {}
function saveMtFilter() {
try { localStorage.setItem("pj_mt_filter", JSON.stringify({ q: mtFilter.q, due: mtFilter.due, priority: mtFilter.priority })); } catch (_) {}
render();
}
if (mtQ) {
mtQ.value = mtFilter.q; mtDue.value = mtFilter.due; mtPri.value = mtFilter.priority;
let qt = null;
mtQ.addEventListener("input", function () {
clearTimeout(qt);
qt = setTimeout(function () { mtFilter.q = mtQ.value.trim(); saveMtFilter(); }, 150);
});
mtDue.addEventListener("change", function () { mtFilter.due = mtDue.value; saveMtFilter(); });
mtPri.addEventListener("change", function () { mtFilter.priority = mtPri.value; saveMtFilter(); });
}
function passFilter(t) {
if (filter === "open" && t.completed_at) return false;
if (filter === "done" && !t.completed_at) return false;
return taskMatchesFilter(t, mtFilter, me, todayNow());
}
// 최상위 업무만 — 하위 업무(parent_task_id 있음)는 render() 에서 해당
// 부모 행 바로 아래에 트리로 붙인다(별도 필터/정렬은 하위 업무 자체의
// 완료 상태로 각자 판단).
function visible() {
return tasks.filter(function (t) { return !t.parent_task_id && passFilter(t); });
}
function renderHead() {
const tr = document.createElement("tr");
tr.innerHTML = '<th class="pj-mtk-check"></th>' + COLS.map(function (c) {
const arrow = sort.key === c.key ? (sort.dir > 0 ? "▲" : "▼") : "↕";
return '<th class="' + c.cls + '" data-key="' + c.key + '">' +
'<span class="pj-th-label">' + escapeHtml(c.label) +
' <span class="pj-th-sort">' + arrow + "</span></span></th>";
}).join("");
tr.querySelectorAll("th[data-key]").forEach(function (th) {
th.querySelector(".pj-th-label").addEventListener("click", function () {
const key = th.dataset.key;
if (sort.key === key) sort.dir = -sort.dir;
else { sort.key = key; sort.dir = 1; }
render();
});
});
const thead = table.querySelector("thead");
thead.innerHTML = "";
thead.appendChild(tr);
}
async function toggleDone(t, done) {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, { completed: done });
Object.assign(t, res.task);
render();
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
}
function rowContextItems(t) {
return [
{ label: "열기", onClick: function () { location.href = "/project/p/" + t.project_id + "?task=" + t.id; } },
{ label: "작업 링크 복사", onClick: function () { shareTaskLink(t.id); } },
{
label: t.completed_at ? "완료 취소" : "완료로 표시",
onClick: function () { toggleDone(t, !t.completed_at); },
},
null,
{
label: "삭제", danger: true,
onClick: async function () {
if (!(await confirmTaskDelete(t.id, t.title, t.subtask_total))) return;
try {
await deleteTaskRequest(t.id);
tasks = tasks.filter(function (x) { return x.id !== t.id && x.parent_task_id !== t.id; });
render();
} catch (e) { showToast("삭제 실패: " + e.message, "error"); }
},
},
];
}
// 업무 행 하나(최상위든 하위든) 그리기 — 하위 업무면 트리 접속선(├/└)을
// 제목 칸 앞에 붙인다(isLast 면 └, 아니면 ├ — 형제 중 마지막인지로 결정).
function appendTaskRow(tbody, t, opts) {
opts = opts || {};
const tr = document.createElement("tr");
tr.className = "pj-mtk-row" + (t.completed_at ? " is-done" : "") +
(opts.isSub ? " pj-mtk-subrow" : "");
tr.dataset.taskId = t.id;
const branch = opts.isSub
? '<span class="pj-mtk-tree-branch' + (opts.isLast ? " is-last" : "") + '"></span>'
: "";
tr.innerHTML =
'<td class="pj-mtk-check"><input type="checkbox"' + (t.completed_at ? " checked" : "") + " /></td>" +
COLS.map(function (c, i) {
const cell = c.html(t);
return '<td class="' + c.cls + '">' + (i === 0 ? branch + cell : cell) + "</td>";
}).join("");
const chk = tr.querySelector('input[type="checkbox"]');
chk.addEventListener("click", function (e) { e.stopPropagation(); });
chk.addEventListener("change", function () { toggleDone(t, chk.checked); });
tr.addEventListener("click", function (e) {
if (e.target.closest(".pj-cmt-badge")) return; // 말풍선은 댓글 팝업 담당
location.href = "/project/p/" + t.project_id + "?task=" + t.id;
});
tr.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, rowContextItems(t));
});
if (cmt) cmt.wireBadge(tr.querySelector(".pj-cmt-badge"));
tbody.appendChild(tr);
}
// 부모 업무 행이 (다른 사람 담당이라, 또는 현재 탭 필터에 안 맞아) 목록에
// 직접 나오지 않는 하위 업무 — 그 부모를 클릭 가능한 안내 행으로 먼저
// 보여주고, 그 아래에 내 하위 업무를 트리로 건다.
function appendParentGroupRow(tbody, subtask) {
const parentIsMine = String(subtask.parent_assignee_email || "").toLowerCase() === me;
const tr = document.createElement("tr");
tr.className = "pj-mtk-row pj-mtk-parent-group" +
(subtask.parent_completed_at ? " is-done" : "");
tr.innerHTML =
'<td class="pj-mtk-check"></td>' +
'<td class="pj-mtk-title" colspan="' + COLS.length + '">' +
'<span class="material-symbols-outlined pj-mtk-parent-ic">folder</span> ' +
'<span class="pj-mtk-parent-name">' + escapeHtml(subtask.parent_title || "(상위 작업)") + "</span>" +
'<span class="pj-mtk-parent-hint">' + (parentIsMine ? "상위 작업" : "다른 담당자의 상위 작업") + "</span>" +
"</td>";
tr.addEventListener("click", function () {
location.href = "/project/p/" + subtask.project_id + "?task=" + subtask.parent_task_id;
});
tbody.appendChild(tr);
}
function render() {
renderHead();
const rows = visible().slice().sort(function (a, b) {
const col = COLS.find(function (c) { return c.key === sort.key; });
if (!col) return 0;
const va = col.sort(a), vb = col.sort(b);
if (va < vb) return -sort.dir;
if (va > vb) return sort.dir;
return 0;
});
const topIds = {};
rows.forEach(function (t) { topIds[t.id] = true; });
// 내가 담당자인 하위 업무 — 필터를 각자 자기 완료 상태로 통과한 것만,
// 부모 id 별로 묶는다(부모가 내 목록에 있으면 그 아래에, 없으면 안내
// 행 아래에 묶어서 보여준다).
const subsByParent = {};
tasks.forEach(function (t) {
if (!t.parent_task_id || !passFilter(t)) return;
(subsByParent[t.parent_task_id] = subsByParent[t.parent_task_id] || []).push(t);
});
const tbody = table.querySelector("tbody");
tbody.innerHTML = "";
let rowCount = 0;
rows.forEach(function (t) {
appendTaskRow(tbody, t, {});
rowCount++;
const kids = subsByParent[t.id];
if (!kids) return;
delete subsByParent[t.id];
kids.forEach(function (k, i) {
appendTaskRow(tbody, k, { isSub: true, isLast: i === kids.length - 1 });
rowCount++;
});
});
// 남은 그룹 = 부모가 내 업무 목록에 없는(=다른 사람 담당인) 하위 업무.
Object.keys(subsByParent).forEach(function (pid) {
const kids = subsByParent[pid];
if (!kids.length || topIds[pid]) return;
appendParentGroupRow(tbody, kids[0]);
rowCount++;
kids.forEach(function (k, i) {
appendTaskRow(tbody, k, { isSub: true, isLast: i === kids.length - 1 });
rowCount++;
});
});
table.hidden = rowCount === 0;
if (emptyEl) emptyEl.hidden = rowCount > 0;
const openN = tasks.filter(function (t) { return !t.completed_at; }).length;
const overdueN = tasks.filter(function (t) {
return !t.completed_at && t.due_date && t.due_date.slice(0, 10) < todayNow();
}).length;
if (summaryEl) {
summaryEl.innerHTML =
'<span class="pj-mtk-stat">진행 <b>' + openN + "</b></span>" +
'<span class="pj-mtk-stat">완료 <b>' + (tasks.length - openN) + "</b></span>" +
(overdueN ? '<span class="pj-mtk-stat is-overdue">지연 <b>' + overdueN + "</b></span>" : "");
}
const badge = el("pj-myopen-badge");
if (badge) { badge.textContent = openN; badge.hidden = openN === 0; }
}
if (filterTabs) filterTabs.addEventListener("click", function (e) {
const btn = e.target.closest(".pj-tab");
if (!btn) return;
filterTabs.querySelectorAll(".pj-tab").forEach(function (b) { b.classList.toggle("is-active", b === btn); });
filter = btn.dataset.filter;
if (moveFilterHighlight) moveFilterHighlight(true);
render();
});
render();
// 8초 주기 동기화 — 다른 사람이 내 업무를 바꾸면 목록을 다시 받는다.
// 성공하면 true — 실패(false)면 initLiveRefresh 가 같은 버전을 다음 주기에 다시 시도한다.
let syncSeq = 0;
softSyncProjectRef = async function () {
const seq = ++syncSeq;
try {
const res = await api("GET", "/project/api/my-tasks");
if (seq !== syncSeq) return true; // 더 나중에 시작한 동기화가 있다 — 늦은 응답은 버린다
tasks = res.tasks || [];
render();
return true;
} catch (_) { return false; }
};
}
function initProject() {
const root = document.querySelector(".pj-project-view");
if (!root) return;
const projectId = parseInt(root.dataset.projectId, 10);
const canManage = root.dataset.canManage === "true";
const isAdmin = root.dataset.isAdmin === "true";
const me = (root.dataset.me || "").toLowerCase();
const isSuper = root.dataset.isSuper === "true";
// 삭제는 만든 사람만(슈퍼관리자 예외). created_by 없으면 서버가 최종 판정.
function canDelete(createdBy) {
if (isSuper) return true;
const cb = (createdBy || "").toLowerCase();
return !!cb && cb === me;
}
const DELETE_DENIED = "삭제는 만든 사람만 할 수 있습니다.";
// 댓글 있으면 말풍선 아이콘(+개수). 색은 currentColor 상속(막대=흰, 카드/리스트=진회색).
function cmtBadgeInner(t, cls) {
const n = t.comment_count || 0;
if (!n) return "";
return '<span class="pj-cmt-ic ' + (cls || "") +
'" title="댓글 ' + n + '개">💬</span><span class="pj-cmt-n">' + n + "</span>";
}
// 누르면 댓글 대화창(initCommentsChat 의 문서 클릭 처리) — 캘린더 막대·목록 행용.
function cmtBadge(t, cls) {
const inner = cmtBadgeInner(t, cls);
if (!inner) return "";
return '<span class="pj-cmt-badge pj-cmt-inline" data-task-id="' + t.id + '" data-count="' +
(t.comment_count || 0) + '">' + inner + "</span>";
}
const dataEl = el("pj-data");
const data = JSON.parse(dataEl.textContent);
const currentProject = data.project || {};
let stages = data.stages || [];
let tasks = data.tasks || [];
let members = data.members || [];
const priorityLabels = data.priorityLabels || {};
// 전체 프로젝트 집계 데이터 — 4개 뷰는 전 프로젝트를 보여준다.
const projectsMeta = data.projects || [];
const stagesByProject = data.stagesByProject || {};
const boardStages = data.boardStages || [];
const avatars = data.avatars || {};
// 좌측 프로젝트 목록 — 수신함/내 업무/휴지통과 공용 구현(initSideTree).
// projectsMeta 를 그대로 넘기면 삭제·정렬·수정이 그 배열을 제자리에서
// 고치므로 4개 뷰가 보는 전체 프로젝트 목록과 항상 같은 상태다.
const sideTree = initSideTree({
projects: projectsMeta,
currentId: projectId,
onSaved: function (p) {
if (String(p.id) !== String(projectId)) return;
Object.assign(currentProject, p);
const pillEl = document.querySelector(".pj-project-title-pill");
if (pillEl) {
pillEl.innerHTML =
'<span class="material-symbols-outlined pj-pill-ic">' + escapeHtml(currentProject.icon || "folder") + "</span>" +
'<span class="pj-pill-name">' + escapeHtml(currentProject.name || "") + "</span>";
pillEl.style.setProperty("--pj-color", currentProject.color || "#4573d2");
pillEl.classList.toggle("is-light", isLightColor(currentProject.color || "#4573d2"));
}
},
// 새 최상위 프로젝트 — 이 화면에선 이동하지 않고 트리/뷰에만 추가한다.
onCreated: function (project) {
stagesByProject[project.id] = [];
sideTree.merge(project);
},
});
function renderTree() { sideTree.render(); }
(function () {
const pill = document.querySelector(".pj-project-title-pill");
if (pill) pill.classList.toggle("is-light", isLightColor(currentProject.color || "#4573d2"));
})();
// 제목 알약 — 마우스를 올리면 수정 가능 표시, 누르면 그 자리에서 이름 수정(아사나식).
// Enter/바깥 클릭=저장, Esc=취소. 저장 권한(_require_manage)이 있을 때만.
(function () {
const pill = document.querySelector(".pj-project-title-pill");
if (!pill || !canManage || !projectId) return;
pill.classList.add("is-editable");
pill.title = "클릭해서 프로젝트 이름 수정";
let editing = false;
pill.addEventListener("click", function () {
if (editing) return;
const nameEl = pill.querySelector(".pj-pill-name");
if (!nameEl) return;
editing = true;
const orig = currentProject.name || nameEl.textContent;
pill.classList.add("is-editing");
nameEl.contentEditable = "true";
nameEl.focus();
const r = document.createRange();
r.selectNodeContents(nameEl);
const sel = window.getSelection();
sel.removeAllRanges();
sel.addRange(r);
let done = false;
async function finish(save) {
if (done) return;
done = true;
nameEl.contentEditable = "false";
pill.classList.remove("is-editing");
nameEl.removeEventListener("keydown", onKey);
nameEl.removeEventListener("blur", onBlur);
const name = nameEl.textContent.replace(/\s+/g, " ").trim();
if (!save || !name || name === orig) { nameEl.textContent = orig; editing = false; return; }
nameEl.textContent = name;
try {
const res = await api("PUT", "/project/api/projects/" + projectId, { name: name });
Object.assign(currentProject, res.project);
sideTree.merge(res.project);
document.title = document.title.split(orig).join(res.project.name);
} catch (err) {
nameEl.textContent = orig;
showToast("이름 변경 실패: " + err.message, "error");
}
editing = false;
}
function onKey(e) {
if (e.isComposing) return;
if (e.key === "Enter") { e.preventDefault(); nameEl.blur(); }
else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); finish(false); nameEl.blur(); }
}
function onBlur() { finish(true); }
nameEl.addEventListener("keydown", onKey);
nameEl.addEventListener("blur", onBlur);
});
// 서식 붙여넣기 방지 — 글자만.
pill.addEventListener("paste", function (e) {
if (!pill.classList.contains("is-editing")) return;
e.preventDefault();
const text = ((e.clipboardData || window.clipboardData).getData("text/plain") || "").replace(/\s+/g, " ");
document.execCommand("insertText", false, text);
});
})();
// 댓글 말풍선 더블클릭 팝업 — 공용 구현(initCommentsChat, 위쪽 정의).
// 제목은 이 화면이 이미 들고 있는 업무 목록에서 찾는다.
const cmt = initCommentsChat(function (taskId) {
const t = tasks.find(function (x) { return String(x.id) === String(taskId); });
return t && t.title;
});
// 좌측 사이드바의 "내 업무" 진행 개수 배지 — 이 화면에서 업무를 완료/
// 재배정하면 숫자가 바로 맞도록 서버에서 다시 세어 갱신한다(목록 자체는
// 별도 화면 /project/ 에 있다).
async function refreshMyOpenBadge() {
const badge = el("pj-myopen-badge");
if (!badge) return;
try {
// 숫자만 받는다(예전엔 내 업무 목록 전체를 받아 세었다).
const n = (await api("GET", "/project/api/my-tasks/open-count")).open || 0;
badge.textContent = n;
badge.hidden = n === 0;
} catch (_) {}
}
// 담당자/작성자 아이콘 = 구글 프로필 이미지(원형). 없으면 기본 아이콘.
function avatarHtml(email, cls) {
const url = email ? avatars[String(email).toLowerCase()] : "";
const c = cls || "";
if (url) return '<img class="pj-avatar ' + c + '" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer">';
return '<span class="material-symbols-outlined pj-gicon ' + c + '">account_circle</span>';
}
let timeline = null;
// 기본 보기는 항상 보드(왼쪽 프로젝트 클릭 등으로 들어오면 보드).
// 예외: 달력 이전/다음달 이동은 페이지를 통째로 새로고침하므로(?y=&m=),
// 그때만 마지막으로 보던 뷰를 되살린다 — 안 그러면 달력을 넘기다가
// 보드로 튕겨나간다.
const VIEW_KEY = "pj_view";
let currentView = "board";
try {
const qs = new URLSearchParams(location.search);
const saved = localStorage.getItem(VIEW_KEY);
if ((qs.has("y") || qs.has("m")) && saved &&
["board", "list", "calendar", "timeline", "dashboard"].indexOf(saved) >= 0) currentView = saved;
} catch (_) {}
// ── 프로젝트 스코프 — 아사나처럼 기본은 "이 프로젝트만", "전체 프로젝트"로
// 전환하면 예전처럼 접근 가능한 모든 프로젝트를 합쳐서 보여준다.
// tasks 배열의 각 행은 서버가 어느 프로젝트를 보다가 담았는지를
// context_project_id 로 표시한다(멀티호밍된 업무는 원 소속과 연결된
// 프로젝트 양쪽에서 각각 한 번씩 나온다 — 그래야 각 화면에 다 보인다).
// "전체" 모드는 원 소속(context_project_id === project_id)만 세어 중복을 없앤다.
let viewScope = "project";
// 필터 바(#pj-filterbar) 상태 — 프로젝트별로 이 브라우저에 기억한다.
const FILTER_KEY = "pj_filter_" + projectId;
let taskFilter = Object.assign({}, TASK_FILTER_DEFAULT);
try { Object.assign(taskFilter, JSON.parse(localStorage.getItem(FILTER_KEY) || "{}")); } catch (_) {}
const todayNowP = kstTodayIso; // 한국시간 오늘(그때그때)
function scopeTasks() {
return viewScope === "project"
? tasks.filter(function (t) { return t.context_project_id === projectId; })
: tasks.filter(function (t) { return t.context_project_id === t.project_id; });
}
// 모든 뷰가 이 함수로 업무를 받는다 — 스코프 → 필터 → 정렬 순.
function visibleTasks() {
const todayIso = todayNowP();
const rows = scopeTasks().filter(function (t) { return taskMatchesFilter(t, taskFilter, me, todayIso); });
return sortTasksBy(rows, taskFilter.sort);
}
// 보드 카드 순서 바꾸기는 "기본 정렬 + 필터 없음"일 때만 — 가려진 카드가 있거나
// 다른 기준으로 정렬돼 있으면 놓은 자리가 실제 순서와 어긋난다(아사나도 같다).
function manualOrderAllowed() {
return taskFilter.sort === "manual" && !taskFilterActive(taskFilter);
}
const FB = {
q: el("pj-fb-q"), status: el("pj-fb-status"), assignee: el("pj-fb-assignee"),
due: el("pj-fb-due"), priority: el("pj-fb-priority"), sort: el("pj-fb-sort"),
count: el("pj-fb-count"), reset: el("pj-fb-reset"),
};
// 담당자 선택지 = 이 프로젝트 멤버 + 지금 목록에 나오는 담당자(전체 스코프 대비).
function fillAssigneeFilter() {
if (!FB.assignee) return;
const emails = [];
members.forEach(function (m) { const e = (m.user_email || "").toLowerCase(); if (e && emails.indexOf(e) < 0) emails.push(e); });
scopeTasks().forEach(function (t) { const e = (t.assignee_email || "").toLowerCase(); if (e && emails.indexOf(e) < 0) emails.push(e); });
if (taskFilter.assignee.indexOf("@") > 0 && emails.indexOf(taskFilter.assignee) < 0) emails.push(taskFilter.assignee);
emails.sort(function (a, b) { return idOf(a).localeCompare(idOf(b)); });
FB.assignee.innerHTML =
'<option value="all">담당자: 전체</option><option value="me">나</option><option value="none">담당자 없음</option>' +
emails.map(function (e) { return '<option value="' + escapeHtml(e) + '">' + escapeHtml(idOf(e)) + "</option>"; }).join("");
FB.assignee.value = taskFilter.assignee;
}
function updateFilterSummary() {
if (!FB.count) return;
const active = taskFilterActive(taskFilter);
if (active) {
FB.count.textContent = visibleTasks().length + " / " + scopeTasks().length + "건";
}
FB.count.hidden = !active;
FB.reset.hidden = !(active || taskFilter.sort !== "manual");
Object.keys(FB).forEach(function (k) {
if (FB[k] && FB[k].tagName === "SELECT") FB[k].classList.toggle("is-set", FB[k].value !== TASK_FILTER_DEFAULT[k]);
});
if (FB.q) FB.q.parentNode.classList.toggle("is-set", !!taskFilter.q);
}
function applyFilterChange() {
try { localStorage.setItem(FILTER_KEY, JSON.stringify(taskFilter)); } catch (_) {}
refreshActiveView();
}
if (FB.q) {
FB.q.value = taskFilter.q;
["status", "due", "priority", "sort"].forEach(function (k) { FB[k].value = taskFilter[k]; });
fillAssigneeFilter();
let qTimer = null;
FB.q.addEventListener("input", function () {
clearTimeout(qTimer);
qTimer = setTimeout(function () { taskFilter.q = FB.q.value.trim(); applyFilterChange(); }, 150);
});
FB.q.addEventListener("keydown", function (e) { if (e.key === "Escape") { FB.q.value = ""; taskFilter.q = ""; applyFilterChange(); } });
["status", "assignee", "due", "priority", "sort"].forEach(function (k) {
FB[k].addEventListener("change", function () { taskFilter[k] = FB[k].value; applyFilterChange(); });
});
FB.reset.addEventListener("click", function () {
taskFilter = Object.assign({}, TASK_FILTER_DEFAULT);
FB.q.value = "";
["status", "assignee", "due", "priority", "sort"].forEach(function (k) { FB[k].value = taskFilter[k]; });
applyFilterChange();
});
}
// ── 뷰 토글 ──
const tabs = el("pj-view-tabs");
const moveViewHighlight = initTabSlider(tabs);
tabs.addEventListener("click", function (e) {
const btn = e.target.closest(".pj-tab");
if (!btn) return;
const view = btn.dataset.view;
tabs.querySelectorAll(".pj-tab").forEach(function (t) {
t.classList.toggle("is-active", t === btn);
});
document.querySelectorAll(".pj-view").forEach(function (v) {
v.hidden = v.dataset.view !== view;
});
currentView = view;
try { localStorage.setItem(VIEW_KEY, view); } catch (_) {}
renderView(view);
});
// 서버가 그린 기본 탭(보드)과 기억된 탭이 다르면 화면을 맞춰준다.
if (currentView !== "board") {
tabs.querySelectorAll(".pj-tab").forEach(function (t) {
t.classList.toggle("is-active", t.dataset.view === currentView);
});
document.querySelectorAll(".pj-view").forEach(function (v) {
v.hidden = v.dataset.view !== currentView;
});
if (moveViewHighlight) moveViewHighlight(false);
}
// ── 프로젝트 스코프 토글 ──
const scopeToggle = el("pj-scope-toggle");
const moveScopeHighlight = initTabSlider(scopeToggle);
if (scopeToggle) {
scopeToggle.addEventListener("click", function (e) {
const btn = e.target.closest("[data-scope]");
if (!btn) return;
viewScope = btn.dataset.scope;
scopeToggle.querySelectorAll("[data-scope]").forEach(function (b) {
b.classList.toggle("is-active", b === btn);
});
// 전체 프로젝트 보기 — 위 제목도 "전체 프로젝트"로(멤버 아이콘은 이 프로젝트 것이라 숨김).
const titleWrap = el("pj-title-wrap");
if (titleWrap) titleWrap.classList.toggle("is-all-scope", viewScope === "all");
fillAssigneeFilter(); // 스코프가 바뀌면 담당자 후보도 달라진다
renderView(currentView);
updateFilterSummary();
});
}
if (moveScopeHighlight) moveScopeHighlight(false);
let calResizeTimer = null;
window.addEventListener("resize", function () {
if (currentView !== "calendar") return;
clearTimeout(calResizeTimer);
calResizeTimer = setTimeout(renderCalendar, 150);
});
function renderView(view) {
if (view === "calendar") renderCalendar();
else if (view === "timeline") renderTimeline();
else if (view === "board") renderBoard();
else if (view === "list") renderList();
else if (view === "dashboard") renderDashboard();
}
// ════════════════════════════════════════════════════════════
// 달력 — 구글 캘린더식. 막대(칩)는 클라이언트가 그린다.
// · 한 주에 표시 행 수 제한(MAX_LANES) → 넘치면 "+N" 칩, 클릭 시 그날 목록 팝오버
// · 드래그 이동: 낙관적 업데이트(즉시 다시 그림, 새로고침 없음) + 실패 시 롤백
// ════════════════════════════════════════════════════════════
const MAX_LANES = 3;
function addDays(dstr, days) {
if (!dstr) return null;
const d = new Date(dstr + "T00:00:00");
d.setDate(d.getDate() + days);
const y = d.getFullYear(), m = String(d.getMonth() + 1).padStart(2, "0"), dd = String(d.getDate()).padStart(2, "0");
return y + "-" + m + "-" + dd;
}
function dayDiff(a, b) {
return Math.round((new Date(b + "T00:00:00") - new Date(a + "T00:00:00")) / 86400000);
}
function clearDropHL() {
document.querySelectorAll(".pj-day.pj-drop-over").forEach(function (d) { d.classList.remove("pj-drop-over"); });
}
function dayCellAt(x, y) {
const elAt = document.elementFromPoint(x, y);
return elAt ? elAt.closest(".pj-day[data-date]") : null;
}
// 업무 표시 기간 [시작, 끝] (문자열, 끝>=시작). 둘 중 하나만 있으면 단일일.
function taskSpan(t) {
const s = t.start_date, d = t.due_date;
if (s && d) return s <= d ? [s, d] : [d, s];
if (s) return [s, s];
if (d) return [d, d];
return null;
}
// 업무마다 '한 달 전체' 기준으로 고정 레인(행) 배정 → 여러 주에 걸쳐도 같은 줄 유지.
// (주마다 따로 배치하면 첫주/다음주의 순서가 바뀌는 문제 방지)
function computeLanes() {
const items = [];
visibleTasks().forEach(function (t) {
const sp = taskSpan(t);
if (sp) items.push({ id: t.id, s: sp[0], e: sp[1] });
});
// 시작일 → 종료일 → id 순(결정적). 문자열 'YYYY-MM-DD' 사전식 비교.
items.sort(function (a, b) {
if (a.s !== b.s) return a.s < b.s ? -1 : 1;
if (a.e !== b.e) return a.e < b.e ? -1 : 1;
return a.id - b.id;
});
const laneEnd = []; // lane 별 마지막 점유 종료일
const map = {};
items.forEach(function (it) {
for (var i = 0; i < laneEnd.length; i++) {
if (it.s > laneEnd[i]) { map[it.id] = i; laneEnd[i] = it.e; return; }
}
map[it.id] = laneEnd.length; laneEnd.push(it.e);
});
return map;
}
// 전체 달력 다시 그리기 — 서버가 그린 날짜 셀(.pj-day[data-date])을 읽어 주별로 막대 배치.
function renderCalendar() {
const cal = document.querySelector(".pj-cal");
if (!cal) return;
closeDayPop();
const laneOf = computeLanes();
cal.querySelectorAll(".pj-week").forEach(function (weekEl) {
const dayEls = weekEl.querySelectorAll(".pj-day[data-date]");
if (!dayEls.length) return;
const weekStart = dayEls[0].dataset.date;
const weekEnd = dayEls[dayEls.length - 1].dataset.date;
// 이 주에 걸치는 업무 → 막대 세그먼트(레인은 전역 배정값 사용)
const bars = [];
visibleTasks().forEach(function (t) {
const sp = taskSpan(t);
if (!sp) return;
if (sp[1] < weekStart || sp[0] > weekEnd) return;
const segStart = sp[0] < weekStart ? weekStart : sp[0];
const segEnd = sp[1] > weekEnd ? weekEnd : sp[1];
bars.push({
t: t,
startCol: dayDiff(weekStart, segStart),
span: dayDiff(segStart, segEnd) + 1,
cl: sp[0] < weekStart, cr: sp[1] > weekEnd,
lane: laneOf[t.id] || 0,
});
});
// 전역 레인 순서는 유지하되, 이 주에 실제 존재하는 레인만 0,1,2…로 압축
// (빈 행 제거 → 헛된 '+N' 방지, 단 두 막대의 상하 순서는 항상 동일).
const present = {};
bars.forEach(function (b) { present[b.lane] = true; });
const lanesSorted = Object.keys(present).map(Number).sort(function (a, b) { return a - b; });
const rankOf = {};
lanesSorted.forEach(function (l, i) { rankOf[l] = i; });
const cont = weekEl.querySelector(".pj-week-bars");
cont.innerHTML = "";
// 이 주에 들어갈 막대 줄 수 — 달력이 화면 높이에 맞춰 줄어들므로 실제 높이로 센다
// (줄 22px + 간격 2px). 다 들어가면 전부, 넘치면 맨 아래 한 줄은 "+N 더" 자리.
const fitRows = cont.clientHeight ? Math.max(1, Math.floor((cont.clientHeight + 2) / 24)) : MAX_LANES + 1;
const maxLanes = lanesSorted.length <= fitRows ? fitRows : Math.max(1, fitRows - 1);
const overflow = [0, 0, 0, 0, 0, 0, 0];
bars.forEach(function (b) {
const row = rankOf[b.lane];
if (row >= maxLanes) { // 넘침 → 그 칸들 +N 카운트
for (var c = b.startCol; c < b.startCol + b.span; c++) overflow[c]++;
return;
}
const div = document.createElement("div");
div.className = "pj-bar" + (b.t.completed_at ? " pj-bar-done" : "") +
(b.cl ? " pj-bar-l" : "") + (b.cr ? " pj-bar-r" : "");
div.dataset.taskId = b.t.id;
div.style.gridColumn = (b.startCol + 1) + " / span " + b.span;
div.style.gridRow = (row + 1);
div.style.background = b.t.completed_at ? "#9aa5b1" : (b.t.project_color || "#4573d2");
div.title = "[" + (b.t.project_name || "") + "] " + (b.t.title || "") +
(b.t.assignee_email ? " · " + idOf(b.t.assignee_email) : "");
div.innerHTML = '<span class="pj-bar-label">' + escapeHtml(b.t.title || "") + "</span>" + cmtBadge(b.t);
cont.appendChild(div);
});
for (var col = 0; col < 7; col++) {
if (overflow[col] > 0) {
const m = document.createElement("div");
m.className = "pj-bar-more";
m.style.gridColumn = (col + 1) + " / span 1";
m.style.gridRow = (maxLanes + 1);
m.dataset.date = dayEls[col].dataset.date;
m.textContent = "+" + overflow[col] + " 더";
cont.appendChild(m);
}
}
});
wireCalendarDrag(cal);
}
// 드래그(포인터 기반). 안 움직이면 클릭=모달, +N 칩 클릭=그날 팝오버.
function wireCalendarDrag(cal) {
cal.querySelectorAll(".pj-bar[data-task-id]").forEach(function (bar) {
if (canManage) bar.addEventListener("contextmenu", function (e) {
e.preventDefault();
const t = tasks.find(function (x) { return String(x.id) === String(bar.dataset.taskId); });
if (t) showContextMenu(e.clientX, e.clientY, taskContextItems(t));
});
bar.addEventListener("mousedown", function (e) {
if (e.button !== 0) return;
// 댓글 말풍선 — 댓글 대화창만 연다(문서 클릭 처리). 편집 창·드래그는 시작하지 않는다.
if (e.target.closest && e.target.closest(".pj-cmt-badge")) return;
e.preventDefault();
const taskId = bar.dataset.taskId;
const sx = e.clientX, sy = e.clientY;
let dragging = false, ghost = null;
function onMove(ev) {
if (!dragging) {
if (Math.abs(ev.clientX - sx) + Math.abs(ev.clientY - sy) < 5) return;
dragging = true;
cal.classList.add("pj-cal-dragging");
if (canManage) {
ghost = document.createElement("div");
ghost.className = "pj-bar-ghost";
ghost.textContent = (bar.textContent || "").trim();
document.body.appendChild(ghost);
}
}
if (ghost) { ghost.style.left = (ev.clientX + 10) + "px"; ghost.style.top = (ev.clientY + 12) + "px"; }
clearDropHL();
const cell = dayCellAt(ev.clientX, ev.clientY);
if (cell) cell.classList.add("pj-drop-over");
}
function onUp(ev) {
document.removeEventListener("mousemove", onMove);
document.removeEventListener("mouseup", onUp);
cal.classList.remove("pj-cal-dragging");
if (ghost) ghost.remove();
clearDropHL();
const t = tasks.find(function (x) { return String(x.id) === String(taskId); });
if (!dragging) { if (t && canManage) openTaskModal(t); return; }
if (!canManage) return;
const cell = dayCellAt(ev.clientX, ev.clientY);
if (cell) moveTaskTo(taskId, cell.dataset.date);
}
document.addEventListener("mousemove", onMove);
document.addEventListener("mouseup", onUp);
});
});
}
// 낙관적 이동 — 즉시 다시 그리고 백그라운드 저장, 실패 시 롤백.
async function moveTaskTo(taskId, dropDate) {
const t = tasks.find(function (x) { return String(x.id) === String(taskId); });
if (!t) return;
const anchor = t.start_date || t.due_date;
if (!anchor) { alert("날짜가 없는 작업은 캘린더에서 이동할 수 없습니다."); return; }
const delta = dayDiff(anchor, dropDate);
if (delta === 0) return;
const old = { s: t.start_date, d: t.due_date };
t.start_date = t.start_date ? addDays(t.start_date, delta) : null;
t.due_date = t.due_date ? addDays(t.due_date, delta) : null;
renderCalendar();
try {
await api("PUT", "/project/api/tasks/" + taskId, { start_date: t.start_date, due_date: t.due_date });
} catch (err) {
t.start_date = old.s; t.due_date = old.d; renderCalendar();
alert("이동 실패: " + err.message);
}
}
// ── "+N 더" 그날 업무 팝오버 ──
let dayPop = null;
function closeDayPop() {
if (dayPop) { dayPop.remove(); dayPop = null; document.removeEventListener("mousedown", onDocDown, true); }
}
function onDocDown(e) {
if (dayPop && !dayPop.contains(e.target) && !e.target.closest(".pj-bar-more")) closeDayPop();
}
function openDayPopover(dateStr, anchorEl) {
closeDayPop();
const list = visibleTasks().filter(function (t) {
const sp = taskSpan(t); return sp && sp[0] <= dateStr && dateStr <= sp[1];
});
dayPop = document.createElement("div");
dayPop.className = "pj-daypop";
const head = document.createElement("div");
head.className = "pj-daypop-head"; head.textContent = dateStr;
dayPop.appendChild(head);
list.forEach(function (t) {
const row = document.createElement("div");
row.className = "pj-daypop-item" + (t.completed_at ? " is-done" : "");
row.innerHTML =
'<span class="pj-daypop-dot" style="background:' +
(t.completed_at ? "#9aa5b1" : (t.project_color || "#4573d2")) + '"></span>' +
'<span class="pj-daypop-title">' + escapeHtml(t.title || "") + "</span>";
row.addEventListener("click", function () { closeDayPop(); if (canManage) openTaskModal(t); });
dayPop.appendChild(row);
});
document.body.appendChild(dayPop);
const r = anchorEl.getBoundingClientRect();
let left = window.scrollX + r.left;
const top = window.scrollY + r.bottom + 4;
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - dayPop.offsetWidth - 8);
dayPop.style.left = Math.max(8, left) + "px";
dayPop.style.top = top + "px";
setTimeout(function () { document.addEventListener("mousedown", onDocDown, true); }, 0);
}
(function () {
const cal = document.querySelector(".pj-cal");
if (cal) cal.addEventListener("click", function (e) {
const more = e.target.closest(".pj-bar-more");
if (more) openDayPopover(more.dataset.date, more);
});
})();
// 타임라인 하위 작업 펼치기(아사나) — 카드의 "N ⤷" 를 누르면 그 작업 바로 아래에 하위
// 작업들이 각자 날짜 자리에 작은 카드로 나온다. 펼친 작업·받아 둔 하위 작업은 타임라인을
// 다시 그려도 유지(작업 창이 닫히면 캐시는 비운다 — 거기서 하위 작업을 고쳤을 수 있다).
const tlExpanded = new Set();
const tlSubCache = {};
let tlToggleSubs = null;
// 타임라인을 그린 화면 배율 — 배율 토글(_help_btn.html 이 resize 를 보낸다)로 바뀌면 다시 그린다.
let tlZoom = null;
window.addEventListener("resize", function () {
if (currentView === "timeline" && timeline && tlZoom !== uiZoom()) renderTimeline();
});
// 누른 자리 — 카드를 끌고 놓으면 브라우저가 click 을 한 번 더 보내므로, 누른 뒤 움직였으면
// 그 click 으로는 작업 창을 열지 않는다(아래 timeline.on("click")).
let tlDownPt = null;
(function () {
const node = el("pj-timeline");
if (!node) return;
node.addEventListener("pointerdown", function (e) { tlDownPt = { x: e.clientX, y: e.clientY }; }, true);
node.addEventListener("click", function (e) {
const b = e.target.closest && e.target.closest(".pj-tli-sub[data-task-id]");
if (!b) return;
e.preventDefault(); e.stopPropagation();
if (tlToggleSubs) tlToggleSubs(parseInt(b.dataset.taskId, 10));
}, true);
})();
// ── 타임라인 (vis-timeline) — 프로젝트별 행(그룹), 행마다 전체 일정 배경 + 업무 막대 ──
function renderTimeline() {
const node = el("pj-timeline");
if (timeline) { timeline.destroy(); timeline = null; }
const dated = visibleTasks().filter(function (t) { return t.start_date || t.due_date; });
if (!dated.length) { node.innerHTML = '<div class="pj-empty">기간이 설정된 작업이 없습니다.</div>'; return; }
// 프로젝트 메타(시작/마감/색) 조회용
const projById = {};
projectsMeta.forEach(function (p) { projById[p.id] = p; });
// "이 프로젝트" 스코프는 세션별로 행을 나눈다(아사나 타임라인=섹션 스윔레인).
// "전체 프로젝트"는 예전처럼 프로젝트별로 나눈다(세션이 프로젝트마다 달라
// 하나로 묶을 수 없다).
const groupBySession = viewScope === "project";
const byGroup = {};
dated.forEach(function (t) {
const gid = groupBySession ? String(t.stage_id || "none") : String(t.project_id);
(byGroup[gid] = byGroup[gid] || []).push(t);
});
let groupOrder = Object.keys(byGroup);
if (groupBySession) {
const sessionOrder = (stagesByProject[projectId] || []).slice()
.sort(function (a, b) { return a.sort_order - b.sort_order; })
.map(function (s) { return String(s.id); });
groupOrder = sessionOrder.filter(function (id) { return byGroup[id]; });
if (byGroup.none) groupOrder.push("none");
}
const items = [];
const groupRows = [];
// 펼친 작업의 하위 작업 → 작은 카드 아이템(날짜 있는 것만). 작업처럼 끌어서 날짜를 옮긴다(onMove).
function subItemsFor(parent, grp, color) {
const pStart = new Date(parent.start_date || parent.due_date).getTime();
return (tlSubCache[parent.id] || []).filter(function (s) { return s.start_date || s.due_date; }).map(function (s) {
const st = s.start_date || s.due_date, en = s.due_date || s.start_date;
const isRange = en !== st;
return {
id: "sub-" + s.id, group: grp, content: s.title || "",
start: st, end: isRange ? en : undefined, type: isRange ? "range" : "point",
className: "pj-tli-item pj-tli-subitem" + (s.completed_at ? " is-done" : ""),
style: "--pj-tl-color:" + (s.completed_at ? "#9aa5b1" : color) + ";",
pjTask: s, pjParentId: parent.id, pjParentStart: pStart,
};
});
}
const stageById = {};
(stagesByProject[projectId] || []).forEach(function (s) { stageById[String(s.id)] = s; });
groupOrder.forEach(function (gid) {
const list = byGroup[gid];
const grp = (groupBySession ? "S" : "P") + gid;
const meta = groupBySession ? {} : (projById[gid] || {});
// 행 색 — 프로젝트 색(섹션별 색은 없앴다, 2026-10-07)
const groupColor = list[0].project_color || meta.color || "#4573d2";
const groupName = groupBySession
? (gid === "none" ? "미지정" : (list[0].stage_name || "섹션"))
: (list[0].project_name || meta.name || "프로젝트");
groupRows.push({ id: grp, content: groupName, pjColor: groupColor });
let minMs = Infinity, maxMs = -Infinity;
list.forEach(function (t) {
const s = t.start_date || t.due_date;
const e = t.due_date || t.start_date;
const startISO = s + (t.start_time ? "T" + t.start_time : "");
const endISO = e + (t.due_time ? "T" + t.due_time : "");
const isRange = (e !== s) || (!!t.start_time && !!t.due_time && t.start_time !== t.due_time);
items.push({
// 내용은 opts.template(tlItemEl)이 아사나식 카드로 그린다 — 담당자 사진 · 제목 ·
// 하위 작업 N⤷ · 댓글 💬N / 둘째 줄 날짜. 색은 행(섹션) 색을 CSS 변수로 넘긴다.
id: t.id, group: grp,
content: t.title || "",
start: startISO, end: isRange ? endISO : undefined,
type: isRange ? "range" : "point",
className: "pj-tli-item" + (t.completed_at ? " is-done" : ""),
style: "--pj-tl-color:" + (t.completed_at ? "#9aa5b1" : groupColor) + ";",
pjTask: t, pjColor: t.completed_at ? "#9aa5b1" : groupColor,
pjExpanded: tlExpanded.has(t.id),
});
if (tlExpanded.has(t.id)) subItemsFor(t, grp, groupColor).forEach(function (x) { items.push(x); });
const sm = new Date(startISO).getTime();
const em = new Date(endISO).getTime();
if (sm < minMs) minMs = sm;
if (em > maxMs) maxMs = em;
});
// 배경(전체 일정) = 프로젝트 모드일 때만 프로젝트 자체 시작/마감일 우선,
// 세션 모드는 세션에 자체 기간이 없으므로 업무 최소~최대만 쓴다.
let bgStart = (!groupBySession && meta.start_date) ? new Date(meta.start_date + "T00:00:00").getTime() : minMs;
let bgEnd = (!groupBySession && meta.due_date) ? new Date(meta.due_date + "T00:00:00").getTime() : maxMs;
// 업무가 그 기간 밖에 있어도 가려지지 않게 범위를 넓힌다.
bgStart = Math.min(bgStart, minMs);
bgEnd = Math.max(bgEnd, maxMs);
bgEnd += 86400000; // 마지막 날 하루를 덮도록 +1일
items.push({
id: "bg" + grp, group: grp, type: "background",
start: new Date(bgStart), end: new Date(bgEnd),
style: "background-color:" + groupColor + "22;",
});
});
const groups = new vis.DataSet(groupRows);
const koWd = function (d) { return ["일", "월", "화", "수", "목", "금", "토"][d.getDay()]; };
const pad2 = function (n) { return ("0" + n).slice(-2); };
// 저장된 보던 구간이 있으면 생성 옵션에 start/end 로 넣어 자동맞춤(autofit)을 막는다.
// (setWindow 로 나중에 바꾸면 초기 autofit 이 rangechanged 로 덮어써 초기화됨)
const saved = loadTLWindow();
const tlHolidays = data.holidays || {};
// 아사나식 카드 — 반환값이 요소(Element)면 vis 가 정화(sanitize)하지 않고 그대로 붙인다
// (문자열은 정화돼 사진·아이콘이 빠진다). 글자는 전부 escapeHtml 로 넣는다.
function tlDateText(t) {
const s = t.start_date, d = t.due_date;
if (s && d && s !== d) return fmtFieldDate(s) + " – " + fmtFieldDate(d);
if (d) return "마감일: " + fmtFieldDate(d);
return "시작일: " + fmtFieldDate(s);
}
function tlItemEl(item) {
const t = item && item.pjTask;
if (!t) return document.createTextNode("");
const box = document.createElement("div");
box.className = "pj-tli";
box.innerHTML =
(t.assignee_email ? '<span class="pj-tli-av" data-tip="' + escapeHtml(idOf(t.assignee_email)) + '">' +
avatarHtml(t.assignee_email, "pj-gicon-sm") + "</span>" : "") +
'<span class="pj-tli-text">' +
'<span class="pj-tli-title"><span class="pj-tli-name">' + escapeHtml(t.title || "") + "</span>" +
// 하위 작업은 개수만(펼치기 없음 — 말풍선 "하위 작업 N개"), 댓글 💬N, 설명이 있으면 줄글 아이콘.
(t.subtask_total
? '<span class="pj-tli-sub" title="하위 작업 ' + t.subtask_total + '개">' + t.subtask_total + SUBTASK_ICON_SVG + "</span>"
: "") +
cmtBadge(t) +
(hasDescription(t.description)
? '<span class="pj-tli-desc" title="설명 있음">' + DESC_ICON_SVG + "</span>"
: "") +
"</span>" +
'<span class="pj-tli-due">' + escapeHtml(tlDateText(t)) + "</span>" +
"</span>";
return box;
}
function tlGroupEl(group) {
const g = document.createElement("div");
g.className = "pj-tlg";
if (!group) return g;
g.innerHTML = '<span class="pj-tlg-dot" style="background:' + escapeHtml(group.pjColor || "#9aa5b1") + '"></span>' +
'<span class="pj-tlg-name">' + escapeHtml(group.content || "") + "</span>";
return g;
}
// 화면 배율 — 타임라인은 CSS 에서 배율을 1로 되돌리고 크기를 --tz 로 줄이므로(project.css
// "타임라인 크기 배율"), vis 에 넘기는 px 값(높이·간격)도 같은 비율로 줄인다.
const tz = uiZoom();
tlZoom = tz;
const opts = {
stack: true, height: Math.round(520 * tz) + "px",
template: tlItemEl,
groupTemplate: tlGroupEl,
// 쌓는 순서: 작업(시작일순) 바로 뒤에 그 작업의 하위 작업들 — 펼친 하위 작업이 부모 아래에 붙는다
order: function (a, b) {
function key(it) {
if (it.pjParentId != null) return [it.pjParentStart, it.pjParentId, 1, new Date(it.start).getTime()];
if (it.pjTask) return [new Date(it.start).getTime(), it.id, 0, 0];
return [0, 0, 0, 0];
}
const ka = key(a), kb = key(b);
for (let i = 0; i < 4; i++) { if (ka[i] !== kb[i]) return ka[i] < kb[i] ? -1 : 1; }
return 0;
},
horizontalScroll: true, // 마우스 휠 = 좌우 이동(패닝)
verticalScroll: false,
zoomKey: "ctrlKey", // 확대/축소는 Ctrl+휠
margin: { item: Math.round(8 * tz) },
// 먼저 눌러 선택하지 않아도 바로 끌어서 옮긴다(vis 기본은 선택된 것만 끌림).
itemsAlwaysDraggable: { item: canManage, range: canManage },
// 끌 때 날짜 칸 단위로만 움직인다 — 가장 가까운 날 0시에 붙인다(vis 기본은 반나절 단위라
// 칸 가운데에 걸렸다가 놓으면 다음 날로 넘어갔다). 저장도 onMove 가 일 단위로 한다.
snap: function (date) {
const d = new Date(new Date(date).getTime() + 12 * 3600000);
d.setHours(0, 0, 0, 0);
return d;
},
format: {
minorLabels: function (date, scale) {
const d = new Date(date.valueOf());
switch (scale) {
case "millisecond": case "second": case "minute": case "hour":
return pad2(d.getHours()) + ":" + pad2(d.getMinutes());
case "weekday": case "day": {
// 캘린더와 같은 색 — 일요일·국경일·대체공휴일 빨강(<em>), 토요일 파랑(<i>).
// 공휴일은 날짜 밑에 이름(<abbr>, 줄인 이름 — 전체 이름은 말풍선). vis 는 라벨을
// xss 필터(태그만 허용, class 불가)를 거쳐 innerHTML 로 넣으므로 색은 태그로 싣고
// CSS 가 칠한다 — 예전처럼 그린 뒤 class 를 다는 방식은 vis 가 라벨 요소를
// 재사용하며 옮길 때 다른 날짜에 색이 남는 일이 있었다.
const hol = tlHolidays[isoOf(d)] || "";
const red = d.getDay() === 0 || !!hol;
const blue = !red && d.getDay() === 6;
const tag = red ? "em" : blue ? "i" : "span";
const short = /\s대체$/.test(hol) ? "대체휴일" : (HOLIDAY_SHORT[hol] || hol);
return "<" + tag + ">" + d.getDate() + "일 (" + koWd(d) + ")</" + tag + ">" +
(hol ? '<br><abbr title="' + escapeHtml(hol) + '">' + escapeHtml(short) + "</abbr>" : "");
}
case "week": return d.getDate() + "일";
case "month": return (d.getMonth() + 1) + "월";
case "year": return d.getFullYear() + "년";
default: return d.getDate() + "일";
}
},
majorLabels: function (date, scale) {
const d = new Date(date.valueOf());
switch (scale) {
case "millisecond": case "second": case "minute": case "hour":
return (d.getMonth() + 1) + "월 " + d.getDate() + "일 (" + koWd(d) + ")";
case "weekday": case "day": case "week":
return d.getFullYear() + "년 " + (d.getMonth() + 1) + "월";
case "month": return d.getFullYear() + "년";
default: return "";
}
},
},
};
if (saved) { opts.start = new Date(saved.start); opts.end = new Date(saved.end); }
else {
// 저장된 구간이 없어도 임시 범위를 넣어 전체 자동맞춤을 막는다 — 실제 범위(하루 폭 =
// 날짜 글자 폭)는 그린 뒤 칸 폭을 재서 setWindow 로 맞춘다(아래 "기본 보기 범위").
const t0 = new Date(); t0.setHours(0, 0, 0, 0);
opts.start = new Date(t0.getTime() - 7 * 86400000);
opts.end = new Date(t0.getTime() + 21 * 86400000);
}
// ── 드래그로 이동/기간 조절 — 아사나처럼 막대 몸통을 끌면 통째로 이동,
// 양 끝을 끌면 시작·마감일만 조절. 세션(그룹) 간 드래그는 막아둔다(그룹
// 이동은 "다른 세션으로 옮기기"라 보드 드래그의 몫 — 타임라인은 날짜만).
opts.editable = { add: false, remove: false, updateGroup: false, updateTime: canManage };
opts.onMove = function (item, callback) {
// 펼친 하위 작업 카드("sub-"+id)는 그 하위 작업(tlSubCache 의 객체)을 고친다.
const isSub = item.pjParentId != null;
const t = isSub ? item.pjTask : tasks.find(function (x) { return x.id === item.id; });
if (!t) { callback(null); return; }
const old = { start_date: t.start_date, due_date: t.due_date, start_time: t.start_time, due_time: t.due_time };
// 하루 단위로 옮긴다 — 끈 거리를 "며칠"로 반올림해 원래 날짜에 더한다(시각은 그대로).
// vis 의 스냅은 반나절 단위라 놓은 자리의 날짜만 잘라 쓰면 하루 모자랄 수 있다.
const DAY = 86400000;
const s = t.start_date || t.due_date, e = t.due_date || t.start_date;
const startMs = new Date(s + "T" + (t.start_time || "00:00")).getTime();
const endMs = new Date(e + "T" + (t.due_time || "00:00")).getTime();
function addDays(iso, n) {
const d = new Date(iso + "T00:00:00");
d.setDate(d.getDate() + n);
return isoOf(d);
}
const ds = Math.round((new Date(item.start).getTime() - startMs) / DAY);
const de = item.type === "point" ? ds : Math.round((new Date(item.end).getTime() - endMs) / DAY);
if (!ds && !de) { callback(null); return; } // 제자리 — 원위치
const payload = {};
if (item.type === "point") {
// 단일 날짜 항목 — 원래 채워져 있던 필드(시작 또는 마감, 혹은 둘 다
// 같은 날짜)를 같이 옮긴다.
if (t.start_date) payload.start_date = addDays(t.start_date, ds);
if (t.due_date) payload.due_date = addDays(t.due_date, ds);
} else {
payload.start_date = addDays(s, ds);
payload.due_date = addDays(e, de);
if (payload.due_date < payload.start_date) payload.due_date = payload.start_date;
}
Object.assign(t, payload);
// vis 표시도 반올림한 날짜 자리로 맞춘다.
item.start = new Date(startMs + ds * DAY);
if (item.type !== "point") item.end = new Date(endMs + de * DAY);
callback(item); // vis 쪽 위치는 즉시 반영(낙관적) — 저장은 백그라운드.
api("PUT", "/project/api/tasks/" + t.id, payload).then(function (res) {
// 하위 작업은 보드 목록(tasks)에 없다 — 캐시 객체에 값만 맞춘다.
if (!isSub) mergeTask(res.task);
}).catch(function (err) {
Object.assign(t, old);
showToast("일정 변경 실패: " + err.message, "error");
// vis 표시만 원래 자리로 되돌린다(전체 재렌더 없이 — 보던 화면 유지).
itemsDS.update({
id: item.id,
start: old.start_date + (old.start_time ? "T" + old.start_time : ""),
end: item.type === "point" ? undefined : (old.due_date || old.start_date) + (old.due_time ? "T" + old.due_time : ""),
});
});
};
// 하루 칸 폭 = 날짜 글자("30일 (수)") 폭 + 약간의 틈. 라벨과 같은 class 로 잠깐 그려 잰다.
// vis 는 하루 폭이 "0" 글자 폭 × maxMinorChars(기본 7)보다 좁으면 이틀 간격 라벨로 바꾸므로,
// 그 기준도 날짜 글자 폭에 맞춘다.
const probe = document.createElement("div");
probe.className = "vis-timeline";
probe.style.cssText = "position:absolute;left:0;top:0;visibility:hidden;border:0;";
probe.innerHTML = '<div class="vis-time-axis"><div class="vis-text vis-minor">30일 (수)</div>' +
'<div class="vis-text vis-minor vis-measure">0</div></div>';
node.appendChild(probe);
const dayPx = probe.querySelector(".vis-text").offsetWidth + Math.round(4 * tz);
const charPx = probe.querySelector(".vis-measure").offsetWidth;
probe.remove();
if (dayPx > 0 && charPx > 0) opts.maxMinorChars = Math.max(1, Math.floor(dayPx / charPx));
const itemsDS = new vis.DataSet(items);
timeline = new vis.Timeline(node, itemsDS, groups, opts);
// 칸 폭을 재서(그려야 알 수 있다) 두 가지를 맞춘다 — 폭이 바뀔 때만(창 크기 변경).
// · 축소 한계(zoomMax) — Ctrl+휠로 줄여도 하루 칸이 날짜 글자(dayPx)보다 좁아지지 않게.
// 더 줄이면 vis 가 이틀 간격 라벨로 바꿔 날짜가 빠져 보인다.
// · 기본 보기 범위(처음 한 번) — 하루 칸 = dayPx, 오늘이 왼쪽 1/4 쯤. 저장된 구간(saved)이
// 있으면 그걸 쓰되 한계보다 넓으면 줄인다. vis 는 첫 "changed" 때 생성 옵션의 범위로
// 다시 맞추므로 그 뒤에 setWindow 한다.
if (dayPx > 0) {
const DAY = 86400000;
let fitted = false, lastW = 0;
timeline.on("changed", function () {
if (!timeline) return;
const center = node.querySelector(".vis-panel.vis-center");
const w = center ? center.clientWidth : 0;
if (!w || w === lastW) return;
lastW = w;
const maxSpan = w / dayPx * DAY;
timeline.setOptions({ zoomMax: maxSpan });
const win = timeline.getWindow();
const st = win.start.getTime(), span = win.end.getTime() - st;
if (!fitted && !saved) {
const t0 = new Date(); t0.setHours(0, 0, 0, 0);
const from = t0.getTime() - Math.floor(w / dayPx / 4) * DAY;
timeline.setWindow(new Date(from), new Date(from + maxSpan), { animation: false });
} else if (span > maxSpan + 1000) {
timeline.setWindow(new Date(st), new Date(st + maxSpan), { animation: false });
}
fitted = true;
});
// 첫 표시 보장 — vis 는 "changed" 때 첫 범위 변경(rangechanged)이 끝났는지 보고서야
// 타임라인을 보이게 한다(그 전엔 visibility:hidden). 위에서 바꾼 범위의 rangechanged 는
// 비동기로 늦게 오고, 첫 그리기 전이라 vis 가 다시 그리지 않아 다음 changed 가 없으면
// 타임라인이 통째로 안 보인다. rangechanged 뒤에도 숨어 있으면 한 번 더 그린다.
timeline.on("rangechanged", function () {
const root = node.querySelector(".vis-timeline");
if (timeline && root && root.style.visibility === "hidden") timeline.redraw();
});
}
tlToggleSubs = function (id) {
const parent = itemsDS.get(id);
if (!parent || !parent.pjTask) return;
const subIds = function () { return itemsDS.getIds({ filter: function (it) { return it.pjParentId === id; } }); };
if (tlExpanded.has(id)) {
tlExpanded.delete(id);
itemsDS.remove(subIds());
itemsDS.update({ id: id, pjExpanded: false });
return;
}
tlExpanded.add(id);
itemsDS.update({ id: id, pjExpanded: true });
function addSubs() {
if (!tlExpanded.has(id) || !itemsDS.get(id)) return;
itemsDS.remove(subIds());
const subs = subItemsFor(parent.pjTask, parent.group, parent.pjColor || "#4573d2");
itemsDS.add(subs);
const undated = (tlSubCache[id] || []).length - subs.length;
if (undated > 0) showToast("날짜가 없는 하위 작업 " + undated + "개는 타임라인에 나오지 않습니다.");
}
if (tlSubCache[id]) { addSubs(); return; }
api("GET", "/project/api/tasks/" + id).then(function (res) {
tlSubCache[id] = (res && res.task && res.task.subtasks) || [];
addSubs();
}).catch(function (err) {
tlExpanded.delete(id);
if (itemsDS.get(id)) itemsDS.update({ id: id, pjExpanded: false });
showToast("하위 작업을 불러오지 못했습니다: " + err.message, "error");
});
};
// 다시 그렸는데 펼친 작업의 하위 작업 캐시가 비어 있으면(작업 창을 닫아 비웠다 등) 새로 받는다.
Array.from(tlExpanded).forEach(function (id) {
if (!tlSubCache[id] && itemsDS.get(id)) { tlExpanded.delete(id); tlToggleSubs(id); }
});
// 카드는 끌어서 날짜 이동, 작업 이름을 누르면 오른쪽 작업 창(아사나). 카드의 다른 곳을
// 누르면 선택만 — 기간 막대 양 끝 손잡이(기간 조절)는 선택된 막대에만 나타난다.
// 끌기는 vis 가 tap 으로 치지 않아 끌고 놓아도 창이 열리지 않는다.
timeline.on("click", function (props) {
if (!canManage || props.item == null) return;
const ev = props.event || {};
const target = ev.target || (ev.srcEvent && ev.srcEvent.target);
if (!target || !target.closest || !target.closest(".pj-tli-name")) return;
const x = ev.center ? ev.center.x : ev.clientX, y = ev.center ? ev.center.y : ev.clientY;
if (tlDownPt && x != null && Math.hypot(x - tlDownPt.x, y - tlDownPt.y) > 5) return; // 끌고 놓은 것
const id = String(props.item);
if (id.indexOf("sub-") === 0) { openTaskById(parseInt(id.slice(4), 10)); return; }
const t = tasks.find(function (x) { return x.id === props.item; });
if (t) openTaskModal(t);
});
// 더블클릭(카드 어디든)·우클릭 메뉴의 "열기"로도 연다.
timeline.on("doubleClick", function (props) {
if (!canManage || props.item == null || String(props.item).indexOf("bg") === 0) return;
if (String(props.item).indexOf("sub-") === 0) { openTaskById(parseInt(String(props.item).slice(4), 10)); return; }
const t = tasks.find(function (x) { return x.id === props.item; });
if (t) openTaskModal(t);
});
// 배경 블록("bg"+그룹id)이나 빈 공간 우클릭은 무시 — 업무 아이템일 때만 메뉴.
timeline.on("contextmenu", function (props) {
if (props.event && props.event.preventDefault) props.event.preventDefault();
if (!canManage || props.item == null || String(props.item).indexOf("bg") === 0) return;
if (String(props.item).indexOf("sub-") === 0) {
const subId = parseInt(String(props.item).slice(4), 10);
const it = itemsDS.get(props.item);
showContextMenu(props.event.clientX, props.event.clientY, [
{ label: "열기", onClick: function () { openTaskById(subId); } },
{ label: "상위 작업 열기", onClick: function () { if (it) openTaskById(it.pjParentId); } },
]);
return;
}
const t = tasks.find(function (x) { return x.id === props.item; });
if (t) showContextMenu(props.event.clientX, props.event.clientY, taskContextItems(t));
});
// 마우스 오버 시 그 업무의 날짜 구간을 전체 높이 배경 밴드로 살짝 강조
// (아사나에서 막대에 마우스를 올리면 헤더 날짜 부분이 진하게 표시되는 것과
// 같은 목적 — vis 의 날짜 헤더 DOM을 직접 건드리는 대신, 같은 자리에
// 반투명 background 아이템을 하나 얹었다 뺐다 하는 방식으로 구현).
const HOVER_ID = "hover-highlight";
timeline.on("itemover", function (props) {
if (props.item == null || String(props.item).indexOf("bg") === 0 || props.item === HOVER_ID) return;
const it = itemsDS.get(props.item);
if (!it) return;
const start = it.start;
const end = it.end || new Date(new Date(it.start).getTime() + 86400000);
try { itemsDS.remove(HOVER_ID); } catch (_) {}
itemsDS.add({ id: HOVER_ID, type: "background", start: start, end: end, className: "pj-tl-hover-band" });
});
timeline.on("itemout", function (props) {
if (props.item === HOVER_ID) return;
try { itemsDS.remove(HOVER_ID); } catch (_) {}
});
// 사용자가 직접 확대/이동했을 때만 저장(autofit 등 프로그램 변경은 무시).
timeline.on("rangechanged", function (p) { if (p.byUser) saveTLWindow(p.start, p.end); });
const todayBtn = el("pj-tl-today");
if (todayBtn) todayBtn.onclick = function () { timeline.moveTo(new Date()); };
}
// 보던 구간 — 키 "2": 하루 폭을 날짜 글자에 맞춘 새 기본 보기로 한 번 초기화하려고 바꿨다.
function loadTLWindow() {
try {
const r = JSON.parse(localStorage.getItem("pj_tl_window2") || "null");
return (r && r.start && r.end) ? r : null;
} catch (_) { return null; }
}
function saveTLWindow(s, e) {
try {
localStorage.setItem("pj_tl_window2",
JSON.stringify({ start: new Date(s).toISOString(), end: new Date(e).toISOString() }));
} catch (_) {}
}
// ── 보드 (칸반 = 세션) ──
// scope==="project" → 이 프로젝트의 실제 세션(id 기준) + 세션 관리(이름변경·
// 완료토글·삭제·추가·드래그 재정렬).
// scope==="all" → 여러 프로젝트를 세션 '이름' 기준으로 합쳐 보여준다(기존
// 동작 그대로 — 세션 하나를 특정할 수 없어 관리 컨트롤은 없다).
// "+ 세션 추가" 버튼은 보드(스크롤 영역) 밖 고정 위치에 있어 세션이
// 늘어나 스크롤이 생겨도 항상 보인다 — 한 번만 wiring, 표시 여부만 매
// 렌더마다 토글.
const STAGE_HEAD_BG = "#f3f3f3";
// ── 섹션 추가/편집 팝업 — 이름 + 기본 담당자(색 지정은 없앰). "+ 세션 추가" 버튼과
// 세션 헤더 ✎(세션 편집) 아이콘·컨텍스트 메뉴가 전부 이 모달 하나를 쓴다.
const stageModal = el("pj-modal-stage");
if (stageModal) wireModalClose(stageModal);
function openStageModal(stage) {
if (!stageModal) return;
el("pj-stage-modal-title").textContent = stage ? "\"" + stage.name + "\" 섹션 편집" : "새 섹션";
el("pj-stg-id").value = stage ? stage.id : "";
el("pj-stg-name").value = stage ? stage.name : "";
// 기본 담당자 후보 = 업무 담당자 후보와 같다(프로젝트 멤버 + owner).
// 지금 지정된 사람이 멤버에서 빠졌어도 선택지에 남겨 칸이 비지 않게 한다.
const cur = stage ? (stage.default_assignee_email || "") : "";
const emails = members.map(function (m) { return (m.user_email || "").toLowerCase(); });
[currentProject.owner_email, cur].forEach(function (e) {
e = (e || "").toLowerCase();
if (e && emails.indexOf(e) < 0) emails.push(e);
});
// 멤버 추가 창과 같은 아이콘+이름 카드(한 명만 고르는 라디오). 맨 앞 "없음".
const picker = el("pj-stg-assignee");
function pickCard(value, icon, label) {
return '<label class="pj-member-pick pj-member-pick-stacked pj-stg-pick">' +
'<span class="pj-member-pick-avatar">' + icon + "</span>" +
'<span class="pj-member-pick-name">' + escapeHtml(label) + "</span>" +
'<input type="radio" name="pj-stg-assignee" value="' + escapeHtml(value) + '" />' +
"</label>";
}
picker.innerHTML =
pickCard("", '<span class="material-symbols-outlined pj-gicon pj-member-pick-icon">person_off</span>', "없음") +
emails.map(function (e) { return pickCard(e, avatarHtml(e, "pj-member-pick-icon"), idOf(e)); }).join("");
const curVal = cur.toLowerCase();
picker.querySelectorAll("input").forEach(function (r) { r.checked = r.value === curVal; });
picker.dataset.orig = curVal;
openModal(stageModal);
}
const saveStageBtn = el("pj-save-stage");
if (saveStageBtn) saveStageBtn.addEventListener("click", async function () {
const id = el("pj-stg-id").value;
const name = el("pj-stg-name").value.trim();
if (!name) { alert("섹션 이름을 입력하세요."); return; }
const body = { name: name }; // 섹션 색은 보내지 않는다(화면은 늘 #f3f3f3)
// 기본 담당자는 바뀐 경우에만 보낸다 — DB 마이그레이션 009 전이라도
// 이름·색상 편집은 그대로 되게.
const picker = el("pj-stg-assignee");
if (picker) {
const checked = picker.querySelector("input:checked");
const val = checked ? checked.value : "";
if (val !== (picker.dataset.orig || "")) body.default_assignee_email = val;
}
try {
if (id) {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + id, body);
} else {
await api("POST", "/project/api/projects/" + projectId + "/stages", body);
}
await reloadStagesForCurrentProject();
closeModal(stageModal);
renderBoard();
} catch (e) { showToast("저장 실패: " + e.message, "error"); }
});
const boardAddStageBtn = el("pj-board-addstage");
if (boardAddStageBtn) {
boardAddStageBtn.addEventListener("click", function () { openStageModal(null); });
}
// 섹션별 빠른 작업 입력 초안 — 보드를 다시 그려도 입력값/저장 중 상태를 유지한다.
const boardTaskDrafts = {};
const boardTaskOutsideDown = {};
const BOARD_FOLD_KEY = "pj_board_fold:" + projectId;
let boardFold = {};
try { boardFold = JSON.parse(localStorage.getItem(BOARD_FOLD_KEY) || "{}") || {}; } catch (_) {}
function wireBoardCollapse(col) {
const head = col.querySelector(".pj-col-head");
let actions = head.querySelector(".pj-col-actions");
if (!actions) {
actions = document.createElement("span"); actions.className = "pj-col-actions"; head.appendChild(actions);
}
const btn = document.createElement("button");
btn.type = "button"; btn.className = "pj-icon-btn pj-col-collapse";
// 아사나의 왼쪽 화살표 + 세로 경계선 모양.
btn.innerHTML = '<svg viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M4 3v14M8 6l-4 4 4 4M4 10h12"/></svg>';
actions.prepend(btn);
const key = colKey(col);
function update() {
const folded = boardFold[key] === true;
col.classList.toggle("is-collapsed", folded);
btn.setAttribute("aria-expanded", String(!folded));
btn.setAttribute("aria-label", (folded ? "그룹 펼치기: " : "그룹 축소: ") + head.querySelector(".pj-col-name").textContent);
btn.title = folded ? "그룹 펼치기" : "그룹 축소";
btn.dataset.tip = btn.title;
col.querySelector(".pj-col-body").inert = folded;
}
btn.addEventListener("mousedown", function (e) { e.stopPropagation(); });
btn.addEventListener("dragstart", function (e) { e.preventDefault(); e.stopPropagation(); });
btn.addEventListener("click", function (e) {
e.stopPropagation();
boardFold[key] = !boardFold[key];
try { localStorage.setItem(BOARD_FOLD_KEY, JSON.stringify(boardFold)); } catch (_) {}
update(); syncBoardHBar();
});
update();
}
function renderBoard() {
// pj-board(바깥)는 가로 스크롤 뷰포트, pj-board-canvas(안쪽)는 세션을
// 가로로 늘어놓는 flex 컨테이너(width:max-content) — 세션이 아무리
// 늘어나도 아래로 접히지 않고 오른쪽으로 계속 이어진다.
const canvas = el("pj-board-canvas");
// 다시 그려도 보던 자리 유지 — 작업 창을 닫거나 완료를 체크하면 보드를 통째로 다시
// 그리는데, 그대로 두면 섹션 세로 스크롤·보드 가로 스크롤이 맨 처음으로 돌아간다.
const board = el("pj-board");
const scrollLeft = board ? board.scrollLeft : 0;
const colScroll = {};
canvas.querySelectorAll(".pj-col").forEach(function (col) {
const b = col.querySelector(".pj-col-body");
if (b && b.scrollTop) colScroll[colKey(col)] = b.scrollTop;
});
Object.keys(boardTaskOutsideDown).forEach(function (id) {
document.removeEventListener("pointerdown", boardTaskOutsideDown[id], true);
delete boardTaskOutsideDown[id];
});
canvas.innerHTML = "";
const vis = visibleTasks();
if (viewScope === "project") renderBoardByStage(canvas, vis);
else renderBoardByName(canvas, vis);
// "+ 섹션 추가" — 아사나처럼 마지막 섹션 바로 오른쪽(캔버스 맨 끝)에.
if (boardAddStageBtn) {
boardAddStageBtn.hidden = !(viewScope === "project" && canManage);
canvas.appendChild(boardAddStageBtn);
}
canvas.querySelectorAll(".pj-col").forEach(function (col) {
wireBoardCollapse(col);
const top = colScroll[colKey(col)];
const b = col.querySelector(".pj-col-body");
if (top && b) b.scrollTop = top;
});
if (board && scrollLeft) board.scrollLeft = scrollLeft;
syncBoardHBar();
}
// 섹션 식별 — 이 프로젝트 보드는 섹션 id, 전체 프로젝트 보드는 섹션 이름.
function colKey(col) {
return col.dataset.stageId ? "id:" + col.dataset.stageId : "name:" + (col.dataset.stageName || "");
}
// 아사나식 가로 보드 — 세션은 CSS flex 로 왼쪽부터 나란히 놓이고, 세션이
// 늘어나면 아래로 접히지 않고 계속 오른쪽으로 이어지며 보드가 가로로
// 스크롤된다(예전 매이슨리 절대배치를 대체). 배치는 전부 CSS 가 하므로
// JS 는 직접 그리는 가로 스크롤 막대만 갱신한다.
let boardHBarUpdate = null;
function syncBoardHBar() {
const board = el("pj-board");
const bar = el("pj-board-hbar");
if (!board || !bar) return;
if (!boardHBarUpdate) boardHBarUpdate = attachHScrollIndicator(board, bar);
if (boardHBarUpdate) boardHBarUpdate();
}
window.addEventListener("resize", function () {
if (currentView !== "board") return;
syncBoardHBar();
});
function renderBoardByName(board, vis) {
// 컬럼 이름 = 서버가 정렬해준 전체 세션 이름 + 세션 미지정 업무용 '미지정'
let names = boardStages.slice();
const hasUnstaged = vis.some(function (t) { return !t.stage_name; });
if (hasUnstaged) names.push("미지정");
names.forEach(function (name) {
const col = document.createElement("div");
col.className = "pj-col";
col.dataset.stageName = name;
col.innerHTML =
'<div class="pj-col-head"><span class="pj-col-name">' + escapeHtml(name) + "</span>" +
'<span class="pj-col-count"></span></div>' +
'<div class="pj-col-body"></div>';
const body = col.querySelector(".pj-col-body");
const colTasks = vis.filter(function (t) {
return name === "미지정" ? !t.stage_name : (t.stage_name || "") === name;
});
col.querySelector(".pj-col-count").textContent = colTasks.length;
colTasks.forEach(function (t) { body.appendChild(taskCard(t)); });
if (canManage && name !== "미지정") enableDropByName(body, name);
board.appendChild(col);
});
}
// 보드 드롭(전체보기) — 컬럼 이름(세션명)으로 옮긴다. 업무가 속한 '그
// 프로젝트'의 동일 이름 세션 id 를 찾아 적용(프로젝트마다 세션 id 가 다르다).
function enableDropByName(body, name) {
body.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); body.classList.add("is-over");
});
body.addEventListener("dragleave", function () { body.classList.remove("is-over"); });
body.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault();
body.classList.remove("is-over");
const taskId = parseInt(e.dataTransfer.getData("text/plain"), 10);
const t = tasks.find(function (x) { return x.id === taskId; });
if (!t || (t.stage_name || "") === name) return;
const plist = stagesByProject[t.project_id] || [];
const target = plist.find(function (s) { return s.name === name; });
if (!target) { alert("'" + (t.project_name || "이 프로젝트") + "' 에는 '" + name + "' 섹션이 없습니다."); return; }
try {
const res = await api("PUT", "/project/api/tasks/" + taskId, { stage_id: target.id });
mergeTask(res.task);
renderBoard();
} catch (err) { alert("이동 실패: " + err.message); }
});
}
// ── 보드(프로젝트 스코프) — 세션은 이 프로젝트의 실제 행(id)이라 관리 UI를
// 붙일 수 있다: 이름변경·완료토글·삭제(만든 사람만)·추가·드래그 재정렬.
function renderBoardByStage(board, vis) {
// 완료 세션은 끝으로 보낸다 — sort_order 자체는 안 건드리고 정렬
// 기준에서만 뒤로 미루므로, 완료 체크를 해제하면 sort_order 가 그대로라
// 원래 있던 자리로 자동 복귀한다(별도 "이전 위치" 저장 불필요).
const list = (stagesByProject[projectId] || []).slice()
.sort(function (a, b) {
if (!!a.is_done_stage !== !!b.is_done_stage) return a.is_done_stage ? 1 : -1;
return a.sort_order - b.sort_order;
});
// 세션은 프로젝트를 만들 때 자동으로 생기지 않는다(아사나처럼 직접 추가) —
// 아직 하나도 없으면 안내만 보여준다.
if (!list.length && !vis.length) {
const empty = document.createElement("div");
empty.className = "pj-empty";
empty.textContent = "섹션이 없습니다. 위 \"+ 섹션 추가\"로 만들어 보세요.";
board.appendChild(empty);
}
list.forEach(function (s) {
const col = document.createElement("div");
col.className = "pj-col" + (s.is_done_stage ? " pj-col-done" : "");
col.dataset.stageId = s.id;
// 섹션 머리 색은 모두 같은 연회색(#f3f3f3) — 섹션별 색 지정은 2026-10-07 요청으로 없앴다(DB 의 예전 색은 쓰지 않는다)
col.innerHTML =
'<div class="pj-col-head pj-col-head-colored is-light"' +
(canManage ? ' draggable="true"' : "") + ' style="background:' + STAGE_HEAD_BG + '">' +
// 아사나처럼: 이름 바로 오른쪽에 업무 수(숫자만), 맨 오른쪽에 + / … 버튼.
'<span class="pj-col-name">' + escapeHtml(s.name) + "</span>" +
'<span class="pj-col-count"></span>' +
// 세션 기본 담당자 — 작은 아이콘(마우스를 올리면 누구인지).
(s.default_assignee_email
? '<span class="pj-col-assignee" title="기본 담당자: ' + escapeHtml(idOf(s.default_assignee_email)) + '">' +
avatarHtml(s.default_assignee_email, "pj-gicon-sm") + "</span>"
: "") +
(s.is_done_stage ? '<span class="pj-chip pj-chip-sm">완료</span>' : "") +
(canManage
? '<span class="pj-col-actions">' +
'<button type="button" class="pj-icon-btn pj-col-add" title="작업 추가">' +
'<span class="material-symbols-outlined">add</span></button>' +
'<button type="button" class="pj-icon-btn pj-col-more" title="섹션 메뉴">' +
'<span class="material-symbols-outlined">more_horiz</span></button>' +
"</span>"
: "") +
"</div><div class=\"pj-col-body\"></div>" +
// 세션 맨 아래 "+ 업무 추가" — 카드 목록이 길어져도 컬럼 바닥에
// 고정으로 남는다(.pj-col-body 만 스크롤).
(canManage
? '<button type="button" class="pj-col-addtask">+ 작업 추가</button>'
: "");
const body = col.querySelector(".pj-col-body");
const colTasks = vis.filter(function (t) { return t.stage_id === s.id; });
col.querySelector(".pj-col-count").textContent = colTasks.length;
colTasks.forEach(function (t) { body.appendChild(taskCard(t)); });
if (canManage) {
renderBoardTaskDraft(body, s);
enableDropByStageId(body, s.id);
wireColumnControls(col, s);
wireColumnDrag(col, s);
wireStageAddTask(body, s);
col.querySelector(".pj-col-addtask").addEventListener("click", function () {
openBoardTaskDraft(s);
});
}
board.appendChild(col);
});
const hasUnstaged = vis.some(function (t) { return !t.stage_id; });
if (hasUnstaged) {
const col = document.createElement("div");
col.className = "pj-col";
col.dataset.stageName = "미지정";
col.innerHTML =
'<div class="pj-col-head"><span class="pj-col-name">미지정</span>' +
'<span class="pj-col-count"></span></div><div class="pj-col-body"></div>';
const body = col.querySelector(".pj-col-body");
const colTasks = vis.filter(function (t) { return !t.stage_id; });
col.querySelector(".pj-col-count").textContent = colTasks.length;
colTasks.forEach(function (t) { body.appendChild(taskCard(t)); });
board.appendChild(col);
}
}
async function reloadStagesForCurrentProject() {
const res = await api("GET", "/project/api/projects/" + projectId + "/stages");
stages = res.stages || [];
stagesByProject[projectId] = stages;
}
function wireColumnControls(col, s) {
function editStage() { openStageModal(s); }
async function toggleDoneStage() {
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + s.id,
{ is_done_stage: !s.is_done_stage });
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) { showToast("변경 실패: " + err.message, "error"); }
}
async function deleteStage() {
if (!canDelete(s.created_by)) { alert(DELETE_DENIED); return; }
const ok = await window.erpConfirm(
"'" + s.name + "' 섹션을 삭제할까요? 이 섹션의 작업은 '미지정'이 됩니다.",
{ okText: "삭제", cancelText: "취소" }
);
if (!ok) return;
try {
await api("DELETE", "/project/api/projects/" + projectId + "/stages/" + s.id);
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) { showToast("삭제 실패: " + err.message, "error"); }
}
// 세션의 미완료 업무를 한 번에 완료 처리("세션 업무 모두 완료").
async function completeAllInStage() {
const open = tasks.filter(function (t) {
return t.stage_id === s.id && !t.parent_task_id && !t.completed_at;
});
if (!open.length) { showToast("완료할 작업이 없습니다."); return; }
const ok = await window.erpConfirm(
"'" + s.name + "' 섹션의 미완료 작업 " + open.length + "개를 모두 완료로 표시할까요?",
{ okText: "모두 완료", cancelText: "취소" }
);
if (!ok) return;
let fail = 0;
for (const t of open) {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, { completed: true });
if (res && res.task) mergeTask(res.task);
} catch (_) { fail++; }
}
renderBoard();
if (fail) showToast(fail + "개 완료 처리 실패", "error");
}
// 세션 … 메뉴(버튼 클릭)와 머리 우클릭이 같은 항목을 쓴다.
function stageMenuItems() {
return [
{ label: "작업 추가", onClick: function () { openBoardTaskDraft(s); } },
{ label: "이름 변경", onClick: startRename },
{ label: "섹션 편집 (색상·기본 담당자)", onClick: editStage },
null,
{ label: "섹션 작업 모두 완료", onClick: completeAllInStage },
{ label: s.is_done_stage ? "완료 섹션 해제" : "완료 섹션으로 지정", onClick: toggleDoneStage },
null,
{ label: "삭제", danger: true, onClick: deleteStage },
];
}
// 세션 이름 클릭(또는 메뉴 "이름 변경") → 그 자리에서 이름 변경
// (Enter/포커스 이탈=저장, Esc=취소). 헤더가 드래그(세션 재정렬) 대상이라
// 편집 중엔 draggable 을 꺼 둔다 — 안 끄면 입력칸 안에서 글자 선택하려고
// 끌면 컬럼이 끌려간다.
const nameEl = col.querySelector(".pj-col-name");
function startRename() {
if (!nameEl || !nameEl.isConnected) return;
const head = col.querySelector(".pj-col-head");
const wasDraggable = head.getAttribute("draggable");
head.setAttribute("draggable", "false");
const input = document.createElement("input");
input.type = "text";
input.className = "pj-col-name-input";
input.value = s.name;
input.maxLength = 100;
nameEl.replaceWith(input);
input.focus();
input.select();
let done = false;
async function finish(save) {
if (done) return;
done = true;
const name = input.value.trim();
if (!save || !name || name === s.name) {
input.replaceWith(nameEl);
if (wasDraggable) head.setAttribute("draggable", wasDraggable);
return;
}
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + s.id, { name: name });
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) {
showToast("이름 변경 실패: " + err.message, "error");
input.replaceWith(nameEl);
if (wasDraggable) head.setAttribute("draggable", wasDraggable);
}
}
input.addEventListener("keydown", function (ev) {
if (ev.isComposing) return; // 한글 조합 중 Enter 는 무시
if (ev.key === "Enter") { ev.preventDefault(); finish(true); }
else if (ev.key === "Escape") { ev.preventDefault(); finish(false); }
});
input.addEventListener("blur", function () { finish(true); });
input.addEventListener("click", function (ev) { ev.stopPropagation(); });
}
if (nameEl) {
nameEl.classList.add("pj-col-name-editable");
nameEl.title = "클릭해서 이름 변경";
nameEl.addEventListener("click", function (e) { e.stopPropagation(); startRename(); });
}
const addBtn = col.querySelector(".pj-col-add");
if (addBtn) addBtn.addEventListener("click", function (e) { e.stopPropagation(); openTaskModal(null, s.id); });
const moreBtn = col.querySelector(".pj-col-more");
if (moreBtn) moreBtn.addEventListener("click", function (e) {
e.stopPropagation();
const r = moreBtn.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, stageMenuItems());
});
const head = col.querySelector(".pj-col-head");
if (head) head.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, stageMenuItems());
});
}
// 세션 본문(카드 사이 빈 공간) 우클릭 — "업무 추가"만. 카드 위에서 우클릭한
// 경우는 taskCard() 쪽 컨텍스트 메뉴(수정/완료/삭제 등)가 대신 뜨도록 건너뛴다.
function wireStageAddTask(body, s) {
body.addEventListener("contextmenu", function (e) {
if (e.target.closest(".pj-card")) return;
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "작업 추가", onClick: function () { openBoardTaskDraft(s); } },
]);
});
}
// 아사나식 빠른 추가 카드: 이름 + 담당자 + 마감일만. Enter는 계속 입력,
// 바깥 클릭은 저장 후 닫기, Esc/이름 없이 바깥 클릭은 취소.
function openBoardTaskDraft(stage) {
if (!canManage || accessLost) return;
if (!boardTaskDrafts[stage.id]) {
boardTaskDrafts[stage.id] = {
title: "", assignee: stage.default_assignee_email || "", due: null, focused: true, saving: false,
};
} else boardTaskDrafts[stage.id].focused = true;
renderBoard();
}
function renderBoardTaskDraft(body, stage) {
const draft = boardTaskDrafts[stage.id];
if (!draft) return;
const card = document.createElement("div");
card.className = "pj-card pj-tasknew";
card.setAttribute("aria-label", "새 작업");
card.setAttribute("aria-busy", String(draft.saving));
card.innerHTML =
'<div class="pj-tasknew-name"><span class="material-symbols-outlined pj-tasknew-check">check_circle</span>' +
'<input type="text" class="pj-tasknew-title" placeholder="작업 이름 입력" aria-label="작업 이름" autocomplete="off"></div>' +
'<div class="pj-tasknew-meta"><button type="button" class="pj-tasknew-assignee" aria-label="담당자 지정"></button>' +
'<button type="button" class="pj-tasknew-due" aria-label="마감일 지정"></button></div>';
body.appendChild(card);
const inp = card.querySelector(".pj-tasknew-title");
const av = card.querySelector(".pj-tasknew-assignee");
const due = card.querySelector(".pj-tasknew-due");
inp.value = draft.title;
inp.disabled = av.disabled = due.disabled = draft.saving;
function current() { return boardTaskDrafts[stage.id] === draft && !accessLost; }
function refocus() { if (current() && inp.isConnected && !draft.saving) inp.focus(); }
function paintAv() {
av.innerHTML = draft.assignee ? avatarHtml(draft.assignee, "pj-gicon-sm") : ASSIGN_EMPTY_ICON_SVG;
av.title = draft.assignee ? idOf(draft.assignee) : "담당자 지정";
}
function paintDue() {
const di = dueInfo(draft.due, false);
due.innerHTML = di ? escapeHtml(di.text) : DUE_EMPTY_ICON_SVG;
due.title = draft.due || "마감일 지정";
}
paintAv(); paintDue();
inp.addEventListener("input", function () { draft.title = inp.value; });
inp.addEventListener("focus", function () { draft.focused = true; });
inp.addEventListener("blur", function () { draft.focused = false; });
inp.addEventListener("keydown", function (e) {
if (isImeEnter(e)) return;
if (e.key === "Enter") { e.preventDefault(); save(true); }
if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); close(); }
});
av.addEventListener("click", async function () {
draft.picking = true; // 멤버 조회 중에는 바깥 클릭으로 저장하지 않는다.
try {
const list = await membersOfProject(projectId);
if (!current() || !av.isConnected) return;
const r = av.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, assigneeMenuItems(
list.map(function (m) { return m.user_email; }), draft.assignee,
function (email) { if (!current()) return; draft.assignee = email || ""; paintAv(); refocus(); }
));
} catch (err) { showToast("멤버 조회 실패: " + err.message, "error"); }
finally { draft.picking = false; }
});
due.addEventListener("click", function () {
openDatePopover(due, {
due: draft.due, allowStart: false,
onChange: function (patch) { if (!current()) return; draft.due = patch.due_date || null; paintDue(); refocus(); },
});
});
function close() {
if (!current() || draft.saving) return;
delete boardTaskDrafts[stage.id];
renderBoard();
}
async function save(keepOpen) {
if (!current() || draft.saving) return;
if (inp.isConnected) draft.title = inp.value;
const title = draft.title.trim();
if (!title) return;
draft.saving = true;
inp.disabled = av.disabled = due.disabled = true;
card.setAttribute("aria-busy", "true");
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/tasks", {
title: title, stage_id: stage.id,
assignee_email: draft.assignee, assignee_name: draft.assignee ? idOf(draft.assignee) : "",
due_date: draft.due || null,
});
if (!current()) return;
mergeTask(res.task);
if (keepOpen) {
boardTaskDrafts[stage.id] = {
title: "", assignee: stage.default_assignee_email || "", due: null, focused: true, saving: false,
};
} else delete boardTaskDrafts[stage.id];
refreshActiveView();
refreshMyOpenBadge();
} catch (err) {
if (current()) {
draft.saving = false;
draft.focused = true;
renderBoard();
}
showToast("작업 추가 실패: " + err.message, "error");
}
}
function outside(e) {
if (!current() || !card.isConnected || draft.saving || draft.picking) return;
const target = e.target;
if (card.contains(target) || (datePopEl && datePopEl.contains(target)) || (ctxMenuEl && ctxMenuEl.contains(target))) return;
const add = target.closest(".pj-col-addtask, .pj-col-add");
if (add && add.closest(".pj-col") === body.closest(".pj-col")) return;
// 한글 조합의 마지막 글자가 blur에서 확정된 뒤 읽는다.
setTimeout(function () {
if (!current()) return;
if (inp.isConnected) draft.title = inp.value;
if (draft.title.trim()) save(false);
else close();
}, 0);
}
boardTaskOutsideDown[stage.id] = outside;
document.addEventListener("pointerdown", outside, true);
if (draft.focused && !draft.saving) setTimeout(function () {
if (!current() || !inp.isConnected || datePopEl || ctxMenuEl) return;
inp.focus();
inp.setSelectionRange(inp.value.length, inp.value.length);
// 컬럼 안에 새 카드가 보이도록만 스크롤한다(보드 가로 위치는 유지).
body.scrollTop = body.scrollHeight;
}, 0);
}
// 세션(컬럼) 드래그 재정렬 — 카드 드래그와 같은 네이티브 HTML5 DnD 방식이되,
// dataTransfer 타입을 달리 써서(application/x-pj-stage) 카드 드롭과 안 섞인다.
function wireColumnDrag(col, s) {
const head = col.querySelector(".pj-col-head");
if (!head || head.getAttribute("draggable") !== "true") return;
head.addEventListener("dragstart", function (e) {
e.dataTransfer.setData("application/x-pj-stage", String(s.id));
e.dataTransfer.effectAllowed = "move";
col.classList.add("is-dragging");
});
head.addEventListener("dragend", function () { col.classList.remove("is-dragging"); });
col.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("application/x-pj-stage")) return;
e.preventDefault();
col.classList.add("pj-col-drop-target");
});
col.addEventListener("dragleave", function () { col.classList.remove("pj-col-drop-target"); });
col.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("application/x-pj-stage")) return;
e.preventDefault();
col.classList.remove("pj-col-drop-target");
const draggedId = parseInt(e.dataTransfer.getData("application/x-pj-stage"), 10);
if (!draggedId || draggedId === s.id) return;
const list = (stagesByProject[projectId] || []).slice()
.sort(function (a, b) { return a.sort_order - b.sort_order; });
const ids = list.map(function (x) { return x.id; });
const from = ids.indexOf(draggedId), to = ids.indexOf(s.id);
if (from < 0 || to < 0) return;
ids.splice(from, 1);
ids.splice(to, 0, draggedId);
try {
const res = await api("PUT", "/project/api/projects/" + projectId + "/stages/order",
{ ordered_ids: ids });
stages = res.stages || [];
stagesByProject[projectId] = stages;
renderBoard();
} catch (err) { alert("순서 변경 실패: " + err.message); }
});
}
// 보드 드롭(프로젝트 스코프) — 세션 id 로 바로 옮긴다. 이 프로젝트가 원
// 소속이 아닌(멀티호밍된) 업무는 원본을 안 건드리고 "이 프로젝트 안에서의
// 세션"만 연결(POST .../links)로 바꾼다.
// 드롭 지점(마우스 Y)이 이 컬럼의 카드들 중 어디에 해당하는지 인덱스로.
// 드래그 중인 카드 자신은 계산에서 제외(자기 위치가 기준을 흔들지 않게).
function cardDropIndex(body, clientY, excludeTaskId) {
const cards = Array.prototype.slice.call(body.querySelectorAll(".pj-card[data-task-id]"))
.filter(function (c) { return String(c.dataset.taskId) !== String(excludeTaskId); });
for (let i = 0; i < cards.length; i++) {
const r = cards[i].getBoundingClientRect();
if (clientY < r.top + r.height / 2) return i;
}
return cards.length;
}
function enableDropByStageId(body, stageId) {
body.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); body.classList.add("is-over");
});
body.addEventListener("dragleave", function () { body.classList.remove("is-over"); });
body.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault();
body.classList.remove("is-over");
const taskId = parseInt(e.dataTransfer.getData("text/plain"), 10);
const t = tasks.find(function (x) { return x.id === taskId; });
if (!t) return;
if (t.stage_id === stageId) {
if (!manualOrderAllowed()) {
showToast("필터·정렬을 쓰는 중에는 카드 순서를 바꿀 수 없습니다. (정렬: 기본, 필터 초기화 후 가능)", "error");
return;
}
// 같은 세션 안에서 카드 위치만 이동 — 세션 이동이 아니라 정렬.
const currentOrder = tasks.filter(function (x) { return x.stage_id === stageId; });
const idx = cardDropIndex(body, e.clientY, taskId);
const withoutDragged = currentOrder.filter(function (x) { return x.id !== taskId; });
withoutDragged.splice(idx, 0, t);
const orderedIds = withoutDragged.map(function (x) { return x.id; });
const beforeIds = currentOrder.map(function (x) { return x.id; });
if (beforeIds.join(",") === orderedIds.join(",")) return; // 놓은 자리가 원래 자리와 같으면 아무것도 안 함
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + stageId + "/tasks/order",
{ ordered_ids: orderedIds });
applyStageOrder(stageId, orderedIds);
renderBoard();
} catch (err) { showToast("순서 변경 실패: " + err.message, "error"); }
return;
}
try {
if (t.project_id === projectId) {
const res = await api("PUT", "/project/api/tasks/" + taskId, { stage_id: stageId });
mergeTask(res.task);
} else {
await api("POST", "/project/api/tasks/" + taskId + "/links",
{ project_id: projectId, stage_id: stageId });
t.stage_id = stageId;
t.is_linked = true;
}
renderBoard();
} catch (err) { showToast("이동 실패: " + err.message, "error"); }
});
}
// ── 보드 카드에서 바로 고치는 담당자/마감일 ──
// 업무 팝업을 열지 않고 카드 위에서 끝낸다(아사나와 같은 조작감).
// 후보는 "그 업무가 속한 프로젝트"의 멤버다 — 전체 프로젝트 보기에서는
// 카드마다 프로젝트가 달라서 필요할 때 받아와 캐시한다.
const memberCacheByProject = {};
async function membersOfProject(pid) {
if (pid === projectId) return members;
if (memberCacheByProject[pid]) return memberCacheByProject[pid];
const res = await api("GET", "/project/api/projects/" + pid + "/members");
memberCacheByProject[pid] = res.members || [];
return memberCacheByProject[pid];
}
async function applyTaskPatch(t, patch, failMsg) {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, patch);
mergeTask(res.task);
refreshActiveView();
refreshMyOpenBadge();
} catch (e) { showToast(failMsg + ": " + e.message, "error"); }
}
async function openAssigneePicker(t, x, y) {
let list;
try { list = await membersOfProject(t.project_id); }
catch (e) { showToast("멤버 조회 실패: " + e.message, "error"); return; }
showContextMenu(x, y, assigneeMenuItems(
list.map(function (m) { return m.user_email; }), t.assignee_email,
function (email) {
applyTaskPatch(t, { assignee_email: email, assignee_name: email ? idOf(email) : "" }, "담당자 변경 실패");
}
));
}
// 마감일(+시작일) — 아사나식 날짜 팝업(openDatePopover). onPick(patch) 를
// 주면 저장을 그쪽에 맡긴다(카드의 하위 업무 줄 — 그 목록만 다시 그림).
// 없으면 applyTaskPatch 로 업무에 저장.
function openDuePicker(t, anchorEl, onPick) {
const save = onPick || function (patch) { applyTaskPatch(t, patch, "마감일 변경 실패"); };
openDatePopover(anchorEl, { start: t.start_date, due: t.due_date, allowStart: true, onChange: save });
}
// ── 카드 하위 업무 펼치기(아사나처럼) — 카드의 "N ⤷ ▾" 버튼을 누르면 카드
// 아래로 하위 업무 목록이 늘어난다. 펼친 상태는 보드를 다시 그려도 유지
// (페이지에 머무는 동안). 목록은 처음 펼칠 때 받아 캐시하고, 업무 팝업이
// 닫히면(거기서 하위 업무를 고쳤을 수 있으니) 캐시를 비운다(아래 observer).
const expandedSubs = new Set();
const subsCache = {};
// 지금 끌고 있는 하위 업무 줄 { sub, from(상위 업무) } — dragover 중엔
// dataTransfer 값을 읽을 수 없어서(보안상 type 만 보임) 여기 들고 있는다.
let dragSub = null;
const subOrderSaving = new Set();
const SUB_DRAG_TYPE = "application/x-pj-subtask";
function clearSubDropMarks() {
document.querySelectorAll(".pj-sub-drop-before, .pj-sub-drop-after").forEach(function (row) {
row.classList.remove("pj-sub-drop-before", "pj-sub-drop-after");
});
}
function cardSubRowHtml(sub) {
const di = dueInfo(sub.due_date, !!sub.completed_at);
return '<div class="pj-card-sub' + (sub.completed_at ? " is-done" : "") + '" data-sub-id="' + sub.id + '">' +
'<button type="button" class="pj-card-sub-check" title="' + (sub.completed_at ? "완료 취소" : "완료로 표시") + '">' +
'<span class="material-symbols-outlined">check_circle</span></button>' +
'<span class="pj-card-sub-title">' + escapeHtml(sub.title || "") + "</span>" +
subMetaHtml(sub, "pj-card-sub-nsubs") +
// 마감일 — 있으면 날짜, 없으면 아사나처럼 점선 원 달력 아이콘(줄에 마우스를
// 올리면 보임). 둘 다 누르면 날짜 선택.
(sub.due_date
? '<span class="pj-card-sub-due ' + di.cls + '" data-tip="' + dueTip(di) + '">' + escapeHtml(di.text) + "</span>"
: '<span class="pj-card-sub-due is-empty" data-tip="마감일 추가">' + DUE_EMPTY_ICON_SVG + "</span>") +
// 담당자 — 있으면 아바타, 없으면 아사나처럼 점선 원 사람 아이콘(줄에
// 마우스를 올리면 보임). 누르면 멤버 선택, 말풍선은 data-tip(initHoverTips).
(sub.assignee_email
? '<span class="pj-card-sub-av" data-tip="' + escapeHtml(idOf(sub.assignee_email)) + '">' +
avatarHtml(sub.assignee_email, "pj-gicon-sm") + "</span>"
: '<span class="pj-card-sub-av is-empty" data-tip="이 작업 배정">' + ASSIGN_EMPTY_ICON_SVG + "</span>") +
"</div>";
}
// 담당자 미지정 아이콘(아사나 모양: 점선 원 안의 사람).
const ASSIGN_EMPTY_ICON_SVG =
'<svg viewBox="0 0 24 24" width="22" height="22" fill="none" stroke="currentColor" stroke-width="1.4" aria-hidden="true">' +
'<circle cx="12" cy="12" r="10.3" stroke-dasharray="2.6 2.2"/>' +
'<circle cx="12" cy="9.6" r="3.1"/>' +
'<path d="M6.8 17.2c1.1-2.2 3-3.3 5.2-3.3s4.1 1.1 5.2 3.3" stroke-linecap="round"/>' +
"</svg>";
// 하위 업무 담당자 선택 — 부모 업무의 프로젝트 멤버 중에서. 저장 후
// 보드 전체가 아니라 그 카드의 펼친 목록만 다시 채운다.
async function openSubAssigneePicker(t, sub, box, x, y) {
let list;
try { list = await membersOfProject(t.project_id); }
catch (e) { showToast("멤버 조회 실패: " + e.message, "error"); return; }
async function pick(email) {
try {
await api("PUT", "/project/api/tasks/" + sub.id,
{ assignee_email: email, assignee_name: email ? idOf(email) : "" });
sub.assignee_email = email;
if (box.isConnected) fillCardSubs(box, t);
} catch (e) { showToast("담당자 변경 실패: " + e.message, "error"); }
}
showContextMenu(x, y, assigneeMenuItems(
list.map(function (m) { return m.user_email; }), sub.assignee_email, pick
));
}
// 하위 업무를 받아 캐시. 카드 숫자가 옛 값이면(팝업에서 하위 업무를
// 추가·삭제) 맞춰 두고 true 를 돌려준다 — 그땐 보드를 다시 그려야 한다.
function loadCardSubs(t) {
return api("GET", "/project/api/tasks/" + t.id).then(function (res) {
// GET /api/tasks/{id} 응답은 {task: {..., subtasks: [...]}}.
const subs = (res && res.task && res.task.subtasks) || [];
subsCache[t.id] = subs;
const doneN = subs.filter(function (x) { return x.completed_at; }).length;
if (subs.length === (t.subtask_total || 0) && doneN === (t.subtask_done || 0)) return false;
t.subtask_total = subs.length;
t.subtask_done = doneN;
if (!subs.length && !canManage) expandedSubs.delete(t.id);
return true;
});
}
function fillCardSubs(box, t) {
const subs = subsCache[t.id];
if (!subs) {
box.innerHTML = '<div class="pj-card-sub-empty">불러오는 중…</div>';
loadCardSubs(t).then(function (changed) {
if (changed) renderBoard();
else if (box.isConnected) fillCardSubs(box, t);
}).catch(function (e) {
box.innerHTML = '<div class="pj-card-sub-empty">불러오기 실패: ' + escapeHtml(e.message) + "</div>";
});
return;
}
box.innerHTML = subs.length
? subs.map(cardSubRowHtml).join("")
: (canManage ? "" : '<div class="pj-card-sub-empty">하위 작업 없음</div>');
if (canManage) {
function dropPosition(e) {
let row = e.target.closest(".pj-card-sub");
if (!row || !box.contains(row)) {
const rows = box.querySelectorAll(".pj-card-sub");
row = rows[rows.length - 1];
}
if (!row) return null;
const rect = row.getBoundingClientRect();
return { row: row, id: Number(row.dataset.subId), after: e.clientY >= rect.top + rect.height / 2 };
}
box.ondragover = function (e) {
if (!dragSub || dragSub.from.id !== t.id || !e.dataTransfer.types.includes(SUB_DRAG_TYPE)) return;
e.preventDefault(); e.stopPropagation();
e.dataTransfer.dropEffect = "move";
clearSubDropMarks();
const pos = dropPosition(e);
if (pos && pos.id !== dragSub.sub.id && !subOrderSaving.has(t.id)) {
pos.row.classList.add(pos.after ? "pj-sub-drop-after" : "pj-sub-drop-before");
}
};
box.ondragleave = function (e) { if (!box.contains(e.relatedTarget)) clearSubDropMarks(); };
box.ondrop = async function (e) {
if (!dragSub || dragSub.from.id !== t.id || !e.dataTransfer.types.includes(SUB_DRAG_TYPE)) return;
e.preventDefault(); e.stopPropagation();
const movingId = dragSub.sub.id, pos = dropPosition(e);
dragSub = null;
clearSubDropMarks();
box.querySelectorAll(".is-dragging").forEach(function (row) { row.classList.remove("is-dragging"); });
if (!pos || pos.id === movingId || subOrderSaving.has(t.id)) return;
const ordered = subs.filter(function (sub) { return sub.id !== movingId; });
const moving = subs.find(function (sub) { return sub.id === movingId; });
const index = ordered.findIndex(function (sub) { return sub.id === pos.id; });
if (!moving || index < 0) return;
ordered.splice(index + (pos.after ? 1 : 0), 0, moving);
const ids = ordered.map(function (sub) { return sub.id; });
if (ids.join(",") === subs.map(function (sub) { return sub.id; }).join(",")) return;
subOrderSaving.add(t.id);
try {
await api("PUT", "/project/api/tasks/" + t.id + "/subtasks/order", { ordered_ids: ids });
if (subsCache[t.id] === subs) {
subsCache[t.id] = ordered;
renderBoard();
}
} catch (err) { showToast("하위 작업 순서 변경 실패: " + err.message, "error"); }
finally { subOrderSaving.delete(t.id); }
};
}
box.querySelectorAll(".pj-card-sub").forEach(function (row) {
const sub = subs.find(function (x) { return String(x.id) === row.dataset.subId; });
if (!sub) return;
// 드래그 — 같은 카드에서 순서를 바꾸거나 다른 상위 업무로 옮긴다. 카드 자체도
// draggable 이라 이벤트가 카드로 올라가면 카드 이동이 시작되므로 막는다.
if (canManage) {
row.draggable = true;
row.addEventListener("dragstart", function (e) {
e.stopPropagation();
if (subOrderSaving.has(t.id)) { e.preventDefault(); return; }
dragSub = { sub: sub, from: t };
e.dataTransfer.setData(SUB_DRAG_TYPE, String(sub.id));
e.dataTransfer.effectAllowed = "move";
row.classList.add("is-dragging");
});
row.addEventListener("dragend", function (e) {
e.stopPropagation();
row.classList.remove("is-dragging");
dragSub = null;
clearSubDropMarks();
document.querySelectorAll(".pj-card.is-sub-drop").forEach(function (c) { c.classList.remove("is-sub-drop"); });
});
}
// 우클릭 — 하위 업무 메뉴(아사나처럼): 열기 / 완료 / 삭제.
if (canManage) row.addEventListener("contextmenu", function (e) {
e.preventDefault();
e.stopPropagation();
showContextMenu(e.clientX, e.clientY, [
{ label: "열기", onClick: function () { openTaskById(sub.id); } },
{ label: "상위 작업 열기", onClick: function () { openTaskModal(t); } },
{
label: sub.completed_at ? "완료 취소" : "완료로 표시",
onClick: function () { row.querySelector(".pj-card-sub-check").click(); },
},
null,
{
label: "하위 작업 삭제", danger: true,
onClick: async function () {
if (!canDelete(sub.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(sub.id, sub.title, null))) return;
try {
await deleteTaskRequest(sub.id);
const i = subs.indexOf(sub);
if (i >= 0) subs.splice(i, 1);
t.subtask_total = Math.max(0, (t.subtask_total || 0) - 1);
if (sub.completed_at) t.subtask_done = Math.max(0, (t.subtask_done || 0) - 1);
if (!t.subtask_total) expandedSubs.delete(t.id);
renderBoard();
} catch (err) { showToast("삭제 실패: " + err.message, "error"); }
},
},
]);
});
const due = row.querySelector(".pj-card-sub-due");
if (due && canManage) due.addEventListener("click", function (e) {
e.stopPropagation();
openDuePicker(sub, due, async function (patch) {
try {
await api("PUT", "/project/api/tasks/" + sub.id, patch);
Object.assign(sub, patch);
if (box.isConnected) fillCardSubs(box, t);
} catch (err) { showToast("마감일 변경 실패: " + err.message, "error"); }
});
});
const av = row.querySelector(".pj-card-sub-av");
if (av && canManage) av.addEventListener("click", function (e) {
e.stopPropagation();
const r = av.getBoundingClientRect();
openSubAssigneePicker(t, sub, box, r.left, r.bottom + 4);
});
const check = row.querySelector(".pj-card-sub-check");
check.addEventListener("click", async function (e) {
e.stopPropagation();
if (!canManage) return;
const done = !sub.completed_at;
try {
const res = await api("PUT", "/project/api/tasks/" + sub.id, { completed: done });
sub.completed_at = (res && res.task && res.task.completed_at) || (done ? todayNowP() : null);
t.subtask_done = Math.max(0, (t.subtask_done || 0) + (done ? 1 : -1));
renderBoard();
} catch (err) { showToast("변경 실패: " + err.message, "error"); }
});
});
renderSubAdd(box, t);
}
// ── 카드 하위 작업 목록 맨 아래 "+ 하위 작업 추가"(아사나) — 누르면 그 자리에
// 새 줄(✓ · 작업 이름 입력 · 마감일 · 담당자)이 열리고 Enter 로 바로 만든다.
// 만든 뒤에도 줄은 열린 채로 다음 하위 작업을 이어서 입력(아사나와 같음).
// 이름을 쓴 채 다른 곳을 누르면 Enter 처럼 만들고 줄을 닫는다. Esc 또는 빈 채로 다른 곳을
// 누르면 그냥 닫힌다. 보드는 8초마다 다시 그려지므로
// 입력 중인 값·포커스는 subDrafts 에 두고 다시 그릴 때 되살린다.
const subDrafts = {};
const subOutsideDown = {}; // 카드별 "바깥 누름" 리스너 — 다시 그릴 때 이전 것을 뗀다
function renderSubAdd(box, t) {
if (!canManage) return;
const draft = subDrafts[t.id];
const wrap = document.createElement("div");
wrap.className = "pj-card-subadd-wrap";
if (draft) {
wrap.innerHTML =
'<div class="pj-card-subnew">' +
'<span class="pj-card-sub-check is-ghost"><span class="material-symbols-outlined">check_circle</span></span>' +
'<input type="text" class="pj-card-subnew-title" placeholder="작업 이름 입력" autocomplete="off" />' +
'<span class="pj-card-sub-due pj-card-subnew-due"></span>' +
'<span class="pj-card-sub-av pj-card-subnew-av"></span>' +
"</div>";
}
wrap.insertAdjacentHTML("beforeend",
'<button type="button" class="pj-card-subadd">' +
'<span class="material-symbols-outlined">add</span>하위 작업 추가</button>');
box.appendChild(wrap);
const card = box.closest(".pj-card");
// 카드 클릭(작업 팝업 열기)·카드 드래그가 이 영역에서는 안 일어나게.
wrap.addEventListener("click", function (e) { e.stopPropagation(); });
wrap.addEventListener("mousedown", function () { if (card) card.draggable = false; });
wrap.querySelector(".pj-card-subadd").addEventListener("click", function () {
if (!subDrafts[t.id]) subDrafts[t.id] = { title: "", due: null, assignee: "", focused: true };
else subDrafts[t.id].focused = true;
refillSubs(box, t);
});
if (!draft) return;
const inp = wrap.querySelector(".pj-card-subnew-title");
const dueEl = wrap.querySelector(".pj-card-subnew-due");
const avEl = wrap.querySelector(".pj-card-subnew-av");
inp.value = draft.title;
function paintDue() {
const di = dueInfo(draft.due, false);
dueEl.className = "pj-card-sub-due pj-card-subnew-due" + (di ? " " + di.cls : " is-empty");
dueEl.innerHTML = di ? escapeHtml(di.text) : DUE_EMPTY_ICON_SVG;
dueEl.dataset.tip = di ? dueTip(di) : "마감일 지정";
}
function paintAv() {
avEl.className = "pj-card-sub-av pj-card-subnew-av" + (draft.assignee ? "" : " is-empty");
avEl.innerHTML = draft.assignee ? avatarHtml(draft.assignee, "pj-gicon-sm") : ASSIGN_EMPTY_ICON_SVG;
avEl.dataset.tip = draft.assignee ? idOf(draft.assignee) : "담당자 지정";
}
paintDue(); paintAv();
function refocus() { if (inp.isConnected) inp.focus(); }
inp.addEventListener("input", function () { draft.title = inp.value; });
inp.addEventListener("focus", function () { draft.focused = true; if (card) card.draggable = false; });
inp.addEventListener("blur", function () {
if (card) card.draggable = canManage;
// 다시 그리느라 없어진 칸이면 무시(되살릴 때 포커스를 돌려준다).
setTimeout(function () {
if (!inp.isConnected) return;
draft.focused = document.activeElement === inp;
// 날짜 팝업·담당자 메뉴를 쓰는 중이면 닫지 않는다.
if (draft.focused || datePopEl || ctxMenuEl) return;
if (!draft.title.trim() && !draft.due && !draft.assignee) closeDraft();
}, 150);
});
inp.addEventListener("keydown", function (e) {
if (e.isComposing) return;
if (e.key === "Enter") { e.preventDefault(); createFromDraft(); }
else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); closeDraft(); }
});
dueEl.addEventListener("click", function () {
openDatePopover(dueEl, {
due: draft.due, allowStart: false,
// 날짜를 고르면 팝업이 닫히므로 이어서 이름을 칠 수 있게 입력칸으로 돌아간다.
onChange: function (patch) { draft.due = patch.due_date || null; paintDue(); refocus(); },
});
});
// 바깥을 누르면 Enter 와 같다 — 이름이 있으면 만들고 줄을 닫는다(아사나). 이름이 없으면
// 예전처럼 마감일·담당자도 비었을 때만 닫는다. 이 줄·날짜 팝업·담당자 메뉴 안은 제외.
// 한글 조합 중인 마지막 글자는 blur 뒤에 확정되므로 한 박자 뒤에 입력칸 값을 읽는다.
// 보드가 다시 그려져 이 줄이 없어졌으면 다음 누름 때 스스로 떼어 낸다.
function onOutsideDown(e) {
if (!wrap.isConnected || subDrafts[t.id] !== draft) {
document.removeEventListener("pointerdown", onOutsideDown, true);
return;
}
const tg = e.target;
if (wrap.contains(tg) || (datePopEl && datePopEl.contains(tg)) || (ctxMenuEl && ctxMenuEl.contains(tg))) return;
document.removeEventListener("pointerdown", onOutsideDown, true);
setTimeout(function () {
if (subDrafts[t.id] !== draft) return;
if (inp.isConnected) draft.title = inp.value;
if (draft.title.trim()) createFromDraft(false);
else if (!draft.due && !draft.assignee) closeDraft();
}, 0);
}
if (subOutsideDown[t.id]) document.removeEventListener("pointerdown", subOutsideDown[t.id], true);
subOutsideDown[t.id] = onOutsideDown;
document.addEventListener("pointerdown", onOutsideDown, true);
avEl.addEventListener("click", async function () {
let list;
try { list = await membersOfProject(t.project_id); }
catch (e) { showToast("멤버 조회 실패: " + e.message, "error"); return; }
const r = avEl.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, assigneeMenuItems(
list.map(function (m) { return m.user_email; }), draft.assignee,
function (email) { draft.assignee = email || ""; paintAv(); refocus(); }
));
});
function closeDraft() {
delete subDrafts[t.id];
if (box.isConnected) refillSubs(box, t);
}
let saving = false;
// keepOpen(기본 true, Enter) — 만든 뒤 줄을 열어 둔 채 다음 입력. false(바깥 누름) — 닫는다.
async function createFromDraft(keepOpen) {
const title = draft.title.trim();
if (!title || saving) return;
saving = true;
try {
const res = await api("POST", "/project/api/projects/" + t.project_id + "/tasks", {
title: title, parent_task_id: t.id,
due_date: draft.due || null,
assignee_email: draft.assignee || "",
assignee_name: draft.assignee ? idOf(draft.assignee) : "",
});
const subs = subsCache[t.id] || (subsCache[t.id] = []);
subs.push(res.task);
adjustSubCounts(t.id, 1, 0);
// Enter — 다음 하위 작업을 이어서 입력(아사나): 이름만 비우고 줄은 열어 둔다.
// 바깥 누름 — 줄을 닫는다.
if (keepOpen === false) delete subDrafts[t.id];
else subDrafts[t.id] = { title: "", due: null, assignee: "", focused: true };
renderBoard(); // 카드의 "N ⤷" 숫자까지 맞춘다
} catch (e) {
showToast("하위 작업 추가 실패: " + e.message, "error");
} finally { saving = false; }
}
// 포커스 되살리기 — 보드를 다시 그릴 땐 카드가 아직 화면에 붙기 전이라
// 바로 focus() 하면 무시된다. 그리기가 끝난 뒤로 미룬다.
if (draft.focused) setTimeout(function () {
if (!inp.isConnected || subDrafts[t.id] !== draft) return;
inp.focus();
const n = inp.value.length;
try { inp.setSelectionRange(n, n); } catch (_) {}
}, 0);
}
// 하위 작업 목록만 다시 그린다(펼침 높이 애니메이션 없이 그 카드 안에서만).
function refillSubs(box, t) { fillCardSubs(box, t); }
// 하위 업무 한 줄을 다른 상위 업무(카드)로 옮긴다 — 보드에서 드래그해 놓았을 때.
// 같은 업무가 여러 프로젝트 맥락 행으로 tasks 에 들어 있을 수 있어(멀티호밍)
// 개수는 같은 id 의 행 모두에서 맞춘다.
function adjustSubCounts(taskId, dTotal, dDone) {
tasks.forEach(function (x) {
if (x.id !== taskId) return;
x.subtask_total = Math.max(0, (x.subtask_total || 0) + dTotal);
x.subtask_done = Math.max(0, (x.subtask_done || 0) + dDone);
});
}
async function moveSubtaskTo(sub, from, to) {
if (sub.project_id && to.project_id && sub.project_id !== to.project_id) {
showToast("다른 프로젝트의 작업으로는 옮길 수 없습니다.", "error");
return;
}
try {
const res = await api("POST", "/project/api/tasks/" + sub.id + "/move-parent",
{ parent_task_id: to.id });
const moved = (res && res.task) || Object.assign({}, sub, { parent_task_id: to.id });
const done = sub.completed_at ? 1 : 0;
const fromSubs = subsCache[from.id];
if (fromSubs) {
const i = fromSubs.indexOf(sub);
if (i >= 0) fromSubs.splice(i, 1);
}
if (subsCache[to.id]) subsCache[to.id].push(moved);
adjustSubCounts(from.id, -1, -done);
adjustSubCounts(to.id, 1, done);
if (!from.subtask_total) expandedSubs.delete(from.id);
renderBoard();
showToast("'" + (sub.title || "") + "' → '" + (to.title || "") + "' 로 옮겼습니다.");
} catch (err) { showToast("이동 실패: " + err.message, "error"); }
}
// 카드 하위 업무 펼치기/접기 — 보드를 다시 그리지 않고 그 카드 안에서만
// 높이를 애니메이션한다(아사나처럼 카드가 아래로 스르륵 늘어남).
// 펼칠 땐 목록을 먼저 받아 채운 뒤 펼친다 — "불러오는 중…"에서 목록으로
// 바뀌며 높이가 한 번 더 튀지 않게.
function toggleCardSubs(card, t, tog) {
let wrap = card.querySelector(".pj-card-subs-wrap");
if (expandedSubs.has(t.id)) {
expandedSubs.delete(t.id);
tog.classList.remove("is-open");
if (wrap) {
wrap.classList.remove("is-open");
wrap.addEventListener("transitionend", function (ev) {
if (ev.propertyName === "grid-template-rows" && !expandedSubs.has(t.id)) wrap.remove();
});
}
return;
}
expandedSubs.add(t.id);
tog.classList.add("is-open");
// 하위 작업이 없는 카드 — 펼치면 곧바로 이름 입력 줄(아사나의 "하위 작업 추가")
if (!t.subtask_total && canManage && !subDrafts[t.id]) {
subDrafts[t.id] = { title: "", due: null, assignee: "", focused: true };
}
loadCardSubs(t).then(function (changed) { // 펼칠 때마다 최신으로
if (changed) { renderBoard(); return; }
if (!expandedSubs.has(t.id) || !card.isConnected) return;
wrap = card.querySelector(".pj-card-subs-wrap");
if (!wrap) {
wrap = document.createElement("div");
wrap.className = "pj-card-subs-wrap";
wrap.innerHTML = '<div class="pj-card-subs"></div>';
card.appendChild(wrap);
}
fillCardSubs(wrap.querySelector(".pj-card-subs"), t);
void wrap.offsetHeight; // 닫힌 상태(0fr)를 한 번 그린 뒤 여는 클래스를 붙여야 전환이 걸린다
wrap.classList.add("is-open");
}).catch(function (err) {
expandedSubs.delete(t.id);
tog.classList.remove("is-open");
showToast("하위 작업을 불러오지 못했습니다: " + err.message, "error");
});
}
const cardCompletionSaving = new Set();
function taskCard(t) {
const card = document.createElement("div");
card.className = "pj-card" + (t.completed_at ? " is-done" : "");
card.draggable = canManage;
card.dataset.taskId = t.id;
// 전체보기는 항상 원 프로젝트 배지를 보여준다. 프로젝트 스코프에서는
// "이 프로젝트가 원 소속"인 카드는 굳이 표시하지 않고, 멀티호밍으로
// 들어온(다른 프로젝트가 원 소속인) 카드만 아사나처럼 배지를 붙인다.
const showProjTag = viewScope === "all" || t.project_id !== projectId;
// 카드 윗부분(배지·제목·담당자/마감일/하위 작업 줄)은 .pj-card-head 로 묶는다 —
// 하위 작업을 펼쳐 컬럼을 스크롤하면 이 부분이 컬럼 맨 위에 고정된다(CSS sticky).
// 설명에 이미지가 있으면 첫 이미지를 카드 위에(아사나 카드 표지)
const cover = cardCoverSrc(t.description);
card.classList.toggle("has-cover", !!cover);
card.innerHTML =
(cover ? '<div class="pj-card-cover"><img src="' + escapeHtml(cover) + '" alt="" loading="lazy" draggable="false"></div>' : "") +
'<div class="pj-card-head">' +
(showProjTag && t.project_name
? '<div class="pj-card-proj" style="color:' + (t.project_color || "#4573d2") + '">● ' + escapeHtml(t.project_name) + "</div>"
: "") +
'<div class="pj-card-title-row"><button type="button" class="pj-card-check" role="checkbox" aria-checked="' + (!!t.completed_at) +
'" aria-label="' + escapeHtml((t.completed_at ? "완료 취소: " : "완료로 표시: ") + t.title) +
'" title="' + (t.completed_at ? "완료 취소" : "완료로 표시") + '"' +
(!(canManage && taskAccessLevel(t) === "full") || cardCompletionSaving.has(t.id) ? " disabled" : "") +
(cardCompletionSaving.has(t.id) ? ' aria-busy="true"' : "") +
'><span class="material-symbols-outlined" aria-hidden="true">check_circle</span></button>' +
'<div class="pj-card-title">' + escapeHtml(t.title) + "</div></div>" +
'<div class="pj-card-meta">' +
(t.priority && t.priority !== "normal"
? '<span class="pj-pri pj-pri-' + t.priority + '">' + (priorityLabels[t.priority] || t.priority) + "</span>"
: "") +
// 담당자/마감일은 카드에서 바로 바꿀 수 있다(아래 클릭 핸들러).
// 값이 없어도 자리는 남겨 둔다 — 카드에 마우스를 올리면 흐리게
// 나타나서 눌러 지정할 수 있다(.is-empty).
// 담당자 없음 — 글자 없이 하위 업무 줄과 같은 점선 원 사람 아이콘만.
(t.assignee_email
? '<span class="pj-assignee pj-card-edit-hit pj-card-assignee" title="담당자 변경">' +
avatarHtml(t.assignee_email, "pj-gicon-sm") + escapeHtml(idOf(t.assignee_email)) + "</span>"
: '<span class="pj-assignee pj-card-edit-hit pj-card-assignee is-empty" title="담당자 지정">' +
ASSIGN_EMPTY_ICON_SVG + "</span>") +
(function () {
const di = dueInfo(t.due_date, !!t.completed_at);
return '<span class="pj-card-due pj-card-edit-hit' + (di ? " " + di.cls : " is-empty") +
'" title="' + (t.due_date ? dueTip(di) : "마감일 추가") + '">' +
// 마감일 없음 — 하위 업무 줄과 같은 점선 원 달력 아이콘만(카드에 마우스를 올리면 보임).
(di ? escapeHtml(di.text) : DUE_EMPTY_ICON_SVG) + "</span>";
})() +
// 하위 업무 — 아사나처럼 "개수 + 하위 업무 아이콘 + ▾", 누르면 카드 아래로 펼침.
(t.subtask_total
? '<button type="button" class="pj-card-subtoggle' + (expandedSubs.has(t.id) ? " is-open" : "") +
'" title="하위 작업 ' + t.subtask_total + "개 (완료 " + (t.subtask_done || 0) + ')">' +
'<span class="pj-card-subtoggle-n">' + t.subtask_total + "</span>" +
SUBTASK_ICON_SVG +
'<span class="material-symbols-outlined pj-card-subtoggle-caret">arrow_drop_down</span>' +
"</button>"
// 하위 작업이 없을 때 — 같은 모양의 빈 버튼(카드에 마우스를 올리면 보임, 담당자·마감일 빈 칸처럼).
// 누르면 카드 아래가 펼쳐지며 새 하위 작업 이름 입력 줄이 열린다.
: canManage
? '<button type="button" class="pj-card-subtoggle is-empty' + (expandedSubs.has(t.id) ? " is-open" : "") +
'" title="하위 작업 추가">' + SUBTASK_ICON_SVG +
'<span class="material-symbols-outlined pj-card-subtoggle-caret">arrow_drop_down</span>' +
"</button>"
: "") +
(t.comment_count
? '<span class="pj-card-cmt pj-cmt-badge" data-task-id="' + t.id + '" data-count="' + t.comment_count +
'" title="댓글 ' + t.comment_count + '개">' + cmtBadgeInner(t) + "</span>"
: "") +
// 설명이 있으면 줄글 아이콘(하위 작업 줄과 같은 모양) — 누르면 카드처럼 작업 창.
(hasDescription(t.description)
? '<span class="pj-card-desc" title="설명 있음">' + DESC_ICON_SVG + "</span>"
: "") +
"</div>" +
"</div>" +
// 펼침 영역 — 바깥(.pj-card-subs-wrap)이 grid 0fr↔1fr 로 높이를
// 부드럽게 늘이고 줄인다(toggleCardSubs). 다시 그릴 땐 펼친 채로.
((t.subtask_total || canManage) && expandedSubs.has(t.id)
? '<div class="pj-card-subs-wrap is-open"><div class="pj-card-subs"></div></div>'
: "");
const subsBox = card.querySelector(".pj-card-subs");
if (subsBox) fillCardSubs(subsBox, t);
const check = card.querySelector(".pj-card-check");
check.addEventListener("click", async function (e) {
e.stopPropagation();
if (!canManage || taskAccessLevel(t) !== "full" || cardCompletionSaving.has(t.id)) return;
cardCompletionSaving.add(t.id); check.disabled = true; check.setAttribute("aria-busy", "true");
let updated = false;
const hadFocus = document.activeElement === check;
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, { completed: !t.completed_at });
mergeTask(res.task); updated = true;
} catch (err) { showToast("완료 상태 변경 실패: " + err.message, "error"); }
finally {
cardCompletionSaving.delete(t.id);
const restoreFocus = hadFocus && (document.activeElement === check || document.activeElement === document.body);
refreshActiveView();
if (restoreFocus) {
const liveCheck = document.querySelector('.pj-card[data-task-id="' + t.id + '"] .pj-card-check');
if (liveCheck) liveCheck.focus();
}
}
if (updated) refreshMyOpenBadge();
});
card.addEventListener("click", function (e) {
// 하위 업무 펼치기/접기 — 보기 권한만 있어도 된다.
const tog = e.target.closest(".pj-card-subtoggle");
if (tog) {
e.stopPropagation();
toggleCardSubs(card, t, tog);
return;
}
if (e.target.closest(".pj-card-sub-check")) return;
if (!canManage) return;
// 하위 업무 줄을 누르면 상위 업무가 아니라 그 하위 업무 팝업(아사나식).
const subRow = e.target.closest(".pj-card-sub");
if (subRow) { e.stopPropagation(); openTaskById(parseInt(subRow.dataset.subId, 10)); return; }
// 담당자/마감일 칩을 누른 경우엔 업무 팝업 대신 그 자리 편집기를 연다.
const hitAssignee = e.target.closest(".pj-card-assignee");
if (hitAssignee) { e.stopPropagation(); openAssigneePicker(t, e.clientX, e.clientY); return; }
const hitDue = e.target.closest(".pj-card-due");
if (hitDue) { e.stopPropagation(); openDuePicker(t, hitDue); return; }
openTaskModal(t);
});
// 댓글 말풍선 한 번 클릭 → 채팅형 댓글 팝업(공용 구현, 안 읽음 표시만 여기서 연결).
if (cmt) cmt.wireBadge(card.querySelector(".pj-cmt-badge"));
if (canManage) {
card.addEventListener("dragstart", function (e) {
e.dataTransfer.setData("text/plain", String(t.id));
card.classList.add("is-dragging");
});
card.addEventListener("dragend", function () { card.classList.remove("is-dragging"); });
// 하위 업무 줄을 이 카드에 놓으면 이 업무의 하위 업무로 옮긴다.
// 원래 상위 업무 카드 위에서는 받지 않는다(제자리).
card.addEventListener("dragover", function (e) {
if (!dragSub || !e.dataTransfer.types.includes(SUB_DRAG_TYPE)) return;
if (dragSub.from.id === t.id) return;
e.preventDefault();
e.stopPropagation();
e.dataTransfer.dropEffect = "move";
card.classList.add("is-sub-drop");
});
card.addEventListener("dragleave", function (e) {
if (!card.contains(e.relatedTarget)) card.classList.remove("is-sub-drop");
});
card.addEventListener("drop", function (e) {
if (!dragSub || !e.dataTransfer.types.includes(SUB_DRAG_TYPE)) return;
e.preventDefault();
e.stopPropagation();
card.classList.remove("is-sub-drop");
const moving = dragSub;
dragSub = null;
if (moving.from.id !== t.id) moveSubtaskTo(moving.sub, moving.from, t);
});
card.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, taskContextItems(t));
});
}
return card;
}
// ── 리스트 (정렬·컬럼 너비 조절) ──
// "전체 프로젝트" 스코프 — 세션이 프로젝트마다 달라 그룹화 의미가 없으므로
// 예전처럼 프로젝트·세션을 컬럼으로 둔 평범한 정렬 테이블.
const LIST_COLS_ALL = [
{ key: "project", label: "프로젝트", text: function (t) { return t.project_name || "-"; }, sort: function (t) { return (t.project_name || "").toLowerCase(); } },
{ key: "title", label: "작업", text: function (t) { return t.title; }, sort: function (t) { return (t.title || "").toLowerCase(); } },
{ key: "assignee", label: "담당자", text: function (t) { return t.assignee_email ? idOf(t.assignee_email) : "-"; }, sort: function (t) { return idOf(t.assignee_email || ""); } },
{ key: "stage", label: "섹션", text: function (t) { return t.stage_name || "-"; }, sort: function (t) { return t.stage_name || ""; } },
{ key: "priority", label: "우선순위", text: function (t) { return priorityLabels[t.priority] || t.priority || "-"; }, sort: function (t) { return ({ low: 0, normal: 1, high: 2 })[t.priority]; } },
{ key: "start", label: "시작", text: function (t) { return t.start_date || "-"; }, sort: function (t) { return t.start_date || ""; } },
{ key: "due", label: "마감", text: function (t) { const di = dueInfo(t.due_date, !!t.completed_at); return di ? di.text : "-"; }, sort: function (t) { return t.due_date || ""; } },
];
// "이 프로젝트" 스코프 — 아사나 리스트 뷰처럼 세션이 컬럼이 아니라 그룹
// 구분선이 된다(renderListGrouped). 그래서 세션 컬럼은 뺀다.
const LIST_COLS_PROJECT = LIST_COLS_ALL.filter(function (c) { return c.key !== "project" && c.key !== "stage"; });
function listCols() { return viewScope === "project" ? LIST_COLS_PROJECT : LIST_COLS_ALL; }
let listSort = { key: null, dir: 1 };
function listWidths() { try { return JSON.parse(localStorage.getItem("pj_list_widths") || "{}"); } catch (_) { return {}; } }
function saveListWidth(key, w) { const m = listWidths(); m[key] = w; try { localStorage.setItem("pj_list_widths", JSON.stringify(m)); } catch (_) {} }
function enableColResize(th, key) {
const handle = th.querySelector(".pj-th-resize");
if (!handle) return;
handle.addEventListener("mousedown", function (e) {
e.preventDefault(); e.stopPropagation();
const startX = e.clientX, startW = th.offsetWidth;
function mv(ev) { th.style.width = Math.max(60, startW + (ev.clientX - startX)) + "px"; }
function up() { document.removeEventListener("mousemove", mv); document.removeEventListener("mouseup", up); saveListWidth(key, th.offsetWidth); }
document.addEventListener("mousemove", mv);
document.addEventListener("mouseup", up);
});
}
function sortRows(rows, cols) {
if (!listSort.key) return rows;
const col = cols.find(function (c) { return c.key === listSort.key; });
if (!col) return rows;
rows.sort(function (a, b) {
let va = col.sort(a), vb = col.sort(b);
if (va == null) va = -Infinity;
if (vb == null) vb = -Infinity;
if (va < vb) return -listSort.dir;
if (va > vb) return listSort.dir;
return 0;
});
return rows;
}
function renderListHead(table, cols) {
const widths = listWidths();
const trh = document.createElement("tr");
cols.forEach(function (col) {
const th = document.createElement("th");
th.dataset.key = col.key;
if (widths[col.key]) th.style.width = widths[col.key] + "px";
const arrow = listSort.key === col.key ? (listSort.dir > 0 ? "▲" : "▼") : "↕";
th.innerHTML =
'<span class="pj-th-label">' + escapeHtml(col.label) +
' <span class="pj-th-sort">' + arrow + "</span></span>" +
'<span class="pj-th-resize"></span>';
th.querySelector(".pj-th-label").addEventListener("click", function () {
if (listSort.key === col.key) listSort.dir = -listSort.dir;
else { listSort.key = col.key; listSort.dir = 1; }
renderList();
});
enableColResize(th, col.key);
trh.appendChild(th);
});
const thead = table.querySelector("thead");
thead.innerHTML = "";
thead.appendChild(trh);
}
function taskRow(t, cols) {
const tr = document.createElement("tr");
if (t.completed_at) tr.className = "is-done";
// 행 배경 = 프로젝트 색 연하게(10%) — 다른 프로젝트에서 온(멀티호밍) 업무를
// 구분하기 위함. 이 프로젝트 고유 업무는 색이 다 같아 사실상 안 보인다.
const pc = t.project_color || "#4573d2";
tr.style.background = pc + "14";
tr.innerHTML = cols.map(function (c) {
let inner = escapeHtml(String(c.text(t)));
if (c.key === "title") inner += cmtBadge(t);
if (c.key === "due" && t.due_date) {
const di = dueInfo(t.due_date, !!t.completed_at);
inner = '<span class="pj-due-label ' + di.cls + '" title="' + t.due_date + '">' + escapeHtml(di.text) + "</span>";
}
if (c.key === "assignee" && t.assignee_email) {
inner = '<span class="pj-assignee">' + avatarHtml(t.assignee_email, "pj-gicon-sm") + escapeHtml(idOf(t.assignee_email)) + "</span>";
}
return "<td>" + inner + "</td>";
}).join("");
if (canManage) {
tr.style.cursor = "pointer";
tr.addEventListener("click", function () { openTaskModal(t); });
tr.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, taskContextItems(t));
});
}
return tr;
}
function listCollapsedSet() {
try { return new Set(JSON.parse(localStorage.getItem("pj_list_collapsed") || "[]")); }
catch (_) { return new Set(); }
}
function toggleListCollapsed(key) {
const s = listCollapsedSet();
if (s.has(key)) s.delete(key); else s.add(key);
try { localStorage.setItem("pj_list_collapsed", JSON.stringify(Array.from(s))); } catch (_) {}
}
function renderList() {
const table = el("pj-list");
table.classList.add("pj-table-fixed");
const cols = listCols();
renderListHead(table, cols);
const tbody = table.querySelector("tbody");
tbody.innerHTML = "";
if (viewScope !== "project") {
sortRows(visibleTasks(), cols).forEach(function (t) { tbody.appendChild(taskRow(t, cols)); });
return;
}
// ── 아사나 리스트 뷰처럼 세션을 그룹 구분선으로 ──
renderListGrouped(tbody, cols);
}
function renderListGrouped(tbody, cols) {
const vis = visibleTasks();
const sessions = (stagesByProject[projectId] || []).slice()
.sort(function (a, b) { return a.sort_order - b.sort_order; });
const collapsed = listCollapsedSet();
const colSpan = cols.length;
function addGroup(key, name, groupTasks) {
const head = document.createElement("tr");
head.className = "pj-list-group-row";
const isCollapsed = collapsed.has(key);
const td = document.createElement("td");
td.colSpan = colSpan;
td.className = "pj-list-group-head";
td.innerHTML =
'<span class="pj-list-group-caret material-symbols-outlined">' +
(isCollapsed ? "chevron_right" : "expand_more") + "</span>" +
'<span class="pj-list-group-name">' + escapeHtml(name) + "</span>" +
'<span class="pj-list-group-count">' + groupTasks.length + "</span>";
td.addEventListener("click", function () { toggleListCollapsed(key); renderList(); });
head.appendChild(td);
tbody.appendChild(head);
if (!isCollapsed) sortRows(groupTasks.slice(), cols).forEach(function (t) { tbody.appendChild(taskRow(t, cols)); });
}
sessions.forEach(function (s) {
addGroup("s" + s.id, s.name, vis.filter(function (t) { return t.stage_id === s.id; }));
});
const unstaged = vis.filter(function (t) { return !t.stage_id; });
if (unstaged.length) addGroup("none", "미지정", unstaged);
if (!sessions.length && !unstaged.length) {
const tr = document.createElement("tr");
const td = document.createElement("td");
td.colSpan = colSpan;
td.className = "pj-empty-sm";
td.textContent = "섹션이 없습니다.";
tr.appendChild(td);
tbody.appendChild(tr);
}
}
// ════════════════════════════════════════════════════════════
// 대시보드 — 통계 카드 + 차트 3종. 전부 이미 로드된 tasks(visibleTasks())
// 로 클라이언트에서 즉시 집계 — 서버 재조회 없음. 스코프 토글(이
// 프로젝트/전체 프로젝트)도 다른 뷰와 똑같이 따른다.
// ════════════════════════════════════════════════════════════
function animateCount(el, target, duration) {
const start = 0;
const t0 = performance.now();
function step(now) {
const p = Math.min(1, (now - t0) / duration);
const eased = 1 - Math.pow(1 - p, 3); // ease-out cubic
el.textContent = Math.round(start + (target - start) * eased);
if (p < 1) requestAnimationFrame(step);
else el.textContent = String(target);
}
requestAnimationFrame(step);
}
function dashStatTile(label, value) {
const tile = document.createElement("div");
tile.className = "pj-dash-stat";
tile.innerHTML =
'<div class="pj-dash-stat-label"></div>' +
'<div class="pj-dash-stat-value">0</div>';
tile.querySelector(".pj-dash-stat-label").textContent = label;
const valEl = tile.querySelector(".pj-dash-stat-value");
animateCount(valEl, value, 700);
return tile;
}
// 세로 막대 그래프 — 섹션별/담당자별 공용. data = [{label, value}].
function dashBarChart(data) {
const wrap = document.createElement("div");
wrap.className = "pj-dash-bars";
if (!data.length) {
wrap.innerHTML = "<div class='pj-empty-sm'>데이터가 없습니다.</div>";
return wrap;
}
const max = Math.max.apply(null, data.map(function (d) { return d.value; }).concat([1]));
const tooltip = dashTooltip();
data.forEach(function (d) {
const col = document.createElement("div");
col.className = "pj-dash-barcol";
col.tabIndex = 0;
col.innerHTML =
'<div class="pj-dash-barcol-value">' + d.value + "</div>" +
'<div class="pj-dash-barcol-track"><div class="pj-dash-barcol-fill"></div></div>' +
'<div class="pj-dash-barcol-label"></div>';
col.querySelector(".pj-dash-barcol-label").textContent = d.label;
const fill = col.querySelector(".pj-dash-barcol-fill");
const pct = Math.round((d.value / max) * 100);
requestAnimationFrame(function () {
requestAnimationFrame(function () { fill.style.height = pct + "%"; });
});
function showTip() { tooltip.show(col, d.label, d.value); }
col.addEventListener("mouseenter", showTip);
col.addEventListener("focus", showTip);
col.addEventListener("mouseleave", tooltip.hide);
col.addEventListener("blur", tooltip.hide);
wrap.appendChild(col);
});
return wrap;
}
// 우클릭 메뉴와 같은 자리에 하나만 떠 있는 공용 호버 툴팁(값 강조, 카테고리는 보조).
function dashTooltip() {
let el = null;
return {
show: function (anchor, label, value) {
if (!el) {
el = document.createElement("div");
el.className = "pj-dash-tooltip";
document.body.appendChild(el);
}
el.innerHTML = '<b></b><span></span>';
el.querySelector("b").textContent = value;
el.querySelector("span").textContent = label;
const r = anchor.getBoundingClientRect();
el.style.left = (window.scrollX + r.left + r.width / 2) + "px";
el.style.top = (window.scrollY + r.top - 8) + "px";
el.hidden = false;
},
hide: function () { if (el) el.hidden = true; },
};
}
// 도넛(완료 상태별) — SVG stroke-dasharray 로 두 구간을 그린다.
function dashDonutChart(segments) {
const total = segments.reduce(function (s, x) { return s + x.value; }, 0);
const R = 52, C = 2 * Math.PI * R;
const wrap = document.createElement("div");
wrap.className = "pj-dash-donut-wrap";
let svg = '<svg viewBox="0 0 120 120" class="pj-dash-donut">' +
'<circle class="pj-dash-donut-track" cx="60" cy="60" r="' + R + '"></circle>';
let offsetAcc = 0;
segments.forEach(function (s, i) {
const frac = total ? s.value / total : 0;
const len = frac * C;
svg += '<circle class="pj-dash-donut-seg" data-i="' + i + '" cx="60" cy="60" r="' + R + '" ' +
'stroke="' + s.color + '" stroke-dasharray="0 ' + C + '" stroke-dashoffset="' + (-offsetAcc) + '" ' +
'transform="rotate(-90 60 60)"></circle>';
offsetAcc += len;
});
svg += '<text x="60" y="65" class="pj-dash-donut-center" text-anchor="middle"></text></svg>';
wrap.innerHTML = svg;
wrap.querySelector(".pj-dash-donut-center").textContent = total;
const legend = document.createElement("div");
legend.className = "pj-dash-legend";
segments.forEach(function (s) {
const item = document.createElement("div");
item.className = "pj-dash-legend-item";
item.innerHTML = '<span class="pj-dash-legend-dot"></span><span class="pj-dash-legend-label"></span> <b></b>';
item.querySelector(".pj-dash-legend-dot").style.background = s.color;
item.querySelector(".pj-dash-legend-label").textContent = s.label;
item.querySelector("b").textContent = s.value;
legend.appendChild(item);
});
wrap.appendChild(legend);
// 다음 프레임에 목표 길이로 트랜지션(애니메이션이 실제로 재생되도록 한 틱 늦춘다).
requestAnimationFrame(function () {
requestAnimationFrame(function () {
const arcs = wrap.querySelectorAll(".pj-dash-donut-seg");
segments.forEach(function (s, i) {
const frac = total ? s.value / total : 0;
const len = frac * C;
arcs[i].setAttribute("stroke-dasharray", len + " " + C);
});
});
});
return wrap;
}
function renderDashboard() {
const root = el("pj-dash");
if (!root) return;
root.innerHTML = "";
const vis = visibleTasks().filter(function (t) { return !t.parent_task_id; }); // 하위 업무는 보드에도 안 보이므로 제외
const today = kstTodayIso(); // UTC 날짜(toISOString)면 한국 오전에 하루 어긋났다
const completed = vis.filter(function (t) { return !!t.completed_at; });
const incomplete = vis.filter(function (t) { return !t.completed_at; });
const overdue = incomplete.filter(function (t) { return t.due_date && t.due_date.slice(0, 10) < today; });
const stats = document.createElement("div");
stats.className = "pj-dash-stats";
stats.appendChild(dashStatTile("완료된 작업 합계", completed.length));
stats.appendChild(dashStatTile("미완료 작업 합계", incomplete.length));
stats.appendChild(dashStatTile("마감일이 지난 작업 합계", overdue.length));
stats.appendChild(dashStatTile("작업 합계", vis.length));
root.appendChild(stats);
const charts = document.createElement("div");
charts.className = "pj-dash-charts";
// 섹션별 미완료 — "이 프로젝트" 스코프면 보드 컬럼과 같은 순서로.
const sectionOrder = viewScope === "project"
? (stagesByProject[projectId] || []).slice().sort(function (a, b) { return a.sort_order - b.sort_order; }).map(function (s) { return s.name; })
: boardStages.slice();
const bySection = {};
incomplete.forEach(function (t) { const k = t.stage_name || "미지정"; bySection[k] = (bySection[k] || 0) + 1; });
const sectionNames = sectionOrder.filter(function (n) { return bySection[n]; });
Object.keys(bySection).forEach(function (n) { if (sectionNames.indexOf(n) < 0) sectionNames.push(n); });
const sectionData = sectionNames.map(function (n) { return { label: n, value: bySection[n] }; });
const sectionCard = document.createElement("div");
sectionCard.className = "pj-dash-card";
sectionCard.innerHTML = '<div class="pj-dash-card-title">미완료 작업 합계(섹션별)</div>';
sectionCard.appendChild(dashBarChart(sectionData));
charts.appendChild(sectionCard);
// 완료 상태별 — 2구간 도넛(완료=초록, 미완료=포인트 컬러).
const statusCard = document.createElement("div");
statusCard.className = "pj-dash-card";
statusCard.innerHTML = '<div class="pj-dash-card-title">작업 합계(완료 상태별)</div>';
statusCard.appendChild(dashDonutChart([
{ label: "완료", value: completed.length, color: "var(--color-success-green, #2e9e5b)" },
{ label: "미완료", value: incomplete.length, color: "var(--pj-accent)" },
]));
charts.appendChild(statusCard);
// 담당자별 작업 합계(2026-10-07) — 이 범위에서 그 사람에게 배정된 작업 전부(마감일·필터와 무관),
// 메인 작업과 하위 작업을 나눠 세고 완료 수·완료율. 하위 업무는 화면 목록에 없어 서버에서 따로 받는다.
// 사람별 업무량이 드러나는 표라 관리자에게만 보여준다.
if (isAdmin) {
const assigneeCard = document.createElement("div");
assigneeCard.className = "pj-dash-card pj-dash-card-wide";
assigneeCard.innerHTML = '<div class="pj-dash-card-title">담당자별 작업 합계(메인·하위 작업, 완료)</div>' +
'<div class="pj-dash-workload"></div>';
charts.appendChild(assigneeCard);
paintWorkload(assigneeCard.querySelector(".pj-dash-workload"));
}
root.appendChild(charts);
}
// ── 담당자별 작업 합계 — 메인(이 범위 최상위 작업, 중복 없이) + 하위(서버 subtasks-summary), 완료 수 ──
let workloadCache = { scope: "", at: 0, subtasks: null, pending: null };
function loadWorkloadSubtasks(force) {
const fresh = workloadCache.scope === viewScope && Date.now() - workloadCache.at < 15000;
if (!force && fresh && workloadCache.subtasks) return Promise.resolve(workloadCache.subtasks);
if (workloadCache.pending && workloadCache.scope === viewScope) return workloadCache.pending;
const scope = viewScope;
workloadCache.scope = scope;
workloadCache.pending = api("GET", "/project/api/projects/" + projectId + "/subtasks-summary?scope=" + scope)
.then(function (res) {
if (workloadCache.scope === scope) Object.assign(workloadCache, { at: Date.now(), subtasks: res.subtasks || [] });
return res.subtasks || [];
})
.finally(function () { workloadCache.pending = null; });
return workloadCache.pending;
}
// ── 담당자별 업무 목록 — 오른쪽에서 밀려 나오는 패널(body 에 붙음). 항목을 누르면 작업 편집 창(openTaskById).
// 하위 작업은 화면 목록에 없으니 openTaskById 가 서버에서 받아 연다. 편집 창을 닫으면 대시보드·패널을 다시 그린다.
let wlDrawer = null;
function closeWorkloadDrawer() {
if (!wlDrawer) return;
const d = wlDrawer;
wlDrawer = null;
d.classList.remove("is-open");
document.removeEventListener("keydown", onWorkloadKey, true);
setTimeout(function () { d.remove(); }, 260);
}
function onWorkloadKey(e) {
if (e.key === "Escape" && taskModal && taskModal.hidden) { e.stopPropagation(); closeWorkloadDrawer(); }
}
function openWorkloadDrawer(person, kind, items, isSub) {
closeWorkloadDrawer();
const done = items.filter(function (t) { return t.completed_at || t.done; });
const open = items.filter(function (t) { return !(t.completed_at || t.done); });
const d = document.createElement("div");
d.className = "pj-wl-drawer";
d.innerHTML = '<div class="pj-wl-drawer-dim"></div><aside class="pj-wl-panel" role="dialog" aria-label="업무 목록">' +
'<header><div><b></b><small></small></div><button type="button" class="pj-icon-btn" data-act="close" title="닫기">' +
'<span class="material-symbols-outlined">close</span></button></header><div class="pj-wl-panel-body"></div></aside>';
d.querySelector("header b").textContent = person + " · " + kind + " 작업";
d.querySelector("header small").textContent = "완료 " + done.length + " / " + items.length + (items.length ? " (" + Math.round(done.length / items.length * 100) + "%)" : "");
const body = d.querySelector(".pj-wl-panel-body");
const sortKey = function (t) { return (t.due_date || "9999") + (t.title || ""); };
[["미완료", open], ["완료", done]].forEach(function (g) {
if (!g[1].length) return;
const h = document.createElement("div");
h.className = "pj-wl-panel-group";
h.textContent = g[0] + " " + g[1].length;
body.appendChild(h);
g[1].slice().sort(function (a, b) { return sortKey(a) < sortKey(b) ? -1 : 1; }).forEach(function (t) {
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-wl-item" + ((t.completed_at || t.done) ? " is-done" : "");
btn.innerHTML = '<span class="material-symbols-outlined">' + ((t.completed_at || t.done) ? "check_circle" : "radio_button_unchecked") + "</span>" +
'<span class="pj-wl-item-main"><span class="pj-wl-item-title"></span><small></small></span><em></em>';
btn.querySelector(".pj-wl-item-title").textContent = t.title || "(제목 없음)";
const parent = isSub && seenTask(t.parent_task_id);
btn.querySelector("small").textContent = parent ? "상위: " + (parent.title || "") : (t.stage_name || "");
btn.querySelector("em").textContent = t.due_date ? fmtShortDate(t.due_date) : "";
btn.addEventListener("click", function () { openTaskById(t.id); });
body.appendChild(btn);
});
});
if (!items.length) body.innerHTML = "<div class='pj-empty-sm'>작업이 없습니다.</div>";
d.addEventListener("click", function (e) {
if (e.target.closest('[data-act="close"]') || e.target.classList.contains("pj-wl-drawer-dim")) closeWorkloadDrawer();
});
document.body.appendChild(d);
wlDrawer = d;
wlDrawer.dataset.person = person; wlDrawer.dataset.kind = kind;
document.addEventListener("keydown", onWorkloadKey, true);
watchTaskModalForWorkload();
requestAnimationFrame(function () { requestAnimationFrame(function () { d.classList.add("is-open"); }); });
}
function seenTask(id) {
return tasks.find(function (x) { return x.id === id; }) || null;
}
function fmtShortDate(iso) {
const m = String(iso).slice(0, 10).split("-");
return m.length === 3 ? parseInt(m[1], 10) + "/" + parseInt(m[2], 10) : "";
}
// 편집 창을 닫으면(hidden) 하위 작업 요약을 새로 받아 대시보드·열린 패널을 다시 그린다.
// taskModal 은 이 함수 아래쪽에서 정의되므로 처음 패널을 열 때 연결한다.
let wlWatching = false;
function watchTaskModalForWorkload() {
if (wlWatching || !taskModal) return;
wlWatching = true;
new MutationObserver(function () {
if (!taskModal.hidden || !wlDrawer) return;
const person = wlDrawer.dataset.person, kind = wlDrawer.dataset.kind;
loadWorkloadSubtasks(true).then(function () {
if (!wlDrawer) return;
renderDashboard();
const bar = Array.from(document.querySelectorAll("#pj-dash .pj-wl-group")).find(function (g) {
return g.querySelector(".pj-wl-name b").textContent === person;
});
const col = bar && bar.querySelector(kind === "메인" ? ".pj-wl-col.is-main" : ".pj-wl-col.is-sub");
if (col && !col.disabled) col.click(); else closeWorkloadDrawer();
}).catch(function () {});
}).observe(taskModal, { attributes: true, attributeFilter: ["hidden"] });
}
function paintWorkload(box) {
const seen = {}, rows = {};
function row(email, name) {
const k = email ? email.toLowerCase() : "";
if (!rows[k]) rows[k] = { label: email ? capName(name || idOf(email)) : "담당자 없음", none: !email,
mains: [], subs: [] };
return rows[k];
}
const mains = scopeTasks().filter(function (t) {
if (t.parent_task_id || seen[t.id]) return false;
seen[t.id] = t; return true;
});
mains.forEach(function (t) { row(t.assignee_email, t.assignee_name).mains.push(t); });
// 세로 막대(다른 대시보드 그래프와 같은 모양) — 사람마다 메인·하위 두 막대. 막대 하나 = 그 작업 전체(100%),
// 초록 채움 = 완료율(9/13 → 69%, 1/1 → 가득). 작업 수는 막대 위 숫자로(높이로 작업 수를 그리면 많은 사람 기준이라
// 다른 막대의 완료가 바닥에 깔려 보였다 — 2026-10-07 수정).
// 막대를 누르면 오른쪽 패널에 그 업무 목록(openWorkloadDrawer).
function draw(subs) {
Object.keys(rows).forEach(function (k) { rows[k].subs = []; });
(subs || []).forEach(function (st) {
if (!seen[st.parent_task_id]) return; // 이 범위의 메인 작업에 딸린 하위 작업만
row(st.assignee_email, st.assignee_name).subs.push(st);
});
const doneOf = function (list) { return list.filter(function (t) { return t.completed_at || t.done; }).length; };
const list = Object.keys(rows).map(function (k) { return rows[k]; })
.filter(function (r) { return r.mains.length + r.subs.length > 0; })
.sort(function (a, b) {
return (a.none - b.none) || ((b.mains.length + b.subs.length) - (a.mains.length + a.subs.length)) || a.label.localeCompare(b.label);
});
if (!list.length) { box.innerHTML = "<div class='pj-empty-sm'>배정된 작업이 없습니다.</div>"; return; }
const allTotal = list.reduce(function (n, r) { return n + r.mains.length + r.subs.length; }, 0);
const allDone = list.reduce(function (n, r) { return n + doneOf(r.mains) + doneOf(r.subs); }, 0);
box.innerHTML = '<div class="pj-wl-legend"><span><i class="is-done"></i>완료</span><span><i class="is-open"></i>미완료</span>' +
'<span class="pj-wl-sum">전체 완료 <b>' + allDone + "</b> / " + allTotal + " (" + (allTotal ? Math.round(allDone / allTotal * 100) : 0) + "%)</span>" +
'<span class="pj-wl-hint">막대를 누르면 업무 목록</span></div><div class="pj-wl-bars"></div>';
const wrap = box.querySelector(".pj-wl-bars");
const tooltip = dashTooltip();
list.forEach(function (r) {
const group = document.createElement("div");
group.className = "pj-wl-group";
const all = r.mains.length + r.subs.length, done = doneOf(r.mains) + doneOf(r.subs);
const pair = document.createElement("div");
pair.className = "pj-wl-pair";
[["main", "메인", r.mains], ["sub", "하위", r.subs]].forEach(function (k) {
const items = k[2], n = items.length, d = doneOf(items);
const col = document.createElement("button");
col.type = "button";
col.className = "pj-wl-col is-" + k[0];
col.disabled = !n;
const pct = n ? Math.round(d / n * 100) : 0;
col.innerHTML = '<span class="pj-wl-val">' + (n ? d + "/" + n : "0") + "<small>" + (n ? pct + "%" : "&nbsp;") + "</small></span>" +
'<span class="pj-wl-track' + (n ? " has-tasks" : "") + '"><i class="pj-wl-done"></i></span>' +
'<span class="pj-wl-kind">' + k[1] + "</span>";
const fill = col.querySelector(".pj-wl-done");
fill.dataset.pct = pct;
requestAnimationFrame(function () { requestAnimationFrame(function () { fill.style.height = pct + "%"; }); });
const tipLabel = r.label + " · " + k[1] + " 작업 (완료 " + d + " / " + n + ")";
col.addEventListener("mouseenter", function () { if (n) tooltip.show(col, tipLabel, d + "/" + n); });
col.addEventListener("mouseleave", tooltip.hide);
col.addEventListener("click", function () {
tooltip.hide();
openWorkloadDrawer(r.label, k[1], items, k[0] === "sub");
});
pair.appendChild(col);
});
group.appendChild(pair);
const name = document.createElement("div");
name.className = "pj-wl-name";
name.innerHTML = "<b></b><small>" + done + "/" + all + " · " + (all ? Math.round(done / all * 100) : 0) + "%</small>";
name.querySelector("b").textContent = r.label;
group.appendChild(name);
wrap.appendChild(group);
});
}
if (workloadCache.subtasks && workloadCache.scope === viewScope) draw(workloadCache.subtasks);
else box.innerHTML = "<div class='pj-empty-sm'>하위 작업을 불러오는 중…</div>";
loadWorkloadSubtasks(false).then(function (subs) {
if (box.isConnected) draw(subs);
}).catch(function (err) {
if (!box.isConnected) return;
draw([]);
const note = document.createElement("div");
note.className = "pj-empty-sm";
note.textContent = "하위 작업을 불러오지 못해 메인 작업만 표시합니다: " + err.message;
box.appendChild(note);
});
}
// 서버가 돌려준 업무를 로컬 목록에 반영. 멀티호밍된 업무는 목록에 여러 행
// (원래 소속 맥락 + 연결된 프로젝트 맥락)으로 들어 있으므로 같은 id 의 행을
// 전부 고친다. 단 "어느 맥락의 세션인지"에 해당하는 필드는 행마다 다르다 —
// 서버 응답(get_task)의 stage_id 는 항상 원래 소속 세션이라, 연결 맥락 행에
// 덮어쓰면 그 카드가 연결된 프로젝트 보드에서 사라졌다.
const CONTEXT_FIELDS = ["stage_id", "stage_name", "is_done_stage", "is_linked", "context_project_id"];
// opts.noInsert — 같은 id 행만 고치고 없으면 추가하지 않는다(동기화용).
function mergeTask(task, opts) {
const base = Object.assign({}, task);
if (task.home_stage_id === undefined && task.stage_id !== undefined) base.home_stage_id = task.stage_id;
// 들어온 값 자체가 연결 맥락 행이면(스냅샷) 그 세션 값은 다른 행에 못 쓴다.
const srcLinked = task.context_project_id != null && task.context_project_id !== task.project_id;
let found = false;
tasks.forEach(function (x, i) {
if (x.id !== task.id) return;
found = true;
const patch = Object.assign({}, base);
const linkedRow = x.context_project_id != null && x.context_project_id !== x.project_id;
if (linkedRow || srcLinked) CONTEXT_FIELDS.forEach(function (k) { delete patch[k]; });
delete patch.context_project_id; // 행의 맥락은 그대로
tasks[i] = Object.assign({}, x, patch);
});
// 하위 업무(팝업에서 저장·완료)는 목록에 넣지 않는다 — 넣으면 보드에 카드로 뜬다.
if (!found && !base.parent_task_id && !(opts && opts.noInsert)) {
// 방금 만든 업무 — 맥락이 없으면 visibleTasks() 필터에 걸려 다음
// 동기화 때까지 화면에 안 나왔다. 원래 소속 맥락으로 넣는다.
if (base.context_project_id == null) base.context_project_id = base.project_id;
tasks.push(base);
}
}
// 같은 세션 안 카드 드래그 재정렬 — tasks 배열은 여러 세션이 뒤섞인
// 하나의 배열이라, 이 세션이 차지하던 자리(인덱스)만 그대로 두고 그
// 자리에 들어갈 값만 새 순서대로 바꿔치기한다(다른 세션 업무의 상대
// 위치는 건드리지 않는다).
function applyStageOrder(stageId, orderedIds) {
const orderMap = {};
orderedIds.forEach(function (id, i) { orderMap[id] = i; });
const idxs = [];
tasks.forEach(function (t, i) { if (t.stage_id === stageId) idxs.push(i); });
const sorted = idxs.map(function (i) { return tasks[i]; })
.sort(function (a, b) { return orderMap[a.id] - orderMap[b.id]; });
idxs.forEach(function (i, k) { tasks[i] = sorted[k]; });
}
function refreshActiveView() {
// 모든 뷰 + 좌측 트리 클라이언트 재렌더(새로고침 없음).
renderView(currentView);
renderTree();
updateFilterSummary();
}
// 업무 우클릭 메뉴 공용 항목 — 보드 카드·리스트 행·달력 막대·타임라인
// 아이템 4곳이 전부 이 함수 하나를 쓴다(열기/완료토글/삭제, 각각 기존
// 버튼과 동일한 API 경로·권한 검사를 그대로 재사용).
function taskContextItems(t) {
return [
{ label: "열기", onClick: function () { openTaskModal(t); } },
{ label: "작업 링크 복사", onClick: function () { shareTaskLink(t.id); } },
{
label: t.completed_at ? "완료 취소" : "완료로 표시",
onClick: async function () {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, { completed: !t.completed_at });
mergeTask(res.task);
refreshActiveView();
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
},
},
null,
{
label: "삭제", danger: true,
onClick: async function () {
if (!canDelete(t.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(t.id, t.title, t.subtask_total))) return;
try {
await deleteTaskRequest(t.id);
tasks = tasks.filter(function (x) { return x.id !== t.id; });
refreshActiveView();
} catch (e) { showToast("삭제 실패: " + e.message, "error"); }
},
},
];
}
// ── 업무 모달 ──
const taskModal = el("pj-modal-task");
// 업무 팝업의 담당자 칸 — "아이콘 + 이름" 버튼/메뉴로(아사나처럼).
enhanceAssigneeSelect(el("pj-t-assignee"));
// 패널 너비 드래그 리사이즈 — 왼쪽 모서리를 끌면 오른쪽에 고정된 패널이
// 넓어진다(최소 420px, 최대 화면 절반). 마지막 너비는 기억해둔다.
(function initTaskPanelResize() {
const card = taskModal.querySelector(".pj-task-modal-card");
const handle = el("pj-task-panel-resizer");
if (!card || !handle) return;
const WKEY = "pj_task_panel_w";
const saved = parseInt(localStorage.getItem(WKEY) || "", 10);
if (saved) card.style.width = saved + "px";
handle.addEventListener("mousedown", function (e) {
e.preventDefault();
// 화면 배율(uiZoom) 모드에선 마우스 좌표는 화면 픽셀, 카드 너비는 배율 전 픽셀.
const z = uiZoom();
const startX = e.clientX;
const startW = card.getBoundingClientRect().width / z;
handle.classList.add("is-dragging");
document.body.style.userSelect = "none";
function mv(ev) {
const maxW = window.innerWidth * 0.5 / z;
const w = Math.max(420, Math.min(maxW, startW + (startX - ev.clientX) / z));
card.style.width = w + "px";
}
function up() {
document.removeEventListener("mousemove", mv);
document.removeEventListener("mouseup", up);
handle.classList.remove("is-dragging");
document.body.style.userSelect = "";
try { localStorage.setItem(WKEY, String(Math.round(card.getBoundingClientRect().width / z))); } catch (_) {}
}
document.addEventListener("mousemove", mv);
document.addEventListener("mouseup", up);
});
})();
let currentTaskId = null;
// 시작일/시간 지정은 폼에서 뺐다(더 이상 이 팝업에서 편집 안 함) — 저장 시
// 값을 그대로 보존해서 보내기 위해 열려 있는 업무의 원본을 들고 있는다.
let currentTaskData = null;
const descEditor = initDescEditor();
const subtaskBlock = initSubtaskBlock();
const linksBlock = initLinksBlock();
if (descEditor) {
descEditor.setOnImageRemoved(function () {
const tid = el("pj-t-id").value;
if (tid) loadAttachments(tid);
});
}
// ── 실시간 저장(아사나식) — 저장 버튼 없이 칸마다 바로 서버에 반영한다.
// 제목: 칸을 벗어나거나 Enter / 설명: 입력 멈추고 1.2초 뒤·칸을 벗어날 때 /
// 담당자·섹션·우선순위·마감일: 바꾸는 즉시. 새 작업은 제목이 생기는 순간 만든다.
// 요청은 한 줄로 세워(saveChain) 순서가 뒤바뀌지 않게 한다. 보낼 값과 작업 id 는
// 부르는 순간 잡아 두므로, 저장 도중 다른 작업을 열어도 엉뚱한 작업에 쓰지 않는다.
//
// 작업 창 세대(taskGen) — 창을 새로 열 때마다(같은 작업을 다시 열어도, A→B→A) 1 올린다. 비동기
// 응답(상세·하위 작업·연결·첨부·댓글·담당자 후보·저장 결과)은 요청을 보낼 때의 세대를 잡아 두고,
// 돌아왔을 때 세대가 바뀌었으면 화면·상태에 반영하지 않는다(늦은 A 응답이 B 화면을 덮던 문제).
// 저장 실패(failedFields)는 창을 닫거나 다른 작업으로 넘어갈 때 다시 시도하고, 그래도 실패하면
// "버리고 닫기 / 계속 편집"을 묻는다 — 실패를 모른 채 닫혀 입력이 사라지던 문제.
const autoStateEl = el("pj-autosave-state");
let saveChain = Promise.resolve(true);
let lastSaved = { title: "", desc: "" };
let descTimer = null;
let creatingTask = null;
let taskGen = 0;
let savingCount = 0;
const failedFields = new Set();
let taskReadOnly = false;
const FIELD_LABEL = { title: "제목", desc: "설명", assignee: "담당자", stage: "섹션", priority: "우선순위", due: "마감일", create: "새 작업" };
function setAutoState(s) {
if (!autoStateEl) return;
autoStateEl.dataset.state = s || "";
autoStateEl.textContent = s === "saving" ? "저장 중…" : s === "saved" ? "저장됨"
: s === "error" ? "저장 실패 · 다시 시도" : "";
autoStateEl.title = s === "error" ? "눌러서 저장 다시 시도(" + failedLabels() + ")" : "";
autoStateEl.classList.toggle("is-retry", s === "error");
}
function failedLabels() {
return Array.from(failedFields).map(function (k) { return FIELD_LABEL[k] || k; }).join("·");
}
if (autoStateEl) autoStateEl.addEventListener("click", function () {
if (autoStateEl.dataset.state === "error") retryFailedSaves();
});
function resetAutoSave() {
clearTimeout(descTimer);
descTimer = null;
failedFields.clear();
lastSaved = {
title: el("pj-t-title").value.trim(),
desc: descEditor ? descEditor.getHtml() : "",
};
setAutoState("");
}
// 사용자가 "버리고 닫기"를 고른 경우에만 — 실패한 초안·예약된 저장을 버리고, 아직 돌아오지 않은
// 저장 결과도 이 창에 반영되지 않게 세대를 넘긴다.
function discardTaskEdits() {
clearTimeout(descTimer);
descTimer = null;
failedFields.clear();
taskGen++;
lastSaved = { title: el("pj-t-title").value.trim(), desc: descEditor ? descEditor.getHtml() : "" };
setAutoState("");
}
function retryFailedSaves() {
if (taskReadOnly) return saveChain;
Array.from(failedFields).forEach(function (k) {
if (k === "create") saveField("title");
else saveField(k);
});
return saveChain;
}
// 저장되지 않은 것이 있는지 — 페이지를 떠날 때 경고용(저장된 상태엔 경고하지 않는다).
function hasUnsavedTaskEdits() {
if (taskModal.hidden || taskReadOnly) return false;
if (failedFields.size || descTimer || savingCount > 0 || creatingTask) return true;
if (descEditor && descEditor.isUploading()) return true;
if (!el("pj-t-id").value) return !!el("pj-t-title").value.trim();
return el("pj-t-title").value.trim() !== lastSaved.title ||
(!!descEditor && descEditor.getHtml() !== lastSaved.desc);
}
window.addEventListener("beforeunload", function (e) {
if (!hasUnsavedTaskEdits()) return;
e.preventDefault();
e.returnValue = "";
});
function assigneePayload() {
const sel = el("pj-t-assignee");
const opt = sel.selectedOptions[0];
return { assignee_email: sel.value, assignee_name: opt ? (opt.dataset.name || "") : "" };
}
// 반환: Promise<boolean> — 이 칸이 저장됐으면(또는 보낼 게 없으면) true, 실패면 false.
function saveField(key) {
if (taskReadOnly) return Promise.resolve(true);
const id = el("pj-t-id").value;
if (!id) return key === "title" ? createTaskFromPanel() : Promise.resolve(true);
const gen = taskGen;
let body = null;
if (key === "title") {
const t = el("pj-t-title").value.trim();
if (!t) { el("pj-t-title").value = lastSaved.title || ""; fitTitleHeight(); return Promise.resolve(true); }
if (t === lastSaved.title) return Promise.resolve(true);
body = { title: t };
lastSaved.title = t;
} else if (key === "desc") {
if (!descEditor) return Promise.resolve(true);
if (descEditor.isUploading()) { scheduleDescSave(); return Promise.resolve(true); } // 이미지 올라간 뒤 다시
const html = descEditor.getHtml();
if (html === lastSaved.desc) return Promise.resolve(true);
body = { description: html };
lastSaved.desc = html;
} else if (key === "assignee") {
body = assigneePayload();
} else if (key === "stage") {
const s = parseInt(el("pj-t-stage").value, 10);
if (!s) return Promise.resolve(true);
body = { stage_id: s };
} else if (key === "priority") {
body = { priority: el("pj-t-priority").value };
} else if (key === "due") {
body = { due_date: el("pj-t-due").value || null };
}
if (!body) return Promise.resolve(true);
setAutoState("saving");
savingCount++;
saveChain = saveChain.then(async function () {
let res;
try {
res = await api("PUT", "/project/api/tasks/" + id, body);
} catch (e) {
if (gen === taskGen) {
if (key === "title") lastSaved.title = null; // 다음에 다시 시도하도록
if (key === "desc") lastSaved.desc = null;
failedFields.add(key);
setAutoState("error");
}
showToast("저장 실패(" + (FIELD_LABEL[key] || key) + "): " + e.message, "error");
savingCount--;
return false;
}
// 여기부터는 저장 성공 — 화면 반영 중 오류가 나도 "저장 실패"로 표시하지 않는다.
try {
const wasDone = !!(currentTaskData && currentTaskData.completed_at);
mergeTask(res.task);
// 같은 창(세대)일 때만 화면·상태에 반영한다 — 그 사이 다른 작업을 열었거나 버렸으면 건드리지 않는다.
if (gen === taskGen && !taskModal.hidden) {
failedFields.delete(key);
currentTaskData = res.task;
// 섹션을 옮기면 서버가 섹션 기본 담당자를 넣거나 완료 처리할 수 있다 — 화면도 맞춘다.
if (key === "stage") {
if ((res.task.assignee_email || "") !== el("pj-t-assignee").value) {
await fillAssigneeSelect(res.task.project_id, res.task.assignee_email || "");
}
setCompleteBtn(!!res.task.completed_at);
syncDueBtn();
}
// 완료 섹션으로 옮기거나 빼면 완료 이력 줄이 생기거나 사라진다.
if (wasDone !== !!res.task.completed_at) loadComments(id);
if (res.task._newly_assigned) loadTaskExtras(res.task); // 새 담당자가 협업자로 들어온다
if (res.mention_skipped && res.mention_skipped.length) warnMentionSkipped(res.mention_skipped);
setAutoState(failedFields.size ? "error" : "saved");
}
if (key !== "desc") refreshActiveView();
} catch (err) {
console.error("저장 후 화면 반영 오류", err); // 저장 자체는 됐다
} finally { savingCount--; }
return true;
});
return saveChain;
}
function warnMentionSkipped(emails) {
showToast("태그하지 못한 사람(이 작업을 볼 수 없음): " + emails.map(idOf).join(", "), "error");
}
// 새 작업 — 제목이 처음 생기는 순간 지금 칸 값으로 만든 뒤, 기존 작업 화면
// (댓글·첨부·하위 작업 등)으로 바꿔 연다. 그 사이 더 입력한 내용은 이어서 저장한다.
function createTaskFromPanel() {
const title = el("pj-t-title").value.trim();
if (!title) return Promise.resolve(true);
if (creatingTask) return creatingTask;
const gen = taskGen;
const sentDesc = descEditor ? descEditor.getHtml() : "";
const payload = Object.assign({
title: title,
description: sentDesc,
priority: el("pj-t-priority").value,
due_date: el("pj-t-due").value || null,
}, assigneePayload());
const stageVal = parseInt(el("pj-t-stage").value, 10);
if (stageVal) payload.stage_id = stageVal;
setAutoState("saving");
savingCount++;
creatingTask = saveChain = saveChain.then(async function () {
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/tasks", payload);
mergeTask(res.task);
refreshActiveView();
if (gen === taskGen && !taskModal.hidden && !el("pj-t-id").value) {
failedFields.delete("create");
const nowTitle = el("pj-t-title").value.trim();
const nowDesc = descEditor ? descEditor.getHtml() : "";
openTaskModalNow(res.task); // 만든 작업 화면으로 — 방금 만든 것이라 저장 확인은 필요 없다
if (nowTitle && nowTitle !== res.task.title) { el("pj-t-title").value = nowTitle; fitTitleHeight(); saveField("title"); }
if (descEditor && nowDesc !== sentDesc) { descEditor.setHtml(nowDesc); saveField("desc"); }
if (res.mention_skipped && res.mention_skipped.length) warnMentionSkipped(res.mention_skipped);
setAutoState("saved");
}
return true;
} catch (e) {
if (gen === taskGen) { failedFields.add("create"); setAutoState("error"); }
showToast("작업 만들기 실패: " + e.message, "error");
return false;
} finally { creatingTask = null; savingCount--; }
});
return creatingTask;
}
function scheduleDescSave() {
clearTimeout(descTimer);
descTimer = setTimeout(function () { descTimer = null; saveField("desc"); }, 1200);
}
// 창을 닫거나 다른 작업으로 넘어가기 직전 — 이미지 업로드·만들기가 끝나길 기다리고, 아직 안 보낸
// 제목·설명과 실패했던 칸을 다시 보낸 뒤 모든 저장이 끝날 때까지 기다린다.
// 반환: Promise<boolean> — 남은 실패가 없으면 true.
async function flushAutoSave() {
if (taskModal.hidden || taskReadOnly) { await saveChain; return true; }
const gen = taskGen;
clearTimeout(descTimer);
descTimer = null;
if (descEditor && descEditor.isUploading()) {
setAutoState("saving");
await descEditor.whenIdle();
}
if (creatingTask) await creatingTask;
if (gen !== taskGen) return true; // 기다리는 사이 창이 바뀌었다(버리기 등)
if (el("pj-t-id").value) {
saveField("title");
saveField("desc");
Array.from(failedFields).forEach(function (k) { if (k !== "title" && k !== "desc" && k !== "create") saveField(k); });
} else if (el("pj-t-title").value.trim()) {
saveField("title"); // 새 작업 — 제목이 있으면 만든다
}
await saveChain;
return gen !== taskGen || failedFields.size === 0;
}
// 닫기·다른 작업 열기 전 — 저장이 끝나야 넘어간다. 끝내 실패하면 사용자가 고른다.
async function settleBeforeLeave() {
if (taskModal.hidden || taskReadOnly) return true;
if (await flushAutoSave()) return true;
const discard = await confirm(
"저장하지 못한 내용이 있습니다(" + failedLabels() + ").\n" +
"버리고 넘어갈까요? '계속 편집'을 고르면 창이 그대로 남고, 위쪽 '저장 실패 · 다시 시도'로 다시 저장할 수 있습니다.",
{ okText: "버리고 넘어가기", cancelText: "계속 편집" });
if (!discard) return false;
discardTaskEdits();
return true;
}
el("pj-t-title").addEventListener("blur", function () { saveField("title"); });
el("pj-t-assignee").addEventListener("change", function () { saveField("assignee"); });
el("pj-t-stage").addEventListener("change", function () { saveField("stage"); });
el("pj-t-priority").addEventListener("change", function () { saveField("priority"); });
el("pj-t-due").addEventListener("change", function () { saveField("due"); });
(function () {
const box = el("pj-t-desc");
if (!box || !descEditor) return;
box.addEventListener("input", scheduleDescSave);
box.addEventListener("click", scheduleDescSave); // 체크리스트 체크 등 input 이 안 나는 변경
box.addEventListener("focusout", function () {
clearTimeout(descTimer);
descTimer = null;
saveField("desc");
});
})();
let taskClosing = false;
async function attemptCloseTaskModal() {
if (taskModal.hidden || taskClosing) return;
taskClosing = true;
try {
if (!(await settleBeforeLeave())) return; // 계속 편집 — 창과 입력을 그대로 둔다
taskGen++; // 닫은 창의 늦은 응답은 버린다
closeSlidePanel(taskModal);
} finally { taskClosing = false; }
}
taskModal.addEventListener("click", function (e) {
if (e.target === taskModal || e.target.closest("[data-close]")) attemptCloseTaskModal();
});
document.addEventListener("keydown", function (e) {
if (e.key === "Escape" && !taskModal.hidden) { e.preventDefault(); attemptCloseTaskModal(); }
});
// ── 팔로워 (아사나의 협업자) — 완료·댓글 알림을 받는 사람 ──
// 저장 버튼과 무관하게 누르는 즉시 서버에 반영된다.
const followersRow = el("pj-followers-row");
let followersTask = null;
let followers = [];
function renderFollowers() {
const box = el("pj-follower-chips");
if (!box) return;
// 담당자 버튼과 같은 "아이콘 + 이름". × 는 마우스를 올릴 때만. 없으면 점선 원
// "협업자 없음"(누르면 추가 메뉴) — 이땐 옆 + 버튼은 숨긴다.
box.innerHTML = followers.map(function (e) {
return '<span class="pj-assignee-btn pj-follower-chip" data-tip="' + escapeHtml(e) + '">' +
personIconHtml(e) + '<span class="pj-assignee-btn-name">' + escapeHtml(idOf(e)) + "</span>" +
'<button type="button" class="pj-follower-x" data-email="' + escapeHtml(e) + '" title="협업자에서 빼기">×</button></span>';
}).join("") ||
'<button type="button" class="pj-assignee-btn is-empty pj-follower-empty">' + personIconHtml("") +
'<span class="pj-assignee-btn-name">협업자 없음</span></button>';
el("pj-follower-add").hidden = !followers.length;
box.querySelectorAll(".pj-follower-x").forEach(function (b) {
b.addEventListener("click", function () { setFollower(b.dataset.email, false); });
});
const empty = box.querySelector(".pj-follower-empty");
if (empty) empty.addEventListener("click", openFollowerAddMenu);
const followingMe = followers.indexOf(me) >= 0;
const tog = el("pj-follow-toggle");
tog.textContent = followingMe ? "협업자에서 나가기" : "협업자로 참여";
tog.classList.toggle("is-on", followingMe);
}
async function setFollower(email, on) {
if (!followersTask) return;
const tid = followersTask.id;
try {
const res = on
? await api("POST", "/project/api/tasks/" + tid + "/followers", { email: email })
: await api("DELETE", "/project/api/tasks/" + tid + "/followers/" + encodeURIComponent(email));
if (!followersTask || followersTask.id !== tid) return; // 그 사이 다른 업무를 열었다
followers = res.followers || [];
renderFollowers();
} catch (e) { showToast("협업자 변경 실패: " + e.message, "error"); }
}
function showFollowers(task, list) {
followersTask = task;
if (!followersRow) return;
if (!task || list == null) { followersRow.hidden = true; return; } // 새 업무 / 008 미적용
followers = list.map(function (e) { return String(e).toLowerCase(); });
followersRow.hidden = false;
renderFollowers();
}
if (followersRow) {
el("pj-follow-toggle").addEventListener("click", function () {
setFollower(me, followers.indexOf(me) < 0);
});
el("pj-follower-add").addEventListener("click", openFollowerAddMenu);
}
// 협업자 추가 메뉴 — 담당자 메뉴처럼 "아이콘 + 이름".
async function openFollowerAddMenu(e) {
if (!followersTask) return;
const r = e.currentTarget.getBoundingClientRect();
let list = [];
try { list = await membersOfProject(followersTask.project_id); } catch (_) {}
const cands = list.map(function (m) { return (m.user_email || "").toLowerCase(); })
.filter(function (em) { return em && followers.indexOf(em) < 0; });
if (!cands.length) { showToast("추가할 수 있는 멤버가 없습니다."); return; }
showContextMenu(r.left, r.bottom + 4, cands.map(function (em) {
return { label: idOf(em), icon: personIconHtml(em), onClick: function () { setFollower(em, true); } };
}));
}
async function loadTaskExtras(task) {
if (!task) return;
const gen = taskGen;
try {
const res = await api("GET", "/project/api/tasks/" + task.id);
// 늦게 온 A 응답이 지금 열린 B(또는 다시 연 A)의 하위 작업·연결 대상을 바꾸지 않게.
if (gen !== taskGen) return;
const detail = res.task;
if (detail.access === "read" && !taskReadOnly) applyTaskReadOnly(true, detail);
showFollowers(task, detail.followers);
if (subtaskBlock) {
subtaskBlock.setContext({
taskId: task.id, projectId: task.project_id, canDelete: canDelete,
readOnly: taskReadOnly,
onOpen: function (sub) { openTaskById(sub.id); },
});
subtaskBlock.render(detail.subtasks || []);
}
if (linksBlock) {
linksBlock.setContext({
taskId: task.id, projectId: task.project_id, readOnly: taskReadOnly,
onChange: function () { if (gen === taskGen) loadTaskExtras(task); },
});
linksBlock.render(detail.links || []);
}
} catch (e) {
// 권한이 없어졌으면(403) 편집을 멈추고 알린다. 그 밖엔 조용히 — 본편집은 계속 가능해야 한다.
if (gen === taskGen && e.status === 403) {
applyTaskReadOnly(true, null);
showToast("이 작업을 볼 권한이 없어졌습니다: " + e.message, "error");
}
}
}
// 단계 select 를 해당 업무가 속한 프로젝트의 단계로 채운다(전체 뷰에서 타 프로젝트 업무 편집 대비).
function fillStageSelect(projId) {
const sel = el("pj-t-stage");
const list = (projId != null && stagesByProject[projId]) ? stagesByProject[projId] : stages;
sel.innerHTML = list.map(function (s) {
return '<option value="' + s.id + '">' + escapeHtml(s.name) + "</option>";
}).join("");
}
// 담당자 select — 업무가 현재 로드된 프로젝트가 아니면 그 프로젝트 멤버를 새로 불러온다
// (전체 뷰/좌측 트리에서 타 프로젝트 업무를 열 때 담당자 옵션이 비어 보이는 문제 방지).
async function fillAssigneeSelect(projId, currentEmail) {
const sel = el("pj-t-assignee");
const gen = taskGen;
let list = members;
if (projId != null && projId !== projectId) {
try { list = (await api("GET", "/project/api/projects/" + projId + "/members")).members || []; }
catch (_) { list = []; }
if (gen !== taskGen) return; // 그 사이 다른 작업 창 — 그 창의 담당자 칸을 덮지 않는다
}
const emails = list.map(function (m) { return m.user_email; });
// 지금 담당자가 멤버 목록에 없어도(프로젝트를 만든 owner, 멤버에서 빠진 사람)
// 선택지에 넣는다 — 없으면 칸이 비고, 저장하면 담당자가 지워졌다.
const cur = (currentEmail || "").toLowerCase();
if (cur && !emails.some(function (e) { return (e || "").toLowerCase() === cur; })) emails.push(currentEmail);
sel.innerHTML = '<option value="">없음</option>' + emails.map(function (e) {
const name = idOf(e);
return '<option value="' + escapeHtml(e) + '" data-name="' + escapeHtml(name) + '">' + escapeHtml(name) + "</option>";
}).join("");
sel.value = currentEmail || "";
}
// 작업 창 열기(보드·목록·캘린더·하위 작업 등 모든 곳). 다른 작업이 열려 있으면 그 창의 저장이
// 끝나야(또는 사용자가 버리기로 해야) 넘어간다 — 저장 실패를 모른 채 넘어가 입력이 사라지지 않게.
// 같은 작업을 다시 누르면 그대로 둔다(쓰던 내용 유지).
let opening = null;
async function openTaskModal(task, presetStageId) {
if (opening) return opening;
opening = (async function () {
if (!taskModal.hidden) {
const curId = el("pj-t-id").value;
if (task && curId && String(task.id) === curId) return true;
if (!(await settleBeforeLeave())) return false;
}
openTaskModalNow(task, presetStageId);
return true;
})();
try { return await opening; } finally { opening = null; }
}
// 읽기 전용(연결된 프로젝트에서 연 작업·권한 회수) — 입력을 막고 안내줄을 보인다. 서버도 거절한다.
function applyTaskReadOnly(ro, detail) {
taskReadOnly = !!ro;
if (ro) { failedFields.clear(); clearTimeout(descTimer); descTimer = null; setAutoState(""); }
el("pj-t-title").readOnly = !!ro;
const desc = el("pj-t-desc");
if (desc) desc.contentEditable = ro ? "false" : "true";
["pj-t-assignee", "pj-t-stage", "pj-t-priority", "pj-t-due-btn"].forEach(function (id) {
const x = el(id); if (x) x.disabled = !!ro;
});
taskModal.classList.toggle("is-readonly", !!ro);
const upBtn = document.querySelector("#pj-attach-block .pj-upload-btn");
if (upBtn) upBtn.hidden = !!ro;
const fmtbar = el("pj-desc-fmtbar");
if (fmtbar) fmtbar.hidden = !!ro;
const note = el("pj-t-readonly");
if (note) {
note.hidden = !ro;
const home = el("pj-t-readonly-home");
if (home) home.textContent = (detail && detail.project_name) || (currentTaskData && currentTaskData.project_name) || "원 소속 프로젝트";
}
if (ro) {
el("pj-toggle-complete").hidden = true;
el("pj-delete-task").hidden = true;
el("pj-comment-dock").hidden = true;
if (followersRow) followersRow.hidden = true;
}
}
// 이 화면에서 작업의 권한 — 서버 상세가 준 값이 있으면 그것, 없으면 원 소속 프로젝트를 이 화면이
// 들고 있는지(=지금 관리할 수 있는 프로젝트)로 판단한다(연결돼 온 행은 원 소속이 목록에 없다).
function taskAccessLevel(task) {
if (!task) return "full";
if (task.access) return task.access;
return projectsMeta.some(function (p) { return String(p.id) === String(task.project_id); }) ? "full" : "read";
}
function openTaskModalNow(task, presetStageId) {
taskGen++;
el("pj-t-id").value = task ? task.id : "";
el("pj-t-title").value = task ? task.title : "";
if (descEditor) { descEditor.setTaskId(task ? task.id : null); descEditor.setHtml(task ? (task.description || "") : ""); }
// 새 업무는 그 세션의 기본 담당자를 미리 채운다(비워 저장해도 서버가
// 같은 사람을 배정하므로 화면에 미리 보여주는 것).
let presetAssignee = "";
if (!task) {
const sid = presetStageId != null ? presetStageId : (stages[0] ? stages[0].id : null);
const ps = stages.find(function (x) { return String(x.id) === String(sid); });
presetAssignee = (ps && ps.default_assignee_email) || "";
}
fillAssigneeSelect(task ? task.project_id : projectId, task ? (task.assignee_email || "") : presetAssignee);
fillStageSelect(task ? task.project_id : projectId);
// "세션" 선택칸은 원래 소속 프로젝트의 세션 목록이다. 다른 프로젝트에서
// 연결돼 온 행은 stage_id 가 연결된 쪽 세션이라 목록에 없다 — 그대로 넣으면
// 선택이 비고, 저장 시 원래 세션이 지워졌다. 그래서 home_stage_id 를 쓴다.
const homeStage = task
? (task.home_stage_id !== undefined ? task.home_stage_id : task.stage_id)
: null;
el("pj-t-stage").value = task ? (homeStage || "")
: (presetStageId != null ? presetStageId : (stages[0] ? stages[0].id : ""));
el("pj-t-priority").value = task ? (task.priority || "normal") : "normal";
el("pj-t-due").value = task ? (task.due_date || "") : "";
currentTaskData = task || null;
syncDueBtn(); // 완료 여부(지남 표시)를 보려면 currentTaskData 다음에
el("pj-delete-task").hidden = !task;
el("pj-toggle-complete").hidden = !task;
// 공유 링크는 저장된 업무에만 있다(새 업무는 아직 id 가 없다).
const shareBtn = el("pj-share-task");
if (shareBtn) shareBtn.hidden = !task;
if (task) setCompleteBtn(!!task.completed_at);
// 댓글·첨부·하위업무·연결·팔로워는 기존 업무 편집 시에만
currentTaskId = task ? task.id : null;
showFollowers(null, null); // 상세를 받으면(loadTaskExtras) 다시 그린다
el("pj-attach-block").hidden = !task;
el("pj-comment-block").hidden = !task;
el("pj-comment-dock").hidden = !task;
// 하위 업무도 업무와 같은 팝업·같은 편집(아사나식). 다른 점은 세 가지 —
// 제목 위에 상위 업무 경로, 세션 칸 없음(하위 업무는 세션이 없다),
// 다른 프로젝트 연결(멀티호밍) 없음.
const isSub = !!(task && task.parent_task_id);
const parentBtn = el("pj-t-parent");
if (parentBtn) {
parentBtn.hidden = !isSub;
parentBtn.dataset.parentId = isSub ? String(task.parent_task_id) : "";
const pt = isSub && tasks.find(function (x) { return x.id === task.parent_task_id; });
el("pj-t-parent-title").textContent = isSub ? (task.parent_title || (pt && pt.title) || "상위 작업") : "";
}
const stageCell = document.querySelector(".pj-meta-cell-stage");
if (stageCell) stageCell.style.display = isSub ? "none" : "";
if (subtaskBlock) {
el("pj-subtask-block").hidden = !task;
subtaskBlock.reset();
}
if (linksBlock) el("pj-links-block").hidden = !task || isSub;
resetAutoSave();
applyTaskReadOnly(taskAccessLevel(task) === "read", task);
if (task) { loadAttachments(task.id); loadComments(task.id); loadTaskExtras(task); }
openSlidePanel(taskModal);
fitTitleHeight();
if (!task) setTimeout(function () { el("pj-t-title").focus(); }, 0);
}
// 작업 제목 — 한 줄 input 대신 textarea 라 창보다 길면 다음 줄로 넘어간다.
// 제목은 한 줄 값이므로 Enter·붙여넣은 줄바꿈은 막고 공백으로 바꾼다.
function fitTitleHeight() {
const ta = el("pj-t-title");
if (!ta || ta.offsetParent === null) return;
ta.style.height = "auto";
ta.style.height = ta.scrollHeight + "px";
}
(function () {
const ta = el("pj-t-title");
if (!ta) return;
ta.addEventListener("keydown", function (e) {
if (e.key === "Enter" && !e.isComposing) { e.preventDefault(); ta.blur(); }
});
ta.addEventListener("input", function () {
if (/[\r\n]/.test(ta.value)) {
const pos = ta.selectionStart;
ta.value = ta.value.replace(/\r?\n|\r/g, " ");
ta.setSelectionRange(pos, pos);
}
fitTitleHeight();
});
// 작업 창 너비를 끌어 바꾸거나 창 크기가 바뀌면 줄 수가 달라진다.
let lastW = 0;
if (window.ResizeObserver) new ResizeObserver(function () {
if (ta.clientWidth === lastW) return;
lastW = ta.clientWidth;
fitTitleHeight();
}).observe(ta);
})();
// id 로 업무 팝업 열기 — 하위 업무(보드 카드의 하위 업무 줄, 팝업 안 하위 업무
// 목록, 상위 업무 경로)에서 쓴다. 보드 목록(tasks)에는 최상위 업무만 있으므로
// 없으면 서버에서 받아 연다(상세 응답엔 parent_title 도 들어 있다).
// 팝업에서 다른 업무로 넘어갈 때 아직 안 보낸 제목·설명은 먼저 저장한다.
async function openTaskById(id) {
const t = tasks.find(function (x) { return x.id === id && x.context_project_id === x.project_id; }) ||
tasks.find(function (x) { return x.id === id; });
if (t) { openTaskModal(t); return; } // 저장 확인은 openTaskModal 이 한다
try {
const res = await api("GET", "/project/api/tasks/" + id);
if (res && res.task) openTaskModal(res.task);
} catch (e) { showToast("작업을 열 수 없습니다: " + e.message, "error"); }
}
if (el("pj-t-parent")) el("pj-t-parent").addEventListener("click", function () {
const pid = parseInt(el("pj-t-parent").dataset.parentId, 10);
if (pid) openTaskById(pid);
});
// 마감일 — 달력 아이콘 버튼(날짜가 있으면 옆에 "09/25(목)"). 진짜 값은 숨긴
// #pj-t-due(input[type=date])가 들고 있어 저장·변경감지 코드는 그대로다.
function syncDueBtn() {
const v = el("pj-t-due").value;
const btn = el("pj-t-due-btn");
if (!btn) return;
const di = dueInfo(v, !!(currentTaskData && currentTaskData.completed_at));
el("pj-t-due-text").textContent = di ? di.text : "";
btn.classList.toggle("has-date", !!v);
btn.classList.toggle("is-overdue", !!di && di.cls === "is-overdue");
btn.classList.toggle("is-soon", !!di && di.cls === "is-soon");
btn.title = v ? "마감일 " + v + " (눌러서 변경)" : "마감일 지정";
}
if (el("pj-t-due-btn")) {
// 아사나식 날짜 팝업 — 숨긴 #pj-t-due 값을 바꾸고 change 를 보내면
// 실시간 저장(saveField "due")이 받는다(시작일은 이 폼에 없어 마감일만).
el("pj-t-due-btn").addEventListener("click", function () {
const inp = el("pj-t-due");
openDatePopover(el("pj-t-due-btn"), {
due: inp.value, allowStart: false,
onChange: function (patch) {
inp.value = patch.due_date || "";
inp.dispatchEvent(new Event("change", { bubbles: true }));
},
});
});
el("pj-t-due").addEventListener("change", syncDueBtn);
el("pj-t-due").addEventListener("input", syncDueBtn);
}
function setCompleteBtn(done) {
const btn = el("pj-toggle-complete");
btn.textContent = done ? "↩ 완료 취소" : "✓ 완료로 표시";
btn.classList.toggle("is-done", done);
btn.dataset.completed = done ? "1" : "";
}
el("pj-toggle-complete").addEventListener("click", async function () {
const id = el("pj-t-id").value;
if (!id) return;
const done = el("pj-toggle-complete").dataset.completed === "1";
try {
const res = await api("PUT", "/project/api/tasks/" + id, { completed: !done });
mergeTask(res.task);
setCompleteBtn(!!res.task.completed_at);
refreshActiveView();
loadComments(id); // "OO 님이 이 작업을 완료했습니다" 줄 — 완료하면 생기고 취소하면 사라진다
} catch (e) { alert("처리 실패: " + e.message); }
});
// ── 첨부파일 ──
function attachmentIconHtml(a) {
const suffix = String(a.filename || "").trim().toLowerCase().match(/\.([^.]+)$/);
const ext = suffix ? suffix[1] : "";
const mime = String(a.content_type || "").split(";")[0].trim().toLowerCase();
// 확장자를 먼저 확인 — CSV/마크다운처럼 MIME 이 일반 text 인 파일도 구분한다.
let kind;
if (/^(png|jpe?g|gif|webp|bmp|svg|tiff?|ico|heic|heif|avif)$/.test(ext)) kind = "image";
else if (/^(xlsx?|xlsm|xlsb|xltx?|xltm|csv|ods)$/.test(ext)) kind = "excel";
else if (/^(pptx?|pptm|ppsx?|ppsm|potx?|potm|odp)$/.test(ext)) kind = "ppt";
else if (/^(docx?|docm|dotx?|dotm|hwp|hwpx|odt|rtf)$/.test(ext)) kind = "document";
else if (ext === "pdf") kind = "pdf";
else if (/^(txt|text|md|markdown|log|json|xml|ya?ml|ini|conf)$/.test(ext)) kind = "text";
else if (mime.startsWith("image/")) kind = "image";
else if (/excel|spreadsheet|opendocument.spreadsheet|csv/.test(mime)) kind = "excel";
else if (/powerpoint|presentation/.test(mime)) kind = "ppt";
else if (/msword|wordprocessing|opendocument.text|hwp|rtf/.test(mime)) kind = "document";
else if (mime === "application/pdf") kind = "pdf";
else if (mime.startsWith("text/") || /json|xml/.test(mime)) kind = "text";
else kind = "file";
const types = {
image: ["image", "이미지 파일"], excel: ["table_chart", "엑셀 파일"],
text: ["article", "텍스트 파일"], ppt: ["slideshow", "PPT 파일"],
document: ["description", "문서 파일"], pdf: ["picture_as_pdf", "PDF 파일"],
file: ["draft", "파일"],
};
return '<span class="material-symbols-outlined pj-attach-icon is-' + kind +
'" role="img" aria-label="' + types[kind][1] + '" title="' + types[kind][1] + '">' + types[kind][0] + '</span>';
}
function fmtSize(n) {
if (n < 1024) return n + " B";
if (n < 1048576) return (n / 1024).toFixed(1) + " KB";
return (n / 1048576).toFixed(1) + " MB";
}
async function loadAttachments(taskId) {
const ul = el("pj-attach-list");
const gen = taskGen;
ul.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
try {
const res = await api("GET", "/project/api/tasks/" + taskId + "/attachments");
if (gen !== taskGen) return; // 그 사이 다른 작업 창
if (!res.attachments.length) { ul.innerHTML = "<li class='pj-empty-sm'>없음</li>"; return; }
ul.innerHTML = "";
res.attachments.forEach(function (a) {
const li = document.createElement("li");
li.className = "pj-attach-item";
// 댓글에 붙은 파일은 "댓글" 표시 — 아래 댓글 목록에도 같은 파일이 보인다(같은 파일임을 알 수 있게).
li.innerHTML =
'<a href="/project/api/attachments/' + a.id + '/download">' + attachmentIconHtml(a) +
'<span class="pj-attach-name">' + escapeHtml(a.filename) + "</span></a>" +
(a.comment_id != null ? '<span class="pj-attach-from-comment" title="댓글에 첨부한 파일">댓글</span>' : "") +
'<span class="pj-attach-size">' + fmtSize(a.size_bytes) + "</span>" +
(canManage && !taskReadOnly ? '<button type="button" class="pj-icon-btn pj-attach-del" data-id="' + a.id + '">×</button>' : "");
ul.appendChild(li);
});
ul.querySelectorAll(".pj-attach-del").forEach(function (b) {
b.addEventListener("click", async function () {
if (!(await confirm("이 첨부 파일을 삭제할까요?"))) return;
try { await api("DELETE", "/project/api/attachments/" + b.dataset.id); loadAttachments(taskId); }
catch (e) { alert("삭제 실패: " + e.message); }
});
});
} catch (e) { ul.innerHTML = "<li class='pj-empty-sm'>불러오기 실패</li>"; }
}
const attachInput = el("pj-attach-input");
if (attachInput) attachInput.addEventListener("change", async function () {
if (!currentTaskId || !attachInput.files.length) return;
const fd = new FormData();
fd.append("file", attachInput.files[0]);
try {
const res = await fetch("/project/api/tasks/" + currentTaskId + "/attachments", { method: "POST", body: fd });
if (!res.ok) { let m = res.statusText; try { m = (await res.json()).detail; } catch (_) {} throw new Error(m); }
attachInput.value = "";
loadAttachments(currentTaskId);
} catch (e) { alert("업로드 실패: " + e.message); }
});
// ── 댓글 ──
// 댓글 목록(아사나식) — 댓글·완료 이력을 시간순으로, 답글은 원 댓글 아래 들여쓰기.
// 마우스를 올리면 오른쪽 위에 반응·답글·수정·삭제 도구 모음.
async function loadComments(taskId) {
const ul = el("pj-comment-list");
const gen = taskGen;
ul.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
try {
const both = await Promise.all([
api("GET", "/project/api/tasks/" + taskId + "/comments"),
api("GET", "/project/api/tasks/" + taskId + "/attachments").catch(function () { return { attachments: [] }; }),
ensureMentionTokens(),
]);
const res = both[0];
// 그 사이 다른 작업을 열었다(A→B→A 로 같은 작업을 다시 연 경우도 이전 요청은 버린다).
if (gen !== taskGen || String(currentTaskId) !== String(taskId)) return;
const comments = res.comments || [];
const feats = res.features || {};
// 댓글에 붙은 파일 — 댓글 대화창과 같은 방식으로 댓글마다 보여 준다(파일만 있는 댓글도 비어 보이지 않게).
const attByComment = {};
(both[1].attachments || []).forEach(function (a) {
if (a.comment_id == null) return;
(attByComment[a.comment_id] = attByComment[a.comment_id] || []).push(a);
});
feats._atts = attByComment;
// 메모리 업무의 댓글 수 동기화(아이콘 표시용)
const tt = tasks.find(function (x) { return String(x.id) === String(taskId); });
if (tt) tt.comment_count = comments.length;
const replies = {};
comments.forEach(function (c) {
if (c.parent_id) (replies[c.parent_id] = replies[c.parent_id] || []).push(c);
});
const items = comments.filter(function (c) { return !c.parent_id; })
.map(function (c) { return { t: c.created_at || "", c: c }; })
.concat((res.events || []).map(function (ev) { return { t: ev.created_at || "", ev: ev }; }))
.sort(function (a, b) { return a.t < b.t ? -1 : a.t > b.t ? 1 : 0; });
if (!items.length) { ul.innerHTML = "<li class='pj-empty-sm'>댓글 없음</li>"; return; }
ul.innerHTML = "";
items.forEach(function (it) {
const li = document.createElement("li");
if (it.ev) {
li.className = "pj-comment-event";
li.innerHTML = completionEventHtml(it.ev);
ul.appendChild(li);
return;
}
li.className = "pj-comment-thread";
li.appendChild(buildCommentItem(it.c, taskId, feats, it.c.id));
const box = document.createElement("div");
box.className = "pj-comment-replies";
(replies[it.c.id] || []).forEach(function (r) {
box.appendChild(buildCommentItem(r, taskId, feats, it.c.id));
});
li.appendChild(box);
ul.appendChild(li);
});
} catch (e) { ul.innerHTML = "<li class='pj-empty-sm'>불러오기 실패</li>"; }
}
function buildCommentItem(c, taskId, feats, rootId) {
const item = document.createElement("div");
item.className = "pj-comment-item" + (c.parent_id ? " is-reply" : "");
const mine = (c.author_email || "").toLowerCase() === me;
const hasReplies = !c.parent_id;
item.innerHTML =
// 답글 — 들여쓴 자리 왼쪽에 ↳ 화살표(원 댓글에 달린 글임을 한눈에).
// 꺾이는 곳은 직각이 아닌 둥근 모서리(SVG — 머티리얼 아이콘은 직각뿐).
(c.parent_id
? '<svg class="pj-reply-arrow" viewBox="0 0 20 20" fill="none" stroke="currentColor" stroke-width="1.8" ' +
'stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">' +
'<path d="M4.5 3.5v6a4.5 4.5 0 0 0 4.5 4.5H17"/><path d="M13.5 10.5 17 14l-3.5 3.5"/></svg>'
: "") +
avatarHtml(c.author_email, "pj-gicon-sm") +
'<div class="pj-comment-main"><div class="pj-comment-head">' +
escapeHtml(idOf(c.author_email)) + ' <span class="pj-comment-time">' +
escapeHtml(fmtCommentTime(c.created_at)) + "</span></div>" +
// 주소 → 새 탭 링크, @태그 → 칩. 나머지 글자는 전부 이스케이프(XSS 안전).
(c.body ? '<div class="pj-comment-body">' + commentBodyHtml(c.body) + "</div>" : "") +
commentAttachmentsHtml((feats._atts || {})[c.id] || []) +
'<div class="pj-react-slot">' + reactionRowHtml(c, me, feats.reactions) + "</div></div>" +
(taskReadOnly ? "" : commentHoverBarHtml(feats, { reply: true, edit: (mine || isAdmin) && !!c.body, del: mine || isAdmin }));
wireCommentReactions(item, c, function () {
item.querySelector(".pj-react-slot").innerHTML = reactionRowHtml(c, me, feats.reactions);
});
item.addEventListener("click", async function (e) {
const btn = e.target.closest("[data-reply],[data-edit],[data-del]");
if (!btn || !item.contains(btn)) return;
if (btn.hasAttribute("data-reply")) { openReplyForm(item.closest(".pj-comment-thread"), rootId, c, taskId); return; }
if (btn.hasAttribute("data-edit")) { editComment(item, c, taskId); return; }
const n = hasReplies ? item.parentNode.querySelectorAll(".pj-comment-item.is-reply").length : 0;
if (!(await confirm(n ? "이 댓글과 답글 " + n + "개를 삭제할까요?" : "이 댓글을 삭제할까요?"))) return;
try { await api("DELETE", "/project/api/comments/" + c.id); loadComments(taskId); }
catch (err) { alert("삭제 실패: " + err.message); }
});
return item;
}
// 답글 입력칸 — 원 댓글 묶음 맨 아래. 답글의 답글도 원 댓글에 붙고, 그 사람을 @태그해 둔다.
function openReplyForm(thread, rootId, target, taskId) {
if (!thread) return;
const box = thread.querySelector(".pj-comment-replies");
let form = box.querySelector(".pj-reply-form");
if (!form) {
form = document.createElement("div");
form.className = "pj-comment-form pj-reply-form";
form.innerHTML = '<textarea class="pj-composer-ta" rows="1" placeholder="답글 입력… (Shift+Enter 줄바꿈)"></textarea>' +
'<button type="button" class="pj-btn pj-btn-primary">답글</button>';
box.appendChild(form);
const inp = form.querySelector("textarea");
attachMentionInput(inp);
attachEmojiPicker(inp);
attachMentionButton(inp);
let replySending = false;
let replyToken = null;
async function send() {
const body = inp.value.trim();
if (!body || replySending) return;
replySending = true;
replyToken = replyToken || newClientToken();
try {
const res = await api("POST", "/project/api/tasks/" + taskId + "/comments",
{ body: body, parent_id: rootId, mentions: takeMentions(inp), client_token: replyToken });
replyToken = null;
if (res.mention_skipped && res.mention_skipped.length) warnMentionSkipped(res.mention_skipped);
if (followersTask && !followersRow.hidden && followers.indexOf(me) < 0) {
followers.push(me);
renderFollowers();
}
loadComments(taskId);
} catch (err) {
if (err.status && err.status < 500) replyToken = null;
alert("답글 등록 실패: " + err.message);
} finally { replySending = false; }
}
form.querySelector("button.pj-btn").addEventListener("click", send);
inp.addEventListener("input", function () { replyToken = null; });
inp.addEventListener("keydown", function (e) {
if (isImeEnter(e)) return;
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); send(); } // Shift+Enter = 줄바꿈
else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); form.remove(); }
});
}
const inp = form.querySelector("textarea");
const author = (target.author_email || "").toLowerCase();
if (target.parent_id && author && author !== me && !inp.value) {
const token = "@" + idOf(author);
inp.value = token + " ";
inp._pjMentions[token] = author;
}
inp.focus();
inp.setSelectionRange(inp.value.length, inp.value.length);
}
// 댓글 인라인 수정 — 본문을 textarea 로 교체, 저장/취소.
function editComment(li, c, taskId) {
const main = li.querySelector(".pj-comment-main");
const bodyEl = li.querySelector(".pj-comment-body");
const acts = li.querySelector(".pj-cmt-hoverbar") || document.createElement("span");
if (li.querySelector(".pj-comment-edit-box")) return; // 중복 방지
acts.style.visibility = "hidden";
const box = document.createElement("div");
box.className = "pj-comment-edit-box";
const ta = document.createElement("textarea");
ta.rows = 2; ta.value = c.body;
const bar = document.createElement("div");
bar.className = "pj-comment-edit-actions";
const save = document.createElement("button");
save.type = "button"; save.className = "pj-btn pj-btn-primary"; save.textContent = "저장";
const cancel = document.createElement("button");
cancel.type = "button"; cancel.className = "pj-btn"; cancel.textContent = "취소";
bar.appendChild(cancel); bar.appendChild(save);
box.appendChild(ta); box.appendChild(bar);
bodyEl.style.display = "none";
main.appendChild(box);
ta.focus();
cancel.addEventListener("click", function () {
box.remove(); bodyEl.style.display = ""; acts.style.visibility = "";
});
save.addEventListener("click", async function () {
const text = ta.value.trim();
if (!text) { alert("내용을 입력하세요."); return; }
try {
await api("PUT", "/project/api/comments/" + c.id, { body: text });
loadComments(taskId);
} catch (e) { alert("수정 실패: " + e.message); }
});
}
// 전송 중엔 다시 보내지 않는다(더블클릭·Enter 연타). 같은 입력의 재전송은 같은 client_token 이라
// 응답을 못 받고 다시 보내도 서버가 한 번만 만든다. 실패하면 입력은 그대로 남아 다시 보낼 수 있다.
let commentSending = false;
let commentToken = null;
async function sendComment() {
const inp = el("pj-comment-input");
const body = inp.value.trim();
const taskId = currentTaskId;
if (!taskId || !body || commentSending || taskReadOnly) return;
const gen = taskGen;
commentSending = true;
commentToken = commentToken || newClientToken();
el("pj-comment-send").disabled = true;
try {
const res = await api("POST", "/project/api/tasks/" + taskId + "/comments",
{ body: body, mentions: takeMentions(inp), client_token: commentToken });
commentToken = null;
if (gen !== taskGen) return; // 그 사이 다른 작업 창 — 그 창의 입력칸을 비우지 않는다
inp.value = "";
fitComposer(inp);
clearMentions(inp);
loadComments(taskId);
if (res.mention_skipped && res.mention_skipped.length) warnMentionSkipped(res.mention_skipped);
// 댓글을 달면(서버가) 자동 팔로우 — 화면의 팔로워 목록도 맞춘다.
if (followersTask && !followersRow.hidden && followers.indexOf(me) < 0) {
followers.push(me);
renderFollowers();
}
} catch (e) {
if (e.status && e.status < 500) commentToken = null; // 거절(권한·검증)은 새 요청으로
alert("등록 실패: " + e.message);
} finally {
commentSending = false;
el("pj-comment-send").disabled = false;
}
}
attachMentionInput(el("pj-comment-input"));
attachEmojiPicker(el("pj-comment-input"));
attachMentionButton(el("pj-comment-input"));
el("pj-comment-send").addEventListener("click", sendComment);
el("pj-comment-input").addEventListener("input", function () { commentToken = null; }); // 내용이 바뀌면 새 댓글
el("pj-comment-input").addEventListener("keydown", function (e) {
if (isImeEnter(e)) return; // 한글 조합 확정 Enter 는 전송하지 않는다
if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendComment(); } // Shift+Enter = 줄바꿈
});
const newTaskBtn = el("pj-new-task");
if (newTaskBtn) newTaskBtn.addEventListener("click", function () { openTaskModal(null); });
// ── 공유 — 이 업무의 퍼머링크를 클립보드로 ──
const shareTaskBtn = el("pj-share-task");
if (shareTaskBtn) shareTaskBtn.addEventListener("click", function () {
const id = el("pj-t-id").value;
if (id) shareTaskLink(id);
});
// ── 프로젝트로 이동 — 수신함 오른쪽 패널(embed)에서만 보이는 버튼.
// 패널(iframe)이 아니라 수신함 창 전체를 그 프로젝트 화면(작업 창 열린 채)으로 옮긴다.
const gotoProjectBtn = el("pj-goto-project");
if (gotoProjectBtn) gotoProjectBtn.addEventListener("click", function () {
const id = el("pj-t-id").value;
const t = tasks.find(function (x) { return String(x.id) === String(id); });
const pid = (t && t.project_id) || projectId;
const url = "/project/p/" + pid + (id ? "?task=" + id : "");
(window.top || window).location.href = url;
});
el("pj-delete-task").addEventListener("click", async function () {
const id = el("pj-t-id").value;
if (!id) return;
const t = tasks.find(function (x) { return String(x.id) === String(id); });
if (t && !canDelete(t.created_by)) { alert(DELETE_DENIED); return; }
if (!(await confirmTaskDelete(id, el("pj-t-title").value.trim(), null))) return;
try {
await deleteTaskRequest(id);
tasks = tasks.filter(function (x) { return String(x.id) !== String(id); });
discardTaskEdits(); // 지운 작업의 남은 저장·실패 표시는 버린다
closeSlidePanel(taskModal);
refreshActiveView();
} catch (e) { alert("삭제 실패: " + e.message); }
});
// ── 멤버 배정/제외 (관리자) ──
const memberModal = el("pj-modal-member");
wireModalClose(memberModal);
// 멤버는 좌측 목록이 아니라 화면 위 프로젝트 제목 옆에 겹친 아바타로
// 보여준다. 이름은 마우스를 올렸을 때만(data-tip → initHoverTips).
function memberRowHtml(m) {
const url = avatars[String(m.user_email).toLowerCase()];
const name = idOf(m.user_email);
const tip = name; // 역할 구분 없음(2026-10-07) — 배정된 멤버는 모두 보기·수정
return '<span class="pj-tmember" data-email="' + escapeHtml(m.user_email) +
'" data-tip="' + escapeHtml(tip) + '">' +
(url
? '<img class="pj-avatar pj-tmember-av" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer" />'
: '<span class="material-symbols-outlined pj-gicon pj-tmember-av">account_circle</span>') +
"</span>";
}
async function removeMember(email) {
if (!(await confirm("이 멤버를 프로젝트에서 제외할까요?"))) return;
try {
await api("DELETE", "/project/api/projects/" + projectId + "/members/" + encodeURIComponent(email));
members = members.filter(function (m) { return m.user_email !== email; });
renderMemberList();
} catch (e) { showToast("제외 실패: " + e.message, "error"); }
}
function renderMemberList() {
const box = el("pj-member-list");
if (!box) return;
box.innerHTML = members.map(memberRowHtml).join("");
box.querySelectorAll(".pj-tmember").forEach(function (chip) {
// 클릭 = 이 프로젝트 안에서 그 사람이 담당하는 업무 팝업.
chip.addEventListener("click", function () {
openMemberTasksModal(chip.dataset.email, idOf(chip.dataset.email), {
projectId: projectId, projectName: currentProject.name,
});
});
if (isAdmin) chip.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "제외", danger: true, onClick: function () { removeMember(chip.dataset.email); } },
]);
});
});
}
renderMemberList();
// 멤버 업무 팝업 — 공용 구현(initMemberTasks, 위쪽 정의). 이 화면에선
// 더블클릭하면 그 자리에서 업무 편집 팝업을 열고, 닫히면 멤버 팝업을 다시 연다.
const openMemberTasksModal = initMemberTasks({ openTask: openTaskModal, taskModal: taskModal });
// 업무 팝업이 닫히면 카드에 펼쳐 둔 하위 업무 캐시를 비운다(팝업에서 하위
// 업무를 추가·수정했을 수 있다). 다음에 보드를 그릴 때 다시 받는다.
if (taskModal) {
new MutationObserver(function () {
if (!taskModal.hidden) return;
// 수신함 오른쪽 패널(iframe)로 열린 경우 — 작업 창을 닫으면 패널도 닫게 알린다.
if (document.documentElement.classList.contains("pj-embed")) {
window.parent.postMessage({ type: "pj-embed-close" }, location.origin);
return;
}
Object.keys(subsCache).forEach(function (k) { delete subsCache[k]; });
// 펼친 카드의 하위 작업을 먼저 다 받아 온 뒤 한 번에 다시 그린다 — "불러오는 중"으로
// 짧아진 채 그리면 섹션 스크롤을 되돌릴 자리가 모자라 위로 밀려 올라간다.
if (expandedSubs.size && currentView === "board") {
Promise.all(Array.from(expandedSubs).map(function (id) {
const t = tasks.find(function (x) { return x.id === id; });
return t ? loadCardSubs(t).catch(function () {}) : null;
})).then(function () { if (currentView === "board") renderBoard(); });
}
Object.keys(tlSubCache).forEach(function (k) { delete tlSubCache[k]; });
if (tlExpanded.size && currentView === "timeline" && tlToggleSubs) {
// 펼친 상태는 두고 하위 작업만 새로 받는다
Array.from(tlExpanded).forEach(function (id) { tlExpanded.delete(id); tlToggleSubs(id); });
}
}).observe(taskModal, { attributes: true, attributeFilter: ["hidden"] });
}
// ── 멤버 배정·제외(2026-10-07) — 후보 전원을 보여 주고 지금 멤버는 체크된 채로. 체크 = 배정, 체크 해제 = 제외.
// 소유자는 늘 권한이 있어 뺄 수 없다(체크·잠금). 권한을 잃어 후보에 없는 지금 멤버도 보여서 뺄 수 있게.
const lowerEmail = function (e) { return String(e || "").toLowerCase(); };
const addMemberBtn = el("pj-add-member");
if (addMemberBtn) addMemberBtn.addEventListener("click", async function () {
const box = el("pj-m-users");
openModal(memberModal);
box.innerHTML = "불러오는 중…";
try {
const res = await api("GET", "/project/api/assignable-users");
const owner = lowerEmail(currentProject && currentProject.owner_email);
const current = new Set(members.map(function (m) { return lowerEmail(m.user_email); }));
const seen = new Set();
const list = (res.users || []).map(function (u) { seen.add(lowerEmail(u.email)); return u; });
members.forEach(function (m) { // 후보 목록에 없는 지금 멤버(권한을 잃은 사람 등)
const e = lowerEmail(m.user_email);
if (!seen.has(e)) list.push({ email: e, id: idOf(e), name: m.user_name || idOf(e), avatar: "" });
});
if (!list.length) { box.innerHTML = "<span class='pj-empty-sm'>배정 가능한 직원이 없습니다(관리자 페이지에서 프로젝트 관리 권한 부여)</span>"; return; }
box.innerHTML = list.map(memberPickHtml).join("");
box.querySelectorAll("input[type=checkbox]").forEach(function (cb) {
const e = lowerEmail(cb.value);
cb.checked = current.has(e) || e === owner;
cb.dataset.was = cb.checked ? "1" : "";
if (e === owner) {
cb.disabled = true;
const lab = cb.closest("label");
if (lab) { lab.title = "소유자 — 뺄 수 없습니다"; lab.classList.add("is-owner"); }
}
});
} catch (e) {
box.innerHTML = "<span class='pj-empty-sm'>불러오기 실패: " + escapeHtml(e.message) + "</span>";
}
});
const saveMemberBtn = el("pj-save-member");
if (saveMemberBtn) saveMemberBtn.addEventListener("click", async function () {
const box = el("pj-m-users");
const boxes = box ? Array.from(box.querySelectorAll("input[type=checkbox]:not(:disabled)")) : [];
const toAdd = boxes.filter(function (cb) { return cb.checked && !cb.dataset.was; });
const toRemove = boxes.filter(function (cb) { return !cb.checked && cb.dataset.was; });
if (!toAdd.length && !toRemove.length) { closeModal(memberModal); return; }
if (toRemove.length && !(await confirm(toRemove.length + "명을 이 프로젝트에서 제외할까요? 제외되면 이 프로젝트를 볼 수 없습니다.",
{ okText: "제외", cancelText: "취소" }))) return;
saveMemberBtn.disabled = true;
let failCount = 0;
for (const cb of toAdd) {
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/members", {
user_email: cb.value, user_name: cb.dataset.name || "",
});
members.push(res.member);
} catch (e) { failCount++; }
}
for (const cb of toRemove) {
try {
await api("DELETE", "/project/api/projects/" + projectId + "/members/" + encodeURIComponent(cb.value));
for (let i = members.length - 1; i >= 0; i--) if (lowerEmail(members[i].user_email) === lowerEmail(cb.value)) members.splice(i, 1);
} catch (e) { failCount++; }
}
saveMemberBtn.disabled = false;
renderMemberList();
closeModal(memberModal);
if (failCount) showToast(failCount + "명 처리 실패", "error");
else showToast("멤버를 저장했습니다" + (toAdd.length ? " · 배정 " + toAdd.length + "명" : "") + (toRemove.length ? " · 제외 " + toRemove.length + "명" : ""));
});
// 최초 렌더 — 아사나처럼 프로젝트에 들어오면 보드(세션)가 기본 화면이다
// (달력을 보던 중이었다면 그 기억된 뷰를 그린다, 위 VIEW_KEY 복원 참고).
renderView(currentView);
updateFilterSummary(); // 기억된 필터가 있으면 개수·초기화 버튼 표시
// 사이드 트리에서 업무 클릭(?task=ID)으로 들어오면 해당 업무 모달 자동 열기.
// 단, 처리 후 URL 에서 task 파라미터를 제거한다 — 같은 페이지에 머무는 동안
// 다시 열리지 않도록.
const params = new URLSearchParams(location.search);
const taskParam = params.get("task");
if (taskParam) {
params.delete("task");
const qs = params.toString();
history.replaceState({}, "", location.pathname + (qs ? "?" + qs : ""));
const t = tasks.find(function (x) { return String(x.id) === String(taskParam); });
if (t) {
openTaskModal(t);
} else {
// 공유 링크로 들어왔는데 이 화면의 목록엔 없는 경우(예: 완료 세션이
// 걸러졌거나 다른 스코프) — 서버에서 그 업무만 받아 연다.
api("GET", "/project/api/tasks/" + taskParam)
.then(function (res) { if (res && res.task) openTaskModal(res.task); })
.catch(function (e) { showToast("작업을 열 수 없습니다: " + e.message, "error"); });
}
}
// 8초 주기 실시간 동기화(initLiveRefresh)가 전체 새로고침 대신 부를 함수 —
// 이 프로젝트의 업무·세션·멤버를 요청 한 번(/snapshot)으로 받아 로컬 상태를
// 고친다(입력 중인 모달 폼은 건드리지 않는다). 이 프로젝트 맥락의 행은
// 통째로 바꿔 끼워 삭제된 업무도 사라지게 한다(live-version 이 007
// 마이그레이션부터 삭제·세션 변경까지 감지한다). "전체 프로젝트" 스코프의
// 다른 프로젝트 행은 공통 필드(제목·담당자·완료 등)만 따라 고친다.
//
// 이 화면은 "이 프로젝트"·"전체 프로젝트" 어느 범위든 접근 가능한 모든 최상위 프로젝트의 작업을
// 들고 있으므로, 같은 범위(scope=all)를 통째로 받아 바꿔 끼운다 — 다른 프로젝트의 새 작업·삭제·
// 섹션 변경·프로젝트 변경·권한 회수까지 반영(예전엔 지금 연 프로젝트 것만 받아 다른 프로젝트 행이
// 남거나 빠졌다). 멀티호밍 작업은 서버가 context_project_id 별로 한 행씩 주므로 그대로 쓴다.
// 필터·정렬·보기·스크롤은 화면 상태라 그대로, 열린 작업 창의 입력도 건드리지 않는다.
// 성공하면 true(반영 완료) — 실패면 false 로 initLiveRefresh 가 다음 주기에 다시 시도.
let syncSeq = 0;
let accessLost = false;
softSyncProjectRef = async function () {
if (accessLost) return true;
const seq = ++syncSeq;
let snap;
try {
snap = await api("GET", "/project/api/projects/" + projectId + "/snapshot?scope=all");
} catch (e) {
if (e.status === 403 || e.status === 404) { onProjectAccessLost(); return true; }
return false;
}
if (seq !== syncSeq) return true; // 더 나중에 시작한 동기화가 있다 — 늦은 응답은 버린다
tasks = snap.tasks || [];
Object.keys(stagesByProject).forEach(function (k) { delete stagesByProject[k]; });
Object.keys(snap.stages_by_project || {}).forEach(function (k) {
stagesByProject[k] = snap.stages_by_project[k];
});
stages = snap.stages || stagesByProject[projectId] || [];
// 보드("전체 프로젝트") 칼럼 이름 — 아는 순서는 그대로, 새 섹션 이름은 뒤에.
const names = [];
Object.keys(stagesByProject).forEach(function (k) {
stagesByProject[k].forEach(function (s) { if (names.indexOf(s.name) < 0) names.push(s.name); });
});
const known = boardStages.filter(function (n) { return names.indexOf(n) >= 0; });
boardStages.splice(0, boardStages.length);
Array.prototype.push.apply(boardStages, known.concat(names.filter(function (n) { return known.indexOf(n) < 0; })));
if (snap.projects) { // 사이드바·타임라인 그룹 — 권한이 없어진 프로젝트는 빠진다
projectsMeta.splice(0, projectsMeta.length);
Array.prototype.push.apply(projectsMeta, snap.projects);
renderTree();
}
if (snap.project) Object.assign(currentProject, snap.project);
members = snap.members || [];
fillAssigneeFilter();
renderMemberList();
refreshActiveView();
refreshMyOpenBadge();
return true;
};
// 이 프로젝트 권한을 잃었다(멤버에서 빠짐·프로젝트 삭제) — 화면의 작업을 비우고, 열린 작업 창은
// 저장 없이 닫고(서버가 어차피 거절한다), 이유를 알린다. 새로고침하면 서버가 안내 화면을 보여 준다.
function onProjectAccessLost() {
if (accessLost) return;
accessLost = true;
Object.keys(boardTaskDrafts).forEach(function (id) { delete boardTaskDrafts[id]; });
Object.keys(boardTaskOutsideDown).forEach(function (id) {
document.removeEventListener("pointerdown", boardTaskOutsideDown[id], true);
delete boardTaskOutsideDown[id];
});
tasks = [];
discardTaskEdits();
if (!taskModal.hidden) closeSlidePanel(taskModal);
refreshActiveView();
const bar = document.createElement("div");
bar.className = "pj-access-lost";
bar.innerHTML = "이 프로젝트에 대한 권한이 없어져 작업을 더 볼 수 없습니다. " +
'<a href="/project/">내 작업으로 이동</a>';
const head = root.querySelector(".pj-main") || root;
head.insertBefore(bar, head.firstChild);
}
// 자동 테스트(tests/js/project_ui.test.js)에서만 — window.__PJ_TEST__ 가 있을 때 내부 동작을 연다.
if (window.__PJ_TEST__) {
window.__pjProject = {
openTaskModal: openTaskModal, openTaskById: openTaskById, attemptClose: attemptCloseTaskModal,
flush: flushAutoSave, sync: function () { return softSyncProjectRef(); },
state: function () {
return { taskGen: taskGen, failed: Array.from(failedFields), readOnly: taskReadOnly, tasks: tasks,
stagesByProject: stagesByProject, projectsMeta: projectsMeta, boardStages: boardStages,
unsaved: hasUnsavedTaskEdits() };
},
};
}
}
// ════════════════════════════════════════════════════════════
// 업무 모달 공용 확장 — 하위 업무 · 연결된 프로젝트(멀티호밍) · 설명 이미지 편집기
// 홈(index.html)과 프로젝트(project.html) 페이지가 업무 모달의 요소 id 를
// 그대로 공유하므로(각자 모달을 따로 갖지만 id는 같다) 여기 한 번만 만들어
// 내 업무/프로젝트 화면 어디서든 그대로 쓴다.
// ════════════════════════════════════════════════════════════
// ── 설명(contenteditable) — 붙여넣기/업로드로 이미지를 끼워 넣는다 ──
function initDescEditor() {
const box = el("pj-t-desc");
if (!box) return null;
// @ 를 누르면 멤버 목록 → 고르면 멘션 칩이 들어간다(수신함에 쌓인다).
attachMentionEditor(box);
const wrap = box.parentElement;
const imgInput = el("pj-desc-img-input");
const hint = el("pj-desc-hint");
let taskId = null;
// ── 서식 도구 모음(간단 워드프로세서) — execCommand 는 구식 API지만
// 크롬/엣지는 여전히 지원하고, 이미 같은 파일의 이미지 삽입에서도 쓰고
// 있어(insertHTML) 일관된 패턴이다. 버튼 mousedown 에서 preventDefault
// 안 하면 클릭 순간 에디터가 포커스를 잃어 선택 범위가 풀린다.
// ── 체크리스트(서식 도구 ☑) — 글머리 기호처럼 줄마다 체크박스.
// <ul class="pj-checklist"><li data-checked="true">한 일</li><li>할 일</li></ul>
// 체크박스는 글자 속 요소가 아니라 글머리 기호 자리에 CSS 가 그린다(li::before) — 그래서
// 체크박스 왼쪽에 글자가 들어갈 수 없고, Enter(새 줄)·빈 줄 Enter(목록 끝)·Backspace 는
// 브라우저의 글머리 목록 동작 그대로다. 체크 여부는 li 의 data-checked 로 저장
// (서버 정리기는 ul 의 class="pj-checklist", li 의 data-checked="true" 만 남긴다).
function selNode() {
const sel = window.getSelection();
if (!sel || !sel.rangeCount) return null;
const n = sel.getRangeAt(0).startContainer;
return n.nodeType === 1 ? n : n.parentElement;
}
function closestIn(n, selector) {
const x = n && n.closest ? n.closest(selector) : null;
return x && box.contains(x) ? x : null;
}
function selectedItems(listEl) {
const sel = window.getSelection();
const r = sel && sel.rangeCount ? sel.getRangeAt(0) : null;
const items = Array.prototype.filter.call(listEl.children, function (li) {
return li.tagName === "LI" && r && r.intersectsNode(li);
});
if (!items.length) { const li = closestIn(selNode(), "li"); if (li) items.push(li); }
return items;
}
// 예전 방식(줄 맨 앞 <input type=checkbox>)으로 저장된 체크리스트를 새 방식으로 바꾸고,
// 체크리스트 밖으로 나간 줄의 data-checked 는 지운다(빈 목록의 class 도).
function normalizeChecklists() {
box.querySelectorAll("ul.pj-checklist > li").forEach(function (li) {
const first = li.firstElementChild;
if (first && first.tagName === "INPUT" && first.type === "checkbox" &&
!(li.firstChild.nodeType === 3 && li.firstChild.nodeValue.replace(/[\s\u00a0\u200b]/g, ""))) {
if (first.hasAttribute("checked")) li.setAttribute("data-checked", "true");
first.remove();
const t = li.firstChild;
if (t && t.nodeType === 3) t.nodeValue = t.nodeValue.replace(/^[\s\u00a0]+/, "");
}
});
box.querySelectorAll("[data-checked]").forEach(function (x) {
if (!(x.tagName === "LI" && x.parentElement && x.parentElement.classList.contains("pj-checklist"))) {
x.removeAttribute("data-checked");
}
});
box.querySelectorAll("ul.pj-checklist").forEach(function (ul) {
if (!ul.querySelector(":scope > li")) { ul.classList.remove("pj-checklist"); if (!ul.className) ul.removeAttribute("class"); }
});
}
function toggleChecklist() {
const cur = closestIn(selNode(), "ul.pj-checklist");
if (cur) {
// 끄기 — 고른 줄을 목록에서 뺀다(글머리 버튼을 다시 누른 것과 같음)
selectedItems(cur).forEach(function (li) { li.removeAttribute("data-checked"); });
try { document.execCommand("insertUnorderedList"); } catch (_) {}
} else {
// 켜기 — 목록이 아니면 먼저 글머리 목록으로(번호 목록이면 글머리로 바뀜), 그 목록을 체크리스트로
if (!closestIn(selNode(), "ul")) { try { document.execCommand("insertUnorderedList"); } catch (_) {} }
const ul = closestIn(selNode(), "ul");
if (ul) ul.classList.add("pj-checklist");
}
normalizeChecklists();
}
// 체크리스트 줄에서 Enter — 브라우저가 새 줄(li)을 만들 때 윗줄의 체크 표시까지
// 복사하므로, 새 줄은 체크 안 된 채로 시작하게 지운다.
box.addEventListener("keydown", function (e) {
if (e.key !== "Enter" || e.shiftKey || e.isComposing) return;
const li = closestIn(selNode(), "ul.pj-checklist > li");
if (!li) return;
setTimeout(function () {
const nli = closestIn(selNode(), "ul.pj-checklist > li");
if (nli && nli !== li) nli.removeAttribute("data-checked");
normalizeChecklists();
}, 0);
});
// 체크박스(글머리 자리) 누르기 — 줄의 글자보다 왼쪽을 누르면 체크/해제.
box.addEventListener("mousedown", function (e) {
const li = e.target && e.target.closest ? e.target.closest("ul.pj-checklist > li") : null;
if (!li || !box.contains(li)) return;
if (e.clientX >= li.getBoundingClientRect().left) return;
e.preventDefault(); // 글자 커서가 옮겨가지 않게
if (li.getAttribute("data-checked") === "true") li.removeAttribute("data-checked");
else li.setAttribute("data-checked", "true");
box.dispatchEvent(new Event("input", { bubbles: true }));
});
const fmtbar = el("pj-desc-fmtbar");
if (fmtbar) {
fmtbar.addEventListener("mousedown", function (e) { e.preventDefault(); });
fmtbar.addEventListener("click", function (e) {
const btn = e.target.closest(".pj-desc-fmtbtn");
if (!btn) return;
box.focus();
const cmd = btn.dataset.cmd;
let arg = btn.dataset.arg || null;
// 링크 — 입력 창(비동기)이 떠 있는 동안 선택 영역이 풀리므로 저장했다가 되돌린다.
if (cmd === "createLink") {
const sel = window.getSelection();
const saved = sel && sel.rangeCount ? sel.getRangeAt(0).cloneRange() : null;
prompt("연결할 주소(URL)를 입력하세요", "https://").then(function (url) {
if (!url) return;
box.focus();
if (saved) { sel.removeAllRanges(); sel.addRange(saved); }
try { document.execCommand("createLink", false, url); } catch (_) {}
normalizeEditorLinks(box);
updateFmtState();
});
return;
}
// 체크리스트 — 글머리 목록처럼 켜고 끈다(줄마다 체크박스).
if (cmd === "insertCheckbox") {
toggleChecklist();
box.dispatchEvent(new Event("input", { bubbles: true }));
updateFmtState();
return;
}
// 체크리스트 안에서 글머리/번호 버튼 — 체크 표시를 빼고 그 목록으로 바꾼다.
if (cmd === "insertUnorderedList" || cmd === "insertOrderedList") {
const cl = closestIn(selNode(), "ul.pj-checklist");
if (cl) {
Array.prototype.forEach.call(cl.children, function (li) { if (li.tagName === "LI") li.removeAttribute("data-checked"); });
cl.classList.remove("pj-checklist");
if (!cl.className) cl.removeAttribute("class");
if (cmd === "insertUnorderedList") { box.dispatchEvent(new Event("input", { bubbles: true })); updateFmtState(); return; }
}
}
try { document.execCommand(cmd, false, arg); } catch (_) {}
if (cmd === "createLink") normalizeEditorLinks(box);
updateFmtState();
});
function updateFmtState() {
fmtbar.querySelectorAll(".pj-desc-fmtbtn[data-cmd]").forEach(function (btn) {
const cmd = btn.dataset.cmd;
if (cmd === "createLink" || cmd === "removeFormat") return;
const inChecklist = !!closestIn(selNode(), "ul.pj-checklist");
let active = false;
if (cmd === "insertCheckbox") active = inChecklist;
else {
try { active = document.queryCommandState(cmd); } catch (_) { active = false; }
if (cmd === "insertUnorderedList" && inChecklist) active = false;
}
btn.classList.toggle("is-active", active);
});
}
box.addEventListener("keyup", updateFmtState);
box.addEventListener("mouseup", updateFmtState);
box.addEventListener("focus", updateFmtState);
// Ctrl+Shift+X = 취소선(구글 문서·아사나와 같은 단축키)
box.addEventListener("keydown", function (e) {
if ((e.ctrlKey || e.metaKey) && e.shiftKey && (e.key === "x" || e.key === "X")) {
e.preventDefault();
try { document.execCommand("strikeThrough"); } catch (_) {}
updateFmtState();
}
});
}
// ── 체크박스 누르기 — 편집칸 안의 체크박스는 브라우저마다 눌림 동작이 달라
// 직접 바꾼다. 저장되는 건 HTML 이라 화면 상태(.checked)가 아니라 checked
// 속성을 바꿔야 저장·다시 열기에도 남는다(서버 정리기는 checked 속성만 남긴다).
box.addEventListener("click", function (e) {
const cb = e.target;
if (!cb || cb.tagName !== "INPUT" || cb.type !== "checkbox") return;
e.preventDefault(); // 브라우저 기본 토글은 막고(취소되면 원래 값으로 되돌려 놓는다) 아래에서 직접
const next = !cb.hasAttribute("checked");
if (next) cb.setAttribute("checked", ""); else cb.removeAttribute("checked");
setTimeout(function () { cb.checked = next; }, 0);
box.dispatchEvent(new Event("input", { bubbles: true }));
}, true);
// ── 설명란 이미지 선택 → 크기 조절 핸들 + 삭제 버튼 오버레이 ──
// 크기는 style이 아니라 width 속성으로 저장한다(서버 sanitize가 style은
// 버리지만 img width/height 속성은 허용 목록에 있어 저장 후에도 유지된다).
const imgTools = document.createElement("div");
imgTools.className = "pj-img-tools";
imgTools.hidden = true;
imgTools.innerHTML =
'<button type="button" class="pj-img-del" title="이미지 삭제">×</button>' +
'<span class="pj-img-handle" title="드래그로 크기 조절"></span>';
wrap.appendChild(imgTools);
const imgDelBtn = imgTools.querySelector(".pj-img-del");
const imgHandle = imgTools.querySelector(".pj-img-handle");
let selectedImg = null;
let onImageRemoved = null;
// 설명란 이미지는 첨부파일 업로드로 들어간 실제 첨부 레코드다 — 에디터에서
// 지우면 첨부파일 목록에도 안 남게 서버 첨부도 같이 삭제한다.
async function deleteSelectedImage() {
if (!selectedImg) return;
const img = selectedImg;
const m = (img.getAttribute("src") || "").match(/\/attachments\/(\d+)\/inline/);
img.remove();
selectImg(null);
if (!m) return;
try {
await api("DELETE", "/project/api/attachments/" + m[1]);
} catch (_) { /* 이미 지워졌을 수 있음 — 에디터에서는 이미 빠졌으니 조용히 무시 */ }
if (onImageRemoved) onImageRemoved();
}
function positionImgTools() {
if (!selectedImg || !selectedImg.isConnected) { selectedImg = null; imgTools.hidden = true; return; }
imgTools.style.left = selectedImg.offsetLeft + "px";
imgTools.style.top = selectedImg.offsetTop + "px";
imgTools.style.width = selectedImg.offsetWidth + "px";
imgTools.style.height = selectedImg.offsetHeight + "px";
imgTools.hidden = false;
}
function selectImg(img) {
if (selectedImg) selectedImg.classList.remove("pj-img-selected");
selectedImg = img || null;
if (selectedImg) { selectedImg.classList.add("pj-img-selected"); positionImgTools(); }
else { imgTools.hidden = true; }
}
// 이미지 더블클릭 → 별도 브라우저 창에서 원본 크기로(확대·축소·끌어서 이동) — openImageWindow
box.addEventListener("dblclick", function (e) {
if (!e.target || e.target.tagName !== "IMG") return;
e.preventDefault();
openImageWindow(e.target);
});
box.addEventListener("click", function (e) {
if (e.target.tagName === "IMG") selectImg(e.target);
else selectImg(null);
// contenteditable 안의 <a> 는 브라우저가 기본으로 열지 않는다 — 직접 연다.
const link = e.target.closest ? e.target.closest("a") : null;
if (link && link.getAttribute("href")) {
e.preventDefault();
window.open(link.href, "_blank", "noopener,noreferrer");
}
});
document.addEventListener("click", function (e) {
if (selectedImg && !wrap.contains(e.target)) selectImg(null);
});
imgDelBtn.addEventListener("click", function () { deleteSelectedImage(); });
let dragging = false, dragStartX = 0, dragStartW = 0;
imgHandle.addEventListener("mousedown", function (e) {
if (!selectedImg) return;
e.preventDefault();
dragging = true;
dragStartX = e.clientX;
dragStartW = selectedImg.offsetWidth;
});
document.addEventListener("mousemove", function (e) {
if (!dragging || !selectedImg) return;
let newW = Math.round(dragStartW + (e.clientX - dragStartX));
newW = Math.max(40, Math.min(newW, wrap.clientWidth || 9999));
selectedImg.setAttribute("width", String(newW));
selectedImg.removeAttribute("height");
selectedImg.style.width = "";
selectedImg.style.height = "";
positionImgTools();
});
document.addEventListener("mouseup", function () { dragging = false; });
document.addEventListener("keydown", function (e) {
if (!selectedImg) return;
if (e.key !== "Delete" && e.key !== "Backspace") return;
const active = document.activeElement;
if (active && ["INPUT", "TEXTAREA", "SELECT"].indexOf(active.tagName) >= 0) return;
e.preventDefault();
deleteSelectedImage();
});
// 업로드 버튼 클릭 → 파일 선택창이 뜨는 동안 contenteditable의 선택 범위가
// 풀린다 — 마지막으로 박스 안에 있던 커서 위치를 기억해뒀다가 삽입 직전에
// 되살린다(안 그러면 이미지가 항상 맨 끝에 붙어버린다).
let lastRange = null;
function saveSelection() {
const sel = window.getSelection();
if (sel && sel.rangeCount && box.contains(sel.anchorNode)) {
lastRange = sel.getRangeAt(0).cloneRange();
}
}
box.addEventListener("keyup", saveSelection);
box.addEventListener("mouseup", saveSelection);
box.addEventListener("blur", saveSelection);
function setTaskId(id) {
taskId = id;
editorGen++; // 작업이 바뀌었다 — 이전 작업에서 시작한 이미지 업로드는 이 설명란에 넣지 않는다
const enabled = !!id;
if (imgInput) {
imgInput.disabled = !enabled;
if (imgInput.parentElement) imgInput.parentElement.style.opacity = enabled ? "1" : ".5";
}
if (hint) hint.textContent = enabled ? "" : "저장 후 이미지를 추가할 수 있습니다.";
}
function insertHtmlAtCursor(html) {
box.focus();
const sel = window.getSelection();
if (lastRange && (!sel.rangeCount || !box.contains(sel.anchorNode))) {
try { sel.removeAllRanges(); sel.addRange(lastRange); } catch (_) { lastRange = null; }
}
let inserted = false;
try { inserted = document.execCommand("insertHTML", false, html); } catch (_) { inserted = false; }
if (!inserted) {
if (sel && sel.rangeCount && box.contains(sel.anchorNode)) {
const range = sel.getRangeAt(0);
range.deleteContents();
const frag = range.createContextualFragment(html);
range.insertNode(frag);
range.collapse(false);
} else {
box.innerHTML += html;
}
}
saveSelection();
}
// 삽입 전 원본 크기를 확인해, 설명란보다 넓으면 90%로 줄여서 넣는다
// (그대로 넣으면 크기조절 핸들이 설명란 밖으로 삐져나간다).
function naturalImageSize(file) {
return new Promise(function (resolve) {
const url = URL.createObjectURL(file);
const img = new Image();
img.onload = function () { URL.revokeObjectURL(url); resolve({ width: img.naturalWidth }); };
img.onerror = function () { URL.revokeObjectURL(url); resolve(null); };
img.src = url;
});
}
// 업로드 중엔 저장을 막는다(안 그러면 업로드가 끝나기 전에 저장을 눌러
// 방금 넣은 이미지가 설명에서 통째로 빠진 채 저장되는 경우가 있었다).
let pendingUploads = 0;
let idleWaiters = [];
let editorGen = 0;
function beginUpload() {
pendingUploads++;
if (hint) hint.textContent = "이미지 업로드 중…";
}
function endUpload() {
pendingUploads = Math.max(0, pendingUploads - 1);
if (pendingUploads === 0 && hint) hint.textContent = taskId ? "" : "저장 후 이미지를 추가할 수 있습니다.";
if (pendingUploads === 0) { const w = idleWaiters; idleWaiters = []; w.forEach(function (fn) { fn(); }); }
}
// 업로드가 모두 끝날 때까지 기다린다 — 창 닫기·다른 작업 열기 전에 작업 창이 부른다.
function whenIdle() {
if (pendingUploads === 0) return Promise.resolve();
return new Promise(function (resolve) { idleWaiters.push(resolve); });
}
async function insertImageFile(file) {
if (!taskId) { alert("먼저 저장한 뒤 이미지를 추가할 수 있습니다."); return; }
if (box.getAttribute("contenteditable") === "false") return; // 읽기 전용
// 업로드를 시작한 작업·세대 — 끝났을 때 창이 다른 작업(또는 다시 연 같은 작업)으로 바뀌었으면
// 그 설명란에 넣지 않는다. 파일은 원래 작업의 첨부 파일로 이미 저장돼 있다.
const myTaskId = taskId, myGen = editorGen;
// 업로드는 비동기라 그 사이 포커스가 파일선택창 등으로 빠져나가면서
// contenteditable 의 선택범위가 사라지거나(브라우저가 엉뚱한 위치로
// 되살리기도 한다) 커서 위치가 틀어진다 — 업로드 시작 "직전"의 커서를
// 무조건 기억해뒀다가 삽입 시 그대로 복원한다(현재 라이브 셀렉션은
// 신뢰하지 않는다).
saveSelection();
const insertAt = lastRange ? lastRange.cloneRange() : null;
beginUpload();
const fd = new FormData();
fd.append("file", file);
try {
const results = await Promise.all([
naturalImageSize(file),
fetch("/project/api/tasks/" + myTaskId + "/attachments", { method: "POST", body: fd }),
]);
const dims = results[0], res = results[1];
if (!res.ok) { let m = res.statusText; try { m = (await res.json()).detail; } catch (_) {} throw new Error(m); }
const data = await res.json();
if (myGen !== editorGen || myTaskId !== taskId) {
showToast("이미지는 원래 작업의 첨부 파일로 저장됐습니다(작업 창이 바뀌어 설명에는 넣지 않았습니다).");
return;
}
const boxW = box.clientWidth || 0;
const widthAttr = (dims && dims.width && boxW && dims.width > boxW)
? ' width="' + Math.round(boxW * 0.9) + '"' : "";
box.focus();
if (insertAt) {
try { const sel = window.getSelection(); sel.removeAllRanges(); sel.addRange(insertAt); } catch (_) {}
}
insertHtmlAtCursor('<img src="/project/api/attachments/' + data.attachment.id + '/inline" alt=""' + widthAttr + '>');
} catch (e) { alert("이미지 업로드 실패: " + e.message); }
finally { endUpload(); }
}
box.addEventListener("paste", function (e) {
const items = (e.clipboardData && e.clipboardData.items) || [];
for (let i = 0; i < items.length; i++) {
if (items[i].type && items[i].type.indexOf("image/") === 0) {
e.preventDefault();
const file = items[i].getAsFile();
if (file) insertImageFile(file);
return;
}
}
// 이미지가 아니면 서식 없는 텍스트로만 붙여넣기(외부 사이트 서식 유입 방지).
// 단, 웹페이지 주소는 자동으로 링크(<a target="_blank">)로 바꾼다.
e.preventDefault();
const text = (e.clipboardData || window.clipboardData).getData("text/plain");
insertHtmlAtCursor(linkifyToHtml(text));
});
if (imgInput) imgInput.addEventListener("change", function () {
if (imgInput.files.length) insertImageFile(imgInput.files[0]);
imgInput.value = "";
});
return {
setTaskId: setTaskId,
setHtml: function (html) {
selectImg(null); lastRange = null;
box.innerHTML = html || "";
normalizeEditorLinks(box);
normalizeChecklists(); // 예전 방식(<input type=checkbox>) 체크리스트 → 글머리식
},
getHtml: function () { return box.innerHTML; },
isUploading: function () { return pendingUploads > 0; },
whenIdle: whenIdle,
setOnImageRemoved: function (fn) { onImageRemoved = fn; },
};
}
// ── 하위 업무(인라인) — 체크박스·제목·담당자·마감일을 한 줄에서 바로 저장 ──
function initSubtaskBlock() {
const listEl = el("pj-subtask-list");
if (!listEl) return null;
const input = el("pj-subtask-input");
const addAssignee = el("pj-subtask-add-assignee");
enhanceAssigneeSelect(addAssignee);
const addDue = el("pj-subtask-add-due");
enhanceDateInput(addDue, { placeholder: "마감일" }); // 아사나식 날짜 팝업
const addBtn = el("pj-subtask-add");
const formEl = listEl.parentNode ? listEl.parentNode.querySelector(".pj-subtask-form") : null;
let taskId = null, projectId = null, canDeleteFn = function () { return false; }, onChange = null, onOpen = null;
// ctxSeq — 작업 창이 바뀔 때마다 1 올린다. 늦게 온 담당자 후보·목록 그리기는 버린다(A→B 전환 중
// A 의 응답이 B 의 추가 칸·목록을 덮지 않게). readOnly — 연결된 프로젝트에서 본 작업(보기만).
let ctxSeq = 0;
let readOnly = false;
// 담당자 후보(프로젝트 멤버) — 줄마다 다시 받지 않게 프로젝트별로 한 번만.
const memberCache = {};
function memberEmails(pid) {
if (!memberCache[pid]) {
memberCache[pid] = api("GET", "/project/api/projects/" + pid + "/members")
.then(function (res) { return (res.members || []).map(function (m) { return m.user_email; }); })
.catch(function () { delete memberCache[pid]; return []; });
}
return memberCache[pid];
}
async function membersOptionsHtml(pid) {
const emails = await memberEmails(pid);
return emails.map(function (e) {
return '<option value="' + escapeHtml(e) + '">' + escapeHtml(idOf(e)) + "</option>";
}).join("");
}
// 제목 칸은 글자 길이만큼만(아사나) — 남는 자리를 누르면 하위 작업이 열린다.
let measureCtx = null;
function fitTitle(inp) {
if (!inp.isConnected) return;
const cs = getComputedStyle(inp);
measureCtx = measureCtx || document.createElement("canvas").getContext("2d");
const text = inp.value || inp.placeholder || "";
if (!measureCtx) { inp.style.width = (text.length * 1.1 + 2) + "em"; return; }
measureCtx.font = cs.fontWeight + " " + cs.fontSize + " " + cs.fontFamily;
const pad = parseFloat(cs.paddingLeft) + parseFloat(cs.paddingRight) +
parseFloat(cs.borderLeftWidth) + parseFloat(cs.borderRightWidth);
inp.style.width = Math.ceil(measureCtx.measureText(text).width + pad + 4) + "px";
}
// 하위 작업 한 줄(아사나식): ⠿ 끌어서 순서 변경 · ✓ 완료 · 제목(글자 폭만큼) ·
// [빈 곳 = 열기] · 마감일(날짜 글자만, 없으면 점선 달력 아이콘) · 담당자(아이콘만) · › 열기.
// 삭제는 우클릭 메뉴로(아사나처럼 줄에 × 없음).
function rowEl(sub, emails) {
const li = document.createElement("li");
li.className = "pj-subtask-row" + (sub.completed_at ? " is-done" : "");
li.dataset.id = sub.id;
li.innerHTML =
'<span class="pj-subtask-handle" title="드래그해서 순서 변경">' +
'<span class="material-symbols-outlined">drag_indicator</span></span>' +
'<button type="button" class="pj-subtask-check">' +
'<span class="material-symbols-outlined">check_circle</span></button>' +
'<input type="text" class="pj-subtask-title" />' +
subMetaHtml(sub, "pj-subtask-nsubs") +
'<span class="pj-subtask-fill"></span>' +
'<span class="pj-subtask-due"></span>' +
'<span class="pj-subtask-av"></span>' +
'<button type="button" class="pj-icon-btn pj-subtask-open" title="하위 작업 열기">' +
'<span class="material-symbols-outlined">chevron_right</span></button>';
const titleInp = li.querySelector(".pj-subtask-title");
const checkBtn = li.querySelector(".pj-subtask-check");
const dueEl = li.querySelector(".pj-subtask-due");
const avEl = li.querySelector(".pj-subtask-av");
titleInp.value = sub.title || "";
function renderCheck() {
li.classList.toggle("is-done", !!sub.completed_at);
checkBtn.title = sub.completed_at ? "완료 취소" : "완료로 표시";
}
function renderDue() {
const di = dueInfo(sub.due_date, !!sub.completed_at);
dueEl.className = "pj-subtask-due" + (di ? " " + di.cls : " is-empty");
dueEl.innerHTML = di ? escapeHtml(di.text) : DUE_EMPTY_ICON_SVG;
dueEl.title = sub.due_date ? dueTip(di) : "마감일 추가";
}
function renderAv() {
const e = sub.assignee_email || "";
avEl.className = "pj-subtask-av" + (e ? "" : " is-empty");
avEl.innerHTML = personIconHtml(e);
avEl.title = e ? idOf(e) : "담당자 지정";
}
renderCheck(); renderDue(); renderAv();
async function patch(fields) {
try {
const res = await api("PUT", "/project/api/tasks/" + sub.id, fields);
if (res && res.task) {
sub.completed_at = res.task.completed_at;
sub.due_date = res.task.due_date;
}
if (onChange) onChange();
return true;
} catch (e) { showToast("저장 실패: " + e.message, "error"); return false; }
}
titleInp.addEventListener("input", function () { fitTitle(titleInp); });
titleInp.addEventListener("keydown", function (e) { if (e.key === "Enter") { e.preventDefault(); titleInp.blur(); } });
titleInp.addEventListener("change", function () {
const v = titleInp.value.trim();
if (!v) { titleInp.value = sub.title || ""; fitTitle(titleInp); return; }
sub.title = v; patch({ title: v });
});
async function toggleDone() {
const done = !sub.completed_at;
sub.completed_at = done ? isoToday() : null;
renderCheck(); renderDue();
if (!(await patch({ completed: done }))) { sub.completed_at = done ? null : isoToday(); renderCheck(); renderDue(); }
}
checkBtn.addEventListener("click", function (e) { e.stopPropagation(); toggleDone(); });
// 마감일 — 보드와 같은 아사나식 날짜 팝업.
dueEl.addEventListener("click", function (e) {
e.stopPropagation();
openDatePopover(dueEl, {
due: sub.due_date, allowStart: false,
onChange: async function (p) {
const prev = sub.due_date;
sub.due_date = p.due_date || null;
renderDue();
if (!(await patch({ due_date: sub.due_date }))) { sub.due_date = prev; renderDue(); }
},
});
});
// 담당자 — 아이콘만. 누르면 "아이콘 + 이름" 메뉴(아사나).
avEl.addEventListener("click", function (e) {
e.stopPropagation();
const r = avEl.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, assigneeMenuItems(emails, sub.assignee_email, async function (v) {
if ((v || "") === (sub.assignee_email || "")) return;
const prev = sub.assignee_email;
sub.assignee_email = v;
renderAv();
if (!(await patch({ assignee_email: v, assignee_name: v ? idOf(v) : "" }))) { sub.assignee_email = prev; renderAv(); }
}));
});
function open() { if (onOpen) onOpen(sub); }
li.querySelector(".pj-subtask-open").addEventListener("click", function (e) { e.stopPropagation(); open(); });
// 제목 칸·아이콘 말고 줄의 나머지(빈 곳)를 누르면 하위 작업 열기(아사나).
li.addEventListener("click", function (e) {
if (e.target.closest(".pj-subtask-title, .pj-subtask-handle, button, .pj-subtask-due, .pj-subtask-av")) return;
open();
});
// 우클릭 — 열기 / 완료 / 삭제.
li.addEventListener("contextmenu", function (e) {
e.preventDefault();
const items = [
{ label: "열기", onClick: open },
{ label: sub.completed_at ? "완료 취소" : "완료로 표시", onClick: toggleDone },
];
if (canDeleteFn(sub.created_by)) {
items.push(null, {
label: "하위 작업 삭제", danger: true,
onClick: async function () {
if (!(await confirmTaskDelete(sub.id, sub.title, null))) return;
try {
await deleteTaskRequest(sub.id);
li.remove();
if (!listEl.querySelector(".pj-subtask-row")) listEl.innerHTML = "<li class='pj-empty-sm'>없음</li>";
if (onChange) onChange();
} catch (err) { showToast("삭제 실패: " + err.message, "error"); }
},
});
}
showContextMenu(e.clientX, e.clientY, items);
});
// 끌어서 순서 변경 — ⠿ 손잡이를 잡았을 때만 줄이 끌린다(제목 글자 선택과 안 섞이게).
const handle = li.querySelector(".pj-subtask-handle");
handle.addEventListener("mousedown", function () { li.draggable = true; });
li.addEventListener("dragstart", function (e) {
if (!li.draggable) return;
dragRow = li;
e.dataTransfer.setData("application/x-pj-subrow", String(sub.id));
e.dataTransfer.effectAllowed = "move";
li.classList.add("is-dragging");
});
li.addEventListener("dragend", function () {
li.draggable = false;
li.classList.remove("is-dragging");
dragRow = null;
});
if (readOnly) {
// 읽기 전용 — 제목·완료·마감일·담당자·순서·삭제 메뉴를 막고 "열기"만 남긴다(서버도 거절).
li.classList.add("is-readonly");
titleInp.readOnly = true;
handle.hidden = true;
li.addEventListener("click", function (e) {
if (e.target.closest(".pj-subtask-check,.pj-subtask-due,.pj-subtask-av")) {
e.preventDefault(); e.stopImmediatePropagation();
}
}, true);
li.addEventListener("contextmenu", function (e) { e.stopImmediatePropagation(); }, true);
}
return li;
}
// 하위 작업 줄 드래그 재정렬 — 목록(ul) 하나에 한 번만 건다.
let dragRow = null;
let orderBefore = "";
listEl.addEventListener("dragstart", function () {
orderBefore = rowIds().join(",");
});
function rowIds() {
return Array.prototype.map.call(listEl.querySelectorAll(".pj-subtask-row"), function (r) {
return parseInt(r.dataset.id, 10);
});
}
listEl.addEventListener("dragover", function (e) {
if (!dragRow) return;
e.preventDefault();
const over = e.target.closest(".pj-subtask-row");
if (!over || over === dragRow) return;
const r = over.getBoundingClientRect();
listEl.insertBefore(dragRow, (e.clientY - r.top) < r.height / 2 ? over : over.nextSibling);
});
listEl.addEventListener("drop", async function (e) {
if (!dragRow) return;
e.preventDefault();
const ids = rowIds();
if (ids.join(",") === orderBefore || !taskId) return;
try {
await api("PUT", "/project/api/tasks/" + taskId + "/subtasks/order", { ordered_ids: ids });
if (onChange) onChange();
} catch (err) { showToast("순서 변경 실패: " + err.message, "error"); }
});
async function render(subtasks) {
const seq = ctxSeq;
listEl.innerHTML = subtasks.length ? "" : "<li class='pj-empty-sm'>없음</li>";
if (!subtasks.length) return;
const emails = projectId && !readOnly ? await memberEmails(projectId) : [];
if (seq !== ctxSeq) return; // 그 사이 다른 작업 창 — 이 목록을 그리지 않는다
listEl.innerHTML = "";
subtasks.forEach(function (sub) { listEl.appendChild(rowEl(sub, emails)); });
listEl.querySelectorAll(".pj-subtask-title").forEach(fitTitle);
}
let adding = false;
if (addBtn) addBtn.addEventListener("click", async function () {
const title = (input.value || "").trim();
if (!title || adding || readOnly) return;
if (!taskId) { alert("먼저 작업을 저장한 뒤 하위 작업을 추가할 수 있습니다."); return; }
// 누른 순간의 상위 작업·프로젝트를 잡아 둔다 — 응답을 기다리는 동안 창이 바뀌어도 엉뚱한 작업에 붙지 않게.
const tid = taskId, pid = projectId, seq = ctxSeq;
const assigneeOpt = addAssignee ? addAssignee.selectedOptions[0] : null;
adding = true;
if (addBtn) addBtn.disabled = true;
try {
const res = await api("POST", "/project/api/projects/" + pid + "/tasks", {
title: title, parent_task_id: tid,
assignee_email: addAssignee ? addAssignee.value : "",
assignee_name: assigneeOpt ? assigneeOpt.textContent : "",
due_date: addDue ? (addDue.value || null) : null,
});
if (seq !== ctxSeq) return; // 다른 작업 창으로 바뀌었다 — 그 창의 목록·입력칸은 건드리지 않는다
input.value = "";
if (addAssignee) addAssignee.value = "";
if (addDue) addDue.value = "";
const emails = await memberEmails(pid);
if (seq !== ctxSeq) return;
const empty = listEl.querySelector(".pj-empty-sm");
if (empty) empty.remove();
const row = rowEl(res.task, emails);
listEl.appendChild(row);
fitTitle(row.querySelector(".pj-subtask-title"));
if (onChange) onChange();
} catch (e) { alert("추가 실패: " + e.message); }
finally { adding = false; if (addBtn) addBtn.disabled = false; }
});
if (input) input.addEventListener("keydown", function (e) {
if (isImeEnter(e)) return; // 한글 조합 확정 Enter 는 추가하지 않는다
if (e.key === "Enter") { e.preventDefault(); if (addBtn) addBtn.click(); }
});
return {
// 다른 작업을 열 때 — 추가 칸에 쓰다 만 제목·담당자·마감일이 새 작업으로 따라가지 않게
// 비우고, 상세를 다 받기 전(setContext 전)에 Enter 를 눌러도 이전 작업에 붙지 않게 끊는다.
reset: function () {
ctxSeq++;
taskId = null;
readOnly = false;
if (formEl) formEl.hidden = false;
if (input) input.value = "";
if (addAssignee) addAssignee.value = "";
if (addDue) addDue.value = "";
},
setContext: function (opts) {
const seq = ++ctxSeq;
taskId = opts.taskId; projectId = opts.projectId;
canDeleteFn = opts.canDelete || function () { return false; };
onChange = opts.onChange || null;
onOpen = opts.onOpen || null;
readOnly = !!opts.readOnly;
if (formEl) formEl.hidden = readOnly;
if (addAssignee && projectId && !readOnly) {
membersOptionsHtml(projectId).then(function (html) {
if (seq !== ctxSeq) return; // 늦게 온 A 의 담당자 후보가 B 의 추가 칸을 덮지 않게
addAssignee.innerHTML = "<option value=''>담당자 없음</option>" + html;
});
}
},
render: render,
};
}
// ── 연결된 프로젝트(멀티호밍, 아사나식) — 업무 하나를 다른 프로젝트의 세션에도 연결 ──
function initLinksBlock() {
const chipsEl = el("pj-link-chips");
if (!chipsEl) return null;
const projSel = el("pj-link-project");
const stageSel = el("pj-link-stage");
const saveBtn = el("pj-link-save");
const linkForm = el("pj-link-form");
let taskId = null, homeProjectId = null, onChange = null;
let ctxSeq = 0, readOnly = false;
function chipEl(link) {
const span = document.createElement("span");
span.className = "pj-link-chip";
span.innerHTML =
'<span style="color:' + escapeHtml(link.project_color || "#4573d2") + '">●</span> ' +
escapeHtml(link.project_name || "") +
(link.stage_name ? " · " + escapeHtml(link.stage_name) : "") +
(readOnly ? "" : ' <button type="button" class="pj-link-del" title="연결 해제">×</button>');
if (readOnly) return span;
const tid = taskId;
span.querySelector(".pj-link-del").addEventListener("click", async function () {
if (!(await confirm("'" + (link.project_name || "") + "' 연결을 해제할까요?"))) return;
try {
await api("DELETE", "/project/api/tasks/" + tid + "/links/" + link.project_id);
span.remove();
if (onChange) onChange();
} catch (e) { alert("해제 실패: " + e.message); }
});
return span;
}
function render(links) {
chipsEl.innerHTML = links.length ? "" : "<span class='pj-empty-sm'>없음</span>";
links.forEach(function (l) { chipsEl.appendChild(chipEl(l)); });
}
async function loadProjects() {
const seq = ctxSeq;
projSel.innerHTML = "<option value=''>불러오는 중…</option>";
stageSel.innerHTML = "<option value=''>프로젝트를 먼저 선택하세요</option>";
try {
const res = await api("GET", "/project/api/projects");
if (seq !== ctxSeq) return;
const list = (res.projects || []).filter(function (p) {
return p.id !== homeProjectId && !p.parent_id;
});
projSel.innerHTML = "<option value=''>프로젝트 선택…</option>" + list.map(function (p) {
return '<option value="' + p.id + '">' + escapeHtml(p.name) + "</option>";
}).join("");
} catch (e) { projSel.innerHTML = "<option value=''>불러오기 실패</option>"; }
}
if (projSel) projSel.addEventListener("change", async function () {
const pid = parseInt(projSel.value, 10);
if (!pid) { stageSel.innerHTML = "<option value=''>프로젝트를 먼저 선택하세요</option>"; return; }
stageSel.innerHTML = "<option value=''>불러오는 중…</option>";
try {
const res = await api("GET", "/project/api/projects/" + pid + "/stages");
stageSel.innerHTML = (res.stages || []).map(function (s) {
return '<option value="' + s.id + '">' + escapeHtml(s.name) + "</option>";
}).join("");
} catch (e) { stageSel.innerHTML = "<option value=''>불러오기 실패</option>"; }
});
if (saveBtn) saveBtn.addEventListener("click", async function () {
const pid = parseInt(projSel.value, 10);
if (!pid) { alert("프로젝트를 선택하세요."); return; }
if (!taskId || readOnly) { alert("먼저 작업을 저장한 뒤 연결할 수 있습니다."); return; }
const tid = taskId, seq = ctxSeq; // 누른 순간의 작업 — 창이 바뀌어도 엉뚱한 작업을 연결하지 않게
try {
await api("POST", "/project/api/tasks/" + tid + "/links",
{ project_id: pid, stage_id: stageSel.value ? parseInt(stageSel.value, 10) : null });
if (seq !== ctxSeq) return;
projSel.value = "";
stageSel.innerHTML = "<option value=''>프로젝트를 먼저 선택하세요</option>";
if (onChange) onChange();
} catch (e) { alert("추가 실패: " + e.message); }
});
return {
setContext: function (opts) {
ctxSeq++;
taskId = opts.taskId; homeProjectId = opts.projectId; onChange = opts.onChange || null;
readOnly = !!opts.readOnly;
el("pj-links-block").classList.toggle("is-readonly", readOnly);
if (linkForm) linkForm.hidden = readOnly;
if (!readOnly) loadProjects();
},
render: render,
};
}
// 화면에 보이는 멤버 이름 = 이메일 아이디, 맨 앞 글자만 대문자(king → King).
function capName(s) {
s = String(s == null ? "" : s);
return s.charAt(0).toUpperCase() + s.slice(1);
}
function idOf(email) {
return capName(String(email == null ? "" : email).split("@")[0]);
}
// ════════════════════════════════════════════════════════════
// 업무 필터·정렬 (프로젝트 화면 필터 바 + 내 업무 화면 공용)
// f = { q, status, assignee, due, priority, sort }
// status : all | open | done
// assignee : all | me | none | <email>
// due : all | overdue | today | week | none
// priority : all | high | normal | low
// sort : manual | due | priority | title | assignee | created
// 서버 재조회 없이 이미 받은 업무 목록에서 거른다.
// ════════════════════════════════════════════════════════════
const TASK_FILTER_DEFAULT = { q: "", status: "all", assignee: "all", due: "all", priority: "all", sort: "manual" };
function localIso(d) {
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
// "이번 주" 마감 = 오늘부터 이번 주 일요일까지(월~일을 한 주로 본다).
function endOfWeekIso(todayIso) {
const d = new Date(todayIso + "T00:00:00");
const add = (7 - d.getDay()) % 7; // 일요일=0 → 오늘이 일요일이면 오늘까지
d.setDate(d.getDate() + add);
return localIso(d);
}
// 설명 HTML → 검색용 평문(업무 객체에 캐시 — 설명이 바뀌면 다시 만든다).
function taskSearchText(t) {
if (t._searchSrc !== t.description) {
t._searchSrc = t.description;
t._searchDesc = String(t.description || "").replace(/<[^>]*>/g, " ")
.replace(/&nbsp;/g, " ").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")
.toLowerCase();
}
return t._searchDesc;
}
function taskFilterActive(f) {
return !!(f.q || f.status !== "all" || f.assignee !== "all" || f.due !== "all" || f.priority !== "all");
}
function taskMatchesFilter(t, f, me, todayIso) {
if (f.status === "open" && t.completed_at) return false;
if (f.status === "done" && !t.completed_at) return false;
const a = (t.assignee_email || "").toLowerCase();
if (f.assignee === "me" && a !== me) return false;
if (f.assignee === "none" && a) return false;
if (f.assignee !== "all" && f.assignee !== "me" && f.assignee !== "none" && a !== f.assignee) return false;
if (f.priority !== "all" && (t.priority || "normal") !== f.priority) return false;
const due = t.due_date ? t.due_date.slice(0, 10) : "";
if (f.due === "none" && due) return false;
if (f.due === "overdue" && !(due && due < todayIso && !t.completed_at)) return false;
if (f.due === "today" && due !== todayIso) return false;
if (f.due === "week" && !(due && due >= todayIso && due <= endOfWeekIso(todayIso))) return false;
if (f.q) {
const q = f.q.toLowerCase();
const hay = [t.title, idOf(a), t.project_name, t.stage_name].join(" ").toLowerCase();
if (hay.indexOf(q) < 0 && taskSearchText(t).indexOf(q) < 0) return false;
}
return true;
}
const PRIORITY_RANK = { high: 0, normal: 1, low: 2 };
function sortTasksBy(rows, sort) {
if (!sort || sort === "manual") return rows;
const key = {
due: function (t) { return t.due_date || "9999-99-99"; },
priority: function (t) { return PRIORITY_RANK[t.priority || "normal"]; },
title: function (t) { return (t.title || "").toLowerCase(); },
assignee: function (t) { return t.assignee_email ? idOf(t.assignee_email).toLowerCase() : "￿"; },
created: function (t) { return -t.id; },
}[sort];
if (!key) return rows;
return rows.slice().sort(function (a, b) {
const va = key(a), vb = key(b);
if (va < vb) return -1;
if (va > vb) return 1;
return (a.due_date || "9999").localeCompare(b.due_date || "9999") || a.id - b.id;
});
}
// ── 좌측 사이드바 전체 검색 — 제목·설명·댓글, 내가 볼 수 있는 모든 프로젝트 ──
function initGlobalSearch() {
const input = el("pj-global-search");
const box = el("pj-search-results");
if (!input || !box) return;
let timer = null, seq = 0, items = [], active = -1;
// body 로 옮긴다 — 화면 배율(.erp-app zoom) 안에 있으면 fixed 좌표가 배율만큼 어긋난다.
document.body.appendChild(box);
function close() { box.hidden = true; active = -1; }
// 사이드바는 자체 스크롤 영역이라 안에 두면 결과창이 잘린다 — 화면 기준(fixed)으로 띄운다.
function place() {
const r = input.getBoundingClientRect();
box.style.left = r.left + "px";
box.style.top = (r.bottom + 6) + "px";
box.style.width = Math.max(380, r.width) + "px";
box.style.maxHeight = Math.max(200, window.innerHeight - r.bottom - 24) + "px";
}
function show() { place(); box.hidden = false; }
window.addEventListener("resize", function () { if (!box.hidden) place(); });
function highlight(text, q) {
const s = String(text || "");
const i = s.toLowerCase().indexOf(q.toLowerCase());
if (!q || i < 0) return escapeHtml(s);
return escapeHtml(s.slice(0, i)) + "<mark>" + escapeHtml(s.slice(i, i + q.length)) + "</mark>" + escapeHtml(s.slice(i + q.length));
}
function go(r) { location.href = "/project/t/" + r.id; }
function setActive(i) {
const rows = box.querySelectorAll(".pj-sr-item");
rows.forEach(function (r, k) { r.classList.toggle("is-active", k === i); });
active = i;
if (rows[i]) rows[i].scrollIntoView({ block: "nearest" });
}
const MATCH_LABEL = { title: "제목", description: "설명", comment: "댓글" };
function render(q) {
if (!items.length) {
box.innerHTML = '<div class="pj-sr-empty">"' + escapeHtml(q) + '" 검색 결과가 없습니다.</div>';
show();
return;
}
box.innerHTML = items.map(function (r, i) {
return '<div class="pj-sr-item' + (r.completed ? " is-done" : "") + '" data-i="' + i + '">' +
'<div class="pj-sr-title">' +
(r.completed ? '<span class="material-symbols-outlined pj-sr-check">check_circle</span>' : "") +
(r.parent_title ? '<span class="pj-sr-parent">' + escapeHtml(r.parent_title) + " ›</span> " : "") +
highlight(r.title, q) + "</div>" +
'<div class="pj-sr-meta"><span style="color:' + escapeHtml(r.project_color) + '">●</span> ' +
escapeHtml(r.project_name) +
(r.assignee_email ? " · " + escapeHtml(idOf(r.assignee_email)) : "") +
(r.due_date ? " · 마감 " + escapeHtml(fmtDateKr(r.due_date)) : "") + "</div>" +
(r.snippet && r.match !== "title"
? '<div class="pj-sr-snippet"><span class="pj-sr-where">' + MATCH_LABEL[r.match] + "</span> " + highlight(r.snippet, q) + "</div>"
: "") +
"</div>";
}).join("");
show();
box.querySelectorAll(".pj-sr-item").forEach(function (row) {
row.addEventListener("mousedown", function (e) { e.preventDefault(); go(items[+row.dataset.i]); });
});
active = -1;
}
async function search() {
const q = input.value.trim();
if (q.length < 2) { items = []; close(); return; }
const my = ++seq;
try {
const res = await api("GET", "/project/api/search?q=" + encodeURIComponent(q));
if (my !== seq) return; // 더 늦게 친 검색어의 결과가 이미 왔다
items = res.results || [];
render(q);
} catch (e) {
if (my === seq) { box.innerHTML = '<div class="pj-sr-empty">검색 실패: ' + escapeHtml(e.message) + "</div>"; show(); }
}
}
input.addEventListener("input", function () { clearTimeout(timer); timer = setTimeout(search, 250); });
input.addEventListener("focus", function () { if (items.length && input.value.trim().length >= 2) show(); });
input.addEventListener("blur", function () { setTimeout(close, 150); });
input.addEventListener("keydown", function (e) {
if (e.key === "ArrowDown" && items.length) { e.preventDefault(); setActive(Math.min(items.length - 1, active + 1)); }
else if (e.key === "ArrowUp" && items.length) { e.preventDefault(); setActive(Math.max(0, active - 1)); }
else if (e.key === "Enter") {
e.preventDefault();
if (active >= 0 && items[active]) go(items[active]);
else if (items.length === 1) go(items[0]);
else { clearTimeout(timer); search(); }
} else if (e.key === "Escape") { close(); input.blur(); }
});
// 어디서든 "/" 를 누르면 검색창으로(입력칸·편집 중일 땐 제외) — 아사나 단축키와 같다.
document.addEventListener("keydown", function (e) {
if (e.key !== "/" || e.ctrlKey || e.metaKey || e.altKey) return;
const t = e.target;
if (t && (t.isContentEditable || /^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName))) return;
e.preventDefault();
input.focus();
input.select();
});
}
function escapeHtml(s) {
return String(s == null ? "" : s)
.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
.replace(/"/g, "&quot;").replace(/'/g, "&#39;");
}
// ── 알림 벨 (미읽음 배지) ──
async function initBell() {
const badge = document.getElementById("pj-bell-badge");
if (!badge) return;
const bell = badge.closest(".pj-bell");
try {
const res = await fetch("/project/api/notifications/unread-count");
if (!res.ok) return;
const d = await res.json();
if (d.unread > 0) {
badge.textContent = d.unread > 99 ? "99+" : d.unread;
badge.hidden = false;
if (bell) bell.classList.add("has-unread"); // 종 흔들림 애니메이션
}
} catch (_) {}
}
// ── 좌측 사이드바 "수신함" 배지 — 아직 확인하지 않은 @태그 개수 ──
async function initMentionBadge() {
const badge = document.getElementById("pj-mention-badge");
if (!badge) return;
try {
const res = await api("GET", "/project/api/mentions/unread-count");
const n = res.unread || 0;
badge.textContent = n > 99 ? "99+" : n;
badge.hidden = n === 0;
} catch (_) {}
}
// ── 수신함: "나를 태그한 업무" 목록 ──
// 항목을 누르면 확인 처리(읽음)하고, "열기"는 그 업무의 편집 팝업까지 연다
// (?task= — project.js 의 프로젝트 화면이 받아서 처리).
function initMentionInbox() {
const list = document.getElementById("pj-mention-tasks");
const readAll = document.getElementById("pj-mentions-readall");
const counter = document.getElementById("pj-mention-unread");
if (!list && !readAll) return;
function setCounter(n) {
if (!counter) return;
counter.textContent = n;
counter.hidden = n <= 0;
}
function remaining() {
return list ? list.querySelectorAll(".pj-mention-item.is-unread").length : 0;
}
async function markRead(li) {
if (!li.classList.contains("is-unread")) return;
try {
await api("POST", "/project/api/mentions/read", { task_id: Number(li.dataset.taskId) });
li.classList.remove("is-unread");
setCounter(remaining());
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
}
if (readAll) readAll.addEventListener("click", async function () {
try {
await api("POST", "/project/api/mentions/read", {});
if (list) list.querySelectorAll(".pj-mention-item.is-unread")
.forEach(function (li) { li.classList.remove("is-unread"); });
setCounter(0);
} catch (e) { showToast("처리 실패: " + e.message, "error"); }
});
if (list) list.querySelectorAll(".pj-mention-item").forEach(function (li) {
li.addEventListener("click", function (e) {
if (e.target.closest("a")) return; // '열기' 링크는 그대로 통과
markRead(li);
});
const go = li.querySelector(".pj-inbox-go");
if (go) go.addEventListener("click", function () { markRead(li); });
});
}
// ── 수신함 "확인" — 페이지를 떠나지 않고 오른쪽 패널에 작업 창만 띄운다(아사나식).
// 작업 창 코드는 프로젝트 화면에 있으므로 그 화면을 ?embed=1 로 iframe 에 연다
// (project.html 이 embed 모드에서 작업 창 외에는 숨긴다). 작업 창을 닫으면
// iframe 이 postMessage("pj-embed-close") 로 알려 패널도 닫는다.
function initInboxTaskPanel() {
if (!document.querySelector(".pj-inbox-view")) return;
let panel = null;
let selected = null;
function close() {
if (!panel || !panel.classList.contains("is-open")) return;
panel.classList.remove("is-open");
if (selected) selected.classList.remove("is-selected");
selected = null;
const p = panel;
setTimeout(function () { if (!p.classList.contains("is-open")) p.querySelector("iframe").src = "about:blank"; }, 250);
}
function open(url, li) {
if (!panel) {
panel = document.createElement("div");
panel.className = "pj-inbox-panel";
panel.innerHTML = '<iframe title="작업"></iframe>';
document.body.appendChild(panel);
try {
const w = parseInt(localStorage.getItem("pj_task_panel_w") || "", 10);
if (w) panel.style.width = "min(" + Math.round(w * uiZoom()) + "px, 92vw)";
} catch (_) {}
}
if (selected) selected.classList.remove("is-selected");
selected = li;
if (li) li.classList.add("is-selected");
panel.querySelector("iframe").src = url + (url.indexOf("?") >= 0 ? "&" : "?") + "embed=1";
void panel.offsetWidth;
panel.classList.add("is-open");
}
window.addEventListener("message", function (e) {
if (e.origin === location.origin && e.data && e.data.type === "pj-embed-close") close();
});
document.addEventListener("keydown", function (e) {
if (e.key === "Escape") close();
});
// 캡처 단계 — 각 목록의 읽음 처리(버블 단계)는 그대로 돈다.
document.addEventListener("click", function (e) {
const a = e.target.closest && e.target.closest(".pj-inbox-go[data-task-id]");
if (!a) return;
if (e.ctrlKey || e.metaKey || e.shiftKey || e.button === 1) return; // 새 탭 열기는 그대로
e.preventDefault();
open(a.getAttribute("href"), a.closest(".pj-inbox-item"));
}, true);
}
// ── 알림센터 페이지 ──
function initInbox() {
const inbox = document.getElementById("pj-inbox");
const readAll = document.getElementById("pj-readall");
if (!inbox && !readAll) return;
if (readAll) readAll.addEventListener("click", async function () {
try {
await fetch("/project/api/notifications/read-all", { method: "POST" });
if (inbox) inbox.querySelectorAll(".pj-inbox-item.is-unread").forEach(function (li) {
li.classList.remove("is-unread");
});
}
catch (e) { showToast("실패: " + e.message, "error"); }
});
async function markRead(li) {
if (!li.classList.contains("is-unread")) return;
try {
await fetch("/project/api/notifications/" + li.dataset.id + "/read", { method: "POST" });
li.classList.remove("is-unread");
} catch (_) {}
}
if (inbox) inbox.querySelectorAll(".pj-inbox-item").forEach(function (li) {
li.addEventListener("click", function () { markRead(li); }); // '확인' 포함
li.addEventListener("contextmenu", function (e) {
if (!li.classList.contains("is-unread")) return; // 이미 읽었으면 메뉴 없음
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "읽음으로 표시", onClick: function () { markRead(li); } },
]);
});
});
}
// ── 실시간 새로고침 ──
// 다른 사용자가 프로젝트/업무/댓글/멤버/단계를 추가·수정하면, 같은 화면을 열어둔
// 모든 사용자에게 8초 주기로 반영한다. 전체 새로고침 대신 배경 목록만 조용히
// 다시 받아 patch 한다(입력 중인 모달 폼은 건드리지 않음) — initMyTasks()/
// initProject() 가 끝나면서 각자 softSyncProjectRef 를 채워준다(내 업무
// 화면은 목록 전체, 프로젝트 화면은 보드/리스트/멤버).
// initLiveRefresh 는 어느 페이지든 항상 이 하나로 처리.
let softSyncProjectRef = null;
function initLiveRefresh() {
if (!document.querySelector(".pj-wrap, .pj-project-view")) return;
// 탭이 안 보이는 동안(다른 탭/최소화)은 묻지 않는다 — 열어둔 탭 수만큼
// 서버에 헛요청이 쌓였다. 다시 보이면 바로 한 번 확인한다.
// observed = 서버에서 마지막으로 본 버전, applied = 화면에 성공적으로 반영한 버전.
// 예전엔 동기화 전에 기준값을 바꿔서, 스냅샷이 한 번 실패하면 같은 버전은 영영 다시 받지
// 않았다. 이제 반영에 성공해야 applied 를 올리고, 실패하면 다음 주기(실패가 이어지면
// 16·32·60초로 늘려 폭주 없이)에 다시 시도한다. 동기화 중에는 겹쳐 돌지 않고, 그 사이
// 버전이 또 바뀌면 끝난 뒤 다음 주기에 한 번 더 받는다.
let observed = null;
let applied = null;
let syncing = false;
let failures = 0;
let timer = null;
async function syncOnce() {
// 회의록 패널을 보는 동안은 이전 프로젝트 화면의 자동 갱신이 왼쪽 메뉴를 다시 만들지 않게 한다.
if (document.querySelector(".pj-meeting-panel-host")) return;
if (syncing || observed === null || observed === applied) return;
syncing = true;
const target = observed;
let ok = true;
try {
initBell();
initMentionBadge();
if (softSyncProjectRef) ok = (await softSyncProjectRef()) !== false;
} catch (_) { ok = false; }
syncing = false;
if (ok) { applied = target; failures = 0; } else { failures++; }
}
async function poll() {
timer = null;
if (document.hidden) return;
try {
const res = await fetch("/project/api/live-version");
if (res.ok) {
const d = await res.json();
if (observed === null) { observed = applied = d.ts; } // 처음 본 값은 이미 화면에 있는 값
else observed = d.ts;
}
} catch (_) {}
await syncOnce();
const delay = failures ? Math.min(60000, 8000 * Math.pow(2, Math.min(failures, 3))) : 8000;
if (!timer && !document.hidden) timer = setTimeout(poll, delay);
}
window.pjLiveRefreshState = function () { // 테스트·점검용
return { observed: observed, applied: applied, syncing: syncing, failures: failures };
};
if (window.__PJ_TEST__) window.__pjLivePoll = poll; // 자동 테스트 전용 — 타이머 없이 한 번 확인
document.addEventListener("visibilitychange", function () {
if (document.hidden) {
if (timer) { clearTimeout(timer); timer = null; }
} else if (!timer) {
poll();
}
});
// 기준값은 바로 잡는다 — 예전엔 첫 확인이 8초 뒤라, 화면을 연 직후 8초
// 사이에 생긴 변경은 기준값에 묻혀 반영되지 않았다.
poll();
}
// ── 항상 보이는 스크롤 막대 ──
// 윈도우/엣지가 오버레이(자동숨김) 스크롤바를 쓰면 네이티브 막대는 마우스를
// 올리거나 스크롤 중일 때만 잠깐 보이고, ::-webkit-scrollbar 커스텀도
// 무시된다(DevTools 박스모델에서 두께 0 확인). 그래서 자체 스크롤하는 패널은
// 네이티브 막대를 CSS 로 숨기고(.pj-vbar-* 참고) 여기서 막대를 직접 그린다.
// 휠·키보드 스크롤은 그대로 동작하고, 막대 드래그/트랙 클릭도 지원한다.
function attachScrollIndicator(scroller) {
if (!scroller || scroller.dataset.pjVbar) return;
scroller.dataset.pjVbar = "1";
const anchor = document.createElement("div");
anchor.className = "pj-vbar-anchor";
anchor.innerHTML = '<div class="pj-vbar-track" hidden><div class="pj-vbar-thumb"></div></div>';
scroller.insertBefore(anchor, scroller.firstChild);
const track = anchor.firstChild;
const thumb = track.firstChild;
let thumbH = 0, thumbTop = 0;
function update() {
const sh = scroller.scrollHeight, ch = scroller.clientHeight;
if (ch <= 0 || sh <= ch + 1) { if (!track.hidden) track.hidden = true; return; }
if (track.hidden) track.hidden = false;
thumbH = Math.max(28, Math.round(ch * ch / sh));
thumbTop = Math.round((ch - thumbH) * scroller.scrollTop / (sh - ch));
// 같은 값이면 안 쓴다 — MutationObserver 가 자기 변경에 반응해 도는 걸 막는다.
const trackH = ch + "px", th = thumbH + "px", tf = "translateY(" + thumbTop + "px)";
if (track.style.height !== trackH) track.style.height = trackH;
if (thumb.style.height !== th) thumb.style.height = th;
if (thumb.style.transform !== tf) thumb.style.transform = tf;
}
scroller.addEventListener("scroll", update, { passive: true });
scroller.addEventListener("load", update, true); // 아바타 이미지 로드로 높이가 바뀔 때
window.addEventListener("resize", update);
if (window.ResizeObserver) new ResizeObserver(update).observe(scroller);
if (window.MutationObserver) {
new MutationObserver(function (records) {
for (let i = 0; i < records.length; i++) {
if (!anchor.contains(records[i].target)) { update(); return; }
}
}).observe(scroller, { childList: true, subtree: true, attributes: true, characterData: true });
}
let dragging = false, startY = 0, startTop = 0;
thumb.addEventListener("mousedown", function (e) {
e.preventDefault(); e.stopPropagation();
dragging = true; startY = e.clientY; startTop = scroller.scrollTop;
thumb.classList.add("is-dragging");
});
document.addEventListener("mousemove", function (e) {
if (!dragging) return;
const sh = scroller.scrollHeight, ch = scroller.clientHeight, room = ch - thumbH;
if (room <= 0) return;
scroller.scrollTop = startTop + (e.clientY - startY) * (sh - ch) / room;
});
document.addEventListener("mouseup", function () {
if (dragging) { dragging = false; thumb.classList.remove("is-dragging"); }
});
track.addEventListener("mousedown", function (e) {
if (e.target !== track) return;
e.preventDefault();
const y = e.clientY - track.getBoundingClientRect().top;
scroller.scrollTop += (y < thumbTop ? -1 : 1) * scroller.clientHeight * 0.9;
});
update();
}
// 공용 왼쪽 메뉴 너비: 170~500px, 마우스·방향키로 조절하고 브라우저에 기억.
function initSideResize() {
const layout = document.querySelector(".pj-layout");
const side = layout && layout.querySelector(".pj-side");
if (!side) return;
const key = "pj_side_w";
const handle = document.createElement("div");
handle.className = "pj-side-resizer"; handle.tabIndex = 0;
handle.setAttribute("role", "separator"); handle.setAttribute("aria-orientation", "vertical");
handle.setAttribute("aria-label", "왼쪽 메뉴 너비 조절");
handle.setAttribute("aria-valuemin", "170"); handle.setAttribute("aria-valuemax", "500");
handle.title = "끌어서 메뉴 너비 조절 (최소 170px)";
layout.appendChild(handle);
function width() { return parseInt(layout.style.getPropertyValue("--pj-side-w"), 10) || Math.round(side.getBoundingClientRect().width / uiZoom()) || 250; }
let currentWidth = width();
function apply(w) {
w = Math.max(170, Math.min(500, Math.round(w)));
// 같은 픽셀 너비면 스타일을 다시 쓰거나 화면을 다시 계산하지 않는다.
if (w === currentWidth && layout.style.getPropertyValue("--pj-side-w") === w + "px") return;
currentWidth = w;
layout.style.setProperty("--pj-side-w", w + "px"); handle.setAttribute("aria-valuenow", String(w));
}
function remember() { try { localStorage.setItem(key, String(currentWidth)); } catch (_) {} }
try { const saved = Number(localStorage.getItem(key)); if (Number.isFinite(saved) && saved > 0) apply(saved); } catch (_) {}
handle.setAttribute("aria-valuenow", String(currentWidth));
let finishDrag = null;
handle.addEventListener("mousedown", function (e) {
if (e.button !== 0 || finishDrag) return;
e.preventDefault();
currentWidth = width(); // 기본 너비는 창 크기에 따라 250px/220px로 바뀔 수 있다.
const x = e.clientX, w = currentWidth, zoom = uiZoom();
let pendingWidth = w, frame = null;
handle.classList.add("is-dragging"); document.documentElement.classList.add("pj-side-resizing");
// 마우스 이벤트가 화면 주사율보다 빨라도 최신 위치만 프레임당 한 번 반영한다.
function flush() { frame = null; apply(pendingWidth); }
function move(ev) {
pendingWidth = w + (ev.clientX - x) / zoom;
if (frame === null) frame = window.requestAnimationFrame(flush);
}
function up() {
// 마지막 프레임 전에 놓아도 마지막 이동 위치를 반영하고 예약된 콜백을 정리한다.
if (frame !== null) { window.cancelAnimationFrame(frame); flush(); }
document.removeEventListener("mousemove", move); document.removeEventListener("mouseup", up);
window.removeEventListener("blur", up); finishDrag = null;
handle.classList.remove("is-dragging"); document.documentElement.classList.remove("pj-side-resizing"); remember();
// resize 는 목표 표의 모든 글 높이·달력 등까지 재계산하므로 드래그 종료 때만 보낸다.
if (currentWidth !== w) window.dispatchEvent(new Event("resize"));
}
finishDrag = up;
document.addEventListener("mousemove", move); document.addEventListener("mouseup", up);
window.addEventListener("blur", up); // 창 밖에서 놓아도 드래그 상태가 남지 않게 한다.
});
handle.addEventListener("keydown", function (e) {
if (!['ArrowLeft', 'ArrowRight', 'Home', 'End'].includes(e.key)) return;
e.preventDefault();
if (finishDrag) finishDrag();
currentWidth = width();
const before = currentWidth;
apply(e.key === "Home" ? 170 : e.key === "End" ? 500 : currentWidth + (e.key === "ArrowLeft" ? -10 : 10)); remember();
if (currentWidth !== before) window.dispatchEvent(new Event("resize"));
});
handle.addEventListener("dblclick", function () {
if (finishDrag) finishDrag();
layout.style.removeProperty("--pj-side-w");
currentWidth = width();
try { localStorage.removeItem(key); } catch (_) {}
handle.setAttribute("aria-valuenow", String(currentWidth)); window.dispatchEvent(new Event("resize"));
});
}
function initScrollIndicators() {
document.querySelectorAll(".pj-side, .pj-mytasks-pane, .pj-inbox-pane")
.forEach(attachScrollIndicator);
}
// ── 마우스를 따라다니는 작은 툴팁 — [data-tip] 달린 요소 아무데나 공용.
// 지금은 제목 옆 프로젝트 멤버 아이콘(이름 표시)에 쓴다. 나중에 그려지는
// 요소에도 붙도록 이벤트 위임 방식이다.
// ── 공용 말풍선(아사나식: 어두운 배경 + 아래 꼬리, 커서 바로 위) ──
// 프로젝트 화면의 "모든" 말풍선은 이것 하나로 통일한다(앞으로 추가하는 기능도).
// · data-tip="문구" 를 달면 이 말풍선이 뜬다.
// · 브라우저 기본 title 말풍선도 자동으로 이걸로 바뀐다 — 마우스를 올리는
// 순간 title 을 data-tip 으로 옮기고 title 은 지운다(기본 말풍선 억제).
// 그래서 새 코드에서 title= 을 써도 같은 모양이 된다.
// 이벤트 위임이라 나중에 그려지는 요소도 따로 배선할 필요가 없다.
function initHoverTips() {
let tipEl = null;
let shown = false;
function show(text, x, y) {
if (!tipEl) {
tipEl = document.createElement("div");
tipEl.className = "pj-hovertip";
document.body.appendChild(tipEl);
}
tipEl.textContent = text;
tipEl.hidden = false;
// 화면 가장자리 보정 — 좌우로 넘치면 말풍선만 안쪽으로 밀고 꼬리는
// 커서를 계속 가리키게(--pj-tip-shift). 위가 모자라면 커서 아래로 뒤집는다.
const w = tipEl.offsetWidth, h = tipEl.offsetHeight;
const vw = document.documentElement.clientWidth;
const cx = Math.min(Math.max(x, 8 + w / 2), vw - 8 - w / 2);
const below = y - 16 - h < 4;
tipEl.classList.toggle("is-below", below);
tipEl.style.setProperty("--pj-tip-shift", (x - cx) + "px");
tipEl.style.left = cx + "px";
tipEl.style.top = (below ? y + 22 : y - 10) + "px";
}
function hide() { shown = false; if (tipEl) tipEl.hidden = true; }
document.addEventListener("mouseover", function (e) {
const el = e.target.closest ? e.target.closest("[title]") : null;
if (!el) return;
const t = el.getAttribute("title");
if (t) el.dataset.tip = t; // 코드가 title 을 새로 바꿨으면 최신 값으로
el.removeAttribute("title");
}, true);
document.addEventListener("mousemove", function (e) {
const target = e.target.closest ? e.target.closest("[data-tip]") : null;
if (!target || !target.dataset.tip) { if (shown) hide(); return; }
shown = true;
show(target.dataset.tip, e.clientX, e.clientY);
});
// 누르거나 스크롤하면 숨긴다 — 클릭으로 요소가 다시 그려지면 말풍선만
// 허공에 남는 일이 없게.
document.addEventListener("mousedown", hide, true);
window.addEventListener("scroll", hide, true);
window.addEventListener("blur", hide);
document.addEventListener("mouseleave", hide);
}
// ── 사이드바 "목표" — 누르면 바로 아래 연도 목록을 접었다 편다(localStorage pj_goal_open).
// 목표 화면에서는 항상 펼친 채로 시작(data-force-open). 관리자는 "+ 연도 추가".
function initGoalSide() {
const box = el("pj-side-goal");
if (!box) return;
const btn = el("pj-side-goal-toggle");
const list = el("pj-side-goal-years");
function setOpen(open, remember) {
list.hidden = !open;
box.classList.toggle("is-open", open);
btn.setAttribute("aria-expanded", open ? "true" : "false");
if (remember) { try { localStorage.setItem("pj_goal_open", open ? "1" : "0"); } catch (_) {} }
}
if (box.dataset.forceOpen !== "true") {
let saved = null;
try { saved = localStorage.getItem("pj_goal_open"); } catch (_) {}
if (saved === "1") setOpen(true, false);
}
btn.addEventListener("click", function () { setOpen(list.hidden, true); });
const add = el("pj-goal-year-add");
if (add) add.addEventListener("click", async function () {
const v = await prompt("추가할 연도를 입력하세요.", add.dataset.next || "");
if (v == null || !String(v).trim()) return;
try {
const res = await api("POST", "/project/api/goals/years", { year: String(v).trim() });
location.href = "/project/goals/" + res.year;
} catch (e) { showToast("연도 추가 실패: " + e.message, "error"); }
});
}
// ── 연간 목표 화면(/project/goals/{연도}) — 관리자만 입력, 칸마다 바로 저장.
// · 숫자(매출/로아스 목표·실적): 칸을 떠나거나 Enter 에 저장, 서버가 돌려준 표기(쉼표)로 바꿈.
// 매출 연간 합계와 달성률(실적÷목표)은 화면에서 계산.
// · 업무 영역 글: 치는 동안 0.8초 멈추면 저장, 칸을 떠날 때·페이지를 떠날 때도 저장.
// · 영역/줄 추가·이름·순서·삭제는 저장 후 새로고침(스크롤 위치는 되살림).
function initGoals() {
const pane = el("pj-goal-pane");
if (!pane) return;
const SCROLL_KEY = "pj_goal_scroll";
function reloadKeepScroll() {
try { sessionStorage.setItem(SCROLL_KEY, JSON.stringify([location.pathname, pane.scrollLeft, pane.scrollTop])); } catch (_) {}
location.reload();
}
try {
const s = JSON.parse(sessionStorage.getItem(SCROLL_KEY) || "null");
sessionStorage.removeItem(SCROLL_KEY);
if (s && s[0] === location.pathname) { pane.scrollLeft = s[1]; pane.scrollTop = s[2]; }
} catch (_) {}
const create = el("pj-goal-create");
if (create) create.addEventListener("click", async function () {
create.disabled = true;
try {
await api("POST", "/project/api/goals/years", { year: create.dataset.year });
location.reload();
} catch (e) { create.disabled = false; showToast("만들기 실패: " + e.message, "error"); }
});
const table = el("pj-goal-table");
if (!table) return;
const year = table.dataset.year;
const isAdmin = table.dataset.admin === "true";
// ── 열 너비 — 셀 오른쪽 경계에서 끌기·더블클릭 맞춤, 브라우저에 기억(localStorage pj_goal_col_w) ──
// · c1·c2 = 왼쪽 이름 두 칸(구분·항목) → 표의 CSS 변수 --goal-c1-w·--goal-c2-w(c2 의 left 도 c1 너비로 정해진다)
// · y = 연간, m1~m12 = 월, q1~q4 = 분기 → 그 머리 칸의 --cw(표는 table-layout: fixed 라 머리 칸 너비가 열 너비)
// 화면 배율(uiZoom) 안이라 마우스 이동 거리는 배율로 나눈다. 더블클릭 = 가장 긴 문단에 맞춤.
const COL_KEY = "pj_goal_col_w";
const colDefault = { c1: 72, c2: 72, y: 90, q1: 80, q2: 80, q3: 80, q4: 80 };
for (let m = 1; m <= 12; m++) colDefault["m" + m] = 85;
function colLimit(key) { return key === "c1" || key === "c2" ? [48, 320] : [40, 600]; }
function clampCol(key, w) { const lim = colLimit(key); return Math.min(lim[1], Math.max(lim[0], w)); }
const colW = Object.assign({}, colDefault);
try {
const saved = JSON.parse(localStorage.getItem(COL_KEY) || "null");
if (saved) Object.keys(colDefault).forEach(function (k) {
const v = parseInt(saved[k], 10);
// 자동 맞춤은 긴 문단을 자르지 않도록 드래그 최대 너비를 넘을 수 있다.
if (v > 0) colW[k] = Math.max(colLimit(k)[0], v);
});
} catch (_) {}
function saveColW() {
// 기본값과 같은 칸은 저장하지 않는다(나중에 기본 너비를 바꾸면 따라가게)
const out = {};
Object.keys(colW).forEach(function (k) { if (colW[k] !== colDefault[k]) out[k] = colW[k]; });
try { localStorage.setItem(COL_KEY, JSON.stringify(out)); } catch (_) {}
}
function applyColW() {
table.style.setProperty("--goal-c1-w", colW.c1 + "px");
table.style.setProperty("--goal-c2-w", colW.c2 + "px");
table.querySelectorAll("thead th[data-col]").forEach(function (th) {
th.style.setProperty("--cw", colW[th.dataset.col] + "px");
});
// 접기/펼치기 중에도 글 칸의 자연 높이와 숫자 입력칸의 원래 폭을 유지한다.
table.querySelectorAll("td.pj-goal-m[data-month]").forEach(function (td) {
const m = parseInt(td.dataset.month, 10), span = parseInt(td.dataset.span || "1", 10);
let w = 0;
for (let i = m; i < m + span; i++) w += colW["m" + i] || 85;
td.style.setProperty("--fold-w", (w - 1) + "px");
});
}
applyColW();
let lastColResize = 0;
// rowspan/colspan 을 포함한 논리 열을 따라 각 셀의 오른쪽 경계에 손잡이를 붙인다.
// 병합 셀에서는 오른쪽 끝 열의 너비를 조절한다. 새 줄·병합 뒤에도 다시 배선한다.
function addColHandles() {
const keys = Array.from(table.tHead.rows[0].cells).map(function (th) { return th.querySelector(".pj-goal-colresize").dataset.col; });
const occupied = [];
Array.from(table.rows).forEach(function (tr, r) {
occupied[r] = occupied[r] || [];
let c = 0;
Array.from(tr.cells).forEach(function (td) {
while (occupied[r][c]) c++;
const end = c + td.colSpan - 1;
for (let rr = r; rr < r + td.rowSpan; rr++) {
occupied[rr] = occupied[rr] || [];
for (let cc = c; cc <= end; cc++) occupied[rr][cc] = true;
}
td.dataset.goalCols = keys.slice(c, end + 1).join(",");
if (!td.querySelector(".pj-goal-colresize") && keys[end]) {
const h = document.createElement("span"); h.className = "pj-goal-colresize";
h.dataset.col = keys[end]; td.appendChild(h);
}
const handle = td.querySelector(".pj-goal-colresize");
if (handle) handle.title = "끌어서 너비 조절 · 더블클릭하면 내용에 맞춤";
c = end + 1;
});
});
}
addColHandles();
function naturalCellWidth(td) {
// 원본은 건드리지 않는다. 같은 표 구조의 숨은 복사본으로 폰트·부분 서식·여백을
// 그대로 재되, 화면 폭에 따른 줄바꿈만 해제한다(직접 넣은 줄바꿈은 유지).
const probe = document.createElement("div"), copy = td.cloneNode(true);
const measureTable = table.cloneNode(false), section = td.parentElement.parentElement.cloneNode(false), row = td.parentElement.cloneNode(false);
probe.style.cssText = "position:fixed;left:0;top:0;visibility:hidden;pointer-events:none;width:max-content;";
probe.setAttribute("aria-hidden", "true");
[measureTable, section, row].forEach(function (n) { n.removeAttribute("id"); });
measureTable.style.cssText += ";width:max-content;table-layout:auto;";
copy.classList.add("pj-goal-autofit-measure");
copy.querySelectorAll(".pj-goal-colresize, .pj-goal-menu-btn, .pj-goal-move-edge").forEach(function (n) { n.remove(); });
// input의 현재 초안은 HTML 속성과 다를 수 있고, 기본 입력칸의 내재 너비도 제외한다.
copy.querySelectorAll("input, textarea").forEach(function (n) {
const text = document.createElement("span");
text.className = n.className; text.style.cssText = n.style.cssText;
text.textContent = n.value; n.replaceWith(text);
});
[copy].concat(Array.from(copy.querySelectorAll("*"))).forEach(function (n) {
n.removeAttribute("id"); n.removeAttribute("contenteditable"); n.removeAttribute("data-placeholder");
n.classList.remove("is-gone", "is-shrunk", "is-folding");
const overrides = { position: "static", width: "max-content", "min-width": "0", "max-width": "none",
height: "auto", overflow: "visible", transition: "none", "overflow-wrap": "normal", "word-break": "normal" };
Object.keys(overrides).forEach(function (p) { n.style.setProperty(p, overrides[p], "important"); });
if (n.matches(".pj-goal-text, .pj-goal-text-ro, .pj-goal-area-text, .pj-goal-row-text")) {
n.style.setProperty("white-space", "pre", "important");
}
});
copy.style.setProperty("display", "block", "important");
row.appendChild(copy); section.appendChild(row); measureTable.appendChild(section); probe.appendChild(measureTable);
// 접힌 분기의 display:none 셀도 전체 자동 맞춤 때 측정할 수 있다.
pane.appendChild(probe);
try { return Math.ceil(copy.getBoundingClientRect().width / uiZoom()) + 2; }
finally { probe.remove(); }
}
function autoFitCol(key) {
let width = colLimit(key)[0];
table.querySelectorAll("[data-goal-cols]").forEach(function (td) {
const keys = td.dataset.goalCols.split(",");
if (!keys.includes(key)) return;
// 병합 칸의 다른 열은 유지하고 선택한 열에 필요한 나머지 너비만 더한다.
const otherWidth = keys.reduce(function (sum, k) { return sum + (k === key ? 0 : colW[k]); }, 0);
width = Math.max(width, naturalCellWidth(td) - otherWidth);
});
colW[key] = width;
applyColW(); saveColW(); fitAll(); stickKpi();
}
function autoFitAllCols() {
const cells = Array.from(table.querySelectorAll("[data-goal-cols]")).map(function (td) {
return { keys: td.dataset.goalCols.split(","), width: naturalCellWidth(td) };
});
Object.keys(colDefault).forEach(function (key) { colW[key] = colLimit(key)[0]; });
cells.filter(function (cell) { return cell.keys.length === 1; }).forEach(function (cell) {
colW[cell.keys[0]] = Math.max(colW[cell.keys[0]], cell.width);
});
cells.filter(function (cell) { return cell.keys.length > 1; }).forEach(function (cell) {
const sum = cell.keys.reduce(function (w, key) { return w + colW[key]; }, 0);
if (cell.width > sum) colW[cell.keys[cell.keys.length - 1]] += cell.width - sum;
});
applyColW(); saveColW(); fitAll(); stickKpi();
}
function widthMenuItems(td) {
const key = (td.dataset.goalCols || "").split(",").pop();
if (!colDefault[key]) return [];
return [
{ label: "현재 열 너비 자동 맞춤", icon: menuIcon("fit_screen"), onClick: function () { autoFitCol(key); } },
{ label: "전체 열 너비 자동 맞춤", icon: menuIcon("view_week"), onClick: autoFitAllCols },
];
}
// 입력한 문단이 칸을 넘으면 해당 열만 늘린다. 명시적 개행·선택·초안은 유지한다.
const growingCells = new Set();
let growFrame = 0;
function queueCellGrowth(e) {
const field = e.target.closest("input, textarea, [contenteditable='true']");
const td = field && field.closest("td, th");
if (!isAdmin || !td || !table.contains(td)) return;
growingCells.add(td);
if (growFrame) return;
growFrame = requestAnimationFrame(function () {
growFrame = 0; let changed = false;
growingCells.forEach(function (cell) {
if (!table.contains(cell)) return;
const keys = (cell.dataset.goalCols || "").split(",").filter(Boolean), key = keys[keys.length - 1];
if (!colDefault[key]) return;
const width = naturalCellWidth(cell) - keys.slice(0, -1).reduce((sum, k) => sum + colW[k], 0);
if (width > colW[key]) { colW[key] = width; changed = true; }
});
growingCells.clear();
if (changed) { applyColW(); saveColW(); fitAll(); stickKpi(); }
});
}
table.addEventListener("input", queueCellGrowth);
table.addEventListener("compositionend", queueCellGrowth);
table.addEventListener("contextmenu", function (e) {
const td = e.target.closest("th, td");
if (!td || !table.contains(td)) return;
// 관리자 업무 셀·이름 칸은 아래의 기존 편집 메뉴에 합쳐 표시한다.
if (isAdmin && td.closest("tbody.pj-goal-area") &&
(td.tagName === "TH" || table.dataset.halves === "true" || td.dataset.month === "0")) return;
e.preventDefault(); showContextMenu(e.clientX, e.clientY, widthMenuItems(td));
});
table.addEventListener("mousedown", function (e) {
const h = e.target.closest(".pj-goal-colresize");
if (!h) return;
if (e.button !== 0) return;
e.preventDefault();
e.stopPropagation();
const key = h.dataset.col;
const startX = e.clientX, startW = colW[key];
h.classList.add("is-dragging");
document.documentElement.classList.add("pj-goal-resizing");
function onMove(ev) {
colW[key] = clampCol(key, Math.round(startW + (ev.clientX - startX) / uiZoom()));
applyColW();
}
function onUp() {
document.removeEventListener("mousemove", onMove);
document.removeEventListener("mouseup", onUp);
h.classList.remove("is-dragging");
document.documentElement.classList.remove("pj-goal-resizing");
lastColResize = Date.now(); // 끈 직후 머리 칸 클릭(분기 접기)으로 받지 않게
saveColW();
fitAll(); // 폭이 바뀌면 글 줄바꿈이 달라진다
}
document.addEventListener("mousemove", onMove);
document.addEventListener("mouseup", onUp);
}, true);
table.addEventListener("click", function (e) { if (e.target.closest(".pj-goal-colresize")) e.stopPropagation(); }, true);
table.addEventListener("dblclick", function (e) {
const h = e.target.closest(".pj-goal-colresize");
if (!h) return;
e.preventDefault();
e.stopPropagation();
lastColResize = Date.now();
autoFitCol(h.dataset.col);
});
// ── 틀 고정 — 머리 줄 아래 숫자 지표(매출·로아스) 줄까지 세로 스크롤에도 위에 붙어 있다.
// 줄마다 sticky top(--kpi-top) = 머리 줄 높이 + 앞 지표 줄 높이 합. 배율 안이라 offsetHeight(배율 전 값)로 잰다.
function stickKpi() {
const head = table.tHead && table.tHead.rows[0];
if (!head) return;
let top = head.offsetHeight;
table.querySelectorAll("tbody.pj-goal-kpi > tr").forEach(function (tr) {
tr.style.setProperty("--kpi-top", top + "px");
top += tr.offsetHeight;
});
}
stickKpi();
if (document.fonts && document.fonts.ready) document.fonts.ready.then(stickKpi);
window.addEventListener("resize", stickKpi);
// ── 합계·달성률 ──
function numOf(node) {
const raw = (node.tagName === "INPUT" ? node.value : node.textContent) || "";
const s = raw.replace(/[,%\s]/g, "");
if (!s) return null;
const n = Number(s);
return isFinite(n) ? n : null;
}
function fmtNum(n) {
return (Math.round(n * 100) / 100).toLocaleString("ko-KR", { maximumFractionDigits: 2 });
}
function values(metric, kind) {
const out = {};
table.querySelectorAll('.pj-goal-num[data-metric="' + metric + '"][data-kind="' + kind + '"]')
.forEach(function (n) { out[n.dataset.month] = numOf(n); });
return out;
}
function setRate(td, actual, target) {
td.classList.remove("is-good", "is-low");
if (actual == null || !target) { td.textContent = ""; return; }
const r = actual / target * 100;
td.textContent = (Math.round(r * 10) / 10).toLocaleString("ko-KR") + "%";
td.classList.add(r >= 100 ? "is-good" : "is-low");
}
// 합계 칸 — 연간(0) · 분기 칸(store.GOAL_QUARTER_COL: 13 = 1분기 1~3월, 15 = 2분기, 14 = 3분기, 16 = 4분기)
const SUM_SCOPES = [[0, 1, 12], [13, 1, 3], [15, 4, 6], [14, 7, 9], [16, 10, 12]];
const SCOPE_NAME = { 0: "연간", 13: "1분기", 15: "2분기", 14: "3분기", 16: "4분기" };
function recompute() {
const tg = values("sales", "target"), ac = values("sales", "actual");
for (let m = 1; m <= 12; m++) {
const td = table.querySelector('.pj-goal-rate[data-month="' + m + '"]');
if (td) setRate(td, ac[m], tg[m]);
}
SUM_SCOPES.forEach(function (sc) {
let sumT = null, sumA = null;
for (let m = sc[1]; m <= sc[2]; m++) {
if (tg[m] != null) sumT = (sumT || 0) + tg[m];
if (ac[m] != null) sumA = (sumA || 0) + ac[m];
}
const st = table.querySelector('.pj-goal-sum[data-metric="sales"][data-kind="target"][data-scope="' + sc[0] + '"]');
const sa = table.querySelector('.pj-goal-sum[data-metric="sales"][data-kind="actual"][data-scope="' + sc[0] + '"]');
if (st) st.textContent = sumT == null ? "" : fmtNum(sumT);
if (sa) sa.textContent = sumA == null ? "" : fmtNum(sumA);
const rt = table.querySelector('.pj-goal-rate[data-month="' + sc[0] + '"]');
// 연간·분기 달성률 = 입력된 실적 합계 ÷ 그 기간 목표 합계 전체(2026-10-01 사용자 기준 — 예전엔 실적이 있는 달의 목표만)
if (rt) {
setRate(rt, sumA, sumT);
rt.dataset.tip = sumT ? SCOPE_NAME[sc[0]] + " 목표 합계 대비 실적" : "";
}
});
// 로아스 연간·분기 — 기간 로아스 = 기간 매출 ÷ 기간 광고비. 광고비를 따로 적지 않으니 월마다 매출 ÷ 로아스로 환산해
// 합친다(매출 가중 평균). 로아스가 있는 달 중 매출(같은 목표/실적)이 없는 달이 있으면 단순 평균.
["target", "actual"].forEach(function (kind) {
const roas = values("roas", kind), sales = kind === "target" ? tg : ac;
SUM_SCOPES.forEach(function (sc) {
const td = table.querySelector('.pj-goal-sum[data-metric="roas"][data-kind="' + kind + '"][data-scope="' + sc[0] + '"]');
if (!td) return;
const months = [];
for (let m = sc[1]; m <= sc[2]; m++) if (roas[m] != null && roas[m] > 0) months.push(m);
if (!months.length) { td.textContent = ""; td.dataset.tip = ""; return; }
const weighted = months.every(function (m) { return sales[m] != null && sales[m] > 0; });
let v;
if (weighted) {
let s = 0, spend = 0;
months.forEach(function (m) { s += sales[m]; spend += sales[m] / roas[m]; });
v = s / spend;
} else {
v = months.reduce(function (a, m) { return a + roas[m]; }, 0) / months.length;
}
td.textContent = (Math.round(v * 10) / 10).toLocaleString("ko-KR") + "%";
td.dataset.tip = (weighted ? "매출 가중 평균(월 광고비 = 매출 ÷ 로아스로 환산)" : "단순 평균(매출이 없는 달이 있어서)") +
" · " + months.length + "개월";
});
});
addColHandles(); // 합계·달성률의 textContent 를 바꾼 뒤에도 손잡이를 유지한다.
}
recompute();
// ── 분기 접기 — 분기 칸 머리의 버튼이 그 분기 월 칸(.pj-goal-m[data-h], 1~4)을 접었다 편다.
// 월 열 너비를 애니메이션하되 내용은 완료 뒤 표시해 숫자의 정렬 이동을 감춘다.
// 상태는 브라우저에 기억(localStorage pj_goal_fold_q — 반기 때 키 pj_goal_fold 와 따로).
// 보기만 하는 사람도 쓸 수 있다.
const FOLD_KEY = "pj_goal_fold_q";
const FOLD_MS = 320;
const foldTimers = {};
const QUARTERS = [1, 2, 3, 4];
const fold = { 1: false, 2: false, 3: false, 4: false };
try {
const saved = JSON.parse(localStorage.getItem(FOLD_KEY) || "null");
if (saved) QUARTERS.forEach(function (q) { fold[q] = !!saved[q]; });
} catch (_) {}
function halfCells(h) { return table.querySelectorAll('.pj-goal-m[data-h="' + h + '"]'); }
function syncFoldBtn(h) {
const btn = table.querySelector('.pj-goal-fold[data-h="' + h + '"]');
if (!btn) return;
btn.classList.toggle("is-folded", fold[h]);
btn.setAttribute("aria-expanded", fold[h] ? "false" : "true");
btn.title = (btn.dataset.label || "") + (fold[h] ? " 펼치기" : " 접기");
delete btn.dataset.tip; // 공용 말풍선이 옮겨 둔 예전 문구 대신 새 title 을 쓰게
const th = btn.closest("th");
if (th) {
th.classList.toggle("is-folded", fold[h]);
th.title = btn.title; // 머리 칸 어디에 올려도 같은 안내
delete th.dataset.tip;
}
}
function applyFold(h, animate) {
const cells = halfCells(h);
const folded = fold[h];
clearTimeout(foldTimers[h]);
delete foldTimers[h];
syncFoldBtn(h);
function finish() {
cells.forEach(function (c) {
c.classList.toggle("is-gone", folded);
c.classList.toggle("is-shrunk", folded);
c.classList.remove("is-folding");
});
if (!folded) table.querySelectorAll('.pj-goal-m[data-h="' + h + '"] .pj-goal-text').forEach(fit);
delete foldTimers[h];
}
const reduce = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (!animate || reduce) { finish(); return; }
cells.forEach(function (c) { c.classList.add("is-folding"); c.classList.remove("is-gone"); });
void table.offsetWidth; // 펼침은 너비 0, 접기는 현재 너비에서 시작한다.
cells.forEach(function (c) { c.classList.toggle("is-shrunk", folded); });
foldTimers[h] = setTimeout(finish, FOLD_MS + 20);
}
// 분기 머리 칸 아무 곳이나 누르면 접기/펴기(버튼만이 아니라). 너비 조절 손잡이를 끈 뒤의 클릭은 무시.
table.querySelectorAll("thead th.pj-goal-fold-th").forEach(function (th) {
const btn = th.querySelector(".pj-goal-fold");
if (!btn) return;
th.addEventListener("click", function (e) {
if (e.target.closest(".pj-goal-colresize") || Date.now() - lastColResize < 300) return;
e.stopPropagation();
const h = btn.dataset.h;
fold[h] = !fold[h];
try { localStorage.setItem(FOLD_KEY, JSON.stringify(fold)); } catch (_) {}
clearMergeSel();
applyFold(h, true);
});
});
// contenteditable 글 칸은 내용의 자연 높이를 쓴다. 표가 가장 높은 칸에 행을 맞추고
// 짧은 칸은 상단에 둔다. 글·폭·부분 서식 변경과 숨긴 분기에서도 오래된 높이가 남지 않는다.
function fit(ta) {
if (ta.tagName !== "TEXTAREA") { ta.style.removeProperty("height"); return; }
// 예전 textarea 템플릿도 지원하되 접힌 칸은 펼친 뒤 잰다.
if (!ta.offsetParent) return;
ta.style.height = "auto";
ta.style.height = ta.scrollHeight + "px";
}
function fitAll() { table.querySelectorAll(".pj-goal-text").forEach(fit); }
QUARTERS.forEach(function (q) { applyFold(q, false); });
function flashSaved(node) {
node.classList.remove("is-saved");
void node.offsetWidth;
node.classList.add("is-saved");
}
// ── 주차별 매출 목표(020) — 매출 목표 칸을 누르면 그 달 입력 창(body 에 붙음). 월 목표는 맨 위에 직접 입력,
// 아래에 주차별 목표, 맨 아래 주차 합계와 차이(월 목표 − 주차 합계). 주차 합계가 월 목표가 되지 않는다.
// 관리자는 입력·저장, 보기만 하는 사람은 값 보기. 주차는 서버(store.month_weeks)가 정한다.
const WEEKS = window.PJ_GOAL_WEEKS || null;
let weekPop = null;
function closeWeekPop() {
if (!weekPop) return;
weekPop.remove();
weekPop = null;
document.removeEventListener("mousedown", onWeekDoc, true);
document.removeEventListener("keydown", onWeekKey, true);
}
function onWeekDoc(e) { if (weekPop && !weekPop.contains(e.target)) closeWeekPop(); }
function onWeekKey(e) { if (e.key === "Escape") closeWeekPop(); }
function openWeekPop(cell) {
closeWeekPop();
const mo = cell.dataset.month, list = (WEEKS && WEEKS[mo]) || [];
const unit = window.PJ_GOAL_UNIT || "";
const edit = isAdmin && cell.tagName === "INPUT";
weekPop = document.createElement("div");
weekPop.className = "pj-goal-wkpop";
weekPop.innerHTML = '<div class="pj-goal-wkpop-head">' + mo + "월 주차별 매출 목표" +
(unit ? " <small>(" + escapeHtml(unit) + ")</small>" : "") + "</div>" +
'<label class="pj-goal-wkpop-row pj-goal-wkpop-month"><span>' + mo + "월 전체 목표</span>" +
'<input type="text" inputmode="decimal" autocomplete="off" data-month-total="1" value="' +
escapeHtml((cell.tagName === "INPUT" ? cell.value : cell.textContent).trim()) + '"' +
(edit ? "" : " readonly") + "></label>" +
list.map(function (w) {
return '<label class="pj-goal-wkpop-row"><span>' + w.n + "주차 <em>" + escapeHtml(w.label) + "</em>" +
(w.days ? ' <i class="pj-goal-wkpop-days">' + w.days + "일</i>" : "") + "</span>" +
'<input type="text" inputmode="decimal" autocomplete="off" data-start="' + w.start + '" value="' +
escapeHtml(w.value || "") + '"' + (edit ? "" : " readonly") + "></label>";
}).join("") +
'<div class="pj-goal-wkpop-sum"><span>주차 합계</span><b data-sum="weeks"></b></div>' +
'<div class="pj-goal-wkpop-sum pj-goal-wkpop-diff"><span>차이 <small>(월 목표 − 주차 합계)</small></span><b data-sum="diff"></b></div>' +
(edit ? '<div class="pj-goal-wkpop-acts"><button type="button" class="pj-btn pj-btn-sm" data-act="cancel">취소</button>' +
'<button type="button" class="pj-btn pj-btn-sm pj-btn-primary" data-act="save">저장</button></div>' : "");
document.body.appendChild(weekPop);
const r = cell.getBoundingClientRect(), vw = document.documentElement.clientWidth, vh = document.documentElement.clientHeight;
weekPop.style.left = Math.max(8, Math.min(r.left, vw - weekPop.offsetWidth - 8)) + "px";
weekPop.style.top = (r.bottom + 6 + weekPop.offsetHeight > vh ? Math.max(8, r.top - weekPop.offsetHeight - 6) : r.bottom + 6) + "px";
const monthInput = weekPop.querySelector("input[data-month-total]");
const inputs = Array.from(weekPop.querySelectorAll("input[data-start]"));
const sumEl = weekPop.querySelector('[data-sum="weeks"]'), diffEl = weekPop.querySelector('[data-sum="diff"]');
function paintSum() {
let t = null;
inputs.forEach(function (i) { const n = numOf(i); if (n != null) t = (t || 0) + n; });
sumEl.textContent = t == null ? "—" : fmtNum(t);
const total = numOf(monthInput);
const d = total == null ? null : total - (t || 0);
// 차이 + = 주차에 아직 못 나눈 금액, − = 주차 합계가 월 목표를 넘음, 0 = 딱 맞음
diffEl.textContent = d == null ? "—" : (d > 0 ? "+" : "") + fmtNum(d);
diffEl.classList.toggle("is-over", d != null && d < 0);
diffEl.classList.toggle("is-left", d != null && d > 0);
diffEl.classList.toggle("is-even", d != null && Math.abs(d) < 0.005);
}
[monthInput].concat(inputs).forEach(function (i) { i.addEventListener("input", paintSum); });
paintSum();
async function save(btn) {
const weeks = {};
inputs.forEach(function (i) { weeks[i.dataset.start] = i.value; });
btn.disabled = true;
try {
const res = await api("PUT", "/project/api/goals/" + year + "/week-targets/" + mo,
{ month: monthInput.value, weeks: weeks });
list.forEach(function (w) { if (res.weeks && w.start in res.weeks) w.value = res.weeks[w.start]; });
cell.value = res.label || "";
recompute();
flashSaved(cell.parentElement);
closeWeekPop();
} catch (err) {
btn.disabled = false;
showToast("저장 실패: " + err.message, "error");
}
}
weekPop.addEventListener("click", function (e) {
const b = e.target.closest("[data-act]");
if (!b) return;
if (b.dataset.act === "save") save(b); else closeWeekPop();
});
weekPop.addEventListener("keydown", function (e) {
if (edit && e.key === "Enter" && !isImeEnter(e) && e.target.tagName === "INPUT") {
e.preventDefault();
save(weekPop.querySelector('[data-act="save"]'));
}
});
setTimeout(function () {
document.addEventListener("mousedown", onWeekDoc, true);
document.addEventListener("keydown", onWeekKey, true);
}, 0);
if (edit) { monthInput.focus(); monthInput.select(); }
}
if (WEEKS) {
table.addEventListener("click", function (e) {
const c = e.target.closest(".pj-goal-num[data-weekly]");
if (c) openWeekPop(c);
});
table.addEventListener("keydown", function (e) {
const c = e.target.closest(".pj-goal-num[data-weekly]");
if (c && (e.key === "Enter" || e.key === " ") && !isImeEnter(e)) { e.preventDefault(); openWeekPop(c); }
});
}
// 병합 선택(Shift+클릭) — 관리자 전용, 아래에서 채운다. 접기 버튼이 먼저 부르므로 여기 둔다.
let clearMergeSel = function () {};
if (!isAdmin) return;
// ── 숫자 칸 — Enter·칸 떠남에 저장(createFieldSaver: 같은 칸 요청 차례대로, 늦은 응답이 새 입력을 덮지 않음).
// 서버 표기(쉼표)는 요청 뒤 입력이 그대로일 때만 칸에 넣는다. 실패해도 입력값은 그대로(빨간 테두리), Esc = 저장된 값으로.
const numSaver = createFieldSaver({
read: function (inp) { return inp.value; },
write: function (inp, v) { inp.value = v; },
unload: "warn", // Enter·칸 떠남 전의 숫자는 페이지를 떠날 때 보내지 않고 경고만
send: function (inp, v, o) {
const d = inp.dataset;
return api("PUT", "/project/api/goals/" + year + "/metrics",
{ metric: d.metric, kind: d.kind, month: parseInt(d.month, 10), value: v }, o);
},
onSaved: function (inp, v, res, same) {
clearSaveFailed(inp.parentElement);
flashSaved(inp.parentElement);
if (!same) return undefined; // 요청 뒤 새로 입력 중 — 그 초안을 그대로 둔다
inp.value = res.label;
recompute();
return res.label;
},
onFail: function (inp, err) { markSaveFailed(inp.parentElement, err); },
});
table.querySelectorAll("input.pj-goal-num:not([data-weekly])").forEach(function (inp) {
numSaver.track(inp, inp.value);
inp.addEventListener("focus", function () { inp.select(); });
inp.addEventListener("input", recompute);
inp.addEventListener("keydown", function (e) {
if (isImeEnter(e)) return;
if (e.key === "Enter") { e.preventDefault(); if (document.activeElement === inp) inp.blur(); else numSaver.flush(inp).catch(function () {}); }
else if (e.key === "Escape") { inp.value = numSaver.savedOf(inp); recompute(); inp.blur(); }
});
inp.addEventListener("change", function () { numSaver.flush(inp).catch(function () {}); });
inp.addEventListener("blur", function () { numSaver.flush(inp).catch(function () {}); });
});
// ── 글 칸 — 0.8초 멈춤·칸 떠남에 저장(createFieldSaver). 실패해도 글은 그대로 두고 다음 입력·칸 떠남에 다시 보낸다.
// 초안은 localStorage 에도(pj_draft:goal:줄:칸) — 페이지가 닫혀도 다음에 열면 되살린다.
function cellUrl(ta) { return "/project/api/goals/rows/" + ta.dataset.row + "/cells/" + ta.dataset.month; }
let pendingRefresh = false; // 구조는 바뀌었는데 입력 중이라 표를 아직 다시 못 그림 — 저장이 끝나면 다시 그린다
const textSaver = createFieldSaver({
read: function (ta) { return ta.value; },
write: function (ta, v) { ta.value = v; fit(ta); },
send: function (ta, v, o) { return api("PUT", cellUrl(ta), { body: v }, o); },
draftKey: function (ta) { return "goal:" + ta.dataset.row + ":" + ta.dataset.month; },
onSaved: function (ta) {
clearSaveFailed(ta.parentElement);
flashSaved(ta.parentElement);
if (pendingRefresh) setTimeout(function () {
if (pendingRefresh && !textSaver.anyDirty()) refreshTable().catch(function (err) { showToast(err.message, "error"); });
}, 0);
},
onClear: function (ta) { clearSaveFailed(ta.parentElement); },
onFail: function (ta, err) { markSaveFailed(ta.parentElement, err); },
});
function saveText(ta) { return textSaver.flush(ta); }
// 글 칸 연결 — 처음 한 번 + 표를 그 자리에서 다시 그린 뒤 새 칸에(refreshTable). 되살린 초안 수를 돌려준다.
function bindTexts(root) {
let restored = 0, conflict = 0;
root.querySelectorAll(".pj-goal-text").forEach(function (ta) {
if (ta.dataset.bound) return;
ta.dataset.bound = "1";
if (ta.tagName !== "TEXTAREA") window.PJGoalText.attach(ta);
const r = textSaver.track(ta, ta.value);
if (r === "restored") restored++;
else if (r === "conflict") conflict++;
fit(ta);
ta.addEventListener("input", function () { fit(ta); textSaver.queue(ta); });
ta.addEventListener("blur", function () { textSaver.flush(ta).catch(function () {}); });
});
if (restored) showToast("저장되지 않았던 글 " + restored + "칸을 되살려 다시 저장합니다.");
else if (conflict) showToast("다른 곳에서 바뀐 칸 " + conflict + "개는 예전 초안을 되살리지 않았습니다.");
}
bindTexts(table);
window.PJGoalText.init(table, el("pj-goal-format"));
function goalCellTd(node) {
const td = node && node.closest && node.closest("tbody.pj-goal-area td.pj-goal-texttd");
return td && table.contains(td) && td.querySelector(".pj-goal-text") ? td : null;
}
// 누른 글 칸 표시(테두리). 셀 테두리를 끌어 내용·서식 옮기기는 2026-10-07 요청으로 없앴다(회의록 표는 그대로).
function setMoveActive(td) {
table.querySelectorAll(".is-goal-active").forEach(function (cell) { cell.classList.remove("is-goal-active"); });
if (td) td.classList.add("is-goal-active");
}
table.addEventListener("mousedown", function (e) {
if (e.button !== 0 || e.shiftKey) return;
const td = goalCellTd(e.target);
if (td) setMoveActive(td);
}, true);
// 칸이 세로로 길어도(옆 칸 글이 길거나 세로 병합) 칸 아무 곳이나 누르면 그 칸 입력 — 커서는 글 끝(엑셀처럼).
// 입력칸(textarea)은 글 높이만큼이라 그 아래를 누르면 아무것도 안 되던 것. Shift+클릭(범위 고르기)·끌기는 그대로.
table.addEventListener("click", function (e) {
if (e.shiftKey || e.button !== 0) return;
const td = e.target.closest("td.pj-goal-texttd");
if (!td || e.target.closest(".pj-goal-text, textarea, input, button, a")) return;
const ta = td.querySelector(".pj-goal-text");
if (!ta || ta === document.activeElement) return;
ta.focus();
const range = document.createRange(); range.selectNodeContents(ta); range.collapse(false);
const selection = window.getSelection(); selection.removeAllRanges(); selection.addRange(range);
});
// 한 줄 안 칸들 높이는 표가 맞춘다 — 창 폭이 바뀌면 글 줄바꿈이 달라지니 다시 잰다.
window.addEventListener("resize", fitAll);
// 페이지 떠남 — 글은 keepalive 로 한 번 더 보내고(보장 아님, 초안 백업이 남음), 실패·진행 중·숫자 미저장이면 이탈 경고
window.addEventListener("beforeunload", function (e) {
textSaver.onBeforeUnload(e);
numSaver.onBeforeUnload(e);
});
// ── 머리 — 매출 단위 · 연도 삭제 ──
const unit = el("pj-goal-unit");
if (unit) {
unit.dataset.saved = unit.value;
unit.addEventListener("keydown", function (e) { if (e.key === "Enter") unit.blur(); });
unit.addEventListener("change", async function () {
try {
await api("PUT", "/project/api/goals/" + year, { sales_unit: unit.value });
unit.dataset.saved = unit.value;
showToast("매출 단위를 저장했습니다.");
} catch (e) { unit.value = unit.dataset.saved; showToast("저장 실패: " + e.message, "error"); }
});
}
const del = el("pj-goal-year-del");
if (del) del.addEventListener("click", async function () {
const v = await prompt(year + "년 목표를 모두 삭제합니다(숫자·업무 영역·글 전부, 되돌릴 수 없음).\n" +
"계속하려면 " + year + " 를 입력하세요.", "");
if (v == null) return;
if (String(v).trim() !== String(year)) { showToast("연도가 달라 삭제하지 않았습니다."); return; }
try {
await api("DELETE", "/project/api/goals/" + year);
location.href = "/project/goals";
} catch (e) { showToast("삭제 실패: " + e.message, "error"); }
});
// ── 업무 영역 추가 ──
const colors = window.PJ_GOAL_COLORS || [];
const addArea = el("pj-goal-area-add");
// 이름을 묻지 않고 바로 "새 업무 영역"으로 만든 뒤, 그 이름 칸을 바로 입력 상태로(Enter 저장 · Esc 그대로)
if (addArea) addArea.addEventListener("click", async function () {
const n = table.querySelectorAll(".pj-goal-area").length;
await withStruct(async function () {
try {
await flushTexts(); // 저장 못 한 글이 있으면 영역을 만들지 않는다(글은 그대로)
const res = await api("POST", "/project/api/goals/" + year + "/areas",
{ name: "새 업무 영역", color: colors.length ? colors[n % colors.length] : "" });
await refreshTable();
editNewName('tbody.pj-goal-area[data-area-id="' + (res && res.id) + '"] .pj-goal-area-text');
} catch (e) { showToast("추가 실패: " + e.message, "error"); }
});
});
// ── 영역 색 고르기 — 팝업은 body 에(화면 배율 밖) ──
let colorPop = null;
function closeColorPop() {
if (!colorPop) return;
colorPop.remove();
colorPop = null;
document.removeEventListener("mousedown", onColorDocDown, true);
}
function onColorDocDown(e) { if (colorPop && !colorPop.contains(e.target)) closeColorPop(); }
function openColorPop(pt, areaId, current, tbody) {
closeColorPop();
colorPop = document.createElement("div");
colorPop.className = "pj-goal-colorpop";
// 맨 위 "색 없음"(흰 배경, 빈 값) + 연한 16색(8칸×2줄)
colorPop.innerHTML = '<button type="button" class="pj-goal-swatch-none' + (!current ? " is-on" : "") +
'" data-c=""><span class="pj-goal-swatch-x"></span>색 없음</button>' +
colors.map(function (c) {
return '<button type="button" class="pj-goal-swatch' + (c === current ? " is-on" : "") +
'" data-c="' + c + '" style="background:' + c + '"></button>';
}).join("");
document.body.appendChild(colorPop);
const w = colorPop.offsetWidth, h = colorPop.offsetHeight;
colorPop.style.left = Math.max(8, Math.min(pt.x, document.documentElement.clientWidth - w - 8)) + "px";
colorPop.style.top = Math.max(8, Math.min(pt.y + 6, document.documentElement.clientHeight - h - 8)) + "px";
colorPop.addEventListener("click", async function (e) {
const sw = e.target.closest(".pj-goal-swatch, .pj-goal-swatch-none");
if (!sw) return;
const c = sw.dataset.c;
closeColorPop();
try {
await api("PUT", "/project/api/goals/areas/" + areaId, { color: c || "none" });
tbody.style.setProperty("--goal-bg", c || "#fff");
tbody.dataset.color = c;
} catch (err) { showToast("색 변경 실패: " + err.message, "error"); }
});
setTimeout(function () { document.addEventListener("mousedown", onColorDocDown, true); }, 0);
}
// ── 구역(1열) 작업 — 우클릭 메뉴(areaMenuItems)가 부른다. 이름 바꾸기는 이름을 눌러 그 자리에서(아래 startNameEdit) ──
function textOf(node, sel) {
const t = node && node.querySelector(sel);
return t ? t.textContent.trim() : "";
}
// 저장 안 된 글(대기·진행 중·실패했던 칸)을 먼저 저장 — 구조 변경·병합 전에(병합은 서버가 DB 의 글을 모은다).
// 하나라도 실패하면 reject → 부른 쪽은 구조 요청·표 교체를 하지 않는다(글은 그대로).
function flushTexts() { return textSaver.flushAll(); }
// 구조 작업(영역·줄 추가/삭제/이동, 병합/해제)은 한 번에 하나씩 — 앞 작업의 다시 그리기가 끝난 뒤 다음 작업
let structChain = Promise.resolve();
function withStruct(fn) {
const p = structChain.then(fn, fn);
structChain = p.then(function () {}, function () {});
return p;
}
function editingNames() { return !!table.querySelector("[data-goal-edit].is-editing"); }
// ── 구조가 바뀐 뒤(줄·영역 추가/삭제/이동, 병합/해제) 페이지를 새로고침하지 않고 업무 영역 부분만 서버에서 다시 받아
// 그 자리에서 바꿔 끼운다 — 새로고침 때 저장된 열 너비가 늦게 적용돼 표가 줄었다 늘어나거나 깜박이던 것을 없앤다.
// 애니메이션: 지운 줄은 흐려지며 사라지고(opts.removed), 남은 줄은 예전 자리에서 새 자리로 미끄러지고(FLIP),
// 새 줄은 위에서 내려오며 잠깐 강조, 병합한 칸은 테두리 강조(opts.flash = {row, month}). 동작 줄이기 설정이면 애니메이션 없이.
// 받아 오기에 실패하면 예전처럼 새로고침(저장 안 된 글이 없을 때만).
// 글 보호: ① 시작 전에 저장 안 된 글을 저장 — 실패하면 throw(표는 그대로, 글 유지)
// ② 받아 오는 사이에 새로 입력한 글이 있으면 저장 후 다시 받는다(바꿔 끼우기 직전 검사는 동기 — 그 사이 입력 불가)
// ③ 계속 입력 중이면 바꿔 끼우지 않고 pendingRefresh — 저장이 끝나면 다시 그린다.
const GOAL_ANIM_MS = 280;
async function refreshTable(opts) {
opts = opts || {};
await flushTexts();
const reduce = !Element.prototype.animate ||
(window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches);
let fresh = null, anims = [];
const busy = function () { return textSaver.anyDirty() || editingNames(); };
for (let tries = 0; ; tries++) {
fresh = null;
try {
const res = await fetch(location.href, { credentials: "same-origin", cache: "no-store" });
if (res.ok) fresh = new DOMParser().parseFromString(await res.text(), "text/html").getElementById("pj-goal-table");
} catch (_) { fresh = null; }
if (!busy() && opts.removed && opts.removed.length && !reduce && !anims.length) {
anims = opts.removed.map(function (tr) {
return tr.animate([{ opacity: 1 }, { opacity: 0 }], { duration: 180, easing: "ease-in", fill: "forwards" });
});
await Promise.all(anims.map(function (a) { return a.finished.catch(function () {}); }));
}
if (!busy()) break;
anims.forEach(function (a) { try { a.cancel(); } catch (_) {} });
anims = [];
if (tries >= 2) {
pendingRefresh = true;
showToast("입력 중인 칸이 있어 표를 아직 다시 그리지 않았습니다 — 저장되면 다시 그립니다.");
return;
}
await flushTexts(); // 받는 동안 새로 입력한 글 — 저장 실패면 throw(표는 그대로)
}
if (!fresh) { reloadKeepScroll(); return; }
pendingRefresh = false;
const before = new Map();
table.querySelectorAll("tbody.pj-goal-area > tr[data-row-id]").forEach(function (tr) {
before.set(tr.dataset.rowId, tr.getBoundingClientRect().top);
});
clearMergeSel();
table.querySelectorAll("tbody.pj-goal-area").forEach(function (t) { t.remove(); });
fresh.querySelectorAll("tbody.pj-goal-area").forEach(function (t) { table.appendChild(document.importNode(t, true)); });
textSaver.prune();
addColHandles();
applyColW();
QUARTERS.forEach(function (q) { applyFold(q, false); });
bindTexts(table);
if (!reduce) {
table.querySelectorAll("tbody.pj-goal-area > tr[data-row-id]").forEach(function (tr) {
const top = tr.getBoundingClientRect().top;
if (before.has(tr.dataset.rowId)) {
const dy = before.get(tr.dataset.rowId) - top;
if (Math.abs(dy) > 1) {
tr.animate([{ transform: "translateY(" + dy + "px)" }, { transform: "translateY(0)" }],
{ duration: GOAL_ANIM_MS, easing: "cubic-bezier(.2,.8,.2,1)" });
}
} else {
tr.animate([{ opacity: 0, transform: "translateY(-10px)" }, { opacity: 1, transform: "translateY(0)" }],
{ duration: GOAL_ANIM_MS + 40, easing: "cubic-bezier(.2,.8,.2,1)" });
tr.classList.add("is-new-row");
setTimeout(function () { tr.classList.remove("is-new-row"); }, 1400);
}
});
}
if (opts.flash) {
const td = table.querySelector('tr[data-row-id="' + opts.flash.row + '"] > td.pj-goal-texttd[data-month="' + opts.flash.month + '"]');
if (td) {
td.classList.remove("is-merge-flash");
void td.offsetWidth;
td.classList.add("is-merge-flash");
}
}
}
async function goalAct(act, tbody, pt) {
const areaId = tbody.dataset.areaId;
if (act === "area-color") {
openColorPop(pt, areaId, tbody.dataset.color || "", tbody);
return;
}
return withStruct(function () { return goalStructAct(act, tbody, areaId); });
}
async function goalStructAct(act, tbody, areaId) {
try {
await flushTexts(); // 저장 못 한 글이 있으면 구조를 바꾸지 않는다(throw → 아래 catch, 글 유지)
if (act === "area-up" || act === "area-down") {
await api("POST", "/project/api/goals/areas/" + areaId + "/move", { direction: act === "area-up" ? -1 : 1 });
} else if (act === "area-del") {
const name = textOf(tbody, ".pj-goal-area-text");
const ok = await confirm("'" + name + "' 업무 영역을 삭제할까요?\n안의 줄과 글도 모두 삭제됩니다.",
{ okText: "삭제", cancelText: "취소" });
if (!ok) return;
await api("DELETE", "/project/api/goals/areas/" + areaId);
await refreshTable({ removed: Array.from(tbody.rows) });
return;
} else if (act === "row-add") {
// 묻지 않고 바로 빈 이름 줄 — 그 줄의 항목 칸을 바로 입력 상태로
const res = await api("POST", "/project/api/goals/areas/" + areaId + "/rows", { label: "" });
await refreshTable();
editNewName('tr[data-row-id="' + (res && res.id) + '"] .pj-goal-row-text');
return;
} else return;
await refreshTable();
} catch (err) { showToast("처리 실패: " + err.message, "error"); }
}
// 1열(구역 칸) 우클릭 메뉴 — 예전 마우스 오버 도구 막대(색·↑·↓·+·×)를 옮겼다
function areaMenuItems(tbody, pt) {
const areas = Array.from(table.querySelectorAll("tbody.pj-goal-area"));
const i = areas.indexOf(tbody);
const go = function (act) { return function () { goalAct(act, tbody, pt); }; };
const items = [{ label: "색 바꾸기", icon: menuIcon("palette"), onClick: go("area-color") }];
if (i > 0) items.push({ label: "위로", icon: menuIcon("arrow_upward"), onClick: go("area-up") });
if (i < areas.length - 1) items.push({ label: "아래로", icon: menuIcon("arrow_downward"), onClick: go("area-down") });
items.push({ label: "줄 추가(구역 맨 아래)", icon: menuIcon("add_row_below"), onClick: go("row-add") });
items.push(null, { label: "영역 삭제", danger: true, icon: menuIcon("delete"), onClick: go("area-del") });
return items;
}
function openAreaMenu(th, x, y, opts) {
showContextMenu(x, y, areaMenuItems(th.closest("tbody"), { x: x, y: y }).concat([null], widthMenuItems(th)),
Object.assign({ label: textOf(th, ".pj-goal-area-text") + " 구역 메뉴" }, opts || {}));
}
table.addEventListener("contextmenu", function (e) {
const th = e.target.closest("th.pj-goal-area-name");
if (!th || !table.contains(th) || e.target.closest(".is-editing")) return;
e.preventDefault();
openAreaMenu(th, e.clientX, e.clientY);
});
// ── 줄(항목 칸) 추가·삭제 — 항목 칸·연간 칸 우클릭 메뉴가 쓴다. 한 일이 있으면 true.
// sameLabel = 3열에서 추가 — 새 줄을 기준 줄과 같은 항목 칸(2열) 안에(이름을 묻지 않음, 016)
// 이름은 묻지 않는다 — 2열 추가면 빈 이름 줄을 만들고 표를 다시 그린 뒤 그 항목 칸을 바로 입력 상태로(editRow).
async function insertRow(tr, place, sameLabel) {
const res = await api("POST", "/project/api/goals/areas/" + tr.closest(".pj-goal-area").dataset.areaId + "/rows",
{ label: "", ref_row_id: tr.dataset.rowId, place: place, same_label: !!sameLabel });
return sameLabel ? true : { editRow: res && res.id };
}
// 새로 만든 영역·줄 이름 칸을 바로 입력 상태로(표를 다시 그린 뒤)
function editNewName(selector) {
const span = table.querySelector(selector);
if (span && span.dataset.goalEdit) startNameEdit(span);
}
// 항목 칸(2열) 묶음의 맨 아래 줄 — 항목 칸 th 의 rowspan 만큼
function labelGroupBottom(tr) {
const th = tr.querySelector("th.pj-goal-row-label");
const span = th ? th.rowSpan || 1 : 1;
const rows = Array.from(tr.closest("tbody").rows);
return rows[Math.min(rows.length - 1, rows.indexOf(tr) + span - 1)];
}
async function deleteRow(tr) {
const lb = textOf(tr, ".pj-goal-row-text");
const label = lb ? "'" + lb + "' 줄" : "이 줄";
const ok = await confirm(label + "을 삭제할까요? 그 줄의 글도 모두 삭제됩니다.", { okText: "삭제", cancelText: "취소" });
if (!ok) return false;
await api("DELETE", "/project/api/goals/rows/" + tr.dataset.rowId);
return true;
}
// 줄 메뉴 항목 — 항목 칸(2열)·연간 칸(3열) 우클릭이 같이 쓴다. top = 위에 추가할 기준 줄, bottom = 아래에 추가할 기준 줄
// (세로 병합된 연간 칸이면 맨 아래 줄), canDelete = 그 줄 하나를 지울 수 있을 때.
function rowMenuItems(top, bottom, canDelete, opts) {
opts = opts || {};
const run = function (fn) {
return function () {
return withStruct(async function () {
try {
await flushTexts(); // 저장 못 한 글이 있으면 줄 작업을 하지 않는다(글 유지)
const r = await fn();
if (r) await refreshTable(r === true ? {} : r);
if (r && r.editRow) editNewName('tr[data-row-id="' + r.editRow + '"] .pj-goal-row-text');
} catch (err) { showToast("처리 실패: " + err.message, "error"); }
});
};
};
const items = [
{ label: "위에 줄 추가", icon: menuIcon("add_row_above"), onClick: run(function () { return insertRow(top, "above", opts.sameLabel); }) },
{ label: "아래에 줄 추가", icon: menuIcon("add_row_below"), onClick: run(function () { return insertRow(bottom, "below", opts.sameLabel); }) },
];
if (opts.move) { // 2열 — 줄 순서(묶인 줄은 서버가 막으므로 묶음이 아닐 때만)
const rows = Array.from(opts.move.closest("tbody").rows), k = rows.indexOf(opts.move);
const mv = function (dir) {
return run(async function () {
await api("POST", "/project/api/goals/rows/" + opts.move.dataset.rowId + "/move", { direction: dir });
return true;
});
};
if (k > 0) items.push({ label: "위로", icon: menuIcon("arrow_upward"), onClick: mv(-1) });
if (k < rows.length - 1) items.push({ label: "아래로", icon: menuIcon("arrow_downward"), onClick: mv(1) });
}
if (opts.splitRow) { // 항목 칸 묶음 나누기 — 이어 붙은 줄들이 각자 항목 칸으로
items.push({ label: "항목 칸 나누기", icon: menuIcon("horizontal_split"), onClick: run(async function () {
await api("POST", "/project/api/goals/rows/" + opts.splitRow.dataset.rowId + "/split-label");
return true;
}) });
}
// 영역의 마지막 한 줄은 못 지운다(영역을 지운다) — 서버도 400
if (canDelete && top.closest(".pj-goal-area").rows.length > 1) {
items.push(null, { label: "줄 삭제", danger: true, icon: menuIcon("delete"), onClick: run(async function () {
return (await deleteRow(top)) ? { removed: [top] } : false;
}) });
}
return items;
}
function openRowLabelMenu(th, x, y, opts) {
const tr = th.closest("tr");
// 2열 = 항목 칸 밖에 따로 추가(묶음의 맨 위·맨 아래 기준), 묶인 칸이면 "항목 칸 나누기"도
const grouped = (th.rowSpan || 1) > 1;
showContextMenu(x, y, rowMenuItems(tr, labelGroupBottom(tr), true,
{ splitRow: grouped ? tr : null, move: grouped ? null : tr }).concat([null], widthMenuItems(th)),
Object.assign({ label: (textOf(th, ".pj-goal-row-text") || "이름 없는") + " 줄 메뉴" }, opts || {}));
}
table.addEventListener("contextmenu", function (e) {
const th = e.target.closest("th.pj-goal-row-label");
if (!th || !table.contains(th) || e.target.closest(".is-editing")) return;
e.preventDefault();
openRowLabelMenu(th, e.clientX, e.clientY);
});
// ⋮ 메뉴 버튼(구역·항목 칸) — 우클릭과 같은 메뉴를 마우스·키보드(Tab → Enter/Space)·터치로. 닫으면 버튼으로 포커스 복귀.
// 표를 다시 그려도(refreshTable) 위임이라 새 버튼에 그대로 먹는다.
table.addEventListener("click", function (e) {
const btn = e.target.closest(".pj-goal-menu-btn");
if (!btn || !table.contains(btn)) return;
e.preventDefault();
e.stopPropagation();
// 열린 메뉴를 같은 버튼으로 다시 누르면 닫기(마우스는 mousedown 에서 이미 닫혔으니 방금 닫힌 것으로 판단)
if (btn.getAttribute("aria-expanded") === "true") { closeContextMenu({ focus: true }); return; }
if (Date.now() - (btn._pjMenuClosedAt || 0) < 300) return;
const th = btn.closest("th");
const r = btn.getBoundingClientRect();
const opts = {
returnFocus: btn, focusFirst: e.detail === 0, // detail 0 = 키보드(Enter/Space)로 누름
onClose: function (how) {
btn.setAttribute("aria-expanded", "false");
if (how.target && btn.contains(how.target)) btn._pjMenuClosedAt = Date.now(); // 이 버튼을 눌러 닫음
},
};
btn.setAttribute("aria-expanded", "true");
if (btn.dataset.goalMenu === "area") openAreaMenu(th, r.left, r.bottom + 4, opts);
else openRowLabelMenu(th, r.left, r.bottom + 4, opts);
});
// 3열(연간 칸) 우클릭에도 줄 추가·삭제 — 추가한 줄은 같은 항목 칸(2열) 안에 들어간다(sameLabel, 016).
// 병합 메뉴가 있으면(014) 그 메뉴에 붙이고, 없으면 여기서
function yearCellRows(td) {
const tr = td.closest("tr"), rows = Array.from(td.closest("tbody").rows);
const rspan = parseInt(td.dataset.rspan || "1", 10);
return { top: tr, bottom: rows[Math.min(rows.length - 1, rows.indexOf(tr) + rspan - 1)], single: rspan === 1 };
}
if (table.dataset.halves !== "true") {
table.addEventListener("contextmenu", function (e) {
const td = e.target.closest("tbody.pj-goal-area td.pj-goal-texttd[data-month='0']");
if (!td || !table.contains(td)) return;
e.preventDefault();
const r = yearCellRows(td);
showContextMenu(e.clientX, e.clientY, rowMenuItems(r.top, r.bottom, r.single, { sameLabel: true }).concat([null], widthMenuItems(td)));
});
}
// ── 영역·줄 이름 — 눌러서 그 자리에서 수정(Enter·칸 떠남 = 저장, Esc = 취소). 서식 없이 글자만. ──
function startNameEdit(span) {
if (span.isContentEditable) return;
const kind = span.dataset.goalEdit;
const orig = span.textContent;
span.contentEditable = "true";
span.classList.add("is-editing");
span.focus();
const r = document.createRange();
r.selectNodeContents(span);
const sel = window.getSelection();
sel.removeAllRanges();
sel.addRange(r);
let done = false;
async function finish(save) {
if (done) return;
done = true;
span.contentEditable = "false";
span.classList.remove("is-editing");
span.removeEventListener("keydown", onKey);
span.removeEventListener("blur", onBlur);
const v = span.textContent.replace(/\s+/g, " ").trim();
if (!save || v === orig.trim()) { span.textContent = orig; return; }
if (kind === "area" && !v) {
span.textContent = orig;
showToast("업무 영역 이름을 입력하세요.", "error");
return;
}
span.textContent = v;
try {
if (kind === "area") {
await api("PUT", "/project/api/goals/areas/" + span.closest(".pj-goal-area").dataset.areaId, { name: v });
} else {
await api("PUT", "/project/api/goals/rows/" + span.closest("tr").dataset.rowId, { label: v });
}
flashSaved(span.closest("th"));
} catch (err) {
span.textContent = orig;
showToast("이름 변경 실패: " + err.message, "error");
}
}
function onKey(e) {
if (isImeEnter(e)) return;
if (e.key === "Enter") { e.preventDefault(); span.blur(); }
else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); finish(false); span.blur(); }
}
function onBlur() { finish(true); }
span.addEventListener("keydown", onKey);
span.addEventListener("blur", onBlur);
}
table.addEventListener("click", function (e) {
const span = e.target.closest("[data-goal-edit]");
if (span) startNameEdit(span);
});
// 키보드 — 이름 칸에 Tab 으로 와서 Enter·F2 = 이름 수정(수정 중 Enter 는 startNameEdit 이 먼저 받아 preventDefault)
table.addEventListener("keydown", function (e) {
const span = e.target.closest && e.target.closest("[data-goal-edit]");
if (!span || span.isContentEditable || e.defaultPrevented || isImeEnter(e)) return;
if (e.key === "Enter" || e.key === "F2") { e.preventDefault(); startNameEdit(span); }
});
table.addEventListener("paste", function (e) {
const span = e.target.closest && e.target.closest("[data-goal-edit].is-editing");
if (!span) return;
e.preventDefault();
const text = ((e.clipboardData || window.clipboardData).getData("text/plain") || "").replace(/\s+/g, " ");
document.execCommand("insertText", false, text);
});
// ── 칸 병합 — 엑셀처럼: 업무 영역 글 칸을 마우스로 끌어(또는 Shift+클릭) 사각형으로 고른 뒤 우클릭 → 셀 병합,
// 병합된 칸은 우클릭 → 병합 해제(글은 왼쪽 위 칸에 남는다). 같은 업무 영역 안에서만, 가로는 같은 분기 월 칸끼리
// (연간·분기 칸은 세로로만). 고른 범위가 병합된 칸에 걸치면 엑셀처럼 그 칸 전체로 넓힌다.
// 병합하면 서버가 범위 안 글을 왼쪽 위부터 이어 왼쪽 위 칸에 모은다(글을 잃지 않게).
if (table.dataset.halves === "true") {
const ORDER = [0, 1, 2, 3, 13, 4, 5, 6, 15, 7, 8, 9, 14, 10, 11, 12, 16]; // store.GOAL_COL_ORDER
const groupOf = function (m) { return m === 0 ? "y" : m > 12 ? "q" + m : "m" + Math.ceil(m / 3); };
const textTd = function (node) {
const td = node && node.closest && node.closest("td.pj-goal-texttd");
return td && table.contains(td) && td.closest("tbody.pj-goal-area") ? td : null;
};
// 영역 하나의 칸 배치 — 칸마다 덮는 사각형(줄 순번 r0~r1, 칸 순번 c0~c1)
const gridOf = function (tbody) {
const cells = [];
Array.prototype.forEach.call(tbody.rows, function (tr, ri) {
tr.querySelectorAll("td.pj-goal-texttd").forEach(function (td) {
const ci = ORDER.indexOf(parseInt(td.dataset.month, 10));
const span = parseInt(td.dataset.span || "1", 10), rspan = parseInt(td.dataset.rspan || "1", 10);
cells.push({ td: td, r0: ri, r1: ri + rspan - 1, c0: ci, c1: ci + span - 1, merged: span > 1 || rspan > 1 });
});
});
return cells;
};
const cellOf = function (cells, td) { return cells.find(function (c) { return c.td === td; }); };
const hits = function (c, s) { return c.r0 <= s.r1 && c.r1 >= s.r0 && c.c0 <= s.c1 && c.c1 >= s.c0; };
// 걸친 병합 칸을 통째로 품을 때까지 넓힌다(엑셀 선택과 같음)
const expand = function (cells, s) {
let grown = true;
while (grown) {
grown = false;
cells.forEach(function (c) {
if (!hits(c, s)) return;
const n = { r0: Math.min(s.r0, c.r0), r1: Math.max(s.r1, c.r1), c0: Math.min(s.c0, c.c0), c1: Math.max(s.c1, c.c1) };
if (n.r0 !== s.r0 || n.r1 !== s.r1 || n.c0 !== s.c0 || n.c1 !== s.c1) { s = n; grown = true; }
});
}
return s;
};
let sel = null; // {tbody, cells, r0, r1, c0, c1, n(칸 수)}
let anchorCell = null; // 마지막으로 누른 칸 {tbody, cell}
let drag = null;
clearMergeSel = function () {
sel = null;
setMoveActive(null);
table.querySelectorAll("td.is-merge-sel").forEach(function (td) { td.classList.remove("is-merge-sel"); });
};
const paint = function () {
table.querySelectorAll("td.is-merge-sel").forEach(function (td) { td.classList.remove("is-merge-sel"); });
if (!sel) return;
sel.cells.forEach(function (c) { if (hits(c, sel)) c.td.classList.add("is-merge-sel"); });
setMoveActive(sel.n === 1 ? sel.cells.find(function (c) { return hits(c, sel); }).td : null);
};
const select = function (tbody, a, b) {
const cells = gridOf(tbody);
const ca = cellOf(cells, a), cb = cellOf(cells, b);
if (!ca || !cb) return;
const s = expand(cells, { r0: Math.min(ca.r0, cb.r0), r1: Math.max(ca.r1, cb.r1),
c0: Math.min(ca.c0, cb.c0), c1: Math.max(ca.c1, cb.c1) });
sel = Object.assign({ tbody: tbody, cells: cells, n: cells.filter(function (c) { return hits(c, s); }).length }, s);
paint();
};
const mergeSel = async function (s) {
const cols = ORDER.slice(s.c0, s.c1 + 1);
const groups = cols.map(groupOf).filter(function (g, i, a) { return a.indexOf(g) === i; });
if (groups.length > 1) {
showToast("연간·분기 칸은 세로로만, 월 칸은 같은 분기 안에서만 합칠 수 있습니다.", "error");
return;
}
const rows = s.tbody.rows;
const req = { row_from: rows[s.r0].dataset.rowId, row_to: rows[s.r1].dataset.rowId, col_from: cols[0], col_to: cols[cols.length - 1] };
return withStruct(async function () {
try {
await flushTexts(); // 서버가 DB 글을 모으므로 먼저 저장 — 실패면 병합하지 않는다(글 유지)
const res = await api("POST", "/project/api/goals/areas/" + s.tbody.dataset.areaId + "/merge", req);
await refreshTable({ flash: { row: res.row_id, month: res.start } });
} catch (err) { showToast("병합 실패: " + err.message, "error"); }
});
};
const unmerge = async function (cellsToSplit) {
const targets = cellsToSplit.map(function (c) { return { row: c.td.closest("tr").dataset.rowId, month: c.td.dataset.month }; });
return withStruct(async function () {
try {
await flushTexts();
for (const t of targets) await api("DELETE", "/project/api/goals/rows/" + t.row + "/merge/" + t.month);
await refreshTable({ flash: targets[0] || null });
} catch (err) { showToast("병합 해제 실패: " + err.message, "error"); }
});
};
// 고른 칸 내용 지우기(엑셀 Del) — 칸마다 바로 저장. 바로 직전 지우기는 Ctrl+Z 로 되돌린다(입력 중이 아닐 때).
let lastCleared = null; // [[textarea, 예전 글], …]
const clearSel = async function (s) {
const tas = s.cells.filter(function (c) { return hits(c, s); })
.map(function (c) { return c.td.querySelector(".pj-goal-text"); })
.filter(function (ta) { return ta && ta.value !== ""; });
if (!tas.length) return;
lastCleared = tas.map(function (ta) { return [ta, ta.value]; });
tas.forEach(function (ta) { ta.value = ""; fit(ta); });
const rs = await Promise.allSettled(tas.map(saveText));
if (rs.every(function (r) { return r.status === "fulfilled"; })) showToast(tas.length + "칸 내용을 지웠습니다 — Ctrl+Z 로 되돌리기");
};
const undoClear = async function () {
const list = (lastCleared || []).filter(function (x) { return document.contains(x[0]); });
lastCleared = null;
if (!list.length) return;
list.forEach(function (x) { x[0].value = x[1]; fit(x[0]); });
const rs = await Promise.allSettled(list.map(function (x) { return saveText(x[0]); }));
if (rs.every(function (r) { return r.status === "fulfilled"; })) showToast(list.length + "칸 내용을 되돌렸습니다");
};
const typing = function () {
const a = document.activeElement;
return !!(a && (a.matches("textarea, input, select") || a.isContentEditable));
};
document.addEventListener("keydown", function (e) {
if (typing()) return;
if (e.key === "Delete" && sel) { e.preventDefault(); clearSel(sel); }
else if ((e.ctrlKey || e.metaKey) && !e.shiftKey && (e.key === "z" || e.key === "Z") && lastCleared) {
e.preventDefault();
undoClear();
}
});
// 끌어서 고르기 — 다른 칸으로 넘어가는 순간부터 범위 선택(글 선택·입력칸 포커스는 막는다)
table.addEventListener("mousedown", function (e) {
if (e.button !== 0) return;
const td = textTd(e.target);
if (!td) return;
const tbody = td.closest("tbody");
if (e.shiftKey && anchorCell && anchorCell.tbody === tbody && anchorCell.td !== td) {
e.preventDefault(); // Shift+클릭 = 마지막으로 누른 칸부터 여기까지
select(tbody, anchorCell.td, td);
return;
}
clearMergeSel();
anchorCell = { tbody: tbody, td: td };
drag = { tbody: tbody, td: td, moved: false };
select(tbody, td, td);
});
table.addEventListener("mouseover", function (e) {
if (!drag) return;
const td = textTd(e.target);
if (!td || td.closest("tbody") !== drag.tbody) return;
if (td === drag.td && !drag.moved) return;
if (!drag.moved) {
drag.moved = true;
document.documentElement.classList.add("pj-goal-selecting");
if (document.activeElement && document.activeElement.blur) document.activeElement.blur();
}
const s = window.getSelection && window.getSelection();
if (s && s.removeAllRanges) s.removeAllRanges();
select(drag.tbody, drag.td, td);
});
document.addEventListener("mouseup", function () {
if (!drag) return;
drag = null;
document.documentElement.classList.remove("pj-goal-selecting");
});
// 다른 곳을 누르거나 Esc 면 선택 해제
document.addEventListener("mousedown", function (e) {
if (sel && !textTd(e.target) && !e.target.closest(".pj-ctxmenu")) clearMergeSel();
}, true);
document.addEventListener("keydown", function (e) { if (e.key === "Escape" && sel) clearMergeSel(); });
// 우클릭 — 셀 병합(고른 범위가 2칸 이상) / 병합 해제(병합된 칸). 해당 없으면 브라우저 기본 메뉴
table.addEventListener("contextmenu", function (e) {
const td = textTd(e.target);
if (!td) return;
const tbody = td.closest("tbody");
if (!sel || sel.tbody !== tbody || !sel.cells.some(function (c) { return c.td === td && hits(c, sel); })) {
select(tbody, td, td); // 범위 밖을 우클릭하면 그 칸만(엑셀처럼)
}
const s = sel;
const inSel = s.cells.filter(function (c) { return hits(c, s); });
const mergedIn = inSel.filter(function (c) { return c.merged; });
const items = [];
if (s.n >= 2) {
const rowsN = s.r1 - s.r0 + 1, colsN = s.c1 - s.c0 + 1;
items.push({ label: "셀 병합 (" + rowsN + "줄 × " + colsN + "칸)", icon: menuIcon("cell_merge"),
onClick: function () { clearMergeSel(); mergeSel(s); } });
}
if (mergedIn.length) {
items.push({ label: "병합 해제" + (mergedIn.length > 1 ? " (" + mergedIn.length + "곳)" : ""), icon: menuIcon("call_split"),
onClick: function () { clearMergeSel(); unmerge(mergedIn); } });
}
if (inSel.some(function (c) { const t = c.td.querySelector(".pj-goal-text"); return t && t.value; })) {
items.push({ label: "내용 지우기 (Del)", icon: menuIcon("ink_eraser"), onClick: function () { clearSel(s); } });
}
if (td.dataset.month === "0" && s.n === 1) { // 3열(연간 칸) 하나 우클릭 — 줄 추가·삭제도
const r = yearCellRows(td);
if (items.length) items.push(null);
rowMenuItems(r.top, r.bottom, r.single, { sameLabel: true }).forEach(function (it) { items.push(it); });
}
if (items.length) items.push(null);
widthMenuItems(td).forEach(function (item) { items.push(item); });
e.preventDefault();
showContextMenu(e.clientX, e.clientY, items);
});
}
}
// ── 회의록 숫자 칸 다시 그리기 — 서버가 새로 그린 화면에서 숫자 칸만 옮겨 온다(입력 중인 칸·저장 안 된 글·직접 입력 칸은 그대로).
// 매출 갱신 완료·금주 목표 저장 두 곳에서 부르므로 차례 번호로 늦게 도착한 옛 응답은 버린다(옛 비율이 다시 들어오지 않게).
let meetRepaintSeq = 0;
async function meetRepaint() {
const seq = ++meetRepaintSeq;
const res = await fetch(location.href, { credentials: "same-origin", cache: "no-store" });
if (!res.ok) throw new Error("화면을 다시 읽지 못했습니다(" + res.status + ")");
const doc = new DOMParser().parseFromString(await res.text(), "text/html");
if (seq !== meetRepaintSeq) return false; // 더 나중에 시작한 다시 그리기가 있다
const now = document.querySelectorAll(".pj-meet-kpi"), fresh = doc.querySelectorAll(".pj-meet-kpi");
if (now.length === fresh.length) {
now.forEach(function (n, i) {
if (n.querySelector("input, textarea, select")) {
const a = n.querySelector(".pj-meet-sub-slot"), b = fresh[i].querySelector(".pj-meet-sub-slot");
if (a && b) a.innerHTML = b.innerHTML;
return;
}
n.innerHTML = fresh[i].innerHTML;
const t = fresh[i].getAttribute("title");
if (t) { n.dataset.tip = t; n.removeAttribute("title"); }
});
}
document.querySelectorAll("#pj-meet-table tr[data-item]").forEach(function (tr) {
const ftr = doc.querySelector('#pj-meet-table tr[data-item="' + tr.dataset.item + '"]');
if (!ftr) return;
if (tr.querySelector(".pj-meet-c-result input")) return; // 직접 입력 칸 — 이 화면 값 그대로
const a = tr.querySelector(".pj-meet-c-result"), b = ftr.querySelector(".pj-meet-c-result");
if (a && b) a.innerHTML = b.innerHTML;
});
const box = el("pj-meet-sync"), fbox = doc.getElementById("pj-meet-sync");
if (box && fbox) box.dataset.fresh = fbox.dataset.fresh || ""; // 서버가 기록한 마지막 갱신 성공 시각
return true;
}
// ── 회의록 매출 자료 갱신 — 주차를 열면 실적 모듈 [매출 업데이트](지난주 월요일 ~ 이번 주 오늘, 백그라운드)를 한 번 더
// 돌리고, 끝나면 숫자 칸만 다시 그린다(meetRepaint). 같은 주는 10분에 한 번만 자동(새로고침마다 쇼핑몰 API 를 부르지 않게).
// 이미 다른 매출 업데이트가 돌면 그 작업에 합류해 끝나길 기다리고, 그 작업이 이 주 기간을 다 덮지 못했으면 한 번 더 부른다.
// 화면: 정상이면 아무것도 보이지 않는다(2026-10-01 요청 — 큰 상태 줄 없음). 실패·일부 쇼핑몰 실패·권한 없음일 때만 작은
// 안내(#pj-meet-sync) — 실패한 쇼핑몰 이름, 서버가 기록한 마지막 갱신 성공 시각(data-fresh, 가장 오래된 쇼핑몰 기준), [다시 시도].
// 권한 없음(data-can="0")은 서버가 미리 알려 주므로 API 를 부르지 않는다. 브라우저 시각은 10분 제한 계산에만 쓰고 보여 주지 않는다.
function initMeetingSync(pane) {
const box = el("pj-meet-sync");
if (!box) return;
const text = box.querySelector(".pj-meet-sync-text");
const btn = el("pj-meet-sync-btn");
const KEY = "pj_meet_sync:" + pane.dataset.week;
const THROTTLE_MS = 10 * 60 * 1000;
let running = false;
function show(kind, msg, retry) {
box.hidden = false;
box.dataset.state = kind;
if (text) text.textContent = msg;
if (btn) btn.hidden = !retry;
}
function hide() { box.hidden = true; delete box.dataset.state; }
function freshText() {
const f = box.dataset.fresh;
return f ? " · 저장된 실적의 마지막 갱신 성공 " + f + "(가장 오래된 쇼핑몰 기준)" : " · 저장된 실적의 갱신 성공 기록 없음";
}
function report(rec) {
if (!rec || rec.state === "ok") { hide(); return; }
if (rec.state === "partial") show("partial", "일부 쇼핑몰 매출을 새로 받지 못했습니다: " + rec.bad.join(", ") + freshText(), true);
else if (rec.state === "noperm") show("noperm", "실적 모듈 권한이 없어 쇼핑몰 매출을 새로 받지 않고 저장된 실적으로 보여 줍니다" + freshText(), false);
else show("error", "쇼핑몰 매출 갱신 실패 — " + (rec.msg || "알 수 없는 오류") + freshText(), true);
}
function remember(rec) { try { sessionStorage.setItem(KEY, JSON.stringify(rec)); } catch (_) {} }
function recall() {
try {
const raw = sessionStorage.getItem(KEY);
if (!raw) return null;
if (/^\d+$/.test(raw)) return { at: Number(raw), state: "ok" }; // 예전 기록(시각만)
return JSON.parse(raw);
} catch (_) { return null; }
}
if (box.dataset.can !== "1") { report({ state: "noperm" }); return; }
async function waitJob(job) {
while (!job.finished) {
await new Promise(function (ok) { setTimeout(ok, 1000); });
job = (await api("GET", "/performance/api/sync/jobs/" + encodeURIComponent(job.id))).job;
}
return job;
}
async function run(force) {
if (running) return;
if (!force) {
const last = recall();
if (last && (last.state === "noperm" || Date.now() - (last.at || 0) < THROTTLE_MS)) { report(last); return; }
}
running = true;
if (btn) btn.disabled = true;
if (force) show("running", "쇼핑몰 매출을 다시 받는 중…", false); // 직접 누른 재시도만 진행 표시
let rec;
try {
const want = { from: box.dataset.from, to: box.dataset.to };
let r = await api("POST", "/performance/api/sync", { from: want.from, to: want.to, background: true });
let job = await waitJob(r.job);
// 다른 사람이 돌리던 업데이트에 합류했는데 그 기간이 이 주를 다 덮지 못하면 이 주 기간으로 한 번 더
if (r.joined && !(job.from && job.to && job.from <= want.from && job.to >= want.to)) {
r = await api("POST", "/performance/api/sync", { from: want.from, to: want.to, background: true });
job = await waitJob(r.job);
}
await meetRepaint();
const bad = (job.shops || []).filter(function (s) { return s.active !== false && (s.state === "error" || s.state === "cancelled"); })
.map(function (s) { return s.name + (s.label ? "(" + s.label + ")" : ""); });
rec = job.error ? { state: "error", msg: job.error } : bad.length ? { state: "partial", bad: bad } : { state: "ok" };
} catch (e) {
rec = e.status === 403 ? { state: "noperm" } : { state: "error", msg: e.message };
} finally {
running = false;
if (btn) btn.disabled = false;
}
rec.at = Date.now();
remember(rec);
report(rec);
}
if (btn) btn.addEventListener("click", function () { run(true); });
run(false);
}
// ── 주간 회의록(/project/goals/{연도}/meetings/{월}?week=) — 관리자만 입력, 칸마다 바로 저장.
// · 글(주요 업무·메모): 0.8초 멈춤·칸 떠남·페이지 떠남에 저장. 금액·참석자: 칸 떠남·Enter 에 저장.
// · 지난주 결과 금액은 지난 회의록의 같은 줄(tr data-prev)에 저장한다.
// · 줄 추가·순서·삭제·구역 추가는 저장 뒤 새로고침(스크롤 위치 되살림). 메뉴는 body 에 붙는다.
// ── 회의록 표 — 이번주(2칸) ↔ 지난주 리뷰(4칸) 순서 바꾸기. 줄마다 is-this / is-prev 칸 묶음을 통째로 옮긴다
// (colgroup·머리 두 줄·구역 줄 모두). 보는 사람마다 브라우저에 기억 — localStorage pj_meet_order:{로그인 이메일} = "prev"(지난주 먼저).
// 다시 그리기(repaintMeeting)는 칸을 선택자로 찾으므로 순서와 무관.
function initMeetOrder() {
const table = el("pj-meet-table"), btn = el("pj-meet-order");
if (!table || !btn) return;
const wrap = document.querySelector(".pj-wrap");
const KEY = "pj_meet_order:" + ((wrap && wrap.dataset.me) || "");
const isPrev = function (c) { return c.classList.contains("is-prev"); };
const isThis = function (c) {
return c.classList.contains("is-this") ||
(!isPrev(c) && (c.classList.contains("pj-meet-c-text") || c.classList.contains("pj-meet-c-amt")));
};
let prevFirst = false;
try { prevFirst = localStorage.getItem(KEY) === "prev"; } catch (_) {}
function arrange() {
const lines = [table.querySelector("colgroup")].concat(Array.from(table.querySelectorAll("tr")));
lines.forEach(function (line) {
if (!line) return;
const kids = Array.from(line.children);
const mine = kids.filter(isThis), prev = kids.filter(isPrev);
if (!mine.length || !prev.length) return;
if (prevFirst) prev.forEach(function (c) { line.insertBefore(c, mine[0]); });
else mine.forEach(function (c) { line.insertBefore(c, prev[0]); });
});
table.classList.toggle("is-prev-first", prevFirst);
btn.setAttribute("aria-pressed", prevFirst ? "true" : "false");
}
arrange();
btn.addEventListener("click", function () {
prevFirst = !prevFirst;
try { localStorage.setItem(KEY, prevFirst ? "prev" : "this"); } catch (_) {}
const reduce = window.matchMedia && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
if (reduce || !table.animate) { arrange(); return; }
table.animate([{ opacity: 1 }, { opacity: .35 }], { duration: 110, easing: "ease-in" }).finished
.then(function () {
arrange();
table.animate([{ opacity: .35 }, { opacity: 1 }], { duration: 160, easing: "ease-out" });
}).catch(arrange);
});
}
// ── 회의록 위쪽 고정 영역(숫자 4칸 | 결정 사항·메모) — 스크롤해도 위에 붙고, 표 머리 줄은 그 아래에 붙는다.
// 높이가 바뀌면(메모 줄 수·창 너비) --pj-meet-top-h 를 다시 잰다. 배율(.pj-ui-scale) 안이라 offsetHeight(배율 전 값)로.
function initMeetTop(pane) {
const top = el("pj-meet-top");
if (!top) return;
const apply = function () { pane.style.setProperty("--pj-meet-top-h", top.offsetHeight + "px"); };
apply();
if (window.ResizeObserver) new ResizeObserver(apply).observe(top);
else window.addEventListener("resize", apply);
}
// ── 회의록 보드 — 그 주차의 빈 Google 슬라이드를 독립 창으로. 팝업 차단을 피하려고 누르는 순간 빈 창을 먼저 열고,
// 서버(POST …/board — 없으면 공유 드라이브에 만든다)가 주소를 주면 그 창을 슬라이드로 바꾼다. 같은 주차는 같은 창 이름.
function initMeetBoard(week) {
const btn = el("pj-meet-board");
if (!btn) return;
btn.addEventListener("click", async function () {
const w = window.open("", "pj_meet_board_" + week, "popup=yes,width=1400,height=900");
if (w) {
try {
if (w.location.href === "about:blank") {
w.document.title = "회의록 보드";
w.document.body.innerHTML = '<p style="font:14px sans-serif;padding:24px;color:#555">회의록 보드를 여는 중…</p>';
}
} catch (_) {} // 이미 슬라이드가 열린 창(다른 출처)이면 그대로 두고 주소만 바꾼다
}
btn.disabled = true;
try {
const res = await api("POST", "/project/api/goals/meetings/" + week + "/board", {});
if (w && !w.closed) { w.location.replace(res.url); w.focus(); }
else showToast("팝업이 차단되어 창을 열지 못했습니다. 이 사이트의 팝업을 허용한 뒤 다시 눌러 주세요.", "error");
if (res.created) showToast("회의록 보드를 만들었습니다: " + res.title);
} catch (e) {
if (w && !w.closed) w.close();
showToast("회의록 보드를 열지 못했습니다: " + e.message, "error");
} finally {
btn.disabled = false;
}
});
}
// ── 회의록 머리 ③ 작업 등록 표 — 제목 입력, 담당자·프로젝트·섹션 칸을 누르면 목록(showContextMenu — body 에 붙음),
// [적용] = 그 프로젝트에 작업 만들기(POST /project/api/projects/{id}/tasks, 담당자는 그 프로젝트 멤버·소유자만 —
// 서버 _check_assignee). 프로젝트 목록은 내가 멤버인 최상위 프로젝트(GET /project/api/projects).
// 줄은 이 브라우저에 보관(localStorage pj_meet_quick:{이메일}) — 새로고침해도 남는다(등록된 줄도 — 나중에 삭제할 수 있게).
// 등록된 줄의 [삭제] = 확인 뒤 그 작업을 프로젝트에서도 삭제(DELETE /project/api/tasks/{id}, 휴지통 3개월), 적용 전 줄의 × = 줄만 지움.
function initMeetQuickTasks() {
const box = el("pj-meet-quick");
if (!box) return;
const tbody = box.querySelector("tbody");
const wrap = document.querySelector(".pj-wrap");
const KEY = "pj_meet_quick:" + ((wrap && wrap.dataset.me) || "");
const people = {}, faces = {};
(window.PJ_MEET_MEMBERS || []).forEach(function (m) {
people[String(m.email).toLowerCase()] = m.name;
faces[String(m.email).toLowerCase()] = m.avatar || "";
});
const nameOf = function (email) { return people[String(email).toLowerCase()] || capName(idOf(email)); };
// 담당자 = 아이콘(사진, 없으면 첫 글자) + 이름
const faceHtml = function (email) {
const url = faces[String(email).toLowerCase()];
return url ? '<img class="pj-avatar pj-meet-quick-face" src="' + escapeHtml(url) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="pj-meet-quick-face is-ini">' + escapeHtml(nameOf(email).slice(0, 1)) + "</span>";
};
const blank = function () { return { title: "", assignee: "", projectId: null, projectName: "", stageId: null, stageName: "" }; };
let rows = [];
try { rows = (JSON.parse(localStorage.getItem(KEY) || "[]") || []).filter(function (r) { return r && typeof r === "object"; }); } catch (_) { rows = []; }
while (rows.length < 3) rows.push(blank());
const save = function () {
try { localStorage.setItem(KEY, JSON.stringify(rows.filter(function (r) { return r.done || r.title || r.projectId || r.assignee; }))); } catch (_) {}
};
let projects = null;
const memberCache = {}, stageCache = {};
async function loadProjects() {
if (projects) return projects;
const res = await api("GET", "/project/api/projects");
projects = (res.projects || []).filter(function (p) { return !p.parent_id; });
return projects;
}
async function membersOf(pid) {
if (memberCache[pid]) return memberCache[pid];
const res = await api("GET", "/project/api/projects/" + pid + "/members");
const list = (res.members || []).map(function (m) { return String(m.user_email).toLowerCase(); });
const proj = (projects || []).find(function (p) { return p.id === pid; });
if (proj && proj.owner_email && list.indexOf(String(proj.owner_email).toLowerCase()) < 0) list.unshift(String(proj.owner_email).toLowerCase());
memberCache[pid] = list;
return list;
}
async function stagesOf(pid) {
if (stageCache[pid]) return stageCache[pid];
const res = await api("GET", "/project/api/projects/" + pid + "/stages");
stageCache[pid] = (res.stages || []).slice().sort(function (a, b) { return a.sort_order - b.sort_order; });
return stageCache[pid];
}
function cell(kind, text, placeholder) {
return '<button type="button" class="pj-meet-pick-cell' + (text ? "" : " is-empty") + '" data-pick="' + kind + '">' +
escapeHtml(text || placeholder) + "</button>";
}
function render() {
tbody.innerHTML = rows.map(function (r, i) {
return '<tr data-i="' + i + '"' + (r.done ? ' class="is-done"' : "") + ">" +
'<td><input type="text" data-field="title" maxlength="200" placeholder="작업 제목" value="' + escapeHtml(r.title) + '"></td>' +
"<td>" + (r.assignee
? '<button type="button" class="pj-meet-pick-cell is-person" data-pick="assignee">' + faceHtml(r.assignee) +
"<span>" + escapeHtml(nameOf(r.assignee)) + "</span></button>"
: cell("assignee", "", "담당자")) + "</td>" +
"<td>" + cell("project", r.projectName, "프로젝트") + "</td>" +
"<td>" + cell("stage", r.stageName, "섹션") + "</td>" +
'<td class="pj-meet-quick-acts">' + (r.done
? '<span class="pj-meet-quick-done"><span class="material-symbols-outlined" style="font-size:16px">check_circle</span>' +
'<a href="/project/p/' + r.done.pid + "?task=" + r.done.id + '" target="_blank" rel="noopener">등록됨</a></span>' +
'<button type="button" class="pj-meet-quick-del" data-quick="delete" title="이 작업을 프로젝트에서도 삭제(휴지통에 3개월 보관)">' +
'<span class="material-symbols-outlined">delete</span></button>'
: '<button type="button" class="pj-meet-quick-apply" data-quick="apply">적용</button>' +
'<button type="button" class="pj-meet-quick-del" data-quick="remove" title="이 줄 지우기(아직 등록 전)">' +
'<span class="material-symbols-outlined">close</span></button>') + "</td></tr>";
}).join("");
}
function menuAt(btn, items) {
const r = btn.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 2, items.length ? items : [{ label: "고를 항목이 없습니다", onClick: function () {} }]);
}
async function pickProject(r, btn) {
const list = await loadProjects();
menuAt(btn, list.map(function (p) {
return { label: p.name, icon: menuIcon("folder"), checked: r.projectId === p.id, onClick: async function () {
if (r.projectId !== p.id) { r.stageId = null; r.stageName = ""; }
r.projectId = p.id; r.projectName = p.name;
try {
const [mem, stages] = await Promise.all([membersOf(p.id), stagesOf(p.id)]);
if (r.assignee && mem.indexOf(r.assignee.toLowerCase()) < 0) {
showToast(nameOf(r.assignee) + "님은 이 프로젝트 멤버가 아니어서 담당자를 비웠습니다.");
r.assignee = "";
}
if (!r.stageId && stages.length) { r.stageId = stages[0].id; r.stageName = stages[0].name; }
} catch (e) { showToast("프로젝트 정보를 읽지 못했습니다: " + e.message, "error"); }
save(); render();
} };
}));
}
async function pickAssignee(r, btn) {
// 프로젝트를 골랐으면 그 프로젝트 멤버·소유자만(작업을 볼 수 있는 사람), 아니면 프로젝트 권한이 있는 전체 직원
const emails = r.projectId ? await membersOf(r.projectId)
: (window.PJ_MEET_MEMBERS || []).map(function (m) { return String(m.email).toLowerCase(); });
menuAt(btn, [{ label: "담당자 없음", icon: menuIcon("person_off"), checked: !r.assignee, onClick: function () { r.assignee = ""; save(); render(); } }, null]
.concat(emails.map(function (e) {
return { label: nameOf(e), icon: faceHtml(e), checked: r.assignee === e, onClick: function () { r.assignee = e; save(); render(); } };
})));
}
async function pickStage(r, btn) {
if (!r.projectId) { showToast("프로젝트를 먼저 고르세요."); return; }
const stages = await stagesOf(r.projectId);
menuAt(btn, stages.map(function (st) {
return { label: st.name, icon: menuIcon("view_column"), checked: r.stageId === st.id, onClick: function () { r.stageId = st.id; r.stageName = st.name; save(); render(); } };
}));
}
async function apply(r, btn) {
if (!r.title.trim()) { showToast("작업 제목을 쓰세요."); return; }
if (!r.projectId) { showToast("프로젝트를 고르세요."); return; }
btn.disabled = true;
try {
const res = await api("POST", "/project/api/projects/" + r.projectId + "/tasks", {
title: r.title.trim(), stage_id: r.stageId, assignee_email: r.assignee || "",
assignee_name: r.assignee ? nameOf(r.assignee) : "",
});
r.done = { id: res.task.id, pid: r.projectId };
showToast("‘" + r.projectName + "’에 작업을 등록했습니다.");
if (!rows.some(function (x) { return !x.done; })) rows.push(blank());
save(); render();
} catch (e) {
btn.disabled = false;
showToast("작업 등록 실패: " + e.message, "error");
}
}
// 등록된 작업 삭제 — 프로젝트에서도 지운다(휴지통). 이미 없으면(다른 곳에서 삭제) 줄만 지운다.
async function removeTask(r, btn) {
if (!(await confirm("‘" + (r.title || "작업") + "’ 작업을 ‘" + (r.projectName || "프로젝트") + "’에서도 삭제할까요? 삭제한 작업은 휴지통에 3개월 보관됩니다.",
{ okText: "삭제", cancelText: "취소" }))) return;
btn.disabled = true;
try {
await api("DELETE", "/project/api/tasks/" + r.done.id);
showToast("작업을 삭제했습니다.");
} catch (e) {
if (e.status !== 404) { btn.disabled = false; showToast("작업 삭제 실패: " + e.message, "error"); return; }
}
dropRow(r);
}
function dropRow(r) {
const i = rows.indexOf(r);
if (i >= 0) rows.splice(i, 1);
if (!rows.some(function (x) { return !x.done; })) rows.push(blank());
save(); render();
}
tbody.addEventListener("input", function (e) {
const inp = e.target.closest("input[data-field=title]");
if (!inp) return;
rows[+inp.closest("tr").dataset.i].title = inp.value;
save();
});
tbody.addEventListener("keydown", function (e) {
const inp = e.target.closest("input[data-field=title]");
if (inp && e.key === "Enter" && !isImeEnter(e)) { e.preventDefault(); inp.closest("tr").querySelector('[data-pick="assignee"]').click(); }
});
tbody.addEventListener("click", function (e) {
const tr = e.target.closest("tr");
if (!tr) return;
const r = rows[+tr.dataset.i], pick = e.target.closest("[data-pick]");
const del = e.target.closest('[data-quick="delete"], [data-quick="remove"]');
if (del) { if (del.dataset.quick === "delete") removeTask(r, del); else dropRow(r); return; }
if (r.done) return;
const fail = function (err) { showToast("목록을 읽지 못했습니다: " + err.message, "error"); };
if (pick) {
e.stopPropagation();
({ project: pickProject, assignee: pickAssignee, stage: pickStage })[pick.dataset.pick](r, pick).catch(fail);
} else if (e.target.closest('[data-quick="apply"]')) apply(r, e.target.closest('[data-quick="apply"]'));
});
box.querySelector('[data-quick="add"]').addEventListener("click", function () { rows.push(blank()); save(); render(); });
render();
}
function initGoalMeeting() {
const pane = el("pj-meet-pane");
if (!pane) return;
initMeetOrder();
initMeetTop(pane);
initMeetBoard(pane.dataset.week);
initMeetQuickTasks();
const week = pane.dataset.week, year = pane.dataset.year;
const isAdmin = pane.dataset.admin === "true";
// 회의록은 누구나 고친다(2026-10-07) — 회의 완료(잠금)면 아무도 못 고친다(data-edit). 관리자만 삭제·완료·완료 해제.
const canEdit = pane.dataset.edit === "true";
const SCROLL_KEY = "pj_meet_scroll";
function reloadKeepScroll() {
try { sessionStorage.setItem(SCROLL_KEY, JSON.stringify([location.pathname + location.search, window.scrollY, pane.scrollTop])); } catch (_) {}
location.reload();
}
try {
const s = JSON.parse(sessionStorage.getItem(SCROLL_KEY) || "null");
sessionStorage.removeItem(SCROLL_KEY);
if (s && s[0] === location.pathname + location.search) { window.scrollTo(0, s[1]); pane.scrollTop = s[2]; }
} catch (_) {}
const won = function (v) { return v == null || v === "" ? "" : Number(v).toLocaleString("ko-KR"); };
const printBtn = el("pj-meet-print");
if (printBtn) printBtn.addEventListener("click", function () { window.print(); });
const create = el("pj-meet-create");
if (create) create.addEventListener("click", async function () {
create.disabled = true;
try {
await api("POST", "/project/api/goals/meetings/" + week, { year: year });
location.reload();
} catch (e) { create.disabled = false; showToast("만들기 실패: " + e.message, "error"); }
});
initMeetingSync(pane); // 보기만 하는 사람도(실적 권한이 있으면) 매출 자료 갱신
const table = el("pj-meet-table");
const cellGrid = table && window.PJMeetingCells ? window.PJMeetingCells.init({
table: table, pane: pane, admin: canEdit, api: api, confirm: confirm, toast: showToast,
menu: showContextMenu, icon: menuIcon, zoom: uiZoom,
}) : null;
// 회의록 삭제·회의 완료·완료 해제 — 관리자(잠긴 회의록에서도 쓸 수 있게 편집 도구보다 먼저 연결)
const del = el("pj-meet-del");
if (del) del.addEventListener("click", async function () {
const ok = await confirm("이 주 회의록을 삭제할까요? 줄·금액·메모가 모두 삭제되고, 다음 주 회의록의 '지난주' 칸도 비게 됩니다.",
{ okText: "삭제", cancelText: "취소" });
if (!ok) return;
try { await api("DELETE", "/project/api/goals/meetings/" + week); location.reload(); }
catch (e) { showToast("삭제 실패: " + e.message, "error"); }
});
[["pj-meet-complete", true], ["pj-meet-reopen", false]].forEach(function (pair) {
const btn = el(pair[0]);
if (!btn) return;
btn.addEventListener("click", async function () {
const done = pair[1];
if (!(await confirm(done ? "회의를 완료할까요? 완료하면 이 회의록은 아무도 고칠 수 없습니다(관리자가 완료 해제 가능)."
: "완료를 해제할까요? 다시 누구나 고칠 수 있습니다.", { okText: done ? "회의 완료" : "완료 해제", cancelText: "취소" }))) return;
btn.disabled = true;
try {
if (done && canEdit) await flushAll(); // 쓰던 글을 먼저 저장(함수 선언 — 아래쪽 정의)
await api("POST", "/project/api/goals/meetings/" + week + "/complete", { done: done });
reloadKeepScroll();
} catch (e) { btn.disabled = false; showToast((done ? "회의 완료" : "완료 해제") + " 실패: " + e.message, "error"); }
});
});
if (!canEdit) return;
function flashSaved(node) {
if (!node) return;
node.classList.remove("is-saved");
void node.offsetWidth;
node.classList.add("is-saved");
}
function fit(ta) {
if (ta.tagName !== "TEXTAREA") { ta.style.removeProperty("height"); return; }
if (!ta.offsetParent) return;
ta.style.height = "auto";
ta.style.height = ta.scrollHeight + "px";
}
const meetingUrl = "/project/api/goals/meetings/" + week;
function itemUrl(id) { return "/project/api/goals/meeting-items/" + id; }
// ── 금액 칸(줄 정량 목표 · 지난주 결과 금액) — Enter·칸 떠남에 저장(createFieldSaver: 같은 칸 요청 차례대로).
// 서버 확정값(원 정수)을 쉼표 표기로 칸에 넣는 건 요청 뒤 입력이 그대로일 때만 — 그 사이 다시 입력한 초안은 덮지 않는다.
// 실패해도 입력값은 그대로(빨간 테두리), Esc = 저장된 값으로.
// 금주 목표 저장 뒤 머리 숫자는 페이지 새로고침 없이 숫자 칸만 다시 그린다(meetRepaint — 다른 칸의 저장 안 된 글 보존).
const tgt = el("pj-meet-target");
const amtSaver = createFieldSaver({
read: function (inp) { return inp.value; },
write: function (inp, v) { inp.value = v; },
unload: "warn",
send: function (inp, v, o) {
if (inp === tgt) return api("PUT", meetingUrl, { week_target: v }, o);
const tr = inp.closest("tr"), body = {};
body[inp.dataset.field] = v;
return api("PUT", itemUrl(inp.dataset.target === "prev" ? tr.dataset.prev : tr.dataset.item), body, o);
},
onSaved: function (inp, v, res, same) {
const cell = inp.closest("td") || inp.closest(".pj-meet-kpi");
clearSaveFailed(cell);
flashSaved(cell);
let shown;
if (inp === tgt) {
if (res && Object.prototype.hasOwnProperty.call(res, "week_target")) shown = won(res.week_target);
meetRepaint().catch(function () {}); // 머리 숫자 — 서버 계산으로
} else {
// 숫자면 원 정수(쉼표 표기), 숫자가 아니면(예: "20개") 서버가 글 칸(target_text·result_text, 021)에 둔 글 그대로
const tr = inp.closest("tr"), f = inp.dataset.field, item = res.item;
const text = item[f.replace("_amount", "_text")];
shown = text ? text : won(item[f]);
if (f === "target_amount") tr.dataset.targetAmount = item[f] == null ? "" : String(item[f]);
}
if (!same || shown === undefined) return undefined; // 요청 뒤 새로 입력 중 — 그 초안을 그대로
inp.value = shown;
return inp.value;
},
onFail: function (inp, err) { markSaveFailed(inp.closest("td") || inp.closest(".pj-meet-kpi"), err); },
});
function bindAmount(inp) {
amtSaver.track(inp, inp.value);
inp.addEventListener("focus", function () { inp.select(); });
inp.addEventListener("keydown", function (e) {
if (isImeEnter(e)) return;
if (e.key === "Enter") { e.preventDefault(); if (document.activeElement === inp) inp.blur(); else amtSaver.flush(inp).catch(function () {}); }
else if (e.key === "Escape") { inp.value = amtSaver.savedOf(inp); inp.blur(); }
});
inp.addEventListener("change", function () { amtSaver.flush(inp).catch(function () {}); });
inp.addEventListener("blur", function () { amtSaver.flush(inp).catch(function () {}); });
}
if (tgt) bindAmount(tgt);
// ── 참석자 — 전체 멤버에서 고르기(칩 + 고르기 창, 창은 body 에). 바뀔 때마다 이메일(예전 글자는 그대로)을 쉼표로 이어 저장 ──
const attBox = el("pj-meet-attend");
if (attBox && attBox.dataset.edit) {
const members = window.PJ_MEET_MEMBERS || [];
let picked = Array.from(attBox.querySelectorAll(".pj-meet-chip")).map(function (c) {
return { key: c.dataset.key, name: c.dataset.name, avatar: c.dataset.avatar || "" };
});
const addBtn = el("pj-meet-attend-add");
const chipHtml = function (a) {
return '<span class="pj-meet-chip" data-key="' + escapeHtml(a.key) + '">' +
(a.avatar ? '<img class="pj-avatar" src="' + escapeHtml(a.avatar) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="pj-meet-chip-ini">' + escapeHtml((a.name || "?").slice(0, 1)) + "</span>") +
"<span>" + escapeHtml(a.name) + '</span><button type="button" class="pj-meet-chip-x" title="빼기">×</button></span>';
};
const paint = function () {
attBox.querySelectorAll(".pj-meet-chip").forEach(function (c) { c.remove(); });
addBtn.insertAdjacentHTML("beforebegin", picked.map(chipHtml).join(""));
};
const saveAtt = async function () {
try {
await api("PUT", meetingUrl, { attendees: picked.map(function (a) { return a.key; }).join(", ") });
flashSaved(attBox);
} catch (e) { showToast("참석자 저장 실패: " + e.message, "error"); }
};
const has = function (email) { return picked.some(function (a) { return a.key.toLowerCase() === email.toLowerCase(); }); };
const toggle = function (m, on) {
if (on && !has(m.email)) picked.push({ key: m.email, name: m.name, avatar: m.avatar });
if (!on) picked = picked.filter(function (a) { return a.key.toLowerCase() !== m.email.toLowerCase(); });
};
attBox.addEventListener("click", function (e) {
const x = e.target.closest(".pj-meet-chip-x");
if (!x) return;
const key = x.closest(".pj-meet-chip").dataset.key;
picked = picked.filter(function (a) { return a.key !== key; });
paint();
saveAtt();
});
let pop = null;
const closePop = function () {
if (!pop) return;
pop.remove();
pop = null;
document.removeEventListener("mousedown", onDoc, true);
document.removeEventListener("keydown", onKey, true);
};
const onDoc = function (e) { if (pop && !pop.contains(e.target) && e.target !== addBtn && !addBtn.contains(e.target)) closePop(); };
const onKey = function (e) { if (e.key === "Escape") closePop(); };
const drawList = function (q) {
const ul = pop.querySelector(".pj-meet-pick-list");
const qq = (q || "").trim().toLowerCase();
const rows = members.filter(function (m) {
return !qq || m.name.toLowerCase().includes(qq) || m.email.toLowerCase().includes(qq);
});
ul.innerHTML = rows.length ? rows.map(function (m) {
return '<label class="pj-meet-pick-row"><input type="checkbox" data-email="' + escapeHtml(m.email) + '"' +
(has(m.email) ? " checked" : "") + ">" +
(m.avatar ? '<img class="pj-avatar" src="' + escapeHtml(m.avatar) + '" alt="" referrerpolicy="no-referrer">'
: '<span class="pj-meet-chip-ini">' + escapeHtml(m.name.slice(0, 1)) + "</span>") +
'<span class="pj-meet-pick-name">' + escapeHtml(m.name) + '</span><span class="pj-meet-pick-id">' +
escapeHtml(m.email.split("@")[0]) + "</span></label>";
}).join("") : '<p class="pj-meet-pick-empty">' + (members.length ? "찾는 멤버가 없습니다" : "멤버 목록이 없습니다") + "</p>";
};
addBtn.addEventListener("click", function () {
if (pop) { closePop(); return; }
pop = document.createElement("div");
pop.className = "pj-meet-pick";
pop.innerHTML = '<input type="search" class="pj-meet-pick-q" placeholder="이름·아이디 찾기">' +
'<div class="pj-meet-pick-acts"><button type="button" data-all="1">전원 선택</button><button type="button" data-all="0">모두 해제</button></div>' +
'<div class="pj-meet-pick-list"></div>';
document.body.appendChild(pop);
const r = addBtn.getBoundingClientRect();
pop.style.left = Math.max(8, Math.min(r.left, document.documentElement.clientWidth - pop.offsetWidth - 8)) + "px";
pop.style.top = Math.min(r.bottom + 6, document.documentElement.clientHeight - pop.offsetHeight - 8) + "px";
const q = pop.querySelector(".pj-meet-pick-q");
drawList("");
q.focus();
q.addEventListener("input", function () { drawList(q.value); });
pop.addEventListener("change", function (e) {
const cb = e.target.closest("input[type=checkbox]");
if (!cb) return;
const m = members.find(function (x) { return x.email === cb.dataset.email; });
if (!m) return;
toggle(m, cb.checked);
paint();
saveAtt();
});
pop.addEventListener("click", function (e) {
const b = e.target.closest("[data-all]");
if (!b) return;
members.forEach(function (m) { toggle(m, b.dataset.all === "1"); });
drawList(q.value);
paint();
saveAtt();
});
setTimeout(function () {
document.addEventListener("mousedown", onDoc, true);
document.addEventListener("keydown", onKey, true);
}, 0);
});
}
// ── 글 칸(주요 업무 · 지난주 결과 글 · 메모) — 0.8초 멈춤·칸 떠남에 저장(createFieldSaver).
// 지난주 결과 글(.pj-meet-rnote, data-field=result_note)은 지난 주차 줄(tr data-prev)에 저장한다.
// 보낸 값만 저장됨으로 기록하고, 같은 칸 요청은 차례대로(진행 중에 새로 쓴 글은 뒤이어 저장). 실패해도 글은 그대로 두고
// 다음 입력·칸 떠남·줄 작업 전에 다시 보낸다. 초안은 localStorage(pj_draft:meet:…)에도 — 페이지가 닫혀도 다음에 되살린다.
const notes = el("pj-meet-notes");
const textSaver = createFieldSaver({
read: function (ta) { return ta.value; },
write: function (ta, v) { ta.value = v; fit(ta); },
send: function (ta, v, o) {
if (ta === notes) return api("PUT", meetingUrl, { notes: v }, o);
const tr = ta.closest("tr");
if (ta.dataset.field === "result_note") return api("PUT", itemUrl(tr.dataset.prev), { result_note: v }, o);
return api("PUT", itemUrl(tr.dataset.item), { content: v }, o);
},
draftKey: function (ta) {
if (ta === notes) return "meet:notes:" + week;
const tr = ta.closest("tr");
return ta.dataset.field === "result_note" ? "meet:item:" + tr.dataset.prev + ":result_note"
: "meet:item:" + tr.dataset.item + ":content";
},
onSaved: function (ta) { const n = ta.closest("td") || ta; clearSaveFailed(n); flashSaved(n); },
onClear: function (ta) { clearSaveFailed(ta.closest("td") || ta); },
onFail: function (ta, err) { markSaveFailed(ta.closest("td") || ta, err); },
});
function flushAll() {
return Promise.allSettled([textSaver.flushAll(), amtSaver.flushAll()]).then(function (rs) {
const bad = rs.find(function (r) { return r.status === "rejected"; });
if (bad) throw bad.reason;
return true;
});
}
let restored = 0, conflict = 0;
function bindText(ta) {
if (ta.matches("[contenteditable]") && window.PJGoalText) window.PJGoalText.attach(ta);
const r = textSaver.track(ta, ta.value);
if (r === "restored") restored++;
else if (r === "conflict") conflict++;
fit(ta);
ta.addEventListener("input", function () { fit(ta); textSaver.queue(ta); });
ta.addEventListener("blur", function () { textSaver.flush(ta).catch(function () {}); });
}
if (notes) bindText(notes);
if (table) table.querySelectorAll(".pj-meet-text, .pj-meet-rnote").forEach(bindText);
if (cellGrid) cellGrid.bindSaver({ flush: flushAll, save: function (ta) { return textSaver.flush(ta); },
replace: function (ta, value) { ta.value = value; textSaver.acceptSaved(ta, ta.value); },
rowMenu: rowMenu, addRow: function (section, ref, place) { run(function () { return addRow(section, ref, place); }); },
reload: reloadKeepScroll });
if (table && window.PJGoalText) window.PJGoalText.init(table, el("pj-goal-format"));
if (restored) showToast("저장되지 않았던 글 " + restored + "칸을 되살려 다시 저장합니다.");
else if (conflict) showToast("다른 곳에서 바뀐 칸 " + conflict + "개는 예전 초안을 되살리지 않았습니다.");
window.addEventListener("resize", function () { document.querySelectorAll(".pj-meet-text, .pj-meet-rnote, #pj-meet-notes").forEach(fit); });
// 페이지 떠남 — 글은 keepalive 로 한 번 더 보내고(보장 아님, 초안 백업이 남음), 실패·진행 중·금액 미저장이면 이탈 경고
window.addEventListener("beforeunload", function (e) {
textSaver.onBeforeUnload(e);
amtSaver.onBeforeUnload(e);
});
if (!table) return;
// 칸이 세로로 길어도 칸 아무 곳이나 누르면 그 칸 입력(글·금액) — 커서는 끝
table.addEventListener("click", function (e) {
if (e.button !== 0 || e.defaultPrevented || e.target.closest("textarea, input, select, button, a, [contenteditable], [data-meet-edit], .pj-meet-colresize, .pj-goal-move-edge")) return;
const td = e.target.closest("td");
const f = td && td.querySelector(".pj-meet-text, .pj-meet-rnote, input.pj-meet-amount");
if (!f || f === document.activeElement) return;
f.focus();
if (f.tagName === "TEXTAREA") { const n = f.value.length; f.setSelectionRange(n, n); }
else if (f.isContentEditable) {
const range = document.createRange(); range.selectNodeContents(f); range.collapse(false);
const selection = window.getSelection(); selection.removeAllRanges(); selection.addRange(range);
}
});
// ── 금액 칸 — 이번주 정량 목표(이 줄) · 지난주 결과(7일 전 주 회의록의 같은 줄) — amtSaver(위) ──
table.querySelectorAll("input.pj-meet-amount").forEach(bindAmount);
// ── 줄 이름 — 눌러서 그 자리에서 수정(Enter·칸 떠남 = 저장, Esc = 취소) ──
table.addEventListener("click", function (e) {
const span = e.target.closest("[data-meet-edit]");
if (!span || span.isContentEditable) return;
const orig = span.textContent;
const tr = span.closest("tr");
span.contentEditable = "true";
span.classList.add("is-editing");
span.focus();
const r = document.createRange();
r.selectNodeContents(span);
const s = window.getSelection();
s.removeAllRanges();
s.addRange(r);
let done = false;
async function finish(save) {
if (done) return;
done = true;
span.contentEditable = "false";
span.classList.remove("is-editing");
span.removeEventListener("keydown", onKey);
span.removeEventListener("blur", onBlur);
const v = span.textContent.replace(/\s+/g, " ").trim();
if (!save || v === orig.trim()) { span.textContent = orig; return; }
span.textContent = v;
try { await api("PUT", itemUrl(tr.dataset.item), { label: v }); flashSaved(span.closest("th")); }
catch (err) { span.textContent = orig; showToast("이름 변경 실패: " + err.message, "error"); }
}
function onKey(ev) {
if (isImeEnter(ev)) return;
if (ev.key === "Enter") { ev.preventDefault(); span.blur(); }
else if (ev.key === "Escape") { ev.preventDefault(); ev.stopPropagation(); finish(false); span.blur(); }
}
function onBlur() { finish(true); }
span.addEventListener("keydown", onKey);
span.addEventListener("blur", onBlur);
});
// ── 줄 메뉴(⋯ · 항목 우클릭) — 위/아래 줄 추가 · 순서 · 삭제 ──
// 줄 작업 뒤엔 새로고침 — 그 전에 저장 안 된 칸(대기·진행 중·실패)을 저장하고, 실패하면 작업 자체를 하지 않는다(초안 유지)
async function run(fn) {
try {
await flushAll();
if (!(await fn())) return;
await flushAll();
reloadKeepScroll();
} catch (err) { showToast("처리 실패: " + err.message, "error"); }
}
async function addRow(section, ref, place) {
const v = await prompt("새 줄 이름 (예: 쿠팡 — 비워 둬도 됩니다)", "");
if (v == null) return false;
await api("POST", meetingUrl + "/items", { section: section, label: String(v).trim(), ref_item_id: ref, place: place });
return true;
}
function rowMenu(x, y, tr) {
const id = tr.dataset.item, section = tr.dataset.section;
const label = (tr.querySelector(".pj-meet-label") || {}).textContent || "";
showContextMenu(x, y, [
{ label: "위에 줄 추가", icon: menuIcon("add_row_above"), onClick: function () { run(function () { return addRow(section, id, "above"); }); } },
{ label: "아래에 줄 추가", icon: menuIcon("add_row_below"), onClick: function () { run(function () { return addRow(section, id, "below"); }); } },
{ label: "위로", icon: menuIcon("arrow_upward"), onClick: function () { run(async function () { await api("POST", itemUrl(id) + "/move", { direction: -1 }); return true; }); } },
{ label: "아래로", icon: menuIcon("arrow_downward"), onClick: function () { run(async function () { await api("POST", itemUrl(id) + "/move", { direction: 1 }); return true; }); } },
null,
{ label: "줄 삭제", danger: true, icon: menuIcon("delete"), onClick: function () {
run(async function () {
const ok = await confirm("'" + (label.trim() || "이 줄") + "' 줄을 삭제할까요? 주요 업무·금액도 함께 삭제됩니다.",
{ okText: "삭제", cancelText: "취소" });
if (!ok) return false;
await api("DELETE", itemUrl(id));
return true;
});
} },
].concat(cellGrid ? [null].concat(cellGrid.widthItems(tr.querySelector("th.pj-meet-c-label"))) : []));
}
table.addEventListener("click", function (e) {
const b = e.target.closest("[data-meet-act]");
if (!b) return;
const tr = b.closest("tr");
if (b.dataset.meetAct === "menu") {
const r = b.getBoundingClientRect();
rowMenu(r.left, r.bottom + 4, tr);
} else if (b.dataset.meetAct === "sec-add") {
run(function () { return addRow(b.closest("tbody").dataset.section, null, "below"); });
}
});
table.addEventListener("contextmenu", function (e) {
const th = e.target.closest("th.pj-meet-c-label");
if (!th || e.target.closest(".is-editing")) return;
e.preventDefault();
rowMenu(e.clientX, e.clientY, th.closest("tr"));
});
const secNew = el("pj-meet-sec-new");
if (secNew) secNew.addEventListener("click", function () {
run(async function () {
const name = await prompt("새 구역 이름 (예: 물류)", "");
if (name == null || !String(name).trim()) return false;
await api("POST", meetingUrl + "/items", { section: String(name).trim(), label: "" });
return true;
});
});
}
// ── 휴지통(관리자 전용 화면) — [복구] 누르면 원래 id 그대로 되살리고 줄을 지운다.
function initTrash() {
const table = el("pj-trash-table");
if (!table) return;
table.querySelectorAll(".pj-trash-restore").forEach(function (btn) {
btn.addEventListener("click", async function () {
const n = parseInt(btn.dataset.count || "1", 10);
const msg = "'" + btn.dataset.title + "' 작업" + (n > 1 ? "(하위 작업 " + (n - 1) + "개 포함)" : "") +
"을 복구할까요?\n원래 프로젝트·섹션 자리로 돌아갑니다.";
const ok = await confirm(msg, { okText: "복구", cancelText: "취소" });
if (!ok) return;
btn.disabled = true;
try {
const res = await api("POST", "/project/api/trash/" + btn.dataset.id + "/restore");
const tr = btn.closest("tr");
tr.classList.add("is-restored");
btn.outerHTML = '<a class="pj-btn" href="/project/p/' + res.project_id + "?task=" + res.task_id + '">복구됨 · 열기</a>';
showToast("복구했습니다");
} catch (e) {
btn.disabled = false;
showToast("복구 실패: " + e.message, "error");
}
});
});
}
if (window.__PJ_TEST__) { // 자동 테스트 전용 — 순수 도우미
window.__pjHelpers = { kstTodayIso: kstTodayIso, dueInfo: dueInfo, isImeEnter: isImeEnter };
}
// ── 나를 태그하거나 새 작업을 배정받으면 화면 가운데 아래 큰 팝업(2026-10-07) — 깜박여서 눈에 띄고, [닫기] 전까지 남는다.
// 프로젝트 화면들이 20초마다(창을 다시 볼 때 바로) GET /project/api/notifications/alerts?after=본 것 을 확인한다.
// 본 것 = localStorage pj_alert_seen:{이메일} — 처음이면 지금 최신 알림을 기준으로 삼아 옛 알림을 한꺼번에 띄우지 않는다.
// 다른 탭에서 닫으면(storage 이벤트) 이 탭 팝업도 닫는다. 수신함 오른쪽 패널(iframe, html.pj-embed) 안에서는 돌지 않는다.
function initTaskAlerts() {
if (document.documentElement.classList.contains("pj-embed")) return;
const POLL_MS = 20000;
let me = "", pop = null, timer = 0, busy = false;
const shown = new Map(); // id → 알림
const seenKey = function () { return "pj_alert_seen:" + me; };
const readSeen = function () { try { const v = localStorage.getItem(seenKey()); return v == null ? null : Number(v); } catch (_) { return null; } };
const writeSeen = function (v) { try { localStorage.setItem(seenKey(), String(v)); } catch (_) {} };
function schedule() { clearTimeout(timer); timer = setTimeout(poll, POLL_MS); }
async function poll() {
if (busy) return;
if (document.hidden) { schedule(); return; }
busy = true;
try {
let after = me ? readSeen() : null;
let res = await api("GET", "/project/api/notifications/alerts" + (after == null ? "" : "?after=" + after));
if (res && res.me && !me) {
me = res.me;
after = readSeen();
if (after == null) writeSeen(res.latest_id || 0); // 처음 — 지금까지 온 알림은 띄우지 않는다
else if (after < (res.latest_id || 0) && !res.desktop) res = await api("GET", "/project/api/notifications/alerts?after=" + after);
}
// PC 알림 프로그램이 켜져 있으면 웹 팝업은 쉰다 — 지금까지 온 것은 본 것으로(프로그램을 끄면 그 뒤 알림부터 웹에)
if (res && res.desktop) {
if ((res.latest_id || 0) > (readSeen() || 0)) writeSeen(res.latest_id || 0);
if (pop) { shown.clear(); pop.remove(); pop = null; }
return;
}
((res && res.alerts) || []).forEach(function (n) { if (!shown.has(n.id)) shown.set(n.id, n); });
if (shown.size) render();
} catch (_) {
// 알림 확인 실패는 조용히 — 다음 주기에 다시
} finally {
busy = false;
schedule();
}
}
function close() {
if (!pop) return;
const maxId = Math.max.apply(null, Array.from(shown.keys()).concat([readSeen() || 0]));
writeSeen(maxId);
shown.clear();
pop.remove();
pop = null;
}
function render() {
if (!pop) {
pop = document.createElement("div");
pop.className = "pj-alert-pop";
pop.setAttribute("role", "alertdialog");
pop.setAttribute("aria-live", "assertive");
document.body.appendChild(pop); // 배율(.pj-ui-scale) 밖 — body 에
pop.addEventListener("click", function (e) {
if (e.target.closest("[data-alert-close]")) close();
const open = e.target.closest("[data-alert-open]");
if (open) {
const id = open.dataset.alertOpen;
fetch("/project/api/notifications/" + id + "/read", { method: "POST" }).catch(function () {});
}
});
}
const items = Array.from(shown.values());
pop.innerHTML = '<div class="pj-alert-head"><span class="material-symbols-outlined">notifications_active</span>' +
"<b>새 알림 " + items.length + "건</b>" +
'<button type="button" class="pj-btn pj-btn-sm" data-alert-close>닫기</button></div>' +
'<div class="pj-alert-list">' + items.map(function (n) {
const isMention = n.type === "mention";
const href = n.project_id ? "/project/p/" + n.project_id + (n.task_id ? "?task=" + n.task_id : "") : "/project/inbox";
return '<a class="pj-alert-item" href="' + escapeHtml(href) + '" data-alert-open="' + escapeHtml(n.id) + '">' +
'<span class="pj-alert-kind ' + (isMention ? "is-mention" : "is-assigned") + '">' +
(isMention ? "나를 태그" : "작업 배정") + "</span>" +
'<span class="pj-alert-text"><b>' + escapeHtml(String(n.title || "").replace(/^(나를 태그함|작업 배정):\s*/, "")) + "</b>" +
"<small>" + escapeHtml((n.body || "") + (n.actor_email ? " · " + capName(idOf(n.actor_email)) : "")) + "</small></span>" +
'<span class="pj-alert-go">열기 ›</span></a>';
}).join("") + "</div>";
}
window.addEventListener("storage", function (e) {
if (!pop || !me || e.key !== seenKey()) return;
const v = Number(e.newValue || 0);
if (Array.from(shown.keys()).every(function (id) { return id <= v; })) { shown.clear(); pop.remove(); pop = null; }
});
document.addEventListener("visibilitychange", function () { if (!document.hidden) poll(); });
poll();
}
document.addEventListener("DOMContentLoaded", function () {
// 좌측 프로젝트 목록 — 프로젝트 화면은 initProject 가 자기 데이터로 직접 연다.
if (!document.querySelector(".pj-project-view")) initSideTree();
initTrash();
initGoalSide();
initGoals();
initGoalMeeting();
initMyTasks();
initProject();
initAllMembers();
initBell();
initMentionBadge();
initTaskAlerts();
initInbox();
initInboxTaskPanel();
initMentionInbox();
initLiveRefresh();
initGlobalSearch();
initSideResize();
initScrollIndicators();
initHoverTips();
});
})();