6.UserUserGroup (কোন ইউজারের কোন usergroup)

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

module.exports = new EntitySchema({
    name: 'UserUserGroup',
    tableName: 'user_usergroups',
    columns: {
        userId: {
            name: 'user_id',
            type: 'int',
            primary: true,
        },
        usergroupId: {
            name: 'usergroup_id',
            type: 'int',
            primary: true,
        },
    },
    relations: {
        user: {
            type: 'many-to-one',
            target: 'User',
            joinColumn: { name: 'user_id' },
            onDelete: 'CASCADE',
        },
        usergroup: {
            type: 'many-to-one',
            target: 'UserGroup',
            joinColumn: { name: 'usergroup_id' },
            onDelete: 'CASCADE',
        },
    },
});

const { AppDataSource } = require('../../../index');
const UserUserGroup = require('../entities/userUserGroup.entity');

/**
 * Format the userUserGroup response to exclude sensitive or unnecessary fields.
 * @param {object} userUserGroup - The userUserGroup entity object.
 * @returns {object} - The formatted userUserGroup response.
 */
const formatUserUserGroupResponse = (userUserGroup) => {
    if (!userUserGroup) return null;
    return {
        userId: userUserGroup.userId,
        usergroupId: userUserGroup.usergroupId,
    };
};

/**
 * Create a new UserUserGroup entry.
 * @param {object} data - The data to create the userUserGroup.
 * @returns {Promise<object>} - The saved userUserGroup response.
 */
const createUserUserGroup = async (data) => {
    const userUserGroupRepository = AppDataSource.getRepository(UserUserGroup);
    const userUserGroup = userUserGroupRepository.create(data);
    const savedUserUserGroup = await userUserGroupRepository.save(userUserGroup);
    return formatUserUserGroupResponse(savedUserUserGroup);
};

/**
 * Find a UserUserGroup by its userId and usergroupId.
 * @param {number} userId - The ID of the user.
 * @param {number} usergroupId - The ID of the user group.
 * @returns {Promise<object>} - The found userUserGroup or null.
 */
const findUserUserGroupById = async (userId, usergroupId) => {
    const userUserGroupRepository = AppDataSource.getRepository(UserUserGroup);
    const userUserGroup = await userUserGroupRepository.findOne({
        where: { userId, usergroupId },
    });
    return formatUserUserGroupResponse(userUserGroup);
};

/**
 * Update a UserUserGroup entry.
 * @param {number} userId - The ID of the user.
 * @param {number} usergroupId - The ID of the user group.
 * @param {object} newData - The data to update the userUserGroup.
 * @returns {Promise<object>} - The updated userUserGroup or null if not found.
 */
const updateUserUserGroup = async (userId, usergroupId, newData) => {
    const userUserGroupRepository = AppDataSource.getRepository(UserUserGroup);
    const userUserGroup = await userUserGroupRepository.findOne({ where: { userId, usergroupId } });
    if (!userUserGroup) return null;

    Object.assign(userUserGroup, newData); // Update the existing fields
    const updatedUserUserGroup = await userUserGroupRepository.save(userUserGroup);
    return formatUserUserGroupResponse(updatedUserUserGroup);
};

/**
 * Delete a UserUserGroup by userId and usergroupId.
 * @param {number} userId - The ID of the user.
 * @param {number} usergroupId - The ID of the user group.
 * @returns {Promise<number>} - Number of affected rows (0 if not found).
 */
const deleteUserUserGroup = async (userId, usergroupId) => {
    const userUserGroupRepository = AppDataSource.getRepository(UserUserGroup);
    const result = await userUserGroupRepository.delete({ userId, usergroupId });
    return result.affected; // Returns 1 if deleted, 0 if not found
};

/**
 * Get all UserUserGroup entries.
 * @returns {Promise<Array>} - List of all userUserGroups.
 */
const getAllUserUserGroups = async () => {
    const userUserGroupRepository = AppDataSource.getRepository(UserUserGroup);
    const userUserGroups = await userUserGroupRepository.find();
    return userUserGroups.map(formatUserUserGroupResponse);
};

module.exports = {
    createUserUserGroup,
    findUserUserGroupById,
    updateUserUserGroup,
    deleteUserUserGroup,
    getAllUserUserGroups,
};

const userUserGroupService = require('../services/userUserGroup.service');

/**
 * Controller to handle creating a new userUserGroup.
 * @param {object} req - The request object with the userId and usergroupId in the body.
 * @param {object} res - The response object.
 * @returns {Promise<void>}
 */
const createUserUserGroup = async (req, res) => {
    const { userId, usergroupId } = req.body;

    try {
        const newUserUserGroup = await userUserGroupService.createUserUserGroup({ userId, usergroupId });
        res.status(201).json({ message: 'UserUserGroup created successfully', userUserGroup: newUserUserGroup });
    } catch (error) {
        res.status(500).json({ message: 'Error creating userUserGroup', error: error.message });
    }
};

/**
 * Controller to get a userUserGroup by userId and usergroupId.
 * @param {object} req - The request object with userId and usergroupId as params.
 * @param {object} res - The response object.
 * @returns {Promise<void>}
 */
const getUserUserGroupById = async (req, res) => {
    const { userId, usergroupId } = req.params;

    try {
        const userUserGroup = await userUserGroupService.findUserUserGroupById(userId, usergroupId);
        if (!userUserGroup) {
            return res.status(404).json({ message: 'UserUserGroup not found' });
        }
        res.status(200).json(userUserGroup);
    } catch (error) {
        res.status(500).json({ message: 'Error retrieving userUserGroup', error: error.message });
    }
};

/**
 * Controller to update an existing userUserGroup.
 * @param {object} req - The request object with userId and usergroupId as params and data in the body.
 * @param {object} res - The response object.
 * @returns {Promise<void>}
 */
const updateUserUserGroup = async (req, res) => {
    const { userId, usergroupId } = req.params;
    const newData = req.body;

    try {
        const updatedUserUserGroup = await userUserGroupService.updateUserUserGroup(userId, usergroupId, newData);
        if (!updatedUserUserGroup) {
            return res.status(404).json({ message: 'UserUserGroup not found' });
        }
        res.status(200).json({ message: 'UserUserGroup updated successfully', userUserGroup: updatedUserUserGroup });
    } catch (error) {
        res.status(500).json({ message: 'Error updating userUserGroup', error: error.message });
    }
};

/**
 * Controller to delete a userUserGroup.
 * @param {object} req - The request object with userId and usergroupId as params.
 * @param {object} res - The response object.
 * @returns {Promise<void>}
 */
const deleteUserUserGroup = async (req, res) => {
    const { userId, usergroupId } = req.params;

    try {
        const deleted = await userUserGroupService.deleteUserUserGroup(userId, usergroupId);
        if (!deleted) {
            return res.status(404).json({ message: 'UserUserGroup not found' });
        }
        res.status(200).json({ message: 'UserUserGroup deleted successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Error deleting userUserGroup', error: error.message });
    }
};

/**
 * Controller to get all userUserGroups.
 * @param {object} req - The request object.
 * @param {object} res - The response object.
 * @returns {Promise<void>}
 */
const getAllUserUserGroups = async (req, res) => {
    try {
        const userUserGroups = await userUserGroupService.getAllUserUserGroups();
        res.status(200).json(userUserGroups);
    } catch (error) {
        res.status(500).json({ message: 'Error retrieving userUserGroups', error: error.message });
    }
};

module.exports = {
    createUserUserGroup,
    getUserUserGroupById,
    updateUserUserGroup,
    deleteUserUserGroup,
    getAllUserUserGroups,
};

const express = require('express');
const router = express.Router();
const userUserGroupController = require('../controllers/userUserGroup.controller');

// Routes for userUserGroup CRUD operations
router.post('/user-user-groups', userUserGroupController.createUserUserGroup);
router.get('/user-user-groups/:userId/:usergroupId', userUserGroupController.getUserUserGroupById);
router.put('/user-user-groups/:userId/:usergroupId', userUserGroupController.updateUserUserGroup);
router.delete('/user-user-groups/:userId/:usergroupId', userUserGroupController.deleteUserUserGroup);
router.get('/user-user-groups', userUserGroupController.getAllUserUserGroups);

module.exports = router;