2.UserGroup

const { EntitySchema } = require('typeorm');

module.exports = new EntitySchema({
    name: 'UserGroup',
    tableName: 'user_groups',
    columns: {
        id: {
            type: 'int',
            primary: true,
            generated: true,
        },
        name: {
            type: 'varchar',
            unique: true,
            nullable: false,
        },
        createdAt: {
            type: 'timestamp',
            createDate: true,
        },
        updatedAt: {
            type: 'timestamp',
            updateDate: true,
        },
    },
});

// services/userGroup.service.js
const { AppDataSource } = require('../../../index'); // Ensure the path is correct
const UserGroup = require('../entities/userGroup.entity');

/**
 * @function formatUserGroupResponse
 * @description Formats the user group data to ensure consistent field names across all responses.
 * @param {object} userGroup - The user group object to format.
 * @returns {object} - The formatted user group object.
 */
const formatUserGroupResponse = (userGroup) => {
    if (!userGroup) return null;

    return {
        id: userGroup.id,
        name: userGroup.name,
        createdAt: userGroup.createdAt,
        updatedAt: userGroup.updatedAt,
    };
};

const createUserGroup = async (data) => {
    const userGroupRepository = AppDataSource.getRepository(UserGroup);
    const userGroup = userGroupRepository.create(data);
    const savedUserGroup = await userGroupRepository.save(userGroup);
    return formatUserGroupResponse(savedUserGroup);
};

const findUserGroupById = async (id) => {
    const userGroupRepository = AppDataSource.getRepository(UserGroup);
    const userGroup = await userGroupRepository.findOneBy({ id });
    return formatUserGroupResponse(userGroup);
};

const updateUserGroup = async (id, data) => {
    const userGroupRepository = AppDataSource.getRepository(UserGroup);
    const userGroup = await findUserGroupById(id);
    if (!userGroup) return null;

    Object.assign(userGroup, data);
    const updatedUserGroup = await userGroupRepository.save(userGroup);
    return formatUserGroupResponse(updatedUserGroup);
};

const deleteUserGroup = async (id) => {
    const userGroupRepository = AppDataSource.getRepository(UserGroup);
    const result = await userGroupRepository.delete(id);
    return result.affected;
};

const getAllUserGroups = async () => {
    const userGroupRepository = AppDataSource.getRepository(UserGroup);
    const userGroups = await userGroupRepository.find();
    return userGroups.map(formatUserGroupResponse);
};

module.exports = {
    createUserGroup,
    findUserGroupById,
    updateUserGroup,
    deleteUserGroup,
    getAllUserGroups,
};

// controllers/userGroup.controller.js
const userGroupService = require('../services/userGroup.service');

/**
 * @function createUserGroup
 * @description Creates a new user group.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const createUserGroup = async (req, res) => {
    try {
        const userGroup = await userGroupService.createUserGroup(req.body);
        res.status(201).json(userGroup);
    } catch (error) {
        res.status(500).json({ message: 'Failed to create user group', error: error.message });
    }
};

/**
 * @function getUserGroupById
 * @description Retrieves a user group by ID.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const getUserGroupById = async (req, res) => {
    try {
        const userGroup = await userGroupService.findUserGroupById(req.params.id);
        if (!userGroup) {
            return res.status(404).json({ message: 'User group not found' });
        }
        res.status(200).json(userGroup);
    } catch (error) {
        res.status(500).json({ message: 'Failed to retrieve user group', error: error.message });
    }
};

/**
 * @function updateUserGroup
 * @description Updates a user group by ID.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const updateUserGroup = async (req, res) => {
    try {
        const userGroup = await userGroupService.updateUserGroup(req.params.id, req.body);
        if (!userGroup) {
            return res.status(404).json({ message: 'User group not found' });
        }
        res.status(200).json(userGroup);
    } catch (error) {
        res.status(500).json({ message: 'Failed to update user group', error: error.message });
    }
};

/**
 * @function deleteUserGroup
 * @description Deletes a user group by ID.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const deleteUserGroup = async (req, res) => {
    try {
        const result = await userGroupService.deleteUserGroup(req.params.id);
        if (result === 0) {
            return res.status(404).json({ message: 'User group not found' });
        }
        res.status(204).send();
    } catch (error) {
        res.status(500).json({ message: 'Failed to delete user group', error: error.message });
    }
};

/**
 * @function getAllUserGroups
 * @description Retrieves all user groups.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const getAllUserGroups = async (req, res) => {
    try {
        const userGroups = await userGroupService.getAllUserGroups();
        if (!userGroups) {
            return res.status(404).json({ message: 'No user groups found' });
        }
        res.status(200).json(userGroups);
    } catch (error) {
        res.status(500).json({
            message: 'Internal server error',
            error: error.message || 'An unexpected error occurred',
        });
    }
};

module.exports = {
    createUserGroup,
    getUserGroupById,
    updateUserGroup,
    deleteUserGroup,
    getAllUserGroups,
};

    const userGroupRoutes = require('./modules/Authentication/routes/userGroup.routes');
    app.use('/api', userGroupRoutes);