497 lines
14 KiB
JavaScript
497 lines
14 KiB
JavaScript
const express = require("express");
|
|
const db = require("../db/models");
|
|
const wrapAsync = require("../helpers").wrapAsync;
|
|
const { LocalAIApi } = require("../ai/LocalAIApi");
|
|
|
|
const router = express.Router();
|
|
|
|
function isClientUser(req) {
|
|
return req.currentUser?.app_role?.name === "Client";
|
|
}
|
|
|
|
function portalClientIncludes() {
|
|
return [
|
|
{ model: db.sessions, as: "sessions", where: { status: "shared" }, required: false, order: [["session_at", "DESC"]] },
|
|
{ model: db.action_items, as: "action_items", order: [["due_at", "ASC"]] },
|
|
{ model: db.resources, as: "resources", where: { is_shared: true }, required: false },
|
|
{ model: db.prep_briefs, as: "prep_briefs", order: [["updatedAt", "DESC"]] },
|
|
];
|
|
}
|
|
|
|
function splitActionItems(value) {
|
|
return String(value || "")
|
|
.split(/\n|;/)
|
|
.map((item) => item.replace(/^[-*]\s*/, "").trim())
|
|
.filter(Boolean)
|
|
.slice(0, 8);
|
|
}
|
|
|
|
router.get(
|
|
"/summary",
|
|
wrapAsync(async (req, res) => {
|
|
const [clients, sessions, actionItems, resources, prepBriefs] = await Promise.all([
|
|
db.clients.count(),
|
|
db.sessions.count(),
|
|
db.action_items.count({ where: { status: ["not_started", "in_progress"] } }),
|
|
db.resources.count({ where: { is_shared: true } }),
|
|
db.prep_briefs.count({ where: { status: "ready" } }),
|
|
]);
|
|
|
|
const nextSessions = await db.sessions.findAll({
|
|
limit: 4,
|
|
order: [["session_at", "DESC"]],
|
|
include: [{ model: db.clients, as: "client" }],
|
|
});
|
|
|
|
const activeClients = await db.clients.findAll({
|
|
limit: 4,
|
|
order: [["next_session_at", "ASC"]],
|
|
include: [{ model: db.packages, as: "package" }],
|
|
});
|
|
|
|
res.status(200).send({
|
|
counts: {
|
|
clients,
|
|
sessions,
|
|
actionItems,
|
|
resources,
|
|
prepBriefs,
|
|
},
|
|
nextSessions,
|
|
activeClients,
|
|
});
|
|
}),
|
|
);
|
|
|
|
router.get(
|
|
"/clients",
|
|
wrapAsync(async (req, res) => {
|
|
const clients = await db.clients.findAll({
|
|
order: [["next_session_at", "ASC"]],
|
|
include: [
|
|
{ model: db.packages, as: "package" },
|
|
{ model: db.sessions, as: "sessions", limit: 2, order: [["session_at", "DESC"]] },
|
|
{ model: db.action_items, as: "action_items", limit: 3, order: [["due_at", "ASC"]] },
|
|
{ model: db.prep_briefs, as: "prep_briefs", limit: 2, order: [["updatedAt", "DESC"]] },
|
|
],
|
|
});
|
|
|
|
res.status(200).send(clients);
|
|
}),
|
|
);
|
|
|
|
router.get(
|
|
"/clients/:id",
|
|
wrapAsync(async (req, res) => {
|
|
const client = await db.clients.findByPk(req.params.id, {
|
|
include: [
|
|
{ model: db.packages, as: "package" },
|
|
{ model: db.sessions, as: "sessions", order: [["session_at", "DESC"]] },
|
|
{ model: db.action_items, as: "action_items", order: [["due_at", "ASC"]] },
|
|
{ model: db.resources, as: "resources" },
|
|
{ model: db.prep_briefs, as: "prep_briefs", order: [["next_session_at", "DESC"]] },
|
|
],
|
|
});
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
res.status(200).send(client);
|
|
}),
|
|
);
|
|
|
|
router.get(
|
|
"/session-memory",
|
|
wrapAsync(async (req, res) => {
|
|
const sessions = await db.sessions.findAll({
|
|
limit: 20,
|
|
order: [["session_at", "DESC"]],
|
|
include: [{ model: db.clients, as: "client" }],
|
|
});
|
|
|
|
res.status(200).send(sessions);
|
|
}),
|
|
);
|
|
|
|
router.post(
|
|
"/sessions",
|
|
wrapAsync(async (req, res) => {
|
|
const data = req.body.data || req.body;
|
|
const session = await db.sessions.create({
|
|
clientId: data.clientId,
|
|
title: data.title,
|
|
session_at: data.session_at || new Date(),
|
|
status: data.status || "completed",
|
|
transcript_notes: data.transcript_notes,
|
|
ai_summary: data.ai_summary,
|
|
key_topics: data.key_topics,
|
|
goals_discussed: data.goals_discussed,
|
|
blockers: data.blockers,
|
|
commitments: data.commitments,
|
|
homework: data.homework,
|
|
emotional_themes: data.emotional_themes,
|
|
important_quotes: data.important_quotes,
|
|
follow_up_email: data.follow_up_email,
|
|
next_session_prep: data.next_session_prep,
|
|
private_coach_notes: data.private_coach_notes,
|
|
shared_client_notes: data.shared_client_notes,
|
|
createdById: req.currentUser.id,
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
|
|
res.status(200).send(session);
|
|
}),
|
|
);
|
|
|
|
router.post(
|
|
"/session-memory/save",
|
|
wrapAsync(async (req, res) => {
|
|
const data = req.body.data || req.body;
|
|
|
|
if (!data.clientId) {
|
|
res.status(400).send({ error: "client_id_required" });
|
|
return;
|
|
}
|
|
|
|
const client = await db.clients.findByPk(data.clientId);
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
const status = data.shareWithClient ? "shared" : "draft_review";
|
|
const session = await db.sessions.create({
|
|
clientId: data.clientId,
|
|
title: data.title,
|
|
session_at: data.session_at || new Date(),
|
|
status,
|
|
transcript_notes: data.transcript_notes,
|
|
ai_summary: data.ai_summary,
|
|
key_topics: data.key_topics,
|
|
goals_discussed: data.goals_discussed,
|
|
blockers: data.blockers,
|
|
commitments: data.commitments,
|
|
homework: data.homework,
|
|
emotional_themes: data.emotional_themes,
|
|
important_quotes: data.important_quotes,
|
|
follow_up_email: data.follow_up_email,
|
|
next_session_prep: data.next_session_prep,
|
|
private_coach_notes: data.private_coach_notes,
|
|
shared_client_notes: data.shared_client_notes,
|
|
createdById: req.currentUser.id,
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
|
|
const actionTitles = splitActionItems(data.commitments || data.homework);
|
|
|
|
for (const title of actionTitles) {
|
|
await db.action_items.create({
|
|
clientId: data.clientId,
|
|
sessionId: session.id,
|
|
title,
|
|
status: "not_started",
|
|
createdById: req.currentUser.id,
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
}
|
|
|
|
await db.prep_briefs.create({
|
|
clientId: data.clientId,
|
|
sessionId: session.id,
|
|
next_session_at: client.next_session_at,
|
|
previous_summary: data.ai_summary,
|
|
open_commitments: actionTitles.join("; "),
|
|
suggested_questions: data.next_session_prep,
|
|
sensitive_topics: data.blockers,
|
|
status: "ready",
|
|
createdById: req.currentUser.id,
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
|
|
const savedSession = await db.sessions.findByPk(session.id, {
|
|
include: [
|
|
{ model: db.clients, as: "client" },
|
|
{ model: db.action_items, as: "action_items", order: [["createdAt", "ASC"]] },
|
|
],
|
|
});
|
|
|
|
res.status(200).send(savedSession);
|
|
}),
|
|
);
|
|
|
|
router.patch(
|
|
"/sessions/:id/share",
|
|
wrapAsync(async (req, res) => {
|
|
const session = await db.sessions.findByPk(req.params.id);
|
|
|
|
if (!session) {
|
|
res.status(404).send({ error: "session_not_found" });
|
|
return;
|
|
}
|
|
|
|
await session.update({
|
|
shared_client_notes: req.body.shared_client_notes || session.shared_client_notes,
|
|
status: "shared",
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
|
|
const savedSession = await db.sessions.findByPk(session.id, {
|
|
include: [{ model: db.clients, as: "client" }],
|
|
});
|
|
|
|
res.status(200).send(savedSession);
|
|
}),
|
|
);
|
|
|
|
router.post(
|
|
"/session-memory/generate",
|
|
wrapAsync(async (req, res) => {
|
|
const { clientId, sessionId, transcript } = req.body;
|
|
|
|
if (!clientId) {
|
|
res.status(400).send({ error: "client_id_required" });
|
|
return;
|
|
}
|
|
|
|
if (!transcript || !String(transcript).trim()) {
|
|
res.status(400).send({ error: "transcript_required" });
|
|
return;
|
|
}
|
|
|
|
const client = await db.clients.findByPk(clientId, {
|
|
include: [
|
|
{ model: db.sessions, as: "sessions", limit: 5, order: [["session_at", "DESC"]] },
|
|
{ model: db.action_items, as: "action_items", limit: 10, order: [["due_at", "ASC"]] },
|
|
],
|
|
});
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
const response = await LocalAIApi.createResponse(
|
|
{
|
|
input: [
|
|
{
|
|
role: "system",
|
|
content: [
|
|
{
|
|
type: "input_text",
|
|
text: [
|
|
"You are a coaching operations assistant.",
|
|
"Extract structured session memory for a professional coaching workspace.",
|
|
"Return strict JSON only with these string fields:",
|
|
"title, ai_summary, key_topics, goals_discussed, blockers, commitments, homework, emotional_themes, important_quotes, follow_up_email, next_session_prep, private_coach_notes, shared_client_notes.",
|
|
].join(" "),
|
|
},
|
|
],
|
|
},
|
|
{
|
|
role: "user",
|
|
content: [
|
|
{
|
|
type: "input_text",
|
|
text: JSON.stringify({
|
|
client: {
|
|
name: client.name,
|
|
company: client.company,
|
|
role_title: client.role_title,
|
|
goals: client.goals,
|
|
notes: client.notes,
|
|
},
|
|
recent_sessions: client.sessions || [],
|
|
open_action_items: client.action_items || [],
|
|
transcript,
|
|
}),
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{ poll_timeout: 180, poll_interval: 3 },
|
|
);
|
|
|
|
if (!response.success) {
|
|
res.status(502).send(response);
|
|
return;
|
|
}
|
|
|
|
const memory = LocalAIApi.decodeJsonFromResponse(response);
|
|
|
|
if (sessionId) {
|
|
await db.sessions.update(
|
|
{
|
|
title: memory.title,
|
|
ai_summary: memory.ai_summary,
|
|
key_topics: memory.key_topics,
|
|
goals_discussed: memory.goals_discussed,
|
|
blockers: memory.blockers,
|
|
commitments: memory.commitments,
|
|
homework: memory.homework,
|
|
emotional_themes: memory.emotional_themes,
|
|
important_quotes: memory.important_quotes,
|
|
follow_up_email: memory.follow_up_email,
|
|
next_session_prep: memory.next_session_prep,
|
|
private_coach_notes: memory.private_coach_notes,
|
|
shared_client_notes: memory.shared_client_notes,
|
|
updatedById: req.currentUser.id,
|
|
},
|
|
{ where: { id: sessionId } },
|
|
);
|
|
}
|
|
|
|
res.status(200).send(memory);
|
|
}),
|
|
);
|
|
|
|
router.get(
|
|
"/client-portal/me",
|
|
wrapAsync(async (req, res) => {
|
|
if (!isClientUser(req)) {
|
|
res.status(403).send({ error: "client_role_required" });
|
|
return;
|
|
}
|
|
|
|
const client = await db.clients.findOne({
|
|
where: { email: req.currentUser.email },
|
|
include: portalClientIncludes(),
|
|
});
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
res.status(200).send(client);
|
|
}),
|
|
);
|
|
|
|
router.get(
|
|
"/client-portal/:clientId",
|
|
wrapAsync(async (req, res) => {
|
|
let client;
|
|
|
|
if (isClientUser(req)) {
|
|
client = await db.clients.findOne({
|
|
where: { id: req.params.clientId, email: req.currentUser.email },
|
|
include: portalClientIncludes(),
|
|
});
|
|
} else {
|
|
client = await db.clients.findByPk(req.params.clientId, {
|
|
include: portalClientIncludes(),
|
|
});
|
|
}
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
res.status(200).send(client);
|
|
}),
|
|
);
|
|
|
|
router.patch(
|
|
"/client-portal/action-items/:id",
|
|
wrapAsync(async (req, res) => {
|
|
const allowedStatuses = ["not_started", "in_progress", "done"];
|
|
const { status } = req.body;
|
|
|
|
if (!allowedStatuses.includes(status)) {
|
|
res.status(400).send({ error: "invalid_status" });
|
|
return;
|
|
}
|
|
|
|
const actionItem = await db.action_items.findByPk(req.params.id, {
|
|
include: [{ model: db.clients, as: "client" }],
|
|
});
|
|
|
|
if (!actionItem) {
|
|
res.status(404).send({ error: "action_item_not_found" });
|
|
return;
|
|
}
|
|
|
|
if (isClientUser(req) && actionItem.client?.email !== req.currentUser.email) {
|
|
res.status(404).send({ error: "action_item_not_found" });
|
|
return;
|
|
}
|
|
|
|
await actionItem.update({
|
|
status,
|
|
updatedById: req.currentUser.id,
|
|
});
|
|
|
|
res.status(200).send(actionItem);
|
|
}),
|
|
);
|
|
|
|
router.post(
|
|
"/client-portal/reflection",
|
|
wrapAsync(async (req, res) => {
|
|
const reflection = String(req.body.reflection || "").trim();
|
|
|
|
if (!reflection) {
|
|
res.status(400).send({ error: "reflection_required" });
|
|
return;
|
|
}
|
|
|
|
let client;
|
|
|
|
if (isClientUser(req)) {
|
|
client = await db.clients.findOne({ where: { email: req.currentUser.email } });
|
|
} else {
|
|
client = await db.clients.findByPk(req.body.clientId);
|
|
}
|
|
|
|
if (!client) {
|
|
res.status(404).send({ error: "client_not_found" });
|
|
return;
|
|
}
|
|
|
|
const latestSession = await db.sessions.findOne({
|
|
where: { clientId: client.id },
|
|
order: [["session_at", "DESC"]],
|
|
});
|
|
const openActionItems = await db.action_items.findAll({
|
|
where: { clientId: client.id, status: ["not_started", "in_progress"] },
|
|
order: [["due_at", "ASC"]],
|
|
});
|
|
const existingBrief = await db.prep_briefs.findOne({
|
|
where: { clientId: client.id },
|
|
order: [["updatedAt", "DESC"]],
|
|
});
|
|
const openCommitments = openActionItems.map((item) => item.title).join("; ");
|
|
|
|
const data = {
|
|
clientId: client.id,
|
|
sessionId: latestSession?.id,
|
|
next_session_at: client.next_session_at,
|
|
previous_summary: latestSession?.ai_summary,
|
|
open_commitments: openCommitments,
|
|
client_reflection: reflection,
|
|
client_reflection_at: new Date(),
|
|
status: "ready",
|
|
updatedById: req.currentUser.id,
|
|
};
|
|
|
|
let prepBrief;
|
|
|
|
if (existingBrief) {
|
|
prepBrief = await existingBrief.update(data);
|
|
} else {
|
|
prepBrief = await db.prep_briefs.create({
|
|
...data,
|
|
createdById: req.currentUser.id,
|
|
});
|
|
}
|
|
|
|
res.status(200).send(prepBrief);
|
|
}),
|
|
);
|
|
|
|
module.exports = router;
|