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 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 });
    }
};