Source: RouterEvents/event/controller.js

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

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

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

/**
 * Create event controller
 * Handles PUT /:group/:template
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const createEventController = async (req, res) => {
    try {
        const groupUID = UUID2hex(req.params.group);
        const templateUID = UUID2hex(req.params.template);
        
        const result = await eventService.createEvent(
            groupUID,
            templateUID,
            req.body,
            req.session,
            req
        );
        
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Update event controller
 * Handles POST /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const updateEventController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        
        const result = await eventService.updateEvent(
            UID,
            req.body,
            req.session,
            req
        );
        
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Delete event controller
 * Handles DELETE /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const deleteEventController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        
        await eventService.deleteEvent(UID, req.session, req);
        
        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(300).json({ success: false, message: error.message });
    }
};

/**
 * Get event controller
 * Handles GET /:UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @returns {Promise<void>}
 */
export const getEventController = async (req, res) => {
    try {
        if (req.params.UID === 'undefined') {
            res.json({ success: false, message: 'supplied undefined UID' });
            return;
        }
        
        const UID = UUID2hex(req.params.UID);
        
        if (!UID) {
            res.json({ success: false, message: 'supplied invalid UID' });
            return;
        }
        
        const result = await eventService.getEvent(UID, req.session, req);
        
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.json({ success: false, message: error.message });
    }
};

/**
 * List events controller with pagination support
 * Handles GET /
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 * @param {Function} next
 * @returns {Promise<void>}
 */
export const listEventsController = async (req, res, next) => {
    try {
        // Check if pagination is requested
        if (req.query.__page) {
            const paginatedResult = await paginateList(req, eventService.getEventListing);
            res.json(paginatedResult);
            return;
        }
        
        // Normal listing without pagination
        const result = await eventService.getEventListing(req);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};