working leantime widget 33

This commit is contained in:
Alma 2025-04-12 14:22:57 +02:00
parent f0b718442c
commit 7d5255a7c2

View File

@ -2,70 +2,107 @@ import { getServerSession } from "next-auth/next";
import { authOptions } from "@/app/api/auth/[...nextauth]/route";
import { NextResponse } from "next/server";
interface StatusLabel {
interface Task {
id: string;
name: string;
class: string;
statusType: string;
kanbanCol: boolean | string;
sortKey: number | string;
}
interface Project {
id: number;
name: string;
labels: StatusLabel[];
headline: string;
projectName: string;
projectId: number;
status: string;
dueDate: string | null;
milestone: string | null;
details: string | null;
}
// Cache for user IDs to avoid repeated lookups
const userCache = new Map<string, number>();
async function getLeantimeUserId(email: string): Promise<number | null> {
// Check cache first
if (userCache.has(email)) {
return userCache.get(email)!;
}
try {
const response = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-API-Key': process.env.LEANTIME_TOKEN || '',
},
body: JSON.stringify({
jsonrpc: '2.0',
method: 'leantime.rpc.users.getAll',
id: 1,
}),
});
if (!response.ok) {
throw new Error('Failed to fetch users from Leantime');
}
const data = await response.json();
const user = data.result.find((u: any) => u.email === email);
if (user) {
// Cache the user ID
userCache.set(email, user.id);
// Clear cache after 5 minutes
setTimeout(() => userCache.delete(email), 5 * 60 * 1000);
return user.id;
}
return null;
} catch (error) {
console.error('Error getting Leantime user ID:', error);
return null;
}
}
export async function GET() {
try {
const session = await getServerSession(authOptions);
if (!session?.user?.email) {
if (!session || !session.user?.email) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
// Check cache first
let leantimeUserId = userCache.get(session.user.email);
// Get Leantime user ID
const leantimeUserId = await getLeantimeUserId(session.user.email);
// If not in cache, fetch from API
if (!leantimeUserId) {
const userResponse = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-API-Key': process.env.LEANTIME_TOKEN || '',
},
body: JSON.stringify({
jsonrpc: '2.0',
method: 'leantime.rpc.Users.Users.getUserByEmail',
id: 1,
params: {
email: session.user.email
}
})
});
if (!userResponse.ok) {
throw new Error('Failed to fetch user from Leantime');
}
const userData = await userResponse.json();
if (!userData.result || !userData.result.id) {
return NextResponse.json({ error: "User not found in Leantime" }, { status: 404 });
}
leantimeUserId = userData.result.id;
// Cache the user ID for 5 minutes
userCache.set(session.user.email, leantimeUserId);
setTimeout(() => userCache.delete(session.user.email!), 5 * 60 * 1000);
return NextResponse.json({ error: "User not found in Leantime" }, { status: 404 });
}
// Get projects
// Get all tasks assigned to the user
const response = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-API-Key': process.env.LEANTIME_TOKEN || '',
},
body: JSON.stringify({
jsonrpc: '2.0',
method: 'leantime.rpc.Tickets.Tickets.getAllByUserId',
id: 1,
params: {
userId: leantimeUserId,
status: "all",
limit: 100
}
})
});
if (!response.ok) {
throw new Error('Failed to fetch tasks from Leantime');
}
const data = await response.json();
if (!data.result) {
return NextResponse.json({ tasks: [] });
}
// Get project details to include project names
const projectsResponse = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
method: 'POST',
headers: {
@ -84,54 +121,38 @@ export async function GET() {
}
const projectsData = await projectsResponse.json();
const projectsMap = new Map(
projectsData.result.map((project: any) => [project.id, project.name])
);
// Get status labels
const labelsResponse = await fetch('https://agilite.slm-lab.net/api/jsonrpc', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'X-API-Key': process.env.LEANTIME_TOKEN || '',
},
body: JSON.stringify({
jsonrpc: '2.0',
method: 'leantime.rpc.Tickets.Tickets.getAllStatusLabelsByUserId',
id: 1,
params: {
userId: leantimeUserId
}
})
// Transform and sort the tasks
const tasks = data.result.map((task: any) => {
const dueDate = task.dateToFinish ? new Date(task.dateToFinish * 1000).toISOString() : null;
return {
id: task.id,
headline: task.headline,
projectName: projectsMap.get(task.projectId) || `Project ${task.projectId}`,
projectId: task.projectId,
status: task.status,
dueDate: dueDate,
milestone: task.milestoneid || null,
details: task.description || null
};
});
if (!labelsResponse.ok) {
throw new Error('Failed to fetch status labels from Leantime');
}
// Sort tasks by due date (overdue first)
tasks.sort((a: Task, b: Task) => {
if (!a.dueDate) return 1;
if (!b.dueDate) return -1;
return new Date(a.dueDate).getTime() - new Date(b.dueDate).getTime();
});
const labelsData = await labelsResponse.json();
// Transform the data into the required format
const projects: Project[] = projectsData.result.map((project: any) => {
const projectLabels = labelsData.result[project.id];
const labels: StatusLabel[] = projectLabels ? Object.entries(projectLabels).map(([key, value]: [string, any]) => ({
id: key,
name: value.name,
class: value.class,
statusType: value.statusType,
kanbanCol: value.kanbanCol,
sortKey: value.sortKey
})).sort((a: StatusLabel, b: StatusLabel) => Number(a.sortKey) - Number(b.sortKey)) : [];
return {
id: project.id,
name: project.name,
labels
};
}).filter((project: Project) => project.labels.length > 0);
return NextResponse.json({ projects });
return NextResponse.json({ tasks });
} catch (error) {
console.error('Error fetching status labels:', error);
console.error('Error fetching tasks:', error);
return NextResponse.json(
{ error: "Failed to fetch status labels" },
{ error: "Failed to fetch tasks" },
{ status: 500 }
);
}