Source: RouterEvents/eventTemplate/controller.js

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

import * as eventTemplateService from './service.js';
import { errorLoggerUpdate, errorLoggerRead } from '../../utils/requestLogger.js';
import { UUID2hex } from '@commtool/sql-query';
import { isAdmin, isObjectAdmin, isObjectVisible } from '../../utils/authChecks.js';
import { updateTemplateEvent } from '../../server.ws.js';

/**
 * Controller for creating or updating an event template (PUT)
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const createOrUpdateEventTemplateController = async (req, res) => {
    try {
        const UID = UUID2hex(req.body.UID || '');

        if (req.body.UID) {
            if (!isObjectAdmin(req, UID)) {
                res.json({ success: false, message: 'user has no admin rights for this event template' });
                return;
            }
        } else {
            if (!isAdmin(req.session)) {
                res.json({ success: false, message: 'user must be an organisation admin to add a new template' });
                return;
            }
        }

        const result = await eventTemplateService.createOrUpdateEventTemplate(req.body, req.session);
        updateTemplateEvent(req.session.root);
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for updating an existing event template (POST)
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const updateEventTemplateController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        const result = await eventTemplateService.updateEventTemplate(UID, req.body, req.session);
        updateTemplateEvent(req.session.root);
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for deleting an event template
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const deleteEventTemplateController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        if (!isObjectAdmin(req, UID)) {
            res.json({ success: false, message: 'user has no admin rights for this event template' });
            return;
        }
        const result = await eventTemplateService.deleteEventTemplate(UID, req.session.root);
        updateTemplateEvent(req.session.root);
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for getting all event templates
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const getAllEventTemplatesController = async (req, res) => {
    try {
        const isAdminUser = await isAdmin(req.session);
        const result = await eventTemplateService.getAllEventTemplates(req.session.root, req.session.user, isAdminUser);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for getting all event templates with data
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const getAllEventTemplatesWithDataController = async (req, res) => {
    try {
        const isAdminUser = await isAdmin(req.session);
        const result = await eventTemplateService.getAllEventTemplatesWithData(req.session.root, req.session.user, isAdminUser);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for getting administrable event templates
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const getAdminEventTemplatesController = async (req, res) => {
    try {
        const isAdminUser = await isAdmin(req.session);
        const result = await eventTemplateService.getAdminEventTemplates(req.session.root, req.session.user, isAdminUser);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for getting a specific event template by UID
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const getEventTemplateByUIDController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        if (!(await isObjectVisible(req, UID))) {
            res.json({ success: false, message: 'not authorized for this event template' });
            return;
        }
        const result = await eventTemplateService.getEventTemplateByUID(UID, req.session.root);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/**
 * Controller for getting the template for an event
 * @param {ExpressRequestAuthorized} req
 * @param {ExpressResponse} res
 */
export const getEventTemplateByEventUIDController = async (req, res) => {
    try {
        const UID = UUID2hex(req.params.UID);
        if (!(await isObjectVisible(req, UID))) {
            res.json({ success: false, message: 'not authorized for this event' });
            return;
        }
        const result = await eventTemplateService.getEventTemplateByEventUID(UID, req.session.root);
        res.json({ success: true, result });
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};