405 lines
12 KiB
TypeScript
405 lines
12 KiB
TypeScript
import { NextResponse } from 'next/server';
|
|
import { getServerSession } from 'next-auth';
|
|
import { authOptions } from "@/app/api/auth/options";
|
|
import { prisma } from '@/lib/prisma';
|
|
import { N8nService } from '@/lib/services/n8n-service';
|
|
import { Prisma } from '@prisma/client';
|
|
|
|
// Types
|
|
interface MissionCreateInput {
|
|
name: string;
|
|
oddScope: string[];
|
|
niveau?: string;
|
|
intention?: string;
|
|
missionType?: string;
|
|
donneurDOrdre?: string;
|
|
projection?: string;
|
|
services?: string[];
|
|
participation?: string;
|
|
profils?: string[];
|
|
guardians?: Record<string, string>;
|
|
volunteers?: string[];
|
|
creatorId?: string;
|
|
logo?: {
|
|
data: string;
|
|
name?: string;
|
|
type?: string;
|
|
} | null;
|
|
attachments?: Array<{
|
|
data: string;
|
|
name?: string;
|
|
type?: string;
|
|
}>;
|
|
leantimeProjectId?: string | null;
|
|
outlineCollectionId?: string | null;
|
|
rocketChatChannelId?: string | null;
|
|
giteaRepositoryUrl?: string | null;
|
|
penpotProjectId?: string | null;
|
|
}
|
|
|
|
interface MissionUserInput {
|
|
role: string;
|
|
userId: string;
|
|
missionId: string;
|
|
}
|
|
|
|
interface MissionResponse {
|
|
id: string;
|
|
name: string;
|
|
oddScope: string[];
|
|
niveau: string;
|
|
intention: string;
|
|
missionType: string;
|
|
donneurDOrdre: string;
|
|
projection: string;
|
|
services: string[];
|
|
profils: string[];
|
|
participation: string;
|
|
creatorId: string;
|
|
logo: string | null;
|
|
leantimeProjectId: string | null;
|
|
outlineCollectionId: string | null;
|
|
rocketChatChannelId: string | null;
|
|
giteaRepositoryUrl: string | null;
|
|
penpotProjectId: string | null;
|
|
createdAt: Date;
|
|
updatedAt: Date;
|
|
}
|
|
|
|
// Helper function to check authentication
|
|
async function checkAuth(request: Request) {
|
|
const session = await getServerSession(authOptions);
|
|
return {
|
|
authorized: !!session?.user,
|
|
userId: session?.user?.id
|
|
};
|
|
}
|
|
|
|
// GET endpoint to list missions
|
|
export async function GET(request: Request) {
|
|
try {
|
|
const { authorized, userId } = await checkAuth(request);
|
|
if (!authorized || !userId) {
|
|
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
|
|
}
|
|
|
|
const { searchParams } = new URL(request.url);
|
|
const limit = Number(searchParams.get('limit') || '10');
|
|
const offset = Number(searchParams.get('offset') || '0');
|
|
const search = searchParams.get('search');
|
|
const name = searchParams.get('name');
|
|
|
|
const where: Prisma.MissionWhereInput = {};
|
|
|
|
if (search) {
|
|
where.OR = [
|
|
{ name: { contains: search, mode: 'insensitive' } },
|
|
{ intention: { contains: search, mode: 'insensitive' } }
|
|
];
|
|
}
|
|
|
|
if (name) {
|
|
where.name = name;
|
|
}
|
|
|
|
const missions = await prisma.mission.findMany({
|
|
where,
|
|
skip: offset,
|
|
take: limit,
|
|
orderBy: { createdAt: 'desc' },
|
|
include: {
|
|
creator: {
|
|
select: {
|
|
id: true,
|
|
email: true
|
|
}
|
|
},
|
|
missionUsers: {
|
|
include: {
|
|
user: {
|
|
select: {
|
|
id: true,
|
|
email: true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
const totalCount = await prisma.mission.count({ where });
|
|
|
|
return NextResponse.json({
|
|
missions,
|
|
pagination: {
|
|
total: totalCount,
|
|
offset,
|
|
limit
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('Error listing missions:', error);
|
|
return NextResponse.json({
|
|
error: 'Internal server error',
|
|
details: error instanceof Error ? error.message : String(error)
|
|
}, { status: 500 });
|
|
}
|
|
}
|
|
|
|
// POST endpoint to create a new mission
|
|
export async function POST(request: Request) {
|
|
try {
|
|
const { authorized, userId } = await checkAuth(request);
|
|
if (!authorized || !userId) {
|
|
return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
|
|
}
|
|
|
|
const body = await request.json() as MissionCreateInput;
|
|
|
|
// Validate required fields
|
|
const requiredFields = ['name', 'oddScope'];
|
|
const missingFields = requiredFields.filter(field => !body[field as keyof MissionCreateInput]);
|
|
|
|
if (missingFields.length > 0) {
|
|
return NextResponse.json({
|
|
error: 'Missing required fields',
|
|
missingFields
|
|
}, { status: 400 });
|
|
}
|
|
|
|
// Check if this is a request from n8n
|
|
const isN8nRequest = request.headers.get('x-api-key') === process.env.N8N_API_KEY;
|
|
|
|
// Get the creator ID from the appropriate source
|
|
const creatorId = isN8nRequest ? body.creatorId : userId;
|
|
|
|
// Verify creator exists
|
|
const creator = await prisma.user.findUnique({
|
|
where: { id: creatorId }
|
|
});
|
|
|
|
if (!creator) {
|
|
return NextResponse.json({
|
|
error: 'Invalid creator ID',
|
|
details: 'The specified creator does not exist',
|
|
code: 'INVALID_CREATOR'
|
|
}, { status: 400 });
|
|
}
|
|
|
|
// Check if mission with same name exists
|
|
const existingMission = await prisma.mission.findFirst({
|
|
where: { name: body.name }
|
|
});
|
|
|
|
if (existingMission) {
|
|
// Update existing mission with new integration IDs
|
|
const updatedMission = await prisma.mission.update({
|
|
where: { id: existingMission.id },
|
|
data: {
|
|
leantimeProjectId: body.leantimeProjectId ? String(body.leantimeProjectId) : null,
|
|
outlineCollectionId: body.outlineCollectionId || null,
|
|
rocketChatChannelId: body.rocketChatChannelId || null,
|
|
giteaRepositoryUrl: body.giteaRepositoryUrl || null,
|
|
penpotProjectId: body.penpotProjectId || null
|
|
} as Prisma.MissionUpdateInput
|
|
});
|
|
|
|
return NextResponse.json({
|
|
message: 'Mission updated successfully',
|
|
mission: updatedMission,
|
|
isUpdate: true
|
|
});
|
|
}
|
|
|
|
// Handle n8n workflow
|
|
if (!isN8nRequest) {
|
|
const n8nService = new N8nService();
|
|
|
|
// Prepare the data for n8n
|
|
const n8nData = {
|
|
name: body.name,
|
|
oddScope: Array.isArray(body.oddScope) ? body.oddScope : [body.oddScope],
|
|
niveau: body.niveau || 'default',
|
|
intention: body.intention?.trim() || '',
|
|
missionType: body.missionType || 'default',
|
|
donneurDOrdre: body.donneurDOrdre || 'default',
|
|
projection: body.projection || 'default',
|
|
services: Array.isArray(body.services) ? body.services : [],
|
|
participation: body.participation || 'default',
|
|
profils: Array.isArray(body.profils) ? body.profils : [],
|
|
guardians: body.guardians || {},
|
|
volunteers: Array.isArray(body.volunteers) ? body.volunteers : [],
|
|
creatorId: userId,
|
|
logo: body.logo ? {
|
|
data: body.logo.data,
|
|
name: body.logo.name || 'logo.png',
|
|
type: body.logo.type || 'image/png'
|
|
} : null,
|
|
attachments: body.attachments || [],
|
|
config: {
|
|
N8N_API_KEY: process.env.N8N_API_KEY,
|
|
MISSION_API_URL: process.env.NEXT_PUBLIC_API_URL || 'https://api.slm-lab.net/api'
|
|
}
|
|
};
|
|
|
|
try {
|
|
const workflowResult = await n8nService.triggerMissionCreation(n8nData);
|
|
|
|
if (!workflowResult.success) {
|
|
console.error('n8n workflow failed:', workflowResult.error);
|
|
return NextResponse.json({
|
|
error: 'Failed to create mission resources',
|
|
details: workflowResult.error || 'The mission creation process failed',
|
|
code: 'WORKFLOW_ERROR'
|
|
}, { status: 500 });
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
status: 'success',
|
|
message: 'Mission creation initiated',
|
|
mission: {
|
|
name: n8nData.name,
|
|
oddScope: n8nData.oddScope,
|
|
niveau: n8nData.niveau,
|
|
intention: n8nData.intention,
|
|
missionType: n8nData.missionType,
|
|
donneurDOrdre: n8nData.donneurDOrdre,
|
|
projection: n8nData.projection,
|
|
services: n8nData.services,
|
|
profils: n8nData.profils,
|
|
participation: n8nData.participation,
|
|
creatorId: n8nData.creatorId
|
|
}
|
|
});
|
|
} catch (error) {
|
|
console.error('Error triggering n8n workflow:', error);
|
|
return NextResponse.json({
|
|
error: 'Failed to initiate mission creation',
|
|
details: error instanceof Error ? error.message : String(error)
|
|
}, { status: 500 });
|
|
}
|
|
}
|
|
|
|
// Create mission directly (n8n request)
|
|
try {
|
|
const mission = await prisma.mission.create({
|
|
data: {
|
|
name: body.name,
|
|
oddScope: body.oddScope || ['default'],
|
|
niveau: body.niveau,
|
|
intention: body.intention,
|
|
missionType: body.missionType,
|
|
donneurDOrdre: body.donneurDOrdre,
|
|
projection: body.projection,
|
|
services: Array.isArray(body.services) ? body.services.filter(Boolean) : [],
|
|
profils: Array.isArray(body.profils) ? body.profils.filter(Boolean) : [],
|
|
participation: body.participation || 'default',
|
|
creatorId: creatorId,
|
|
logo: body.logo || null,
|
|
leantimeProjectId: body.leantimeProjectId ? String(body.leantimeProjectId) : null,
|
|
outlineCollectionId: body.outlineCollectionId || null,
|
|
rocketChatChannelId: body.rocketChatChannelId || null,
|
|
giteaRepositoryUrl: body.giteaRepositoryUrl || null,
|
|
penpotProjectId: body.penpotProjectId || null
|
|
} as Prisma.MissionUncheckedCreateInput
|
|
});
|
|
|
|
// Add guardians and volunteers
|
|
if (body.guardians || body.volunteers) {
|
|
const missionUsers: MissionUserInput[] = [];
|
|
|
|
// Add guardians
|
|
if (body.guardians) {
|
|
Object.entries(body.guardians).forEach(([role, userId]) => {
|
|
if (userId) {
|
|
missionUsers.push({
|
|
role,
|
|
userId: userId as string,
|
|
missionId: mission.id
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// Add volunteers
|
|
if (body.volunteers && Array.isArray(body.volunteers)) {
|
|
body.volunteers.forEach(userId => {
|
|
if (userId) {
|
|
missionUsers.push({
|
|
role: 'volontaire',
|
|
userId,
|
|
missionId: mission.id
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
if (missionUsers.length > 0) {
|
|
await prisma.missionUser.createMany({
|
|
data: missionUsers
|
|
});
|
|
}
|
|
}
|
|
|
|
return NextResponse.json({
|
|
success: true,
|
|
status: 'success',
|
|
message: 'Mission created successfully',
|
|
mission: {
|
|
id: (mission as any).id,
|
|
name: (mission as any).name,
|
|
oddScope: (mission as any).oddScope,
|
|
niveau: (mission as any).niveau,
|
|
intention: (mission as any).intention,
|
|
missionType: (mission as any).missionType,
|
|
donneurDOrdre: (mission as any).donneurDOrdre,
|
|
projection: (mission as any).projection,
|
|
services: (mission as any).services,
|
|
profils: (mission as any).profils,
|
|
participation: (mission as any).participation,
|
|
creatorId: (mission as any).creatorId,
|
|
logo: (mission as any).logo,
|
|
leantimeProjectId: (mission as any).leantimeProjectId,
|
|
outlineCollectionId: (mission as any).outlineCollectionId,
|
|
rocketChatChannelId: (mission as any).rocketChatChannelId,
|
|
giteaRepositoryUrl: (mission as any).giteaRepositoryUrl,
|
|
penpotProjectId: (mission as any).penpotProjectId,
|
|
createdAt: (mission as any).createdAt,
|
|
updatedAt: (mission as any).updatedAt
|
|
} as MissionResponse
|
|
});
|
|
} catch (error) {
|
|
console.error('Error creating mission:', error);
|
|
if (error instanceof Prisma.PrismaClientKnownRequestError) {
|
|
if (error.code === 'P2003') {
|
|
return NextResponse.json({
|
|
success: false,
|
|
status: 'error',
|
|
error: 'Invalid reference',
|
|
message: 'One or more referenced users do not exist',
|
|
code: 'INVALID_REFERENCE'
|
|
}, { status: 400 });
|
|
}
|
|
}
|
|
return NextResponse.json(
|
|
{
|
|
success: false,
|
|
status: 'error',
|
|
error: 'Failed to create mission',
|
|
message: error instanceof Error ? error.message : String(error)
|
|
},
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
} catch (error) {
|
|
console.error('Error creating mission:', error);
|
|
return NextResponse.json(
|
|
{
|
|
error: 'Failed to create mission',
|
|
details: error instanceof Error ? error.message : String(error)
|
|
},
|
|
{ status: 500 }
|
|
);
|
|
}
|
|
}
|