/* 프로젝트 관리(아사나식) 모듈 — 프론트엔드.
* 두 페이지에서 공용:
* - 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
? ' '
: 'account_circle ';
return '' +
'' + icon + " " +
'' + escapeHtml(u.id) + " " +
' ' +
" ";
}
// 페이지 공용 아바타 맵 — 채팅/멤버 팝업은 여러 화면 공용 코드라 화면별
// init 안의 avatarHtml 을 못 본다. 페이지 데이터(#pj-data 또는
// #pj-mytasks-data)의 avatars 를 한 번 읽고, 전체 멤버 목록을 받으면 거기
// 들어있는 사진도 보탠다(수신함처럼 페이지 데이터가 없는 화면용).
let pageAvatars = null;
function pageAvatarUrl(email) {
if (pageAvatars === null) {
pageAvatars = {};
["pj-data", "pj-mytasks-data"].forEach(function (id) {
try {
const d = el(id);
if (d) Object.assign(pageAvatars, JSON.parse(d.textContent).avatars || {});
} catch (_) {}
});
}
return email ? pageAvatars[String(email).toLowerCase()] || "" : "";
}
function rememberAvatars(users) {
pageAvatarUrl(""); // 맵 초기화 보장
(users || []).forEach(function (u) {
if (u.avatar && !pageAvatars[u.email.toLowerCase()]) pageAvatars[u.email.toLowerCase()] = u.avatar;
});
}
function chatAvatarHtml(email) {
const url = pageAvatarUrl(email);
if (url) return ' ';
return 'account_circle ';
}
// ── 멤버 업무 팝업(#pj-modal-member-tasks) — 그 사람이 담당자인 업무를
// 프로젝트/세션/마감일과 함께 나열. 좌측 "전체 멤버"(관리자 전용, 모든
// 화면)와 프로젝트 화면의 "프로젝트 멤버" 칩이 함께 쓴다. 페이지당 하나라
// 싱글턴으로 둔다 — 프로젝트 화면(initProject)이 먼저 openTask(그 자리 편집
// 팝업)를 넘겨 만들고, 다른 화면은 기본값(그 업무의 프로젝트 화면으로 이동)을
// 쓴다. 반환값 = openMemberTasksModal(email, name, opts).
let memberTasksOpener = null;
function initMemberTasks(cfg) {
if (memberTasksOpener) return memberTasksOpener;
cfg = cfg || {};
const memberTasksModal = el("pj-modal-member-tasks");
if (!memberTasksModal) { memberTasksOpener = function () {}; return memberTasksOpener; }
wireModalClose(memberTasksModal);
const openTask = cfg.openTask || function (t) {
location.href = "/project/p/" + t.project_id + "?task=" + t.id;
};
const taskModal = cfg.taskModal || null;
let mtItems = [];
let mtSort = { key: null, dir: 1 };
// 더블클릭으로 업무 편집 팝업을 열 때 이 팝업을 완전히 닫지 않고 잠깐
// 숨겨두는 용도의 컨텍스트 — 업무 편집을 마치고 닫으면(taskModal 의
// hidden 이 다시 true 로 바뀌면) 같은 조건으로 다시 열어 목록을 최신
// 상태로 되살린다(taskModal 이 있는 프로젝트 화면에서만).
let mtCurrentCtx = null;
let mtReopenCtx = null;
function mtSortValue(t, key) {
if (key === "project") return (t.project_name || "").toLowerCase();
if (key === "stage") return (t.stage_name || "").toLowerCase();
if (key === "title") return (t.title || "").toLowerCase();
if (key === "due") return t.due_date || "9999-99-99";
return "";
}
function mtRowHtml(t) {
return '
' +
'' + escapeHtml(t.project_name || "-") + " " +
'' + escapeHtml(t.stage_name || "미지정") + " " +
'' + escapeHtml(t.title || "") + " " +
'' + (t.due_date ? fmtDateKr(t.due_date) : "-") + " " +
" ";
}
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 = "배정된 업무가 없습니다. "; return; }
const sorted = mtItems.slice();
if (mtSort.key) {
sorted.sort(function (a, b) {
const va = mtSortValue(a, mtSort.key), vb = mtSortValue(b, mtSort.key);
if (va < vb) return -1 * mtSort.dir;
if (va > vb) return 1 * mtSort.dir;
return 0;
});
}
list.innerHTML = sorted.map(mtRowHtml).join("");
list.querySelectorAll("li[data-task-id]").forEach(function (li) {
li.addEventListener("dblclick", function () {
const t = mtItems.find(function (x) { return String(x.id) === li.dataset.taskId; });
if (!t) return;
if (taskModal) mtReopenCtx = mtCurrentCtx;
closeModal(memberTasksModal);
openTask(t);
});
});
}
if (mtHead) mtHead.addEventListener("click", function (e) {
const h = e.target.closest(".pj-mt-h");
if (!h) return;
const key = h.dataset.sort;
if (mtSort.key === key) mtSort.dir *= -1; else { mtSort.key = key; mtSort.dir = 1; }
updateMtSortIcons();
renderMtList();
});
// 제목 앞에 붙는 아이콘 — 아바타 있으면 사진, 없으면 기본 사람 아이콘.
function mtTitleAvatarHtml(email) {
const url = pageAvatarUrl(email);
return url
? ' '
: 'account_circle ';
}
// opts.projectId 를 주면 "이 프로젝트 안에서" 담당하는 업무만, 제목도
// "[프로젝트 이름]의 [사용자]님의 업무" 형식으로. 안 주면(전체 멤버)
// 전체 프로젝트 대상 + "[사용자]님의 업무".
async function openMemberTasksModal(email, name, opts) {
opts = opts || {};
mtCurrentCtx = { email: email, name: name, opts: opts };
const prefix = opts.projectName ? escapeHtml(opts.projectName) + "의 " : "";
el("pj-mt-title").innerHTML = prefix + mtTitleAvatarHtml(email) + escapeHtml(name || email) + "님의 업무";
mtItems = [];
mtSort = { key: null, dir: 1 };
updateMtSortIcons();
const list = el("pj-mt-list");
list.innerHTML = "불러오는 중… ";
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 = "불러오기 실패: " + escapeHtml(e.message) + " ";
}
}
// 업무 편집 팝업이 닫히면(hidden 이 다시 true) 대기 중인 컨텍스트가
// 있을 때만 멤버 업무 팝업을 그 자리에 다시 연다.
if (taskModal) {
new MutationObserver(function () {
if (taskModal.hidden && mtReopenCtx) {
const ctx = mtReopenCtx;
mtReopenCtx = null;
openMemberTasksModal(ctx.email, ctx.name, ctx.opts);
}
}).observe(taskModal, { attributes: true, attributeFilter: ["hidden"] });
}
memberTasksOpener = openMemberTasksModal;
return memberTasksOpener;
}
// ── 좌측 "전체 멤버"(관리자 전용 — 서버가 관리자에게만 그리드를 렌더하고
// /api/all-users 도 관리자만 허용). 아이콘 클릭 = 그 사람의 업무 팝업.
function initAllMembers() {
const grid = el("pj-allmembers-grid");
if (!grid) return;
const openMemberTasksModal = initMemberTasks();
api("GET", "/project/api/all-users").then(function (res) {
const users = res.users || [];
rememberAvatars(users);
grid.innerHTML = users.length
? users.map(function (u) {
const icon = u.avatar
? ' '
: 'account_circle ';
return '' +
icon + '' + escapeHtml(u.id) + " ";
}).join("")
: "없음 ";
grid.querySelectorAll(".pj-allmember-item").forEach(function (btn) {
btn.addEventListener("click", function () { openMemberTasksModal(btn.dataset.email, btn.dataset.name); });
});
}).catch(function (e) {
grid.innerHTML = "불러오기 실패: " + escapeHtml(e.message) + " ";
});
}
// ── 색상 팔레트 렌더 ───────────────────────────────────────
// 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 = "멤버 배정은 관리자가 나중에 할 수 있습니다. ";
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("")
: "배정 가능한 직원이 없습니다. ";
} catch (_) {
membersBox.innerHTML = "불러오기 실패 ";
}
});
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 '' +
'' + icon + " " +
'' + escapeHtml(f.name) + " " +
'× ';
}).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
? '' +
'close '
: "";
if (isImg) {
return '";
}
return '' +
'' +
'' + chatFileIcon(a.filename) + ' ' +
'' + escapeHtml(a.filename) + " " +
delBtn + " ";
}
async function renderChat(taskId) {
const me = currentUserEmail();
const list = el("pj-chat-list");
list.innerHTML = "불러오는 중… ";
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 = "댓글 없음 ";
} 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
? '' + atts.map(function (a) { return attachmentHtml(a, me); }).join("") + "
"
: "";
const inner =
(c.body ? '
' : "") +
attsHtml +
'' +
(mine ? 'close ' : "") +
'' + (c.created_at || "").slice(0, 16).replace("T", " ") + " " +
" ";
// 상대방 댓글 — 카톡처럼 왼쪽에 프로필 아이콘, 그 옆에 이름 + 말풍선.
li.innerHTML = mine
? inner
: '' + chatAvatarHtml(c.author_email) + " " +
'' +
'' + escapeHtml(idOf(c.author_email)) + " " +
inner +
"
";
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) {
console.error("댓글 불러오기 실패", e);
list.innerHTML = "불러오기 실패: " + escapeHtml(e.message || "") + " ";
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) 공용
//
// @를 누르면 등록된 전체 프로젝트 멤버가 뜨고, 고르면
// · 설명란: @아이디 칩
// · 댓글 : "@아이디 " 평문 + 이메일을 따로 기억(전송 시 함께 보냄)
// 으로 들어간다. 태그된 사람은 수신함(/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 = '일치하는 멤버 없음
';
} 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
? ' '
: 'account_circle ') +
"" + escapeHtml(u.id || u.name || u.email) + " ";
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); });
}
// ════════════════════════════════════════════════════════════
// 설명란 링크 — 주소를 붙여넣으면 로 바꾸고, 클릭하면 새 탭으로 연다
// ════════════════════════════════════════════════════════════
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 += ' ' +
escapeHtml(url) + " " + escapeHtml(tail);
last = m.index + m[0].length;
}
out += escapeHtml(src.slice(last));
return out.replace(/\n/g, " ");
}
// 에디터 안의 모든 가 새 탭으로 열리게 맞춘다(서식바 링크 버튼 포함).
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 '' + escapeHtml(t.title || "") + " " +
(t.comment_count
? ' 💬 ' +
'' + t.comment_count + " "
: "");
},
sort: function (t) { return (t.title || "").toLowerCase(); },
},
{
key: "project", label: "프로젝트", cls: "pj-mtk-proj",
html: function (t) {
return '● ' +
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 '보통 ';
return '' +
escapeHtml(priorityLabels[t.priority] || t.priority) + " ";
},
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 '' + fmtDateKr(t.due_date) + " ";
},
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 = ' ' + COLS.map(function (c) {
const arrow = sort.key === c.key ? (sort.dir > 0 ? "▲" : "▼") : "↕";
return '' +
'' + escapeHtml(c.label) +
' ' + arrow + " ";
}).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
? ' '
: "";
tr.innerHTML =
' " +
COLS.map(function (c, i) {
const cell = c.html(t);
return '' + (i === 0 ? branch + cell : cell) + " ";
}).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 =
' ' +
'' +
'folder ' +
'' + escapeHtml(subtask.parent_title || "(상위 업무)") + " " +
'' + (parentIsMine ? "상위 업무" : "다른 담당자의 상위 업무") + " " +
" ";
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 =
'진행 ' + openN + " " +
'완료 ' + (tasks.length - openN) + " " +
(overdueN ? '지연 ' + overdueN + " " : "");
}
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 '💬 ' + n + " ";
}
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 ' ';
return 'account_circle ';
}
let timeline = null;
// 기본 보기는 항상 보드(왼쪽 프로젝트 클릭 등으로 들어오면 보드).
// 예외: 달력 이전/다음달 이동은 페이지를 통째로 새로고침하므로(?y=&m=),
// 그때만 마지막으로 보던 뷰를 되살린다 — 안 그러면 달력을 넘기다가
// 보드로 튕겨나간다.
const VIEW_KEY = "pj_view";
let currentView = "board";
try {
const qs = new URLSearchParams(location.search);
const saved = localStorage.getItem(VIEW_KEY);
if ((qs.has("y") || qs.has("m")) && saved &&
["board", "list", "calendar", "timeline", "dashboard"].indexOf(saved) >= 0) currentView = saved;
} catch (_) {}
// ── 프로젝트 스코프 — 아사나처럼 기본은 "이 프로젝트만", "전체 프로젝트"로
// 전환하면 예전처럼 접근 가능한 모든 프로젝트를 합쳐서 보여준다.
// tasks 배열의 각 행은 서버가 어느 프로젝트를 보다가 담았는지를
// context_project_id 로 표시한다(멀티호밍된 업무는 원 소속과 연결된
// 프로젝트 양쪽에서 각각 한 번씩 나온다 — 그래야 각 화면에 다 보인다).
// "전체" 모드는 원 소속(context_project_id === project_id)만 세어 중복을 없앤다.
let viewScope = "project";
// 필터 바(#pj-filterbar) 상태 — 프로젝트별로 이 브라우저에 기억한다.
const FILTER_KEY = "pj_filter_" + projectId;
let taskFilter = Object.assign({}, TASK_FILTER_DEFAULT);
try { Object.assign(taskFilter, JSON.parse(localStorage.getItem(FILTER_KEY) || "{}")); } catch (_) {}
const todayIso = data.today || localIso(new Date());
function scopeTasks() {
return viewScope === "project"
? tasks.filter(function (t) { return t.context_project_id === projectId; })
: tasks.filter(function (t) { return t.context_project_id === t.project_id; });
}
// 모든 뷰가 이 함수로 업무를 받는다 — 스코프 → 필터 → 정렬 순.
function visibleTasks() {
const rows = scopeTasks().filter(function (t) { return taskMatchesFilter(t, taskFilter, me, todayIso); });
return sortTasksBy(rows, taskFilter.sort);
}
// 보드 카드 순서 바꾸기는 "기본 정렬 + 필터 없음"일 때만 — 가려진 카드가 있거나
// 다른 기준으로 정렬돼 있으면 놓은 자리가 실제 순서와 어긋난다(아사나도 같다).
function manualOrderAllowed() {
return taskFilter.sort === "manual" && !taskFilterActive(taskFilter);
}
const FB = {
q: el("pj-fb-q"), status: el("pj-fb-status"), assignee: el("pj-fb-assignee"),
due: el("pj-fb-due"), priority: el("pj-fb-priority"), sort: el("pj-fb-sort"),
count: el("pj-fb-count"), reset: el("pj-fb-reset"),
};
// 담당자 선택지 = 이 프로젝트 멤버 + 지금 목록에 나오는 담당자(전체 스코프 대비).
function fillAssigneeFilter() {
if (!FB.assignee) return;
const emails = [];
members.forEach(function (m) { const e = (m.user_email || "").toLowerCase(); if (e && emails.indexOf(e) < 0) emails.push(e); });
scopeTasks().forEach(function (t) { const e = (t.assignee_email || "").toLowerCase(); if (e && emails.indexOf(e) < 0) emails.push(e); });
if (taskFilter.assignee.indexOf("@") > 0 && emails.indexOf(taskFilter.assignee) < 0) emails.push(taskFilter.assignee);
emails.sort(function (a, b) { return idOf(a).localeCompare(idOf(b)); });
FB.assignee.innerHTML =
'담당자: 전체 나 담당자 없음 ' +
emails.map(function (e) { return '' + escapeHtml(idOf(e)) + " "; }).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 = '' + escapeHtml(b.t.title || "") + " " + 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 =
' ' +
'' + escapeHtml(t.title || "") + " ";
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 = '기간이 설정된 업무가 없습니다.
'; 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
);
// 기본 담당자 후보 = 업무 담당자 후보와 같다(프로젝트 멤버 + owner).
// 지금 지정된 사람이 멤버에서 빠졌어도 선택지에 남겨 칸이 비지 않게 한다.
const cur = stage ? (stage.default_assignee_email || "") : "";
const emails = members.map(function (m) { return (m.user_email || "").toLowerCase(); });
[currentProject.owner_email, cur].forEach(function (e) {
e = (e || "").toLowerCase();
if (e && emails.indexOf(e) < 0) emails.push(e);
});
// 멤버 추가 창과 같은 아이콘+이름 카드(한 명만 고르는 라디오). 맨 앞 "없음".
const picker = el("pj-stg-assignee");
function pickCard(value, icon, label) {
return '' +
'' + icon + " " +
'' + escapeHtml(label) + " " +
' ' +
" ";
}
picker.innerHTML =
pickCard("", 'person_off ', "없음") +
emails.map(function (e) { return pickCard(e, avatarHtml(e, "pj-member-pick-icon"), idOf(e)); }).join("");
const curVal = cur.toLowerCase();
picker.querySelectorAll("input").forEach(function (r) { r.checked = r.value === curVal; });
picker.dataset.orig = curVal;
openModal(stageModal);
}
const saveStageBtn = el("pj-save-stage");
if (saveStageBtn) saveStageBtn.addEventListener("click", async function () {
const id = el("pj-stg-id").value;
const name = el("pj-stg-name").value.trim();
if (!name) { alert("세션 이름을 입력하세요."); return; }
const color = getStageColor ? getStageColor() : null;
const body = { name: name, color: color };
// 기본 담당자는 바뀐 경우에만 보낸다 — DB 마이그레이션 009 전이라도
// 이름·색상 편집은 그대로 되게.
const picker = el("pj-stg-assignee");
if (picker) {
const checked = picker.querySelector("input:checked");
const val = checked ? checked.value : "";
if (val !== (picker.dataset.orig || "")) body.default_assignee_email = val;
}
try {
if (id) {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + id, body);
} else {
await api("POST", "/project/api/projects/" + projectId + "/stages", body);
}
await reloadStagesForCurrentProject();
closeModal(stageModal);
renderBoard();
} catch (e) { showToast("저장 실패: " + e.message, "error"); }
});
const boardAddStageBtn = el("pj-board-addstage");
if (boardAddStageBtn) {
boardAddStageBtn.addEventListener("click", function () { openStageModal(null); });
}
function renderBoard() {
// pj-board(바깥)는 가로 스크롤 뷰포트, pj-board-canvas(안쪽)는 세션을
// 가로로 늘어놓는 flex 컨테이너(width:max-content) — 세션이 아무리
// 늘어나도 아래로 접히지 않고 오른쪽으로 계속 이어진다.
const canvas = el("pj-board-canvas");
canvas.innerHTML = "";
const vis = visibleTasks();
if (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 =
'' + escapeHtml(name) + " " +
'
' +
'
';
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 =
'' +
// 아사나처럼: 이름 바로 오른쪽에 업무 수(숫자만), 맨 오른쪽에 + / … 버튼.
'' + escapeHtml(s.name) + " " +
' ' +
// 세션 기본 담당자 — 작은 아이콘(마우스를 올리면 누구인지).
(s.default_assignee_email
? '' +
avatarHtml(s.default_assignee_email, "pj-gicon-sm") + " "
: "") +
(s.is_done_stage ? '완료 ' : "") +
(canManage
? '' +
'' +
'add ' +
'' +
'more_horiz ' +
" "
: "") +
"
" +
// 세션 맨 아래 "+ 업무 추가" — 카드 목록이 길어져도 컬럼 바닥에
// 고정으로 남는다(.pj-col-body 만 스크롤).
(canManage
? '+ 업무 추가 '
: "");
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 =
'미지정 ' +
'
';
const body = col.querySelector(".pj-col-body");
const colTasks = vis.filter(function (t) { return !t.stage_id; });
col.querySelector(".pj-col-count").textContent = colTasks.length;
colTasks.forEach(function (t) { body.appendChild(taskCard(t)); });
board.appendChild(col);
}
}
async function reloadStagesForCurrentProject() {
const res = await api("GET", "/project/api/projects/" + projectId + "/stages");
stages = res.stages || [];
stagesByProject[projectId] = stages;
}
function wireColumnControls(col, s) {
function editStage() { openStageModal(s); }
async function toggleDoneStage() {
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + s.id,
{ is_done_stage: !s.is_done_stage });
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) { showToast("변경 실패: " + err.message, "error"); }
}
async function deleteStage() {
if (!canDelete(s.created_by)) { alert(DELETE_DENIED); return; }
const ok = await window.erpConfirm(
"'" + s.name + "' 세션을 삭제할까요? 이 세션의 업무는 '미지정'이 됩니다.",
{ okText: "삭제", cancelText: "취소" }
);
if (!ok) return;
try {
await api("DELETE", "/project/api/projects/" + projectId + "/stages/" + s.id);
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) { showToast("삭제 실패: " + err.message, "error"); }
}
// 세션의 미완료 업무를 한 번에 완료 처리("세션 업무 모두 완료").
async function completeAllInStage() {
const open = tasks.filter(function (t) {
return t.stage_id === s.id && !t.parent_task_id && !t.completed_at;
});
if (!open.length) { showToast("완료할 업무가 없습니다."); return; }
const ok = await window.erpConfirm(
"'" + s.name + "' 세션의 미완료 업무 " + open.length + "개를 모두 완료로 표시할까요?",
{ okText: "모두 완료", cancelText: "취소" }
);
if (!ok) return;
let fail = 0;
for (const t of open) {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, { completed: true });
if (res && res.task) mergeTask(res.task);
} catch (_) { fail++; }
}
renderBoard();
if (fail) showToast(fail + "개 완료 처리 실패", "error");
}
// 세션 … 메뉴(버튼 클릭)와 머리 우클릭이 같은 항목을 쓴다.
function stageMenuItems() {
return [
{ label: "업무 추가", onClick: function () { openTaskModal(null, s.id); } },
{ label: "이름 변경", onClick: startRename },
{ label: "세션 편집 (색상·기본 담당자)", onClick: editStage },
null,
{ label: "세션 업무 모두 완료", onClick: completeAllInStage },
{ label: s.is_done_stage ? "완료 세션 해제" : "완료 세션으로 지정", onClick: toggleDoneStage },
null,
{ label: "삭제", danger: true, onClick: deleteStage },
];
}
// 세션 이름 클릭(또는 메뉴 "이름 변경") → 그 자리에서 이름 변경
// (Enter/포커스 이탈=저장, Esc=취소). 헤더가 드래그(세션 재정렬) 대상이라
// 편집 중엔 draggable 을 꺼 둔다 — 안 끄면 입력칸 안에서 글자 선택하려고
// 끌면 컬럼이 끌려간다.
const nameEl = col.querySelector(".pj-col-name");
function startRename() {
if (!nameEl || !nameEl.isConnected) return;
const head = col.querySelector(".pj-col-head");
const wasDraggable = head.getAttribute("draggable");
head.setAttribute("draggable", "false");
const input = document.createElement("input");
input.type = "text";
input.className = "pj-col-name-input";
input.value = s.name;
input.maxLength = 100;
nameEl.replaceWith(input);
input.focus();
input.select();
let done = false;
async function finish(save) {
if (done) return;
done = true;
const name = input.value.trim();
if (!save || !name || name === s.name) {
input.replaceWith(nameEl);
if (wasDraggable) head.setAttribute("draggable", wasDraggable);
return;
}
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + s.id, { name: name });
await reloadStagesForCurrentProject();
renderBoard();
} catch (err) {
showToast("이름 변경 실패: " + err.message, "error");
input.replaceWith(nameEl);
if (wasDraggable) head.setAttribute("draggable", wasDraggable);
}
}
input.addEventListener("keydown", function (ev) {
if (ev.isComposing) return; // 한글 조합 중 Enter 는 무시
if (ev.key === "Enter") { ev.preventDefault(); finish(true); }
else if (ev.key === "Escape") { ev.preventDefault(); finish(false); }
});
input.addEventListener("blur", function () { finish(true); });
input.addEventListener("click", function (ev) { ev.stopPropagation(); });
}
if (nameEl) {
nameEl.classList.add("pj-col-name-editable");
nameEl.title = "클릭해서 이름 변경";
nameEl.addEventListener("click", function (e) { e.stopPropagation(); startRename(); });
}
const addBtn = col.querySelector(".pj-col-add");
if (addBtn) addBtn.addEventListener("click", function (e) { e.stopPropagation(); openTaskModal(null, s.id); });
const moreBtn = col.querySelector(".pj-col-more");
if (moreBtn) moreBtn.addEventListener("click", function (e) {
e.stopPropagation();
const r = moreBtn.getBoundingClientRect();
showContextMenu(r.left, r.bottom + 4, stageMenuItems());
});
const head = col.querySelector(".pj-col-head");
if (head) head.addEventListener("contextmenu", function (e) {
e.preventDefault();
showContextMenu(e.clientX, e.clientY, stageMenuItems());
});
}
// 세션 본문(카드 사이 빈 공간) 우클릭 — "업무 추가"만. 카드 위에서 우클릭한
// 경우는 taskCard() 쪽 컨텍스트 메뉴(수정/완료/삭제 등)가 대신 뜨도록 건너뛴다.
function wireStageAddTask(body, s) {
body.addEventListener("contextmenu", function (e) {
if (e.target.closest(".pj-card")) return;
e.preventDefault();
showContextMenu(e.clientX, e.clientY, [
{ label: "업무 추가", onClick: function () { openTaskModal(null, s.id); } },
]);
});
}
// 세션(컬럼) 드래그 재정렬 — 카드 드래그와 같은 네이티브 HTML5 DnD 방식이되,
// dataTransfer 타입을 달리 써서(application/x-pj-stage) 카드 드롭과 안 섞인다.
function wireColumnDrag(col, s) {
const head = col.querySelector(".pj-col-head");
if (!head || head.getAttribute("draggable") !== "true") return;
head.addEventListener("dragstart", function (e) {
e.dataTransfer.setData("application/x-pj-stage", String(s.id));
e.dataTransfer.effectAllowed = "move";
col.classList.add("is-dragging");
});
head.addEventListener("dragend", function () { col.classList.remove("is-dragging"); });
col.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("application/x-pj-stage")) return;
e.preventDefault();
col.classList.add("pj-col-drop-target");
});
col.addEventListener("dragleave", function () { col.classList.remove("pj-col-drop-target"); });
col.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("application/x-pj-stage")) return;
e.preventDefault();
col.classList.remove("pj-col-drop-target");
const draggedId = parseInt(e.dataTransfer.getData("application/x-pj-stage"), 10);
if (!draggedId || draggedId === s.id) return;
const list = (stagesByProject[projectId] || []).slice()
.sort(function (a, b) { return a.sort_order - b.sort_order; });
const ids = list.map(function (x) { return x.id; });
const from = ids.indexOf(draggedId), to = ids.indexOf(s.id);
if (from < 0 || to < 0) return;
ids.splice(from, 1);
ids.splice(to, 0, draggedId);
try {
const res = await api("PUT", "/project/api/projects/" + projectId + "/stages/order",
{ ordered_ids: ids });
stages = res.stages || [];
stagesByProject[projectId] = stages;
renderBoard();
} catch (err) { alert("순서 변경 실패: " + err.message); }
});
}
// 보드 드롭(프로젝트 스코프) — 세션 id 로 바로 옮긴다. 이 프로젝트가 원
// 소속이 아닌(멀티호밍된) 업무는 원본을 안 건드리고 "이 프로젝트 안에서의
// 세션"만 연결(POST .../links)로 바꾼다.
// 드롭 지점(마우스 Y)이 이 컬럼의 카드들 중 어디에 해당하는지 인덱스로.
// 드래그 중인 카드 자신은 계산에서 제외(자기 위치가 기준을 흔들지 않게).
function cardDropIndex(body, clientY, excludeTaskId) {
const cards = Array.prototype.slice.call(body.querySelectorAll(".pj-card"))
.filter(function (c) { return String(c.dataset.taskId) !== String(excludeTaskId); });
for (let i = 0; i < cards.length; i++) {
const r = cards[i].getBoundingClientRect();
if (clientY < r.top + r.height / 2) return i;
}
return cards.length;
}
function enableDropByStageId(body, stageId) {
body.addEventListener("dragover", function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault(); body.classList.add("is-over");
});
body.addEventListener("dragleave", function () { body.classList.remove("is-over"); });
body.addEventListener("drop", async function (e) {
if (!e.dataTransfer.types.includes("text/plain")) return;
e.preventDefault();
body.classList.remove("is-over");
const taskId = parseInt(e.dataTransfer.getData("text/plain"), 10);
const t = tasks.find(function (x) { return x.id === taskId; });
if (!t) return;
if (t.stage_id === stageId) {
if (!manualOrderAllowed()) {
showToast("필터·정렬을 쓰는 중에는 카드 순서를 바꿀 수 없습니다. (정렬: 기본, 필터 초기화 후 가능)", "error");
return;
}
// 같은 세션 안에서 카드 위치만 이동 — 세션 이동이 아니라 정렬.
const currentOrder = tasks.filter(function (x) { return x.stage_id === stageId; });
const idx = cardDropIndex(body, e.clientY, taskId);
const withoutDragged = currentOrder.filter(function (x) { return x.id !== taskId; });
withoutDragged.splice(idx, 0, t);
const orderedIds = withoutDragged.map(function (x) { return x.id; });
const beforeIds = currentOrder.map(function (x) { return x.id; });
if (beforeIds.join(",") === orderedIds.join(",")) return; // 놓은 자리가 원래 자리와 같으면 아무것도 안 함
try {
await api("PUT", "/project/api/projects/" + projectId + "/stages/" + stageId + "/tasks/order",
{ ordered_ids: orderedIds });
applyStageOrder(stageId, orderedIds);
renderBoard();
} catch (err) { showToast("순서 변경 실패: " + err.message, "error"); }
return;
}
try {
if (t.project_id === projectId) {
const res = await api("PUT", "/project/api/tasks/" + taskId, { stage_id: stageId });
mergeTask(res.task);
} else {
await api("POST", "/project/api/tasks/" + taskId + "/links",
{ project_id: projectId, stage_id: stageId });
t.stage_id = stageId;
t.is_linked = true;
}
renderBoard();
} catch (err) { showToast("이동 실패: " + err.message, "error"); }
});
}
// ── 보드 카드에서 바로 고치는 담당자/마감일 ──
// 업무 팝업을 열지 않고 카드 위에서 끝낸다(아사나와 같은 조작감).
// 후보는 "그 업무가 속한 프로젝트"의 멤버다 — 전체 프로젝트 보기에서는
// 카드마다 프로젝트가 달라서 필요할 때 받아와 캐시한다.
const memberCacheByProject = {};
async function membersOfProject(pid) {
if (pid === projectId) return members;
if (memberCacheByProject[pid]) return memberCacheByProject[pid];
const res = await api("GET", "/project/api/projects/" + pid + "/members");
memberCacheByProject[pid] = res.members || [];
return memberCacheByProject[pid];
}
async function applyTaskPatch(t, patch, failMsg) {
try {
const res = await api("PUT", "/project/api/tasks/" + t.id, patch);
mergeTask(res.task);
refreshActiveView();
refreshMyOpenBadge();
} catch (e) { showToast(failMsg + ": " + e.message, "error"); }
}
async function openAssigneePicker(t, x, y) {
let list;
try { list = await membersOfProject(t.project_id); }
catch (e) { showToast("멤버 조회 실패: " + e.message, "error"); return; }
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 = ' ' +
'지우기 ';
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);
}
// ── 카드 하위 업무 펼치기(아사나처럼) — 카드의 "N ⤷ ▾" 버튼을 누르면 카드
// 아래로 하위 업무 목록이 늘어난다. 펼친 상태는 보드를 다시 그려도 유지
// (페이지에 머무는 동안). 목록은 처음 펼칠 때 받아 캐시하고, 업무 팝업이
// 닫히면(거기서 하위 업무를 고쳤을 수 있으니) 캐시를 비운다(아래 observer).
const expandedSubs = new Set();
const subsCache = {};
// 아사나의 하위 업무 아이콘(위 노드 하나에서 두 갈래로 뻗은 노드).
const SUBTASK_ICON_SVG =
'' +
' ' +
' ' +
' ' +
' ' +
' ' +
" ";
function cardSubRowHtml(sub) {
const overdue = sub.due_date && !sub.completed_at && sub.due_date < todayIso;
return '' +
'' +
'check_circle ' +
'' + escapeHtml(sub.title || "") + " " +
(sub.due_date
? '' + escapeHtml(fmtDateKr(sub.due_date)) + " "
: "") +
(sub.assignee_email
? '' + avatarHtml(sub.assignee_email, "pj-gicon-sm") + " "
: "") +
"
";
}
function fillCardSubs(box, t) {
const subs = subsCache[t.id];
if (!subs) {
box.innerHTML = '불러오는 중…
';
api("GET", "/project/api/tasks/" + t.id).then(function (res) {
// GET /api/tasks/{id} 응답은 {task: {..., subtasks: [...]}}.
const subs = (res && res.task && res.task.subtasks) || [];
subsCache[t.id] = subs;
// 카드 숫자가 옛 값이면(팝업에서 하위 업무를 추가·삭제) 맞춰서 다시 그린다.
const doneN = subs.filter(function (x) { return x.completed_at; }).length;
if (subs.length !== (t.subtask_total || 0) || doneN !== (t.subtask_done || 0)) {
t.subtask_total = subs.length;
t.subtask_done = doneN;
if (!subs.length) expandedSubs.delete(t.id);
renderBoard();
} else if (box.isConnected) fillCardSubs(box, t);
}).catch(function (e) {
box.innerHTML = '불러오기 실패: ' + escapeHtml(e.message) + "
";
});
return;
}
box.innerHTML = subs.length
? subs.map(cardSubRowHtml).join("")
: '하위 업무 없음
';
box.querySelectorAll(".pj-card-sub").forEach(function (row) {
const sub = subs.find(function (x) { return String(x.id) === row.dataset.subId; });
if (!sub) return;
const check = row.querySelector(".pj-card-sub-check");
check.addEventListener("click", async function (e) {
e.stopPropagation();
if (!canManage) return;
const done = !sub.completed_at;
try {
const res = await api("PUT", "/project/api/tasks/" + sub.id, { completed: done });
sub.completed_at = (res && res.task && res.task.completed_at) || (done ? todayIso : null);
t.subtask_done = Math.max(0, (t.subtask_done || 0) + (done ? 1 : -1));
renderBoard();
} catch (err) { showToast("변경 실패: " + err.message, "error"); }
});
});
}
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
? '● ' + escapeHtml(t.project_name) + "
"
: "") +
'' + escapeHtml(t.title) + "
" +
'' +
(t.priority && t.priority !== "normal"
? '' + (priorityLabels[t.priority] || t.priority) + " "
: "") +
// 담당자/마감일은 카드에서 바로 바꿀 수 있다(아래 클릭 핸들러).
// 값이 없어도 자리는 남겨 둔다 — 카드에 마우스를 올리면 흐리게
// 나타나서 눌러 지정할 수 있다(.is-empty).
'' +
avatarHtml(t.assignee_email, "pj-gicon-sm") +
escapeHtml(t.assignee_email ? idOf(t.assignee_email) : "담당자") + " " +
'' + (t.due_date ? escapeHtml(t.due_date) : "마감일") + " " +
// 하위 업무 — 아사나처럼 "개수 + 하위 업무 아이콘 + ▾", 누르면 카드 아래로 펼침.
(t.subtask_total
? '' +
'' + t.subtask_total + " " +
SUBTASK_ICON_SVG +
'arrow_drop_down ' +
" "
: "") +
(t.comment_count
? '' + cmtBadge(t) + " "
: "") +
"
" +
(t.subtask_total && expandedSubs.has(t.id) ? '
' : "");
const subsBox = card.querySelector(".pj-card-subs");
if (subsBox) fillCardSubs(subsBox, t);
card.addEventListener("click", function (e) {
// 하위 업무 펼치기/접기 — 보기 권한만 있어도 된다.
if (e.target.closest(".pj-card-subtoggle")) {
e.stopPropagation();
if (expandedSubs.has(t.id)) expandedSubs.delete(t.id);
else { expandedSubs.add(t.id); delete subsCache[t.id]; } // 펼칠 때마다 최신으로
renderBoard();
return;
}
if (e.target.closest(".pj-card-sub-check")) return;
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 =
'' + escapeHtml(col.label) +
' ' + arrow + " " +
' ';
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 = '' + avatarHtml(t.assignee_email, "pj-gicon-sm") + escapeHtml(idOf(t.assignee_email)) + " ";
}
return "" + inner + " ";
}).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 =
'' +
(isCollapsed ? "chevron_right" : "expand_more") + " " +
'' + escapeHtml(name) + " " +
'' + groupTasks.length + " ";
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 =
'
' +
'0
';
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 = "데이터가 없습니다.
";
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 =
'' + d.value + "
" +
'' +
'
';
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 = ' ';
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 = '' +
' ';
let offsetAcc = 0;
segments.forEach(function (s, i) {
const frac = total ? s.value / total : 0;
const len = frac * C;
svg += ' ';
offsetAcc += len;
});
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 = ' ';
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 = '미완료 작업 합계(섹션별)
';
sectionCard.appendChild(dashBarChart(sectionData));
charts.appendChild(sectionCard);
// 완료 상태별 — 2구간 도넛(완료=초록, 미완료=포인트 컬러).
const statusCard = document.createElement("div");
statusCard.className = "pj-dash-card";
statusCard.innerHTML = '작업 합계(완료 상태별)
';
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 = '예정된 작업 합계(담당자별)
';
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 '' +
avatarHtml(e, "pj-gicon-sm") + '' + escapeHtml(idOf(e)) + " " +
'× ';
}).join("") || '없음 ';
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 '' + escapeHtml(s.name) + " ";
}).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 = '없음 ' + emails.map(function (e) {
const name = idOf(e);
return '' + escapeHtml(name) + " ";
}).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 || "") : ""); }
// 새 업무는 그 세션의 기본 담당자를 미리 채운다(비워 저장해도 서버가
// 같은 사람을 배정하므로 화면에 미리 보여주는 것).
let presetAssignee = "";
if (!task) {
const sid = presetStageId != null ? presetStageId : (stages[0] ? stages[0].id : null);
const ps = stages.find(function (x) { return String(x.id) === String(sid); });
presetAssignee = (ps && ps.default_assignee_email) || "";
}
fillAssigneeSelect(task ? task.project_id : projectId, task ? (task.assignee_email || "") : presetAssignee);
fillStageSelect(task ? task.project_id : projectId);
// "세션" 선택칸은 원래 소속 프로젝트의 세션 목록이다. 다른 프로젝트에서
// 연결돼 온 행은 stage_id 가 연결된 쪽 세션이라 목록에 없다 — 그대로 넣으면
// 선택이 비고, 저장 시 원래 세션이 지워졌다. 그래서 home_stage_id 를 쓴다.
const homeStage = task
? (task.home_stage_id !== undefined ? task.home_stage_id : task.stage_id)
: null;
el("pj-t-stage").value = task ? (homeStage || "")
: (presetStageId != null ? presetStageId : (stages[0] ? stages[0].id : ""));
el("pj-t-priority").value = task ? (task.priority || "normal") : "normal";
el("pj-t-due").value = task ? (task.due_date || "") : "";
currentTaskData = task || null;
syncDueBtn(); // 완료 여부(지남 표시)를 보려면 currentTaskData 다음에
el("pj-delete-task").hidden = !task;
el("pj-toggle-complete").hidden = !task;
// 공유 링크는 저장된 업무에만 있다(새 업무는 아직 id 가 없다).
const shareBtn = el("pj-share-task");
if (shareBtn) shareBtn.hidden = !task;
if (task) setCompleteBtn(!!task.completed_at);
// 댓글·첨부·하위업무·연결·팔로워는 기존 업무 편집 시에만
currentTaskId = task ? task.id : null;
showFollowers(null, null); // 상세를 받으면(loadTaskExtras) 다시 그린다
el("pj-attach-block").hidden = !task;
el("pj-comment-block").hidden = !task;
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 = "불러오는 중… ";
try {
const res = await api("GET", "/project/api/tasks/" + taskId + "/attachments");
if (!res.attachments.length) { ul.innerHTML = "없음 "; return; }
ul.innerHTML = "";
res.attachments.forEach(function (a) {
const li = document.createElement("li");
li.className = "pj-attach-item";
li.innerHTML =
'' + escapeHtml(a.filename) + " " +
'' + fmtSize(a.size_bytes) + " " +
(canManage ? '× ' : "");
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 = "불러오기 실패 "; }
}
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 = "불러오는 중… ";
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 = "댓글 없음 "; 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") +
'' +
'";
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 = "불러오기 실패 "; }
}
// 댓글 인라인 수정 — 본문을 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 = '' +
'✎ ' +
'× ' +
" ";
}
const initial = escapeHtml((p.name || "?").trim().charAt(0).toUpperCase() || "?");
// 드래그로 순서 변경 가능함을 알려주는 손잡이(⣿) — 관리자에게만 보인다.
const handle = isAdmin ? '⣿ ' : "";
return ' ";
}
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) {
// 는 기본 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 = "완료 프로젝트 ";
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 '' +
(url
? ' '
: 'account_circle ') +
" ";
}
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();
// 멤버 업무 팝업 — 공용 구현(initMemberTasks, 위쪽 정의). 이 화면에선
// 더블클릭하면 그 자리에서 업무 편집 팝업을 열고, 닫히면 멤버 팝업을 다시 연다.
const openMemberTasksModal = initMemberTasks({ openTask: openTaskModal, taskModal: taskModal });
// 업무 팝업이 닫히면 카드에 펼쳐 둔 하위 업무 캐시를 비운다(팝업에서 하위
// 업무를 추가·수정했을 수 있다). 다음에 보드를 그릴 때 다시 받는다.
if (taskModal) {
new MutationObserver(function () {
if (!taskModal.hidden) return;
Object.keys(subsCache).forEach(function (k) { delete subsCache[k]; });
if (expandedSubs.size && currentView === "board") renderBoard();
}).observe(taskModal, { attributes: true, attributeFilter: ["hidden"] });
}
const addMemberBtn = el("pj-add-member");
if (addMemberBtn) addMemberBtn.addEventListener("click", async function () {
const box = el("pj-m-users");
openModal(memberModal);
box.innerHTML = "불러오는 중…";
try {
const res = await api("GET", "/project/api/assignable-users");
const existing = new Set(members.map(function (m) { return m.user_email; }));
const candidates = res.users.filter(function (u) { return !existing.has(u.email); });
box.innerHTML = candidates.length
? candidates.map(memberPickHtml).join("")
: "배정 가능한 직원이 없습니다(권한 미부여 또는 전원 배정됨) ";
} catch (e) {
box.innerHTML = "불러오기 실패: " + escapeHtml(e.message) + " ";
}
});
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 =
'× ' +
' ';
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 안의 는 브라우저가 기본으로 열지 않는다 — 직접 연다.
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(' ');
} 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;
}
}
// 이미지가 아니면 서식 없는 텍스트로만 붙여넣기(외부 사이트 서식 유입 방지).
// 단, 웹페이지 주소는 자동으로 링크( )로 바꾼다.
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 '' + escapeHtml(idOf(m.user_email)) + " ";
}).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 =
' " +
' ' +
'(미지정) ' + optionsHtml + " " +
' ' +
'× ';
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 ? "" : "없음 ";
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 = "(미지정) " + 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 =
'● ' +
escapeHtml(link.project_name || "") +
(link.stage_name ? " · " + escapeHtml(link.stage_name) : "") +
' × ';
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 ? "" : "없음 ";
links.forEach(function (l) { chipsEl.appendChild(chipEl(l)); });
}
async function loadProjects() {
projSel.innerHTML = "불러오는 중… ";
stageSel.innerHTML = "프로젝트를 먼저 선택하세요 ";
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 = "프로젝트 선택… " + list.map(function (p) {
return '' + escapeHtml(p.name) + " ";
}).join("");
} catch (e) { projSel.innerHTML = "불러오기 실패 "; }
}
if (projSel) projSel.addEventListener("change", async function () {
const pid = parseInt(projSel.value, 10);
if (!pid) { stageSel.innerHTML = "프로젝트를 먼저 선택하세요 "; return; }
stageSel.innerHTML = "불러오는 중… ";
try {
const res = await api("GET", "/project/api/projects/" + pid + "/stages");
stageSel.innerHTML = (res.stages || []).map(function (s) {
return '' + escapeHtml(s.name) + " ";
}).join("");
} catch (e) { stageSel.innerHTML = "불러오기 실패 "; }
});
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 = "프로젝트를 먼저 선택하세요 ";
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 |
// 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(/ /g, " ").replace(/</g, "<").replace(/>/g, ">").replace(/&/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)) + "" + escapeHtml(s.slice(i, i + q.length)) + " " + 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 = '"' + escapeHtml(q) + '" 검색 결과가 없습니다.
';
show();
return;
}
box.innerHTML = items.map(function (r, i) {
return '' +
'
' +
(r.completed ? 'check_circle ' : "") +
(r.parent_title ? '' + escapeHtml(r.parent_title) + " › " : "") +
highlight(r.title, q) + "
" +
'
● ' +
escapeHtml(r.project_name) +
(r.assignee_email ? " · " + escapeHtml(idOf(r.assignee_email)) : "") +
(r.due_date ? " · 마감 " + escapeHtml(fmtDateKr(r.due_date)) : "") + "
" +
(r.snippet && r.match !== "title"
? '
' + MATCH_LABEL[r.match] + " " + highlight(r.snippet, q) + "
"
: "") +
"
";
}).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 = '검색 실패: ' + escapeHtml(e.message) + "
"; 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, "&").replace(//g, ">")
.replace(/"/g, """).replace(/'/g, "'");
}
// ── 알림 벨 (미읽음 배지) ──
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 = '';
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();
initAllMembers();
initBell();
initMentionBadge();
initInbox();
initMentionInbox();
initLiveRefresh();
initGlobalSearch();
initScrollIndicators();
initHoverTips();
});
})();