Source: RouterEvents/eventJob/controller.js

/**
 * Event Job Controller Layer
 * Handles HTTP request/response and delegates to service layer
 */

// @ts-check
/**
 * @import {ExpressRequestAuthorized, ExpressResponse} from './../../types.js'
 */

import { query, UUID2hex } from '@commtool/sql-query';
import { paginateList } from '../../utils/paginateList.js';
import * as eventJobService from './service.js';
import { errorLoggerUpdate, errorLoggerRead } from '../../utils/requestLogger.js';
import { getUID } from '../../utils/UUIDs.js';

/**
 * Recreate all jobs for organization
 * Handles GET /recreate
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const recreateAllJobsController = async (req, res) => {
    try {
        // Get all groups in the organization and recreate their jobs
        const groups = await query(
            `SELECT UID FROM ObjectBase WHERE Type='group' AND UIDBelongsTo=?`,
            [UUID2hex(req.session.root)]
        );

        for (const group of groups) {
            await eventJobService.recreateJobsGroup(req, group.UID);
        }

        res.json({ success: true });
    } catch (e) {
        errorLoggerUpdate(e);
        res.json({ success: false, message: e.message });
    }
};

/**
 * Recreate jobs for a person
 * Handles GET /recreate/:UIDperson
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const recreatePersonJobsController = async (req, res) => {
    try {
        const person = UUID2hex(req.params.UIDperson);
        
        // Get all job groups for this person and recreate them
        const groups = await query(
            `SELECT DISTINCT Links.UIDTarget AS UID
             FROM ObjectBase 
             INNER JOIN Links ON (Links.UID=ObjectBase.UID AND Links.Type IN ('member','memberA'))
             WHERE ObjectBase.Type='job' AND ObjectBase.UIDBelongsTo=?`,
            [person]
        );

        for (const group of groups) {
            await eventJobService.recreateJobsGroup(req, group.UID);
        }

        res.json({ success: true });
    } catch (e) {
        errorLoggerUpdate(e);
        res.json({ success: false, message: e.message });
    }
};

/**
 * Create job with template
 * Handles PUT /:member/:event/:function
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const createJobWithTemplateController = async (req, res) => {
    try {
        const jobUID = await getUID(req);
        req.body.UID = req.body.UID || jobUID;

        const result = await eventJobService.putMemberFunctionTemplate(
            req.params.member,
            req.params.event,
            req.params.function,
            req.body.UID,
            req
        );

        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Create free job without template
 * Handles PUT /:member/:event
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const createFreeJobController = async (req, res) => {
    try {
        const jobUID = await getUID(req);
        req.body.UID = req.body.UID || jobUID;

        const result = await eventJobService.createFreeJob(
            req.params.member,
            req.params.event,
            req.body.name,
            req.body.UID,
            req
        );

        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Update job template
 * Handles POST /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const updateJobController = async (req, res) => {
    try {
        if (!req.body.UIDTemplate) {
            res.status(300).json({ success: false, message: 'missing UIDTemplate parameter in the body' });
            return;
        }

        await eventJobService.updateJobTemplate(
            req.params.UID,
            req.body.UIDTemplate,
            req
        );

        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Set responsible person
 * Handles POST /responsible/:event
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const setResponsibleController = async (req, res) => {
    try {
        if (!req.body.UID) {
            res.status(300).json({ success: false, message: 'missing UID parameter in body' });
            return;
        }

        const result = await eventJobService.setResponsible(
            req.params.event,
            req.body.UID,
            req
        );

        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Delete job
 * Handles DELETE /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const deleteJobController = async (req, res) => {
    try {
        await eventJobService.deleteJob(req.params.UID, req);
        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.json({ success: false, message: error.message });
    }
};

/**
 * Delete all jobs for person in event
 * Handles DELETE /leader/:UIDevent/:UIDperson
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const deleteLeaderJobsController = async (req, res) => {
    try {
        await eventJobService.deleteLeaderJobs(
            req.params.UIDevent,
            req.params.UIDperson,
            req
        );

        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.json({ success: false, message: error.message });
    }
};

/**
 * Get single job
 * Handles GET /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const getJobController = async (req, res) => {
    try {
        const result = await eventJobService.getJob(req.params.UID);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.json({ success: false, message: error.message });
    }
};

/**
 * List jobs for event with pagination support
 * Handles GET /jobs/:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @param {Function} next
 * @returns {Promise<void>}
 */
export const listJobsController = async (req, res, next) => {
    try {
        // Check if pagination is requested
        if (req.query.__page) {
            const paginatedResult = await paginateList(req, eventJobService.getJobsListing);
            res.json(paginatedResult);
            return;
        }

        // Normal listing without pagination
        const result = await eventJobService.getJobsListing(req);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};