Files
dbx-main/app/static/project.js
T

4730 lines
228 KiB
JavaScript
Raw Blame History

This file contains ambiguous Unicode characters
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); }
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" : "");
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 () {
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 window.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 + ")";
}
// ── 탭 그룹(뷰 탭/스코프 토글, 둘 다 .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 + ")";
}
// 멤버 선택 후보 카드(아이콘 위 / 이름 가운데 / 체크박스 아래) — 새 프로젝트
// 모달(홈·프로젝트 페이지)과 멤버 배정 모달 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(u.id) + "</span>" +
'<input type="checkbox" value="' + u.email + '" data-name="' + escapeHtml(u.name) + '" />' +
"</label>";
}
// ── 색상 팔레트 렌더 ───────────────────────────────────────
// 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.indexOf(initial) >= 0) ? 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;
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; };
}
// ════════════════════════════════════════════════════════════
// 댓글만 보는 채팅형 팝업(#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);
const getColor = renderColorPalette(el("pj-f-colors"));
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(),
});
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 = "";
if (onCreated) onCreated(res.project);
} catch (e) { showToast("생성 실패: " + e.message, "error"); }
});
}
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);
if (cmInput) cmInput.addEventListener("paste", function (e) {
const items = (e.clipboardData || window.clipboardData || {}).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>";
}
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"),
]);
const comments = cRes.comments || [];
// 댓글에 딸린 첨부만 채팅 말풍선에 표시(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) {
list.innerHTML = "<li class='pj-empty-sm'>댓글 없음</li>";
} else {
list.innerHTML = "";
comments.forEach(function (c) {
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 inner =
(c.body ? '<div class="pj-chat-bubble"></div>' : "") +
attsHtml +
'<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">' + avatarHtml(c.author_email, "pj-chat-avatar") + "</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.textContent = c.body;
if (mine) {
li.querySelector(".pj-chat-del").addEventListener("click", async function () {
if (!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 (!confirm("이 파일을 삭제할까요?")) return;
try {
await api("DELETE", "/project/api/attachments/" + btn.dataset.id);
await renderChat(taskId);
} catch (err) { alert("삭제 실패: " + err.message); }
});
});
list.appendChild(li);
});
list.scrollTop = list.scrollHeight;
}
return comments.length;
} catch (e) {
list.innerHTML = "<li class='pj-empty-sm'>불러오기 실패</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();
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");
b.addEventListener("click", function (e) { e.preventDefault(); e.stopPropagation(); });
b.addEventListener("dblclick", function (e) {
e.preventDefault(); e.stopPropagation();
open(b.dataset.taskId);
});
}
document.querySelectorAll(".pj-cmt-badge").forEach(wireBadge);
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) });
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;
}
function renderMentionMenu(users, rect, onPick) {
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(u.id || u.name || u.email) + "</span>";
b.addEventListener("click", function () { onPick(u); });
menu.appendChild(b);
});
}
menu.hidden = false;
// 커서/입력칸 바로 아래. 화면 밖으로 나가면 위쪽으로 뒤집는다.
let top = window.scrollY + rect.bottom + 4;
let left = window.scrollX + rect.left;
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - menu.offsetWidth - 8);
if (rect.bottom + menu.offsetHeight + 8 > document.documentElement.clientHeight) {
top = window.scrollY + rect.top - menu.offsetHeight - 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);
renderMentionMenu(users, input.getBoundingClientRect(), function (u) {
const token = "@" + (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();
});
}
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 = {}; }
// ── 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 = "@" + (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 overdue = !t.completed_at && t.due_date.slice(0, 10) < today;
return '<span class="' + (overdue ? "pj-mtk-overdue" : "") + '">' + fmtDateKr(t.due_date) + "</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 (!confirm("이 업무를 삭제할까요?")) return;
try {
await api("DELETE", "/project/api/tasks/" + t.id);
tasks = tasks.filter(function (x) { return x.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();
// 좌측 사이드바 "+" — 새 프로젝트. 만들면 그 프로젝트 화면으로 이동한다.
initNewProjectModal(root.dataset.isAdmin === "true", function (project) {
location.href = "/project/p/" + project.id;
});
// 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 cmtBadge(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>";
}
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개 뷰는 전 프로젝트를 보여준다.
let projectsMeta = data.projects || [];
const stagesByProject = data.stagesByProject || {};
const boardStages = data.boardStages || [];
const avatars = data.avatars || {};
// 댓글 말풍선 더블클릭 팝업 — 공용 구현(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 saved = localStorage.getItem(VIEW_KEY);
if (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);
});
fillAssigneeFilter(); // 스코프가 바뀌면 담당자 후보도 달라진다
renderView(currentView);
updateFilterSummary();
});
}
if (moveScopeHighlight) moveScopeHighlight(false);
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 = "";
const overflow = [0, 0, 0, 0, 0, 0, 0];
bars.forEach(function (b) {
const row = rankOf[b.lane];
if (row >= MAX_LANES) { // 넘침 → 그 칸들 +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 = (MAX_LANES + 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;
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);
});
})();
// ── 타임라인 (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 = [];
groupOrder.forEach(function (gid) {
const list = byGroup[gid];
const grp = (groupBySession ? "S" : "P") + gid;
const meta = groupBySession ? {} : (projById[gid] || {});
const groupColor = list[0].project_color || meta.color || "#4573d2";
const groupName = groupBySession
? (gid === "none" ? "미지정" : (list[0].stage_name || "세션"))
: (list[0].project_name || meta.name || "프로젝트");
groupRows.push({ id: grp, content: escapeHtml(groupName) });
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({
// vis 가 HTML 을 정화(sanitize)하므로 아이콘 폰트 대신 이모지로 댓글 표시.
id: t.id, group: grp,
content: (t.title || "") + (t.comment_count ? " 💬" + t.comment_count : ""),
start: startISO, end: isRange ? endISO : undefined,
type: isRange ? "range" : "point",
style: "background-color:" + (t.completed_at ? "#9aa5b1" : groupColor) + ";color:#fff;border:none;",
});
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 opts = {
stack: true, height: "520px",
horizontalScroll: true, // 마우스 휠 = 좌우 이동(패닝)
verticalScroll: false,
zoomKey: "ctrlKey", // 확대/축소는 Ctrl+휠
margin: { item: 8 },
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": return 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); }
// ── 드래그로 이동/기간 조절 — 아사나처럼 막대 몸통을 끌면 통째로 이동,
// 양 끝을 끌면 시작·마감일만 조절. 세션(그룹) 간 드래그는 막아둔다(그룹
// 이동은 "다른 세션으로 옮기기"라 보드 드래그의 몫 — 타임라인은 날짜만).
opts.editable = { add: false, remove: false, updateGroup: false, updateTime: canManage };
opts.onMove = function (item, callback) {
const t = 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 };
const useTime = !!(t.start_time || t.due_time);
function toParts(d) {
const dt = new Date(d);
const date = dt.getFullYear() + "-" + String(dt.getMonth() + 1).padStart(2, "0") + "-" + String(dt.getDate()).padStart(2, "0");
const time = String(dt.getHours()).padStart(2, "0") + ":" + String(dt.getMinutes()).padStart(2, "0");
return { date: date, time: time };
}
const payload = {};
if (item.type === "point") {
// 단일 날짜 항목 — 원래 채워져 있던 필드(시작 또는 마감, 혹은 둘 다
// 같은 날짜)를 이동한 날짜로 같이 옮긴다.
const p = toParts(item.start);
if (t.start_date) { payload.start_date = p.date; if (useTime) payload.start_time = p.time; }
if (t.due_date) { payload.due_date = p.date; if (useTime) payload.due_time = p.time; }
} else {
const ps = toParts(item.start), pe = toParts(item.end);
payload.start_date = ps.date;
payload.due_date = pe.date;
if (useTime) { payload.start_time = ps.time; payload.due_time = pe.time; }
}
Object.assign(t, payload);
callback(item); // vis 쪽 위치는 즉시 반영(낙관적) — 저장은 백그라운드.
api("PUT", "/project/api/tasks/" + t.id, payload).then(function (res) {
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 : ""),
});
});
};
const itemsDS = new vis.DataSet(items);
timeline = new vis.Timeline(node, itemsDS, groups, opts);
// 단일 클릭은 선택만(드래그로 기간 조절할 때 양 끝 손잡이가 나타나려면
// 먼저 선택 상태여야 한다 — vis 의 자체 동작) — 여기서 모달을 열면
// 손잡이가 나타나자마자 모달이 덮어써서 드래그를 할 수가 없다. 편집은
// 더블클릭이나 우클릭 메뉴의 "열기"로.
timeline.on("doubleClick", function (props) {
if (!canManage || props.item == null || String(props.item).indexOf("bg") === 0) 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;
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()); };
}
function loadTLWindow() {
try {
const r = JSON.parse(localStorage.getItem("pj_tl_window") || "null");
return (r && r.start && r.end) ? r : null;
} catch (_) { return null; }
}
function saveTLWindow(s, e) {
try {
localStorage.setItem("pj_tl_window",
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 : "";
getStageColor = renderColorPalette(
el("pj-stg-colors"), null, stage ? stage.color : null, window.PJ_STAGE_COLORS
);
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;
try {
if (id) {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + id, { name: name, color: color });
} else {
await api("POST", "/project/api/projects/" + projectId + "/stages", { name: name, color: color });
}
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 (boardAddStageBtn) boardAddStageBtn.hidden = !(viewScope === "project" && canManage);
if (viewScope === "project") renderBoardByStage(canvas, vis);
else renderBoardByName(canvas, vis);
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" : "") + '"' +
(canManage ? ' draggable="true"' : "") +
(s.color ? ' style="background:' + hexToRgba(s.color, 0.6) + '"' : "") + '>' +
'<span class="pj-col-name">' + escapeHtml(s.name) + "</span>" +
(s.is_done_stage ? '<span class="pj-chip pj-chip-sm">완료</span>' : "") +
'<span class="pj-col-count"></span>' +
(canManage
? '<span class="pj-col-ctrls">' +
'<button type="button" class="pj-icon-btn pj-col-rename" title="세션 편집">✎</button>' +
'<button type="button" class="pj-icon-btn pj-col-toggledone" title="완료 세션 지정/해제">' +
(s.is_done_stage ? "☑" : "☐") + "</button>" +
'<button type="button" class="pj-icon-btn pj-col-del" title="세션 삭제">×</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"); }
}
// 세션 이름 클릭 → 그 자리에서 이름 변경(Enter/포커스 이탈=저장, Esc=취소).
// 헤더가 드래그(세션 재정렬) 대상이라 편집 중엔 draggable 을 꺼 둔다 —
// 안 끄면 입력칸 안에서 글자 선택하려고 끌면 컬럼이 끌려간다.
const nameEl = col.querySelector(".pj-col-name");
if (nameEl) {
nameEl.classList.add("pj-col-name-editable");
nameEl.title = "클릭해서 이름 변경";
nameEl.addEventListener("click", function (e) {
e.stopPropagation();
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(); });
});
}
const renameBtn = col.querySelector(".pj-col-rename");
if (renameBtn) renameBtn.addEventListener("click", function (e) { e.stopPropagation(); editStage(); });
const doneBtn = col.querySelector(".pj-col-toggledone");
if (doneBtn) doneBtn.addEventListener("click", function (e) { e.stopPropagation(); toggleDoneStage(); });
const delBtn = col.querySelector(".pj-col-del");
if (delBtn) delBtn.addEventListener("click", function (e) { e.stopPropagation(); deleteStage(); });
const head = col.querySelector(".pj-col-head");
if (head) head.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "업무 추가", onClick: function () { openTaskModal(null, s.id); } },
{ label: "세션 편집", onClick: editStage },
{ label: s.is_done_stage ? "완료 세션 해제" : "완료 세션으로 지정", onClick: toggleDoneStage },
null,
{ label: "삭제", danger: true, onClick: deleteStage },
]);
});
}
// 세션 본문(카드 사이 빈 공간) 우클릭 — "업무 추가"만. 카드 위에서 우클릭한
// 경우는 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; }
const cur = (t.assignee_email || "").toLowerCase();
const items = [{
label: (cur ? "" : "✓ ") + "(미지정)",
onClick: function () { applyTaskPatch(t, { assignee_email: "", assignee_name: "" }, "담당자 변경 실패"); },
}];
list.forEach(function (m) {
const email = m.user_email;
items.push({
label: (email.toLowerCase() === cur ? "✓ " : "") + idOf(email),
onClick: function () {
applyTaskPatch(t, { assignee_email: email, assignee_name: idOf(email) }, "담당자 변경 실패");
},
});
});
showContextMenu(x, y, items);
}
// 마감일 — 카드 위에 작은 날짜 입력칸을 띄운다. 값이 바뀌면 바로 저장하고,
// "지우기"로 마감일을 없앨 수 있다. 바깥을 누르면 닫힌다.
let inlineDateEl = null;
function closeInlineDate() {
if (inlineDateEl) { inlineDateEl.remove(); inlineDateEl = null; }
document.removeEventListener("mousedown", onInlineDateDown, true);
}
function onInlineDateDown(e) {
if (inlineDateEl && !inlineDateEl.contains(e.target)) closeInlineDate();
}
function openDuePicker(t, anchorEl) {
closeInlineDate();
const box = document.createElement("div");
box.className = "pj-inline-date";
box.innerHTML = '<input type="date" value="' + (t.due_date || "") + '" />' +
'<button type="button" class="pj-btn">지우기</button>';
document.body.appendChild(box);
const r = anchorEl.getBoundingClientRect();
let left = window.scrollX + r.left;
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - box.offsetWidth - 8);
box.style.left = Math.max(8, left) + "px";
box.style.top = (window.scrollY + r.bottom + 4) + "px";
inlineDateEl = box;
const input = box.querySelector("input");
input.addEventListener("change", function () {
const v = input.value || null;
closeInlineDate();
if (v === (t.due_date || null)) return;
applyTaskPatch(t, { due_date: v }, "마감일 변경 실패");
});
box.querySelector("button").addEventListener("click", function () {
closeInlineDate();
if (!t.due_date) return;
applyTaskPatch(t, { due_date: null }, "마감일 변경 실패");
});
setTimeout(function () {
document.addEventListener("mousedown", onInlineDateDown, true);
try { input.focus(); if (input.showPicker) input.showPicker(); } catch (_) {}
}, 0);
}
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;
card.innerHTML =
(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).
'<span class="pj-assignee pj-card-edit-hit pj-card-assignee' +
(t.assignee_email ? '' : ' is-empty') + '" title="담당자 변경">' +
avatarHtml(t.assignee_email, "pj-gicon-sm") +
escapeHtml(t.assignee_email ? idOf(t.assignee_email) : "담당자") + "</span>" +
(t.subtask_total
? '<span class="pj-card-subtasks" title="하위 업무">' + (t.subtask_done || 0) + "/" + t.subtask_total + "</span>"
: "") +
'<span class="pj-card-due pj-card-edit-hit' + (t.due_date ? '' : ' is-empty') +
'" title="마감일 변경">' + (t.due_date ? escapeHtml(t.due_date) : "마감일") + "</span>" +
(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 + '개">' + cmtBadge(t) + "</span>"
: "") +
"</div>";
card.addEventListener("click", function (e) {
if (!canManage) 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("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) { return t.due_date || "-"; }, 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 === "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명.
const byAssignee = {};
incomplete.forEach(function (t) {
if (!t.start_date && !t.due_date) return;
const k = t.assignee_email ? (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 && !(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);
if (typeof renderTree === "function") 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 (!confirm("이 업무를 삭제할까요?")) return;
try {
await api("DELETE", "/project/api/tasks/" + 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");
// 패널 너비 드래그 리사이즈 — 왼쪽 모서리를 끌면 오른쪽에 고정된 패널이
// 넓어진다(최소 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();
const startX = e.clientX;
const startW = card.getBoundingClientRect().width;
handle.classList.add("is-dragging");
document.body.style.userSelect = "none";
function mv(ev) {
const maxW = window.innerWidth * 0.5;
const w = Math.max(420, Math.min(maxW, startW + (startX - ev.clientX)));
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))); } 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);
});
}
// 닫을 때(배경 클릭·Esc·취소 버튼) 수정한 내용이 있으면 저장할지 물어본다.
// 하위업무/첨부/댓글/연결은 각자 즉시 저장돼서 여기서 추적할 필요 없다 —
// "저장" 버튼이 실제로 보내는 필드만 스냅샷으로 비교.
let taskSnapshot = null;
function taskFormSnapshot() {
return JSON.stringify({
title: el("pj-t-title").value,
assignee: el("pj-t-assignee").value,
stage: el("pj-t-stage").value,
priority: el("pj-t-priority").value,
due: el("pj-t-due").value,
desc: descEditor ? descEditor.getHtml() : "",
});
}
function isTaskDirty() {
return taskSnapshot !== null && taskFormSnapshot() !== taskSnapshot;
}
let taskClosing = false;
async function attemptCloseTaskModal() {
// erpConfirm 도 Esc 로 닫히는데 stopPropagation 을 안 해서, 확인창이
// 뜬 상태에서 Esc 를 누르면 이 함수가 다시 불릴 수 있다 — 재진입 방지.
if (taskModal.hidden || taskClosing) return;
taskClosing = true;
try {
if (isTaskDirty()) {
const save = await window.erpConfirm(
"수정한 내용이 있습니다. 저장하시겠습니까?",
{ okText: "저장", cancelText: "저장 안 함" }
);
if (save) { el("pj-save-task").click(); return; }
}
taskSnapshot = null;
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-follower-chip" data-tip="' + escapeHtml(e) + '">' +
avatarHtml(e, "pj-gicon-sm") + '<span class="pj-follower-name">' + escapeHtml(idOf(e)) + "</span>" +
'<button type="button" class="pj-follower-x" data-email="' + escapeHtml(e) + '" title="팔로워에서 빼기">×</button></span>';
}).join("") || '<span class="pj-muted-sm">없음</span>';
box.querySelectorAll(".pj-follower-x").forEach(function (b) {
b.addEventListener("click", function () { setFollower(b.dataset.email, false); });
});
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", async function (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), 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 });
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) {
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 || "") : ""); }
fillAssigneeSelect(task ? task.project_id : projectId, task ? (task.assignee_email || "") : "");
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;
if (subtaskBlock) el("pj-subtask-block").hidden = !task;
if (linksBlock) el("pj-links-block").hidden = !task;
if (task) { loadAttachments(task.id); loadComments(task.id); loadTaskExtras(task); }
openSlidePanel(taskModal);
taskSnapshot = taskFormSnapshot();
}
// 마감일 — 달력 아이콘 버튼(날짜가 있으면 옆에 "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;
el("pj-t-due-text").textContent = v ? fmtDateKr(v) : "";
btn.classList.toggle("has-date", !!v);
btn.classList.toggle("is-overdue", !!v && v < todayIso && !(currentTaskData && currentTaskData.completed_at));
btn.title = v ? "마감일 " + v + " (눌러서 변경)" : "마감일 지정";
}
if (el("pj-t-due-btn")) {
el("pj-t-due-btn").addEventListener("click", function () {
const inp = el("pj-t-due");
try { inp.showPicker(); } // 크롬·엣지·파이어폭스·사파리 최신
catch (_) { inp.focus(); inp.click(); } // 구형 브라우저 폴백
});
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();
} 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 (!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 res = await api("GET", "/project/api/tasks/" + taskId + "/comments");
// 메모리 업무의 댓글 수 동기화(아이콘 표시용)
const tt = tasks.find(function (x) { return String(x.id) === String(taskId); });
if (tt) tt.comment_count = res.comments.length;
if (!res.comments.length) { ul.innerHTML = "<li class='pj-empty-sm'>댓글 없음</li>"; return; }
ul.innerHTML = "";
res.comments.forEach(function (c) {
const li = document.createElement("li");
li.className = "pj-comment-item";
li.innerHTML =
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">' +
(c.created_at || "").slice(0, 16).replace("T", " ") + "</span></div>" +
'<div class="pj-comment-body"></div></div>' +
'<span class="pj-comment-acts">' +
'<button type="button" class="pj-icon-btn pj-comment-edit" title="수정">✎</button>' +
'<button type="button" class="pj-icon-btn pj-comment-del" title="삭제">×</button>' +
"</span>";
li.querySelector(".pj-comment-body").textContent = c.body; // XSS 안전(textContent)
li.querySelector(".pj-comment-del").addEventListener("click", async function () {
try { await api("DELETE", "/project/api/comments/" + c.id); loadComments(taskId); }
catch (e) { alert("삭제 실패: " + e.message); }
});
li.querySelector(".pj-comment-edit").addEventListener("click", function () {
editComment(li, c, taskId);
});
ul.appendChild(li);
});
} catch (e) { ul.innerHTML = "<li class='pj-empty-sm'>불러오기 실패</li>"; }
}
// 댓글 인라인 수정 — 본문을 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-comment-acts");
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"));
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); });
el("pj-save-task").addEventListener("click", async function () {
if (descEditor && descEditor.isUploading()) { alert("이미지 업로드가 끝나면 저장해주세요."); return; }
const id = el("pj-t-id").value;
const assigneeSel = el("pj-t-assignee");
const assigneeName = assigneeSel.selectedOptions[0] ? (assigneeSel.selectedOptions[0].dataset.name || "") : "";
const payload = {
title: el("pj-t-title").value.trim(),
description: descEditor ? descEditor.getHtml() : "",
assignee_email: assigneeSel.value,
assignee_name: assigneeName,
priority: el("pj-t-priority").value,
due_date: el("pj-t-due").value || null,
// 시작일/시간은 이 폼에서 더 이상 편집하지 않는다 — 원래 값을
// 그대로 유지해서 보낸다(타임라인/캘린더 드래그로만 바뀐다).
start_date: currentTaskData ? (currentTaskData.start_date || null) : null,
start_time: currentTaskData ? (currentTaskData.start_time || null) : null,
due_time: currentTaskData ? (currentTaskData.due_time || null) : null,
};
// 세션이 선택돼 있을 때만 보낸다 — 빈 값(세션 없는 업무 등)을 null 로
// 보내면 서버가 세션을 지우고 완료 상태까지 풀어버린다.
const stageVal = parseInt(el("pj-t-stage").value, 10);
if (stageVal) payload.stage_id = stageVal;
if (!payload.title) { alert("제목을 입력하세요."); return; }
try {
let res;
if (id) res = await api("PUT", "/project/api/tasks/" + id, payload);
else res = await api("POST", "/project/api/projects/" + projectId + "/tasks", payload);
mergeTask(res.task);
taskSnapshot = null;
closeSlidePanel(taskModal);
refreshActiveView();
} catch (e) { alert("저장 실패: " + e.message); }
});
// ── 공유 — 이 업무의 퍼머링크를 클립보드로 ──
const shareTaskBtn = el("pj-share-task");
if (shareTaskBtn) shareTaskBtn.addEventListener("click", function () {
const id = el("pj-t-id").value;
if (id) shareTaskLink(id);
});
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 (!confirm("이 업무를 삭제할까요?")) return;
try {
await api("DELETE", "/project/api/tasks/" + id);
tasks = tasks.filter(function (x) { return String(x.id) !== String(id); });
closeSlidePanel(taskModal);
refreshActiveView();
} catch (e) { alert("삭제 실패: " + e.message); }
});
// ── 프로젝트 트리(사이드바) — 아사나처럼 프로젝트 이름만 나열한다(업무 목록은
// 안 보여준다 — 업무는 가운데 화면에서만 본다). 색상 원(첫 글자) 아이콘.
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 initial = escapeHtml((p.name || "?").trim().charAt(0).toUpperCase() || "?");
// 드래그로 순서 변경 가능함을 알려주는 손잡이(⣿) — 관리자에게만 보인다.
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 === projectId ? "is-active" : "") + '">' +
handle +
'<a class="pj-tree-link" href="/project/p/' + p.id + '">' +
'<span class="pj-tree-avatar" style="background:' + (p.color || "#4573d2") + '">' + initial + "</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(projectId)) { location.href = "/project/"; return; }
projectsMeta = projectsMeta.filter(function (x) { return String(x.id) !== String(id); });
renderTree();
} 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 renderTree() {
const rootUl = el("pj-tree-root");
if (!rootUl) return;
const active = projectsMeta.filter(function (p) { return p.status !== "completed"; });
const done = projectsMeta.filter(function (p) { return p.status === "completed"; });
rootUl.innerHTML = active.map(treeProjLi).join("");
wireTreeHandlers(rootUl);
// "완료 프로젝트" 섹션 — 처음 페이지를 열었을 때 완료 프로젝트가
// 하나도 없었으면 서버가 아예 안 그려서 DOM에 없다. 완료로 바뀌는
// 순간 필요해지면 그때 만든다(반대로 마지막 하나가 해제/삭제되면 통째로 치운다).
let doneUl = el("pj-tree-root-done");
if (done.length) {
if (!doneUl) {
const block = rootUl.closest(".pj-side-block");
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();
}
}
// 좌측 프로젝트 목록 드래그 순서 변경 — 홈 화면 카드 정렬과 같은 API/원칙
// (관리자 전용, 최상위 프로젝트만). rootUl 자체는 renderTree() 가 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 });
projectsMeta.sort(function (a, b) { return ids.indexOf(a.id) - ids.indexOf(b.id); });
} catch (err) {
showToast("순서 변경 실패: " + err.message, "error");
renderTree();
}
});
}
function mergeProject(p) {
const i = projectsMeta.findIndex(function (x) { return String(x.id) === String(p.id); });
if (i >= 0) projectsMeta[i] = Object.assign({}, projectsMeta[i], p);
else projectsMeta.push(p);
renderTree();
if (String(p.id) === String(projectId)) {
Object.assign(currentProject, p);
const pillEl = document.querySelector(".pj-project-title-pill");
if (pillEl) {
pillEl.textContent = currentProject.name || "";
pillEl.style.setProperty("--pj-color", currentProject.color || "#4573d2");
}
}
}
renderTree();
wireTreeDrag(el("pj-tree-root"));
wireTreeDrag(el("pj-tree-root-done"));
// 새 최상위 프로젝트 (관리자) — 내 업무 화면과 공용 구현.
initNewProjectModal(isAdmin, function (project) {
stagesByProject[project.id] = [];
mergeProject(project);
});
// ── 좌측 프로젝트 목록 ✎ 버튼 — 프로젝트 수정 모달(홈 화면과 동일).
// 트리는 renderTree() 로 매번 다시 그려지므로(라이브 새로고침 포함) 열기
// 로직을 재사용 가능한 함수로 두고, wireTreeHandlers 에서 매번 다시 건다.
const editModal = el("pj-modal-edit");
let getEditColor = null;
function openProjectEditModal(data) {
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);
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,
status: el("pj-e-done").checked ? "completed" : "active",
});
mergeProject(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 = projectsMeta.find(function (x) { return String(x.id) === String(id); });
closeModal(editModal);
deleteTreeProject(id, p && p.name, p && p.created_by);
});
}
// ── 멤버 배정/제외 (관리자) ──
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 (!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();
// ── 전체 멤버(프로젝트 권한 보유 등록 사용자 전원) — 아이콘 클릭 시
// 그 사람이 담당자인 업무를 팝업으로 보여준다(프로젝트/세션/마감일).
function allMemberItemHtml(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(u.id) + '">' +
icon + '<span class="pj-allmember-name">' + escapeHtml(u.id) + "</span></button>";
}
const memberTasksModal = el("pj-modal-member-tasks");
if (memberTasksModal) wireModalClose(memberTasksModal);
let mtItems = [];
let mtSort = { key: null, dir: 1 };
// 더블클릭으로 업무 편집 팝업을 열 때 이 팝업을 완전히 닫지 않고 잠깐
// 숨겨두는 용도의 컨텍스트 — 업무 편집을 마치고 닫으면(taskModal 의
// hidden 이 다시 true 로 바뀌면) 같은 조건으로 다시 열어 목록을 최신
// 상태로 되살린다("기존 멤버 업무리스트는 그대로 유지" 요구사항).
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("");
// 더블클릭 = 업무 편집 팝업(현재 프로젝트가 아니어도 openTaskModal 은
// task.project_id 기준으로 담당자/세션 옵션을 다시 채우므로 그대로 동작).
// 이 팝업은 닫는 게 아니라 잠깐 숨겨두고, 편집 팝업이 닫히면 같은
// 대상으로 다시 열어 목록을 새로고침한다.
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;
mtReopenCtx = mtCurrentCtx;
closeModal(memberTasksModal);
openTaskModal(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 = avatars[String(email || "").toLowerCase()];
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) {
if (!memberTasksModal) return;
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"] });
}
const allMembersGrid = el("pj-allmembers-grid");
if (allMembersGrid) {
api("GET", "/project/api/all-users").then(function (res) {
const users = res.users || [];
allMembersGrid.innerHTML = users.length
? users.map(allMemberItemHtml).join("")
: "<span class='pj-empty-sm'>없음</span>";
allMembersGrid.querySelectorAll(".pj-allmember-item").forEach(function (btn) {
btn.addEventListener("click", function () { openMemberTasksModal(btn.dataset.email, btn.dataset.name); });
});
}).catch(function (e) {
allMembersGrid.innerHTML = "<span class='pj-empty-sm'>불러오기 실패: " + escapeHtml(e.message) + "</span>";
});
}
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
// 안 하면 클릭 순간 에디터가 포커스를 잃어 선택 범위가 풀린다.
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") {
arg = prompt("연결할 주소(URL)를 입력하세요", "https://");
if (!arg) 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;
let active = false;
try { active = document.queryCommandState(cmd); } catch (_) { active = false; }
btn.classList.toggle("is-active", active);
});
}
box.addEventListener("keyup", updateFmtState);
box.addEventListener("mouseup", updateFmtState);
box.addEventListener("focus", updateFmtState);
}
// ── 설명란 이미지 선택 → 크기 조절 핸들 + 삭제 버튼 오버레이 ──
// 크기는 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);
},
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");
const addDue = el("pj-subtask-add-due");
const addBtn = el("pj-subtask-add");
let taskId = null, projectId = null, canDeleteFn = function () { return false; }, onChange = null;
async function membersOptionsHtml(pid) {
try {
const res = await api("GET", "/project/api/projects/" + pid + "/members");
return (res.members || []).map(function (m) {
return '<option value="' + m.user_email + '">' + escapeHtml(idOf(m.user_email)) + "</option>";
}).join("");
} catch (_) { return ""; }
}
function rowEl(sub, optionsHtml) {
const li = document.createElement("li");
li.className = "pj-subtask-row" + (sub.completed_at ? " is-done" : "");
li.dataset.id = sub.id;
li.innerHTML =
'<input type="checkbox" class="pj-subtask-done"' + (sub.completed_at ? " checked" : "") + " />" +
'<input type="text" class="pj-subtask-title" />' +
'<select class="pj-subtask-assignee"><option value="">(미지정)</option>' + optionsHtml + "</select>" +
'<input type="date" class="pj-subtask-due" />' +
'<button type="button" class="pj-icon-btn pj-subtask-del" title="삭제" hidden>×</button>';
const titleInp = li.querySelector(".pj-subtask-title");
const doneChk = li.querySelector(".pj-subtask-done");
const assigneeSel = li.querySelector(".pj-subtask-assignee");
const dueInp = li.querySelector(".pj-subtask-due");
const delBtn = li.querySelector(".pj-subtask-del");
titleInp.value = sub.title || "";
assigneeSel.value = sub.assignee_email || "";
dueInp.value = sub.due_date || "";
if (canDeleteFn(sub.created_by)) delBtn.hidden = false;
async function patch(fields) {
try { await api("PUT", "/project/api/tasks/" + sub.id, fields); if (onChange) onChange(); }
catch (e) { alert("저장 실패: " + e.message); }
}
titleInp.addEventListener("change", function () {
const v = titleInp.value.trim();
if (!v) { titleInp.value = sub.title || ""; return; }
sub.title = v; patch({ title: v });
});
doneChk.addEventListener("change", function () {
li.classList.toggle("is-done", doneChk.checked);
patch({ completed: doneChk.checked });
});
assigneeSel.addEventListener("change", function () {
const opt = assigneeSel.selectedOptions[0];
patch({ assignee_email: assigneeSel.value, assignee_name: opt ? opt.textContent : "" });
});
dueInp.addEventListener("change", function () { patch({ due_date: dueInp.value || null }); });
delBtn.addEventListener("click", async function () {
if (!confirm("이 하위 업무를 삭제할까요?")) return;
try {
await api("DELETE", "/project/api/tasks/" + sub.id);
li.remove();
if (onChange) onChange();
} catch (e) { alert("삭제 실패: " + e.message); }
});
return li;
}
async function render(subtasks) {
listEl.innerHTML = subtasks.length ? "" : "<li class='pj-empty-sm'>없음</li>";
if (!subtasks.length) return;
const optionsHtml = projectId ? await membersOptionsHtml(projectId) : "";
listEl.innerHTML = "";
subtasks.forEach(function (sub) { listEl.appendChild(rowEl(sub, optionsHtml)); });
}
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 optionsHtml = await membersOptionsHtml(projectId);
const empty = listEl.querySelector(".pj-empty-sm");
if (empty) empty.remove();
listEl.appendChild(rowEl(res.task, optionsHtml));
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: function (opts) {
taskId = opts.taskId; projectId = opts.projectId;
canDeleteFn = opts.canDelete || function () { return false; };
onChange = opts.onChange || 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 (!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,
};
}
function idOf(email) {
return 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;
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); });
});
}
// ── 알림센터 페이지 ──
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 (e) {
if (e.target.closest("a")) return; // '이동' 링크는 통과
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] 달린 요소 아무데나 공용.
// 지금은 제목 옆 프로젝트 멤버 아이콘(이름 표시)에 쓴다. 나중에 그려지는
// 요소에도 붙도록 이벤트 위임 방식이다.
function initHoverTips() {
let tipEl = null;
function show(text, x, y) {
if (!tipEl) {
tipEl = document.createElement("div");
tipEl.className = "pj-hovertip";
document.body.appendChild(tipEl);
}
tipEl.textContent = text;
tipEl.style.left = x + "px";
tipEl.style.top = (y - 10) + "px";
tipEl.hidden = false;
}
function hide() { if (tipEl) tipEl.hidden = true; }
// 이벤트 위임 — 멤버 아이콘(renderMemberList)처럼 나중에 그려지는
// 요소에도 따로 배선하지 않고 그대로 동작한다.
let shown = false;
document.addEventListener("mousemove", function (e) {
const target = e.target.closest ? e.target.closest("[data-tip]") : null;
if (!target) { if (shown) { shown = false; hide(); } return; }
shown = true;
show(target.dataset.tip, e.clientX, e.clientY);
});
}
document.addEventListener("DOMContentLoaded", function () {
initMyTasks();
initProject();
initBell();
initMentionBadge();
initInbox();
initMentionInbox();
initLiveRefresh();
initGlobalSearch();
initScrollIndicators();
initHoverTips();
});
})();