corrad-bp/server/api/process/[id]/start.post.js

import { PrismaClient } from '@prisma/client';
import { v4 as uuidv4 } from 'uuid';

// Initialize Prisma client
const prisma = new PrismaClient();

export default defineEventHandler(async (event) => {
  try {
    // Get the process ID from the route parameter
    const processId = getRouterParam(event, 'id');
    
    if (!processId) {
      return {
        success: false,
        error: 'Process ID is required'
      };
    }

    console.log('Starting process with ID:', processId);

    // Check if the ID is a UUID or numeric ID
    const isUUID = processId.length === 36 && processId.includes('-');
    
    // Find the process
    console.log('Finding process...');
    const process = await prisma.process.findFirst({
      where: isUUID 
        ? { processUUID: processId }
        : { processID: parseInt(processId) },
      include: {
        creator: {
          select: {
            userID: true,
            userFullName: true,
            userUsername: true
          }
        }
      }
    });

    if (!process) {
      console.log('Process not found');
      return {
        success: false,
        error: 'Process not found'
      };
    }

    console.log('Process found:', process.processName);

    // Check if process is published
    if (process.processStatus !== 'published') {
      console.log('Process is not published:', process.processStatus);
      return {
        success: false,
        error: 'Cannot start an unpublished process'
      };
    }

    // Get the current authenticated user from the request context
    const currentUser = event.context.user;
    
    if (!currentUser || !currentUser.userID) {
      console.log('User not authenticated');
      return {
        success: false,
        error: 'Authentication required'
      };
    }

    // Get full user details from database
    const userDetails = await prisma.user.findFirst({
      where: {
        userID: parseInt(currentUser.userID)
      },
      select: {
        userID: true,
        userFullName: true,
        userUsername: true
      }
    });

    if (!userDetails) {
      console.log('User details not found');
      return {
        success: false,
        error: 'User not found'
      };
    }

    console.log('Creating case instance...');
    // Create a new case instance
    const caseInstance = await prisma.caseInstance.create({
      data: {
        caseUUID: uuidv4(),
        processID: process.processID,
        caseName: `${process.processName} - ${new Date().toLocaleDateString()}`,
        caseStatus: 'active',
        caseStartedBy: userDetails.userID,
        caseVariables: process.processVariables || {},
        caseSettings: process.processSettings || {},
        caseDefinition: process.processDefinition || {},
        caseCreatedDate: new Date(),
        caseModifiedDate: new Date()
      }
    });

    console.log('Case instance created:', caseInstance.caseUUID);

    // Get the process definition
    const processDefinition = process.processDefinition || {};
    const nodes = processDefinition.nodes || [];
    const edges = processDefinition.edges || [];
    
    // Find all form nodes
    const formNodes = nodes.filter(node => node.type === 'form');
    
    if (formNodes.length === 0) {
      console.log('No form nodes found in process');
      return {
        success: false,
        error: 'Process does not contain any forms'
      };
    }

    console.log(`Found ${formNodes.length} form nodes`);

    // Create tasks for all forms
    const tasks = [];
    for (const formNode of formNodes) {
      console.log('Creating task for form:', formNode.data?.label);
      const task = await prisma.task.create({
        data: {
          taskUUID: uuidv4(),
          caseID: caseInstance.caseID,
          taskName: formNode.data?.label || 'Complete Form',
          taskType: 'form',
          taskStatus: 'pending',
          taskAssignedTo: userDetails.userID,
          taskFormID: formNode.data?.formId,
          taskCreatedDate: new Date(),
          taskModifiedDate: new Date()
        }
      });
      tasks.push(task);
      console.log('Task created:', task.taskUUID);
    }

    // Add to case timeline
    console.log('Adding to case timeline...');
    await prisma.caseTimeline.create({
      data: {
        caseID: caseInstance.caseID,
        timelineType: 'start',
        timelineDescription: `Process started by ${userDetails.userFullName}`,
        timelineDate: new Date(),
        timelineCreatedBy: userDetails.userID
      }
    });

    console.log('Process started successfully');
    return {
      success: true,
      data: {
        case: {
          id: caseInstance.caseUUID,
          name: caseInstance.caseName,
          status: caseInstance.caseStatus,
          startedAt: caseInstance.caseCreatedDate
        },
        tasks: tasks.map(task => ({
          id: task.taskUUID,
          name: task.taskName,
          type: task.taskType,
          formId: task.taskFormID,
          status: task.taskStatus
        }))
      }
    };
  } catch (error) {
    console.error('Error starting process:', error);
    console.error('Error details:', {
      name: error.name,
      message: error.message,
      stack: error.stack,
      code: error.code
    });
    
    return {
      success: false,
      error: 'Failed to start process',
      details: process.env.NODE_ENV === 'development' ? error.message : undefined
    };
  } finally {
    // Close the Prisma client connection
    await prisma.$disconnect();
  }
});