Files
dbx-main/app/static/project.js
T
king 972b7e4d78 feat(project): 타임라인 드래그로 날짜 이동·이름 클릭 시 작업 창, 하루 폭 = 날짜 글자 폭, 고해상도 배율 축 잘림 수정
- 화면 배율(pj-ui-scale)에서 타임라인만 zoom 을 1 로 되돌리고 크기는 --tz 로 줄임
  (vis-timeline 이 zoom 안에서 하단 년·월 축을 잘라 그리고 끌기가 마우스와 어긋나던 문제)
- 카드를 선택 없이 바로 끌어 하루 단위로 이동(itemsAlwaysDraggable, 하위 작업 카드 포함),
  끈 거리를 일 단위로 반올림해 원래 날짜에 더함(시각 유지)
- 작업 이름 클릭 → 오른쪽 작업 창(끌고 놓은 click 은 무시)
- 처음 보기 범위: 하루 칸 = "30일 (수)" 글자 폭, maxMinorChars 도 맞춤(저장 키 pj_tl_window2)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-29 13:19:27 +09:00

7363 lines
372 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 ─────────────────────────────────────────────
async function api(method, url, body) {
const opts = { method, headers: { "Content-Type": "application/json" } };
if (body !== undefined) opts.body = JSON.stringify(body);
const res = await fetch(url, opts);
if (!res.ok) {
let msg = res.statusText;
try { msg = (await res.json()).detail || msg; } catch (_) {}
throw new Error(msg);
}
if (res.status === 204) return null;
return res.json();
}
function el(id) { return document.getElementById(id); }
// ── 확인/알림/입력 창 — 브라우저 기본 창 대신 공용 창(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;
function closeContextMenu() {
if (!ctxMenuEl) return;
ctxMenuEl.remove();
ctxMenuEl = null;
document.removeEventListener("mousedown", onCtxDocDown, true);
document.removeEventListener("keydown", onCtxKeyDown, true);
window.removeEventListener("scroll", closeContextMenu, true);
window.removeEventListener("resize", closeContextMenu, true);
}
function onCtxDocDown(e) {
if (ctxMenuEl && !ctxMenuEl.contains(e.target)) closeContextMenu();
}
function onCtxKeyDown(e) {
if (e.key === "Escape") closeContextMenu();
}
// items: [{label, danger?, onClick} | null(구분선)]
function showContextMenu(x, y, items) {
closeContextMenu();
const menu = document.createElement("div");
menu.className = "pj-ctxmenu";
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.addEventListener("click", function () { closeContextMenu(); item.onClick(); });
menu.appendChild(b);
});
document.body.appendChild(menu);
ctxMenuEl = menu;
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";
setTimeout(function () {
if (ctxMenuEl !== menu) return; // 그 사이 닫혔으면 문서 리스너를 남기지 않는다
document.addEventListener("mousedown", onCtxDocDown, true);
document.addEventListener("keydown", onCtxKeyDown, true);
window.addEventListener("scroll", closeContextMenu, true);
window.addEventListener("resize", closeContextMenu, true);
}, 0);
}
// ── 클립보드 복사 ── 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");
}
function isoToday() { return isoOf(new Date()); }
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;·공백만 있으면 없음, 이미지만 있어도 있음.
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] || "📎";
}
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 = [];
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);
return '<span class="pj-chat-pending-chip">' +
'<span class="pj-chat-att-icon">' + icon + "</span>" +
'<span>' + escapeHtml(f.name) + "</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);
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 = "";
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(); 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 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, 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: true }) +
"</div>" +
attsHtml +
'<div class="pj-react-slot">' + reactionRowHtml(c, me, feats.reactions) + "</div>" +
'<span class="pj-chat-meta">' +
(mine ? '<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) {
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 = [];
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);
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)) return;
const filesToSend = pendingFiles.slice();
try {
const res = await api("POST", "/project/api/tasks/" + taskId + "/comments", {
body: bodyText, has_attachment: filesToSend.length > 0, mentions: takeMentions(inp),
parent_id: replyTo ? replyTo.id : undefined,
});
setReplyTo(null);
const commentId = res.comment.id;
for (let i = 0; i < filesToSend.length; i++) {
const fd = new FormData();
fd.append("file", filesToSend[i]);
fd.append("comment_id", String(commentId));
try {
const r = await fetch("/project/api/tasks/" + taskId + "/attachments", { method: "POST", body: fd });
if (!r.ok) {
let m = r.statusText;
try { m = (await r.json()).detail || m; } catch (_) {}
showToast("파일 업로드 실패(" + filesToSend[i].name + "): " + m, "error");
}
} catch (_) { showToast("파일 업로드 실패: " + filesToSend[i].name, "error"); }
}
pendingFiles = [];
renderPending();
inp.value = "";
clearMentions(inp);
const n = await renderChat(taskId);
if (n !== null) { markSeen(taskId, n); syncBadge(taskId, n); }
} catch (e) { alert("등록 실패: " + e.message); }
});
el("pj-cm-input").addEventListener("keydown", function (e) {
if (e.key === "Enter") { e.preventDefault(); el("pj-cm-send").click(); }
});
cmtChat = { open: open, wireBadge: wireBadge };
return cmtChat;
}
// ════════════════════════════════════════════════════════════
// 멘션(@태그) — 설명란(contenteditable)과 댓글 입력(평문 input) 공용
//
// @를 누르면 등록된 전체 프로젝트 멤버가 뜨고, 고르면
// · 설명란: <span class="pj-mention" data-email="...">@아이디</span> 칩
// · 댓글 : "@아이디 " 평문 + 이메일을 따로 기억(전송 시 함께 보냄)
// 으로 들어간다. 태그된 사람은 수신함(/project/inbox)에서 그 업무를 본다.
// ════════════════════════════════════════════════════════════
let mentionUsersCache = null;
async function mentionUsers() {
if (mentionUsersCache) return mentionUsersCache;
try {
const res = await api("GET", "/project/api/all-users");
mentionUsersCache = res.users || [];
} catch (_) { mentionUsersCache = []; }
return mentionUsersCache;
}
// 메뉴는 화면에 하나만 띄운다(설명란/댓글/채팅이 번갈아 쓴다).
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;
}
// ── 평문 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 mentionUsers();
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 today = data.today || "";
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, today);
}
// 최상위 업무만 — 하위 업무(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) < today;
}).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초 주기 동기화 — 다른 사람이 내 업무를 바꾸면 목록을 다시 받는다.
softSyncProjectRef = async function () {
try {
const res = await api("GET", "/project/api/my-tasks");
tasks = res.tasks || [];
render();
} catch (_) {}
};
}
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 todayIso = data.today || localIso(new Date());
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 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] || {});
// 행 색 — "이 프로젝트"는 섹션에 지정한 색(없으면 프로젝트 색), "전체 프로젝트"는 프로젝트 색
const stageColor = groupBySession && stageById[gid] ? stageById[gid].color : null;
const groupColor = stageColor || 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>" +
(t.subtask_total
? (item.pjParentId
? '<span class="pj-tli-sub" title="하위 작업 ' + t.subtask_total + '개">' + t.subtask_total + SUBTASK_ICON_SVG + "</span>"
: '<span class="pj-tli-sub is-toggle' + (item.pjExpanded ? " is-open" : "") + '" data-task-id="' + t.id +
'" title="하위 작업 ' + t.subtask_total + "개 " + (item.pjExpanded ? "접기" : "펼치기") + '">' +
t.subtask_total + SUBTASK_ICON_SVG +
'<span class="material-symbols-outlined pj-tli-caret">' + (item.pjExpanded ? "arrow_drop_down" : "arrow_right") + "</span></span>")
: "") +
cmtBadge(t) +
"</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 },
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": {
// 캘린더와 같은 색 — 일요일·국경일·대체공휴일 빨강, 토요일 파랑. 라벨은 글자만
// 받으므로 맨 앞에 보이지 않는 표시 글자(U+2063 빨강 / U+2064 파랑)를 붙이고
// 그린 뒤 paintTLDays 가 그 표시로 색 클래스를 단다.
const red = d.getDay() === 0 || !!tlHolidays[isoOf(d)];
const blue = !red && d.getDay() === 6;
return (red ? "\u2063" : blue ? "\u2064" : "") + d.getDate() + "일 (" + koWd(d) + ")";
}
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);
// 날짜 라벨 색 — 다시 그릴 때마다(vis 가 라벨 class 를 새로 쓴다) 표시 글자를 보고 색 클래스를 단다.
function paintTLDays() {
node.querySelectorAll(".vis-time-axis .vis-text.vis-minor").forEach(function (lab) {
const c = (lab.textContent || "").charAt(0);
lab.classList.toggle("pj-tl-red", c === "\u2063");
lab.classList.toggle("pj-tl-blue", c === "\u2064");
});
}
timeline.on("changed", paintTLDays);
paintTLDays();
// 기본 보기 범위 — 하루 칸 폭 = dayPx, 오늘이 왼쪽 1/4 쯤에 오게. 사용자가 옮기거나
// 확대/축소한 범위가 저장돼 있으면 그걸 쓴다(saved). vis 는 첫 "changed" 때 생성 옵션의
// 범위로 다시 맞추므로, 그 뒤(첫 changed 에서 한 번만) 칸 폭을 재서 setWindow 한다.
if (!saved && dayPx > 0) {
let fitted = false;
timeline.on("changed", function () {
if (fitted || !timeline) return;
fitted = true;
const center = node.querySelector(".vis-panel.vis-center");
if (!center || !center.clientWidth) return;
const days = center.clientWidth / dayPx;
const t0 = new Date(); t0.setHours(0, 0, 0, 0);
const from = t0.getTime() - Math.floor(days / 4) * 86400000;
timeline.setWindow(new Date(from), new Date(from + days * 86400000), { animation: false });
});
}
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, 표시 여부만 매
// 렌더마다 토글.
// ── 세션 추가/편집 팝업 — 이름 + 색상(아사나 10색). "+ 세션 추가" 버튼과
// 세션 헤더 ✎(세션 편집) 아이콘·컨텍스트 메뉴가 전부 이 모달 하나를 쓴다.
const stageModal = el("pj-modal-stage");
let getStageColor = null;
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 : "";
// 프로젝트와 같은 색상표. 색이 없는 섹션은 첫 칸(연회색 = 색 없음)이 선택된 채로.
const noColor = (window.PJ_STAGE_COLORS || [])[0];
getStageColor = renderColorPalette(
el("pj-stg-colors"), null, (stage && stage.color) || noColor, window.PJ_STAGE_COLORS
);
// 기본 담당자 후보 = 업무 담당자 후보와 같다(프로젝트 멤버 + 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 color = getStageColor ? getStageColor() : null;
const body = { name: name, color: color };
// 기본 담당자는 바뀐 경우에만 보낸다 — 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); });
}
function renderBoard() {
// pj-board(바깥)는 가로 스크롤 뷰포트, pj-board-canvas(안쪽)는 세션을
// 가로로 늘어놓는 flex 컨테이너(width:max-content) — 세션이 아무리
// 늘어나도 아래로 접히지 않고 오른쪽으로 계속 이어진다.
const canvas = el("pj-board-canvas");
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);
}
syncBoardHBar();
}
// 아사나식 가로 보드 — 세션은 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;
col.innerHTML =
'<div class="pj-col-head' + (s.color ? " pj-col-head-colored" : "") +
(s.color && isLightColor(s.color, 0.6, "#eef0f4") ? " is-light" : "") + '"' +
(canManage ? ' draggable="true"' : "") +
(s.color ? ' style="background:' + hexToRgba(s.color, 0.6) + '"' : "") + '>' +
// 아사나처럼: 이름 바로 오른쪽에 업무 수(숫자만), 맨 오른쪽에 + / … 버튼.
'<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) {
enableDropByStageId(body, s.id);
wireColumnControls(col, s);
wireColumnDrag(col, s);
wireStageAddTask(body, s);
col.querySelector(".pj-col-addtask").addEventListener("click", function () {
openTaskModal(null, s.id);
});
}
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 () { openTaskModal(null, s.id); } },
{ 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 () { openTaskModal(null, s.id); } },
]);
});
}
// 세션(컬럼) 드래그 재정렬 — 카드 드래그와 같은 네이티브 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"))
.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 SUB_DRAG_TYPE = "application/x-pj-subtask";
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) 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("")
: '<div class="pj-card-sub-empty">하위 작업 없음</div>';
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();
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;
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 ? todayIso : 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 로 바로 만든다.
// 만든 뒤에도 줄은 열린 채로 다음 하위 작업을 이어서 입력(아사나와 같음).
// Esc 또는 빈 채로 다른 곳을 누르면 닫힌다. 보드는 8초마다 다시 그려지므로
// 입력 중인 값·포커스는 subDrafts 에 두고 다시 그릴 때 되살린다.
const subDrafts = {};
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(); },
});
});
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;
async function createFromDraft() {
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);
// 다음 하위 작업을 이어서 입력(아사나) — 이름만 비우고 줄은 열어 둔다.
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");
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");
});
}
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).
card.innerHTML =
'<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">' + escapeHtml(t.title) + "</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>"
: "") +
(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>"
: "") +
"</div>" +
"</div>" +
// 펼침 영역 — 바깥(.pj-card-subs-wrap)이 grid 0fr↔1fr 로 높이를
// 부드럽게 늘이고 줄인다(toggleCardSubs). 다시 그릴 땐 펼친 채로.
(t.subtask_total && 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);
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 = new Date().toISOString().slice(0, 10);
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);
// 담당자별 예정된 작업 — 미완료 + 일정(시작/마감일) 있는 작업만, 상위 10명.
// 사람별 업무량이 드러나는 표라 관리자에게만 보여준다.
if (isAdmin) {
const byAssignee = {};
incomplete.forEach(function (t) {
if (!t.start_date && !t.due_date) return;
const k = t.assignee_email ? capName(t.assignee_name || idOf(t.assignee_email)) : "담당자 없음";
byAssignee[k] = (byAssignee[k] || 0) + 1;
});
let assigneeEntries = Object.keys(byAssignee).map(function (k) { return { label: k, value: byAssignee[k] }; })
.sort(function (a, b) { return b.value - a.value; });
if (assigneeEntries.length > 10) {
const rest = assigneeEntries.slice(10).reduce(function (s, x) { return s + x.value; }, 0);
assigneeEntries = assigneeEntries.slice(0, 10).concat([{ label: "기타", value: rest }]);
}
const assigneeCard = document.createElement("div");
assigneeCard.className = "pj-dash-card pj-dash-card-wide";
assigneeCard.innerHTML = '<div class="pj-dash-card-title">예정된 작업 합계(담당자별)</div>';
assigneeCard.appendChild(dashBarChart(assigneeEntries));
charts.appendChild(assigneeCard);
}
root.appendChild(charts);
}
// 서버가 돌려준 업무를 로컬 목록에 반영. 멀티호밍된 업무는 목록에 여러 행
// (원래 소속 맥락 + 연결된 프로젝트 맥락)으로 들어 있으므로 같은 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 는
// 부르는 순간 잡아 두므로, 저장 도중 다른 작업을 열어도 엉뚱한 작업에 쓰지 않는다.
const autoStateEl = el("pj-autosave-state");
let saveChain = Promise.resolve();
let lastSaved = { title: "", desc: "" };
let descTimer = null;
let creatingTask = null;
function setAutoState(s) {
if (!autoStateEl) return;
autoStateEl.dataset.state = s || "";
autoStateEl.textContent = s === "saving" ? "저장 중…" : s === "saved" ? "저장됨" : s === "error" ? "저장 실패" : "";
}
function resetAutoSave() {
clearTimeout(descTimer);
descTimer = null;
lastSaved = {
title: el("pj-t-title").value.trim(),
desc: descEditor ? descEditor.getHtml() : "",
};
setAutoState("");
}
function assigneePayload() {
const sel = el("pj-t-assignee");
const opt = sel.selectedOptions[0];
return { assignee_email: sel.value, assignee_name: opt ? (opt.dataset.name || "") : "" };
}
function saveField(key) {
const id = el("pj-t-id").value;
if (!id) return key === "title" ? createTaskFromPanel() : Promise.resolve();
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(); }
if (t === lastSaved.title) return Promise.resolve();
body = { title: t };
lastSaved.title = t;
} else if (key === "desc") {
if (!descEditor) return Promise.resolve();
if (descEditor.isUploading()) { scheduleDescSave(); return Promise.resolve(); } // 이미지 올라간 뒤 다시
const html = descEditor.getHtml();
if (html === lastSaved.desc) return Promise.resolve();
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();
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();
setAutoState("saving");
saveChain = saveChain.then(async function () {
try {
const wasDone = !!(currentTaskData && currentTaskData.completed_at);
const res = await api("PUT", "/project/api/tasks/" + id, body);
mergeTask(res.task);
const stillOpen = !taskModal.hidden && el("pj-t-id").value === String(id);
if (stillOpen) {
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 (key !== "desc") refreshActiveView();
setAutoState("saved");
} catch (e) {
if (key === "title") lastSaved.title = null; // 다음에 다시 시도하도록
if (key === "desc") lastSaved.desc = null;
setAutoState("error");
showToast("저장 실패: " + e.message, "error");
}
});
return saveChain;
}
// 새 작업 — 제목이 처음 생기는 순간 지금 칸 값으로 만든 뒤, 기존 작업 화면
// (댓글·첨부·하위 작업 등)으로 바꿔 연다. 그 사이 더 입력한 내용은 이어서 저장한다.
function createTaskFromPanel() {
const title = el("pj-t-title").value.trim();
if (!title) return Promise.resolve();
if (creatingTask) return creatingTask;
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");
creatingTask = saveChain = saveChain.then(async function () {
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/tasks", payload);
mergeTask(res.task);
refreshActiveView();
if (!taskModal.hidden && !el("pj-t-id").value) {
const nowTitle = el("pj-t-title").value.trim();
const nowDesc = descEditor ? descEditor.getHtml() : "";
openTaskModal(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"); }
}
setAutoState("saved");
} catch (e) {
setAutoState("error");
showToast("작업 만들기 실패: " + e.message, "error");
} finally { creatingTask = null; }
});
return creatingTask;
}
function scheduleDescSave() {
clearTimeout(descTimer);
descTimer = setTimeout(function () { descTimer = null; saveField("desc"); }, 1200);
}
// 창을 닫거나 다른 작업으로 넘어가기 직전 — 아직 안 보낸 제목·설명을 보낸다.
function flushAutoSave() {
if (taskModal.hidden) return saveChain;
clearTimeout(descTimer);
descTimer = null;
if (el("pj-t-id").value) { saveField("title"); saveField("desc"); }
return saveChain;
}
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 {
await flushAutoSave();
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 || (!subtaskBlock && !linksBlock)) return;
try {
const res = await api("GET", "/project/api/tasks/" + task.id);
const detail = res.task;
if (currentTaskId === task.id) showFollowers(task, detail.followers);
if (subtaskBlock) {
subtaskBlock.setContext({
taskId: task.id, projectId: task.project_id, canDelete: canDelete,
onOpen: function (sub) { openTaskById(sub.id); },
});
subtaskBlock.render(detail.subtasks || []);
}
if (linksBlock) {
linksBlock.setContext({
taskId: task.id, projectId: task.project_id,
onChange: function () { loadTaskExtras(task); },
});
linksBlock.render(detail.links || []);
}
} catch (_) { /* 조용히 무시 — 본편집은 계속 가능해야 한다 */ }
}
// 단계 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");
let list = members;
if (projId != null && projId !== projectId) {
try { list = (await api("GET", "/project/api/projects/" + projId + "/members")).members || []; }
catch (_) { list = []; }
}
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 || "";
}
function openTaskModal(task, presetStageId) {
// 다른 작업으로 바로 넘어가는 경우 — 보낼 값·id 를 지금 잡아 먼저 저장 요청.
flushAutoSave();
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;
if (task) { loadAttachments(task.id); loadComments(task.id); loadTaskExtras(task); }
openSlidePanel(taskModal);
fitTitleHeight();
resetAutoSave();
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) {
await flushAutoSave();
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; }
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 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");
ul.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
try {
const res = await api("GET", "/project/api/tasks/" + taskId + "/attachments");
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">' + escapeHtml(a.filename) + "</a>" +
'<span class="pj-attach-size">' + fmtSize(a.size_bytes) + "</span>" +
(canManage ? '<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");
ul.innerHTML = "<li class='pj-empty-sm'>불러오는 중…</li>";
try {
const both = await Promise.all([
api("GET", "/project/api/tasks/" + taskId + "/comments"),
ensureMentionTokens(),
]);
const res = both[0];
if (String(currentTaskId) !== String(taskId)) return; // 그 사이 다른 작업을 열었다
const comments = res.comments || [];
const feats = res.features || {};
// 메모리 업무의 댓글 수 동기화(아이콘 표시용)
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 안전).
'<div class="pj-comment-body">' + commentBodyHtml(c.body) + "</div>" +
'<div class="pj-react-slot">' + reactionRowHtml(c, me, feats.reactions) + "</div></div>" +
commentHoverBarHtml(feats, { reply: true, edit: mine || isAdmin, 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 = '<input type="text" placeholder="답글 입력…" />' +
'<button type="button" class="pj-btn pj-btn-primary">답글</button>';
box.appendChild(form);
const inp = form.querySelector("input");
attachMentionInput(inp);
attachEmojiPicker(inp);
attachMentionButton(inp);
async function send() {
const body = inp.value.trim();
if (!body) return;
try {
await api("POST", "/project/api/tasks/" + taskId + "/comments",
{ body: body, parent_id: rootId, mentions: takeMentions(inp) });
if (followersTask && !followersRow.hidden && followers.indexOf(me) < 0) {
followers.push(me);
renderFollowers();
}
loadComments(taskId);
} catch (err) { alert("답글 등록 실패: " + err.message); }
}
form.querySelector("button.pj-btn").addEventListener("click", send);
inp.addEventListener("keydown", function (e) {
if (e.isComposing) return;
if (e.key === "Enter") { e.preventDefault(); send(); }
else if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); form.remove(); }
});
}
const inp = form.querySelector("input");
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); }
});
}
async function sendComment() {
const inp = el("pj-comment-input");
const body = inp.value.trim();
if (!currentTaskId || !body) return;
try {
await api("POST", "/project/api/tasks/" + currentTaskId + "/comments",
{ body: body, mentions: takeMentions(inp) });
inp.value = "";
clearMentions(inp);
loadComments(currentTaskId);
// 댓글을 달면(서버가) 자동 팔로우 — 화면의 팔로워 목록도 맞춘다.
if (followersTask && !followersRow.hidden && followers.indexOf(me) < 0) {
followers.push(me);
renderFollowers();
}
} catch (e) { alert("등록 실패: " + e.message); }
}
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("keydown", function (e) {
if (e.key === "Enter") { e.preventDefault(); sendComment(); }
});
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); });
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 + (m.role === "manager" ? " (관리)" : "");
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") 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"] });
}
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 existing = new Set(members.map(function (m) { return m.user_email; }));
const candidates = res.users.filter(function (u) { return !existing.has(u.email); });
box.innerHTML = candidates.length
? candidates.map(memberPickHtml).join("")
: "<span class='pj-empty-sm'>배정 가능한 직원이 없습니다(권한 미부여 또는 전원 배정됨)</span>";
} 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 checked = box ? Array.from(box.querySelectorAll("input[type=checkbox]:checked")) : [];
if (!checked.length) { alert("직원을 선택하세요."); return; }
const role = el("pj-m-role").value;
let failCount = 0;
for (const cb of checked) {
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/members", {
user_email: cb.value, user_name: cb.dataset.name || "", role: role,
});
members.push(res.member);
} catch (e) { failCount++; }
}
renderMemberList();
closeModal(memberModal);
if (failCount) showToast(failCount + "명 배정 실패", "error");
});
// 최초 렌더 — 아사나처럼 프로젝트에 들어오면 보드(세션)가 기본 화면이다
// (달력을 보던 중이었다면 그 기억된 뷰를 그린다, 위 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
// 마이그레이션부터 삭제·세션 변경까지 감지한다). "전체 프로젝트" 스코프의
// 다른 프로젝트 행은 공통 필드(제목·담당자·완료 등)만 따라 고친다.
softSyncProjectRef = async function () {
try {
const snap = await api("GET", "/project/api/projects/" + projectId + "/snapshot");
const fresh = snap.tasks || [];
tasks = tasks.filter(function (t) { return t.context_project_id !== projectId; });
fresh.forEach(function (t) {
mergeTask(t, { noInsert: true }); // 다른 맥락 행(같은 id)의 공통 필드 갱신
tasks.push(t); // 이 맥락 행은 서버 값 그대로(context_project_id 포함)
});
stages = snap.stages || [];
stagesByProject[projectId] = stages;
members = snap.members || [];
fillAssigneeFilter();
renderMemberList();
refreshActiveView();
refreshMyOpenBadge();
} catch (_) {}
};
}
// ════════════════════════════════════════════════════════════
// 업무 모달 공용 확장 — 하위 업무 · 연결된 프로젝트(멀티호밍) · 설명 이미지 편집기
// 홈(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; }
}
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;
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;
function beginUpload() {
pendingUploads++;
if (hint) hint.textContent = "이미지 업로드 중…";
}
function endUpload() {
pendingUploads = Math.max(0, pendingUploads - 1);
if (pendingUploads === 0 && hint) hint.textContent = taskId ? "" : "저장 후 이미지를 추가할 수 있습니다.";
}
async function insertImageFile(file) {
if (!taskId) { alert("먼저 저장한 뒤 이미지를 추가할 수 있습니다."); return; }
// 업로드는 비동기라 그 사이 포커스가 파일선택창 등으로 빠져나가면서
// 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/" + taskId + "/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();
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; },
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");
let taskId = null, projectId = null, canDeleteFn = function () { return false; }, onChange = null, onOpen = null;
// 담당자 후보(프로젝트 멤버) — 줄마다 다시 받지 않게 프로젝트별로 한 번만.
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;
});
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) {
listEl.innerHTML = subtasks.length ? "" : "<li class='pj-empty-sm'>없음</li>";
if (!subtasks.length) return;
const emails = projectId ? await memberEmails(projectId) : [];
listEl.innerHTML = "";
subtasks.forEach(function (sub) { listEl.appendChild(rowEl(sub, emails)); });
listEl.querySelectorAll(".pj-subtask-title").forEach(fitTitle);
}
if (addBtn) addBtn.addEventListener("click", async function () {
const title = (input.value || "").trim();
if (!title) return;
if (!taskId) { alert("먼저 작업을 저장한 뒤 하위 작업을 추가할 수 있습니다."); return; }
const assigneeOpt = addAssignee ? addAssignee.selectedOptions[0] : null;
try {
const res = await api("POST", "/project/api/projects/" + projectId + "/tasks", {
title: title, parent_task_id: taskId,
assignee_email: addAssignee ? addAssignee.value : "",
assignee_name: assigneeOpt ? assigneeOpt.textContent : "",
due_date: addDue ? (addDue.value || null) : null,
});
input.value = "";
if (addAssignee) addAssignee.value = "";
if (addDue) addDue.value = "";
const emails = await memberEmails(projectId);
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); }
});
if (input) input.addEventListener("keydown", function (e) {
if (e.key === "Enter") { e.preventDefault(); if (addBtn) addBtn.click(); }
});
return {
// 다른 작업을 열 때 — 추가 칸에 쓰다 만 제목·담당자·마감일이 새 작업으로 따라가지 않게
// 비우고, 상세를 다 받기 전(setContext 전)에 Enter 를 눌러도 이전 작업에 붙지 않게 끊는다.
reset: function () {
taskId = null;
if (input) input.value = "";
if (addAssignee) addAssignee.value = "";
if (addDue) addDue.value = "";
},
setContext: function (opts) {
taskId = opts.taskId; projectId = opts.projectId;
canDeleteFn = opts.canDelete || function () { return false; };
onChange = opts.onChange || null;
onOpen = opts.onOpen || null;
if (addAssignee && projectId) {
membersOptionsHtml(projectId).then(function (html) {
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");
let taskId = null, homeProjectId = null, onChange = null;
function chipEl(link) {
const span = document.createElement("span");
span.className = "pj-link-chip";
span.innerHTML =
'<span style="color:' + (link.project_color || "#4573d2") + '">●</span> ' +
escapeHtml(link.project_name || "") +
(link.stage_name ? " · " + escapeHtml(link.stage_name) : "") +
' <button type="button" class="pj-link-del" title="연결 해제">×</button>';
span.querySelector(".pj-link-del").addEventListener("click", async function () {
if (!(await confirm("'" + (link.project_name || "") + "' 연결을 해제할까요?"))) return;
try {
await api("DELETE", "/project/api/tasks/" + taskId + "/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() {
projSel.innerHTML = "<option value=''>불러오는 중…</option>";
stageSel.innerHTML = "<option value=''>프로젝트를 먼저 선택하세요</option>";
try {
const res = await api("GET", "/project/api/projects");
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) { alert("먼저 작업을 저장한 뒤 연결할 수 있습니다."); return; }
try {
await api("POST", "/project/api/tasks/" + taskId + "/links",
{ project_id: pid, stage_id: stageSel.value ? parseInt(stageSel.value, 10) : null });
projSel.value = "";
stageSel.innerHTML = "<option value=''>프로젝트를 먼저 선택하세요</option>";
if (onChange) onChange();
} catch (e) { alert("추가 실패: " + e.message); }
});
return {
setContext: function (opts) {
taskId = opts.taskId; homeProjectId = opts.projectId; onChange = opts.onChange || null;
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;
// 탭이 안 보이는 동안(다른 탭/최소화)은 묻지 않는다 — 열어둔 탭 수만큼
// 서버에 헛요청이 쌓였다. 다시 보이면 바로 한 번 확인한다.
let baseline = null;
let timer = null;
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 (baseline === null) {
baseline = d.ts;
} else if (d.ts !== baseline) {
baseline = d.ts;
initBell();
initMentionBadge();
if (softSyncProjectRef) softSyncProjectRef();
}
}
} catch (_) {}
if (!timer && !document.hidden) timer = setTimeout(poll, 8000);
}
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();
}
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);
}
// ── 휴지통(관리자 전용 화면) — [복구] 누르면 원래 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");
}
});
});
}
document.addEventListener("DOMContentLoaded", function () {
// 좌측 프로젝트 목록 — 프로젝트 화면은 initProject 가 자기 데이터로 직접 연다.
if (!document.querySelector(".pj-project-view")) initSideTree();
initTrash();
initMyTasks();
initProject();
initAllMembers();
initBell();
initMentionBadge();
initInbox();
initInboxTaskPanel();
initMentionInbox();
initLiveRefresh();
initGlobalSearch();
initScrollIndicators();
initHoverTips();
});
})();