8.UserGroupPermission (কোন UserGroup এর কোন পারমিশন )

const { AppDataSource } = require('../../../index');
const UserGroupPermission = require('../entities/userGroupPermission.entity');

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

/**
 * Create a new UserGroupPermission entry.
 * @param {object} data - The data to create the userGroupPermission.
 * @returns {Promise<object>} - The saved userGroupPermission response.
 */
const createUserGroupPermission = async (data) => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const userGroupPermission = userGroupPermissionRepository.create(data);
    const savedUserGroupPermission = await userGroupPermissionRepository.save(userGroupPermission);
    return formatUserGroupPermissionResponse(savedUserGroupPermission);
};

/**
 * Find a UserGroupPermission by its groupId and permissionId.
 * @param {number} groupId - The ID of the group.
 * @param {number} permissionId - The ID of the permission.
 * @returns {Promise<object>} - The found userGroupPermission or null.
 */
const findUserGroupPermissionByGroupIdAndPermissionId = async (groupId, permissionId) => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const userGroupPermission = await userGroupPermissionRepository.findOne({
        where: { groupId, permissionId },
    });
    return formatUserGroupPermissionResponse(userGroupPermission);
};

/**
 * Update a UserGroupPermission entry.
 * @param {number} groupId - The ID of the group.
 * @param {number} permissionId - The ID of the permission.
 * @param {object} newData - The data to update the userGroupPermission.
 * @returns {Promise<object>} - The updated userGroupPermission or null if not found.
 */
const updateUserGroupPermission = async (groupId, permissionId, newData) => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const userGroupPermission = await userGroupPermissionRepository.findOne({ where: { groupId, permissionId } });
    if (!userGroupPermission) return null;

    Object.assign(userGroupPermission, newData); // Update the existing fields
    const updatedUserGroupPermission = await userGroupPermissionRepository.save(userGroupPermission);
    return formatUserGroupPermissionResponse(updatedUserGroupPermission);
};

/**
 * Delete a UserGroupPermission by groupId and permissionId.
 * @param {number} groupId - The ID of the group.
 * @param {number} permissionId - The ID of the permission.
 * @returns {Promise<number>} - Number of affected rows (0 if not found).
 */
const deleteUserGroupPermission = async (groupId, permissionId) => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const result = await userGroupPermissionRepository.delete({ groupId, permissionId });
    return result.affected; // Returns 1 if deleted, 0 if not found
};

/**
 * Get all UserGroupPermission entries.
 * @returns {Promise<Array>} - List of all userGroupPermissions.
 */
const getAllUserGroupPermissions = async () => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const userGroupPermissions = await userGroupPermissionRepository.find();
    return userGroupPermissions.map(formatUserGroupPermissionResponse);
};


/**
 * Get permissions by userGroupId.
 * @param {number} userGroupId - The ID of the user group.
 * @returns {Promise<Array>} - List of permissions belonging to the user group.
 */
const getPermissionsByUserGroup = async (userGroupId) => {
    const userGroupPermissionRepository = AppDataSource.getRepository(UserGroupPermission);
    const permissions = await userGroupPermissionRepository.find({
        where: { groupId: userGroupId },
        relations: ['permission'], // Assuming there's a relation to a Permission entity
    });
    return permissions.map((userGroupPermission) => userGroupPermission.permission); // Returning the permissions
};

/**
 * Get permissions not in the userGroupId.
 * @param {number} userGroupId - The ID of the user group.
 * @returns {Promise<Array>} - List of permissions not in the user group.
 */
const getPermissionsNotInUserGroup = async (userGroupId) => {
    const permissionRepository = AppDataSource.getRepository(Permission); // Assuming Permission entity exists
    const userGroupPermissions = await AppDataSource.getRepository(UserGroupPermission).find({
        where: { groupId: userGroupId },
    });
    const groupPermissionIds = userGroupPermissions.map((ugp) => ugp.permissionId);
    
    const permissionsNotInGroup = await permissionRepository.createQueryBuilder('permission')
        .where('permission.id NOT IN (:...ids)', { ids: groupPermissionIds })
        .getMany();

    return permissionsNotInGroup;
};


module.exports = {
    createUserGroupPermission,
    findUserGroupPermissionByGroupIdAndPermissionId,
    updateUserGroupPermission,
    deleteUserGroupPermission,
    getAllUserGroupPermissions,
    getPermissionsByUserGroup,
    getPermissionsNotInUserGroup,
};

const userGroupPermissionService = require('../services/userGroupPermission.service');

/**
 * Create a new UserGroupPermission entry.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const createUserGroupPermission = async (req, res) => {
    try {
        const data = req.body;
        const userGroupPermission = await userGroupPermissionService.createUserGroupPermission(data);
        res.status(201).json({ userGroupPermission });
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Get a UserGroupPermission by groupId and permissionId.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const getUserGroupPermission = async (req, res) => {
    try {
        const { groupId, permissionId } = req.params;
        const userGroupPermission = await userGroupPermissionService.findUserGroupPermissionByGroupIdAndPermissionId(groupId, permissionId);
        if (userGroupPermission) {
            res.status(200).json({ userGroupPermission });
        } else {
            res.status(404).json({ message: 'UserGroupPermission not found' });
        }
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Update a UserGroupPermission entry.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const updateUserGroupPermission = async (req, res) => {
    try {
        const { groupId, permissionId } = req.params;
        const newData = req.body;
        const updatedUserGroupPermission = await userGroupPermissionService.updateUserGroupPermission(groupId, permissionId, newData);
        if (updatedUserGroupPermission) {
            res.status(200).json({ updatedUserGroupPermission });
        } else {
            res.status(404).json({ message: 'UserGroupPermission not found' });
        }
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Delete a UserGroupPermission entry.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const deleteUserGroupPermission = async (req, res) => {
    try {
        const { groupId, permissionId } = req.params;
        const affectedRows = await userGroupPermissionService.deleteUserGroupPermission(groupId, permissionId);
        if (affectedRows > 0) {
            res.status(200).json({ message: 'UserGroupPermission deleted successfully' });
        } else {
            res.status(404).json({ message: 'UserGroupPermission not found' });
        }
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Get all UserGroupPermission entries.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const getAllUserGroupPermissions = async (req, res) => {
    try {
        const userGroupPermissions = await userGroupPermissionService.getAllUserGroupPermissions();
        res.status(200).json({ userGroupPermissions });
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Get permissions associated with a user group.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const getPermissionsByUserGroup = async (req, res) => {
    try {
        const { userGroupId } = req.params;
        const permissions = await userGroupPermissionService.getPermissionsByUserGroup(userGroupId);
        res.status(200).json({ permissions });
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};

/**
 * Get permissions not associated with a user group.
 * @param {object} req - Request object
 * @param {object} res - Response object
 * @returns {Promise<void>}
 */
const getPermissionsNotInUserGroup = async (req, res) => {
    try {
        const { userGroupId } = req.params;
        const permissions = await userGroupPermissionService.getPermissionsNotInUserGroup(userGroupId);
        res.status(200).json({ permissions });
    } catch (error) {
        res.status(500).json({ message: error.message });
    }
};


module.exports = {
    createUserGroupPermission,
    getUserGroupPermission,
    updateUserGroupPermission,
    deleteUserGroupPermission,
    getAllUserGroupPermissions,
    getPermissionsByUserGroup,
    getPermissionsNotInUserGroup,
};

const express = require('express');
const router = express.Router();
const userGroupPermissionController = require('../controllers/userGroupPermission.controller');

// Create a new UserGroupPermission entry
router.post('/user-group-permissions', userGroupPermissionController.createUserGroupPermission);

// Get a UserGroupPermission by groupId and permissionId
router.get('/user-group-permissions/:groupId/:permissionId', userGroupPermissionController.getUserGroupPermission);

// Update a UserGroupPermission entry
router.put('/user-group-permissions/:groupId/:permissionId', userGroupPermissionController.updateUserGroupPermission);

// Delete a UserGroupPermission entry
router.delete('/user-group-permissions/:groupId/:permissionId', userGroupPermissionController.deleteUserGroupPermission);

// Get all UserGroupPermission entries
router.get('/user-group-permissions', userGroupPermissionController.getAllUserGroupPermissions);

// Fetch permissions belonging to a user group
router.get('/user-group-permissions/:userGroupId/permissions', userGroupPermissionController.getPermissionsByUserGroup);

// Fetch permissions not belonging to a user group
router.get('/user-group-permissions/:userGroupId/permissions-not-in', userGroupPermissionController.getPermissionsNotInUserGroup);


module.exports = router;

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