Source: Router/user/controller.js

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

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

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const updatePersonIdentifyerController = async (req, res) => {
    try {
        let UIDidentifyer;
        try {
            UIDidentifyer = UUID2hex(req.params.identifyer);
        } catch (_error) {
            res.status(300).json({ success: false, message: 'invalid login indentifyer supplied in body' });
            return;
        }

        const UIDperson = UUID2hex(req.params.person);
        const result = await userService.updatePersonIdentifyer(UIDperson, UIDidentifyer, UUID2hex(req.session.root));

        if (!result.success) {
            res.status(300).json(result);
            return;
        }

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

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const putUserController = async (req, res) => {
    try {
        const UIDperson = UUID2hex(req.params.person);
        const result = await userService.putUser(UIDperson, UUID2hex(req.session.root));
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const syncBySourceController = async (req, res) => {
    try {
        const UIDsource = UUID2hex(req.params.UIDsource);
        if (!UIDsource) {
            res.status(300).json({ success: false, message: 'no valid source UID supplied' });
            return;
        }

        const result = await userService.syncUsersBySource(UIDsource, UUID2hex(req.session.root));
        if (!result.success) {
            res.status(300).json(result);
            return;
        }

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

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const syncUsersController = async (req, res) => {
    try {
        if (!req.body.users || !Array.isArray(req.body.users)) {
            res.json({ success: false, message: 'body has to contain an object of {users:[...]}' });
            return;
        }

        const users = req.body.users.map((u) => UUID2hex(u));
        await userService.syncUsers(users, UUID2hex(req.session.root));
        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const deleteUserController = async (req, res) => {
    try {
        const UIDperson = UUID2hex(req.params.UIDperson);
        const result = await userService.deleteUserByPerson(UIDperson, UUID2hex(req.session.root));
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const deleteUsersController = async (req, res) => {
    try {
        if (!req.body.users || !Array.isArray(req.body.users) || req.body.users.length === 0) {
            res.json({ success: false, message: 'body has to contain an object of {users:[...]}' });
            return;
        }

        const users = req.body.users.map((u) => UUID2hex(u));
        await userService.deleteUsers(users, UUID2hex(req.session.root));
        res.json({ success: true });
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const invalidateCacheController = async (req, res) => {
    try {
        const result = await userService.invalidateUserCacheService(req.body, req.session.root);
        if (!result.success) {
            res.status(400).json(result);
            return;
        }

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

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getSearchDataController = async (req, res) => {
    try {
        const result = await userService.getSearchData(String(req.query.search ?? ''), UUID2hex(req.session.root));
        res.json(result.map((r, index) => ({ title: r.title, value: r.value, key: index, type: r.type, UIDuser: r.UIDuser })));
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getPersonIdentifyerController = async (req, res) => {
    try {
        const UIDperson = UUID2hex(req.params.UIDperson);
        const result = await userService.getPersonIdentifyer(UIDperson, UUID2hex(req.session.root));

        if (!result.success) {
            res.status(404).json(result);
            return;
        }

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

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getUserByUIDController = async (req, res) => {
    try {
        const UIDuser = UUID2hex(req.params.UIDuser);
        const result = await userService.getUserByUID(UIDuser, req.session.root);
        res.json(result);
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getAllIdentifyersController = async (req, res) => {
    try {
        const result = await userService.getAllIdentifyers(UUID2hex(req.session.root));
        res.json(result);
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getPersonByEmailController = async (req, res) => {
    try {
        const email = req.params.email?.toLowerCase().trim();
        if (!email) {
            res.status(400).json({ success: false, message: 'email parameter required' });
            return;
        }

        // Optional emailType filter: ?emailType=personal&emailType=member  or  ?emailType=["personal","member"]
        let emailTypes;
        if (req.query.emailType) {
            if (Array.isArray(req.query.emailType)) {
                emailTypes = req.query.emailType.map(String);
            } else if (typeof req.query.emailType === 'string') {
                try {
                    const parsed = JSON.parse(req.query.emailType);
                    emailTypes = Array.isArray(parsed) ? parsed.map(String) : [req.query.emailType];
                } catch {
                    emailTypes = [req.query.emailType];
                }
            }
        }

        const result = await userService.getPersonByEmail(email, UUID2hex(req.session.root), emailTypes);
        if (!result.success) {
            res.status(404).json(result);
            return;
        }
        res.json(result);
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const upsertPortalPendingController = async (req, res) => {
    try {
        const UIDperson = UUID2hex(req.params.person);
        const UIDkc = UUID2hex(req.params.kcUID);
        const result = await userService.usertPortalPending(UIDperson, UIDkc, req.body || {}, UUID2hex(req.session.root));
        if (!result.success) {
            res.status(403).json(result);
            return;
        }
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const getPortalPendingByKcUIDController = async (req, res) => {
    try {
        const UIDkc = UUID2hex(req.params.kcUID);
        const result = await userService.getPortalPendingByKcUID(UIDkc, req.session.root);
        res.json(result);
    } catch (error) {
        errorLoggerRead(error);
        res.status(500).json({ success: false, message: error.message });
    }
};

/** @param {ExpressRequestAuthorized} req @param {ExpressResponse} res */
export const deletePortalPendingController = async (req, res) => {
    try {
        const UIDperson = UUID2hex(req.params.person);
        const result = await userService.deletePortalPending(UIDperson, UUID2hex(req.session.root));
        if (!result.success) {
            res.status(403).json(result);
            return;
        }
        res.json(result);
    } catch (error) {
        errorLoggerUpdate(error);
        res.status(500).json({ success: false, message: error.message });
    }
};