Power BI Dev
521 lines
19 KiB
JavaScript
521 lines
19 KiB
JavaScript
import { prisma } from '../prisma.js';
|
|
export class KanbanService {
|
|
/**
|
|
* Create a new column in a board.
|
|
*/
|
|
static async createColumn(boardId, title, maxWipLimit = 0, autoStaleHours = 0) {
|
|
const lastCol = await prisma.column.findFirst({
|
|
where: { boardId },
|
|
orderBy: { order: 'desc' },
|
|
});
|
|
const nextOrder = lastCol ? lastCol.order + 1 : 0;
|
|
const col = await prisma.column.create({
|
|
data: {
|
|
boardId,
|
|
title: title.trim() || 'New Column',
|
|
order: nextOrder,
|
|
maxWipLimit: Math.max(0, maxWipLimit),
|
|
autoStaleHours: Math.max(0, autoStaleHours),
|
|
},
|
|
});
|
|
// Touch board updatedAt
|
|
await prisma.board.update({
|
|
where: { id: boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
return {
|
|
id: col.id,
|
|
boardId: col.boardId,
|
|
title: col.title,
|
|
order: col.order,
|
|
maxWipLimit: col.maxWipLimit,
|
|
autoStaleHours: col.autoStaleHours,
|
|
tickets: [],
|
|
createdAt: col.createdAt.toISOString(),
|
|
updatedAt: col.updatedAt.toISOString(),
|
|
};
|
|
}
|
|
/**
|
|
* Update a column (title, maxWipLimit, autoStaleHours).
|
|
*/
|
|
static async updateColumn(columnId, updates) {
|
|
const data = {};
|
|
if (updates.title !== undefined)
|
|
data.title = updates.title.trim();
|
|
if (updates.maxWipLimit !== undefined)
|
|
data.maxWipLimit = Math.max(0, updates.maxWipLimit);
|
|
if (updates.autoStaleHours !== undefined)
|
|
data.autoStaleHours = Math.max(0, updates.autoStaleHours);
|
|
const col = await prisma.column.update({
|
|
where: { id: columnId },
|
|
data,
|
|
include: {
|
|
tickets: {
|
|
orderBy: { order: 'asc' },
|
|
},
|
|
},
|
|
});
|
|
await prisma.board.update({
|
|
where: { id: col.boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
return {
|
|
id: col.id,
|
|
boardId: col.boardId,
|
|
title: col.title,
|
|
order: col.order,
|
|
maxWipLimit: col.maxWipLimit,
|
|
autoStaleHours: col.autoStaleHours,
|
|
tickets: col.tickets.map((t) => ({
|
|
id: t.id,
|
|
columnId: t.columnId,
|
|
title: t.title,
|
|
description: t.description,
|
|
order: t.order,
|
|
priority: t.priority,
|
|
tags: JSON.parse(t.tags || '[]'),
|
|
subtasks: JSON.parse(t.subtasks || '[]'),
|
|
dueDate: t.dueDate,
|
|
isBlocked: t.isBlocked,
|
|
blockedReason: t.blockedReason,
|
|
assignee: t.assignee,
|
|
movedAt: t.movedAt.toISOString(),
|
|
createdAt: t.createdAt.toISOString(),
|
|
updatedAt: t.updatedAt.toISOString(),
|
|
})),
|
|
createdAt: col.createdAt.toISOString(),
|
|
updatedAt: col.updatedAt.toISOString(),
|
|
};
|
|
}
|
|
/**
|
|
* Delete a column and its tickets.
|
|
*/
|
|
static async deleteColumn(columnId) {
|
|
const col = await prisma.column.delete({
|
|
where: { id: columnId },
|
|
});
|
|
await prisma.board.update({
|
|
where: { id: col.boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
return col.boardId;
|
|
}
|
|
/**
|
|
* Create a new ticket in a column and record activity log.
|
|
*/
|
|
static async createTicket(columnId, title, description = '', priority = 'MEDIUM', tags = [], assignee = '', dueDate = '', subtasks = [], isBlocked = false, blockedReason = '', userName) {
|
|
const lastTicket = await prisma.ticket.findFirst({
|
|
where: { columnId },
|
|
orderBy: { order: 'desc' },
|
|
});
|
|
const nextOrder = lastTicket ? lastTicket.order + 1 : 0;
|
|
const ticket = await prisma.ticket.create({
|
|
data: {
|
|
columnId,
|
|
title: title.trim() || 'New Task',
|
|
description: description || '',
|
|
order: nextOrder,
|
|
priority,
|
|
tags: JSON.stringify(tags),
|
|
subtasks: JSON.stringify(subtasks),
|
|
dueDate: dueDate || null,
|
|
isBlocked: isBlocked || false,
|
|
blockedReason: blockedReason || null,
|
|
assignee: assignee || null,
|
|
movedAt: new Date(),
|
|
},
|
|
include: {
|
|
column: true,
|
|
},
|
|
});
|
|
// Create activity log in DB
|
|
let activityPayload;
|
|
try {
|
|
const act = await prisma.activityLog.create({
|
|
data: {
|
|
boardId: ticket.column.boardId,
|
|
ticketId: ticket.id,
|
|
ticketTitle: ticket.title,
|
|
action: 'CREATED',
|
|
toColumnTitle: ticket.column.title,
|
|
userName: userName || 'User',
|
|
details: `Tugas "${ticket.title}" dibuat di kolom "${ticket.column.title}"`,
|
|
},
|
|
});
|
|
activityPayload = {
|
|
id: act.id,
|
|
boardId: act.boardId,
|
|
ticketId: act.ticketId,
|
|
ticketTitle: act.ticketTitle,
|
|
action: act.action,
|
|
fromColumnTitle: act.fromColumnTitle,
|
|
toColumnTitle: act.toColumnTitle,
|
|
userName: act.userName,
|
|
details: act.details,
|
|
createdAt: act.createdAt.toISOString(),
|
|
};
|
|
}
|
|
catch (err) {
|
|
console.error('Failed to log ticket creation activity:', err);
|
|
}
|
|
// Touch board updatedAt
|
|
await prisma.board.update({
|
|
where: { id: ticket.column.boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
return {
|
|
ticket: {
|
|
id: ticket.id,
|
|
columnId: ticket.columnId,
|
|
title: ticket.title,
|
|
description: ticket.description,
|
|
order: ticket.order,
|
|
priority: ticket.priority,
|
|
tags,
|
|
subtasks,
|
|
dueDate: ticket.dueDate,
|
|
isBlocked: ticket.isBlocked,
|
|
blockedReason: ticket.blockedReason,
|
|
assignee: ticket.assignee,
|
|
movedAt: ticket.movedAt.toISOString(),
|
|
createdAt: ticket.createdAt.toISOString(),
|
|
updatedAt: ticket.updatedAt.toISOString(),
|
|
},
|
|
activity: activityPayload,
|
|
};
|
|
}
|
|
/**
|
|
* Update ticket fields.
|
|
*/
|
|
static async updateTicket(ticketId, updates, userName) {
|
|
const data = {};
|
|
if (updates.title !== undefined)
|
|
data.title = updates.title;
|
|
if (updates.description !== undefined)
|
|
data.description = updates.description;
|
|
if (updates.priority !== undefined)
|
|
data.priority = updates.priority;
|
|
if (updates.tags !== undefined)
|
|
data.tags = JSON.stringify(updates.tags);
|
|
if (updates.subtasks !== undefined)
|
|
data.subtasks = JSON.stringify(updates.subtasks);
|
|
if (updates.dueDate !== undefined)
|
|
data.dueDate = updates.dueDate;
|
|
if (updates.isBlocked !== undefined)
|
|
data.isBlocked = updates.isBlocked;
|
|
if (updates.blockedReason !== undefined)
|
|
data.blockedReason = updates.blockedReason;
|
|
if (updates.assignee !== undefined)
|
|
data.assignee = updates.assignee;
|
|
const existingTicket = await prisma.ticket.findUnique({
|
|
where: { id: ticketId },
|
|
include: { column: true },
|
|
});
|
|
if (!existingTicket)
|
|
throw new Error('Ticket not found');
|
|
const ticket = await prisma.ticket.update({
|
|
where: { id: ticketId },
|
|
data,
|
|
include: { column: true },
|
|
});
|
|
// Touch board updatedAt
|
|
await prisma.board.update({
|
|
where: { id: ticket.column.boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
let activityPayload;
|
|
if (updates.isBlocked !== undefined && updates.isBlocked !== existingTicket.isBlocked) {
|
|
try {
|
|
const act = await prisma.activityLog.create({
|
|
data: {
|
|
boardId: ticket.column.boardId,
|
|
ticketId: ticket.id,
|
|
ticketTitle: ticket.title,
|
|
action: updates.isBlocked ? 'BLOCKED' : 'UNBLOCKED',
|
|
toColumnTitle: ticket.column.title,
|
|
userName: userName || 'User',
|
|
details: updates.isBlocked
|
|
? `Status tugas ditandai MACET / BLOCKED (${updates.blockedReason || 'Tanpa keterangan'})`
|
|
: 'Status macet diatasi (Unblocked)',
|
|
},
|
|
});
|
|
activityPayload = {
|
|
id: act.id,
|
|
boardId: act.boardId,
|
|
ticketId: act.ticketId,
|
|
ticketTitle: act.ticketTitle,
|
|
action: act.action,
|
|
fromColumnTitle: act.fromColumnTitle,
|
|
toColumnTitle: act.toColumnTitle,
|
|
userName: act.userName,
|
|
details: act.details,
|
|
createdAt: act.createdAt.toISOString(),
|
|
};
|
|
}
|
|
catch (err) {
|
|
console.error('Failed to log blocked status activity:', err);
|
|
}
|
|
}
|
|
let parsedTags = [];
|
|
let parsedSubtasks = [];
|
|
try {
|
|
parsedTags = JSON.parse(ticket.tags || '[]');
|
|
}
|
|
catch {
|
|
parsedTags = [];
|
|
}
|
|
try {
|
|
parsedSubtasks = JSON.parse(ticket.subtasks || '[]');
|
|
}
|
|
catch {
|
|
parsedSubtasks = [];
|
|
}
|
|
return {
|
|
ticket: {
|
|
id: ticket.id,
|
|
columnId: ticket.columnId,
|
|
title: ticket.title,
|
|
description: ticket.description,
|
|
order: ticket.order,
|
|
priority: ticket.priority,
|
|
tags: parsedTags,
|
|
subtasks: parsedSubtasks,
|
|
dueDate: ticket.dueDate,
|
|
isBlocked: ticket.isBlocked,
|
|
blockedReason: ticket.blockedReason,
|
|
assignee: ticket.assignee,
|
|
movedAt: ticket.movedAt.toISOString(),
|
|
createdAt: ticket.createdAt.toISOString(),
|
|
updatedAt: ticket.updatedAt.toISOString(),
|
|
},
|
|
activity: activityPayload,
|
|
};
|
|
}
|
|
/**
|
|
* Delete a ticket.
|
|
*/
|
|
static async deleteTicket(ticketId, userName) {
|
|
const ticket = await prisma.ticket.findUnique({
|
|
where: { id: ticketId },
|
|
include: { column: true },
|
|
});
|
|
if (!ticket)
|
|
throw new Error('Ticket not found');
|
|
const boardId = ticket.column.boardId;
|
|
let activityPayload;
|
|
try {
|
|
const act = await prisma.activityLog.create({
|
|
data: {
|
|
boardId,
|
|
ticketId: ticket.id,
|
|
ticketTitle: ticket.title,
|
|
action: 'DELETED',
|
|
fromColumnTitle: ticket.column.title,
|
|
userName: userName || 'User',
|
|
details: `Tugas "${ticket.title}" dihapus dari kolom "${ticket.column.title}"`,
|
|
},
|
|
});
|
|
activityPayload = {
|
|
id: act.id,
|
|
boardId: act.boardId,
|
|
ticketId: act.ticketId,
|
|
ticketTitle: act.ticketTitle,
|
|
action: act.action,
|
|
fromColumnTitle: act.fromColumnTitle,
|
|
toColumnTitle: act.toColumnTitle,
|
|
userName: act.userName,
|
|
details: act.details,
|
|
createdAt: act.createdAt.toISOString(),
|
|
};
|
|
}
|
|
catch (err) {
|
|
console.error('Failed to log delete activity:', err);
|
|
}
|
|
await prisma.ticket.delete({
|
|
where: { id: ticketId },
|
|
});
|
|
await prisma.board.update({
|
|
where: { id: boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
return { boardId, activity: activityPayload };
|
|
}
|
|
/**
|
|
* Move ticket: changes column and/or reorders within a column.
|
|
* Updates orders in batch transaction, resets movedAt timestamp, and records movement log in DB.
|
|
*/
|
|
static async moveTicket(ticketId, targetColumnId, newOrder, ticketIdsInTargetColumn, movedBy) {
|
|
const ticket = await prisma.ticket.findUnique({
|
|
where: { id: ticketId },
|
|
include: { column: true },
|
|
});
|
|
if (!ticket)
|
|
throw new Error('Ticket not found');
|
|
const sourceBoardId = ticket.column.boardId;
|
|
const isChangingColumn = ticket.columnId !== targetColumnId;
|
|
let targetColumn = ticket.column;
|
|
if (isChangingColumn) {
|
|
const foundTarget = await prisma.column.findUnique({
|
|
where: { id: targetColumnId },
|
|
});
|
|
if (foundTarget)
|
|
targetColumn = foundTarget;
|
|
}
|
|
let createdActivity = null;
|
|
await prisma.$transaction(async (tx) => {
|
|
// 1. Move target ticket to new column and update movedAt timestamp if changing column
|
|
await tx.ticket.update({
|
|
where: { id: ticketId },
|
|
data: {
|
|
columnId: targetColumnId,
|
|
order: newOrder,
|
|
movedAt: isChangingColumn ? new Date() : ticket.movedAt,
|
|
},
|
|
});
|
|
// 2. Re-assign sequential orders to all tickets in target column
|
|
if (ticketIdsInTargetColumn && ticketIdsInTargetColumn.length > 0) {
|
|
for (let i = 0; i < ticketIdsInTargetColumn.length; i++) {
|
|
const id = ticketIdsInTargetColumn[i];
|
|
await tx.ticket.update({
|
|
where: { id },
|
|
data: {
|
|
columnId: targetColumnId,
|
|
order: i,
|
|
},
|
|
});
|
|
}
|
|
}
|
|
// 3. Save Movement Log to DB if column changed
|
|
if (isChangingColumn) {
|
|
const act = await tx.activityLog.create({
|
|
data: {
|
|
boardId: sourceBoardId,
|
|
ticketId: ticket.id,
|
|
ticketTitle: ticket.title,
|
|
action: 'MOVED',
|
|
fromColumnTitle: ticket.column.title,
|
|
toColumnTitle: targetColumn.title,
|
|
userName: movedBy || 'User',
|
|
details: `Dipindahkan dari "${ticket.column.title}" ke "${targetColumn.title}"`,
|
|
},
|
|
});
|
|
createdActivity = {
|
|
id: act.id,
|
|
boardId: act.boardId,
|
|
ticketId: act.ticketId,
|
|
ticketTitle: act.ticketTitle,
|
|
action: act.action,
|
|
fromColumnTitle: act.fromColumnTitle,
|
|
toColumnTitle: act.toColumnTitle,
|
|
userName: act.userName,
|
|
details: act.details,
|
|
createdAt: act.createdAt.toISOString(),
|
|
};
|
|
}
|
|
// Touch board
|
|
await tx.board.update({
|
|
where: { id: sourceBoardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
});
|
|
return createdActivity;
|
|
}
|
|
/**
|
|
* Get recent activity logs for a board.
|
|
*/
|
|
static async getBoardActivityLogs(boardId, limit = 50) {
|
|
const logs = await prisma.activityLog.findMany({
|
|
where: { boardId },
|
|
orderBy: { createdAt: 'desc' },
|
|
take: Math.min(100, Math.max(1, limit)),
|
|
});
|
|
return logs.map((log) => ({
|
|
id: log.id,
|
|
boardId: log.boardId,
|
|
ticketId: log.ticketId,
|
|
ticketTitle: log.ticketTitle,
|
|
action: log.action,
|
|
fromColumnTitle: log.fromColumnTitle,
|
|
toColumnTitle: log.toColumnTitle,
|
|
userName: log.userName,
|
|
details: log.details,
|
|
createdAt: log.createdAt.toISOString(),
|
|
}));
|
|
}
|
|
/**
|
|
* Get activity logs for a specific ticket.
|
|
*/
|
|
static async getTicketActivityLogs(ticketId, limit = 30) {
|
|
const logs = await prisma.activityLog.findMany({
|
|
where: { ticketId },
|
|
orderBy: { createdAt: 'desc' },
|
|
take: Math.min(50, Math.max(1, limit)),
|
|
});
|
|
return logs.map((log) => ({
|
|
id: log.id,
|
|
boardId: log.boardId,
|
|
ticketId: log.ticketId,
|
|
ticketTitle: log.ticketTitle,
|
|
action: log.action,
|
|
fromColumnTitle: log.fromColumnTitle,
|
|
toColumnTitle: log.toColumnTitle,
|
|
userName: log.userName,
|
|
details: log.details,
|
|
createdAt: log.createdAt.toISOString(),
|
|
}));
|
|
}
|
|
/**
|
|
* Reorder columns in a board.
|
|
*/
|
|
static async reorderColumns(boardId, columnIdsInOrder) {
|
|
await prisma.$transaction(async (tx) => {
|
|
for (let i = 0; i < columnIdsInOrder.length; i++) {
|
|
const id = columnIdsInOrder[i];
|
|
await tx.column.update({
|
|
where: { id },
|
|
data: { order: i },
|
|
});
|
|
}
|
|
await tx.board.update({
|
|
where: { id: boardId },
|
|
data: { updatedAt: new Date() },
|
|
});
|
|
});
|
|
}
|
|
/**
|
|
* Check for stale tickets in active columns and auto-move them to Backlog if enabled.
|
|
*/
|
|
static async processStaleTickets(boardId) {
|
|
const board = await prisma.board.findUnique({
|
|
where: { id: boardId },
|
|
include: {
|
|
columns: {
|
|
orderBy: { order: 'asc' },
|
|
include: { tickets: true },
|
|
},
|
|
},
|
|
});
|
|
if (!board || board.columns.length < 2)
|
|
return { movedTicketIds: [] };
|
|
const backlogColumn = board.columns[0];
|
|
const movedTicketIds = [];
|
|
const now = Date.now();
|
|
for (let i = 1; i < board.columns.length; i++) {
|
|
const col = board.columns[i];
|
|
if (col.autoStaleHours && col.autoStaleHours > 0) {
|
|
const thresholdMs = col.autoStaleHours * 60 * 60 * 1000;
|
|
for (const ticket of col.tickets) {
|
|
const ticketMovedAt = new Date(ticket.movedAt || ticket.createdAt).getTime();
|
|
const ageMs = now - ticketMovedAt;
|
|
if (ageMs >= thresholdMs && board.autoMoveStale) {
|
|
// Auto move to backlog
|
|
await this.moveTicket(ticket.id, backlogColumn.id, 0, [ticket.id, ...backlogColumn.tickets.map((t) => t.id)], 'Sistem (Auto-Stale)');
|
|
movedTicketIds.push(ticket.id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return { movedTicketIds };
|
|
}
|
|
}
|