7.RolePermission(কোন রোলের কোন পারমিশন)

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

module.exports = new EntitySchema({
    name: 'RolePermission',
    tableName: 'role_permissions',
    columns: {
        roleId: {
            name: 'role_id',
            type: 'int',
            primary: true,
        },
        permissionId: {
            name: 'permission_id',
            type: 'int',
            primary: true,
        },
    },
    relations: {
        role: {
            type: 'many-to-one',
            target: 'Role',
            joinColumn: { name: 'role_id' },
            onDelete: 'CASCADE',
        },
        permission: {
            type: 'many-to-one',
            target: 'Permission',
            joinColumn: { name: 'permission_id' },
            onDelete: 'CASCADE',
        },
    },
});

const { AppDataSource } = require('../../../index');
const RolePermission = require('../entities/rolePermission.entity');

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

/**
 * Create a new RolePermission entry.
 * @param {object} data - The data to create the rolePermission.
 * @returns {Promise<object>} - The saved rolePermission response.
 */
const createRolePermission = async (data) => {
    const rolePermissionRepository = AppDataSource.getRepository(RolePermission);
    const rolePermission = rolePermissionRepository.create(data);
    const savedRolePermission = await rolePermissionRepository.save(rolePermission);
    return formatRolePermissionResponse(savedRolePermission);
};

/**
 * Find a RolePermission by its roleId and permissionId.
 * @param {number} roleId - The ID of the role.
 * @param {number} permissionId - The ID of the permission.
 * @returns {Promise<object>} - The found rolePermission or null.
 */
const findRolePermissionById = async (roleId, permissionId) => {
    const rolePermissionRepository = AppDataSource.getRepository(RolePermission);
    const rolePermission = await rolePermissionRepository.findOne({
        where: { roleId, permissionId },
    });
    return formatRolePermissionResponse(rolePermission);
};

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

    Object.assign(rolePermission, newData); // Update the existing fields
    const updatedRolePermission = await rolePermissionRepository.save(rolePermission);
    return formatRolePermissionResponse(updatedRolePermission);
};

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

/**
 * Get all RolePermission entries.
 * @returns {Promise<Array>} - List of all rolePermissions.
 */
const getAllRolePermissions = async () => {
    const rolePermissionRepository = AppDataSource.getRepository(RolePermission);
    const rolePermissions = await rolePermissionRepository.find();
    return rolePermissions.map(formatRolePermissionResponse);
};

module.exports = {
    createRolePermission,
    findRolePermissionById,
    updateRolePermission,
    deleteRolePermission,
    getAllRolePermissions,
};

const rolePermissionService = require('../services/rolePermission.service');

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

    try {
        const newRolePermission = await rolePermissionService.createRolePermission({ roleId, permissionId });
        res.status(201).json({ message: 'RolePermission created successfully', rolePermission: newRolePermission });
    } catch (error) {
        res.status(500).json({ message: 'Error creating rolePermission', error: error.message });
    }
};

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

    try {
        const rolePermission = await rolePermissionService.findRolePermissionById(roleId, permissionId);
        if (!rolePermission) {
            return res.status(404).json({ message: 'RolePermission not found' });
        }
        res.status(200).json(rolePermission);
    } catch (error) {
        res.status(500).json({ message: 'Error retrieving rolePermission', error: error.message });
    }
};

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

    try {
        const updatedRolePermission = await rolePermissionService.updateRolePermission(roleId, permissionId, newData);
        if (!updatedRolePermission) {
            return res.status(404).json({ message: 'RolePermission not found' });
        }
        res.status(200).json({ message: 'RolePermission updated successfully', rolePermission: updatedRolePermission });
    } catch (error) {
        res.status(500).json({ message: 'Error updating rolePermission', error: error.message });
    }
};

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

    try {
        const deleted = await rolePermissionService.deleteRolePermission(roleId, permissionId);
        if (!deleted) {
            return res.status(404).json({ message: 'RolePermission not found' });
        }
        res.status(200).json({ message: 'RolePermission deleted successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Error deleting rolePermission', error: error.message });
    }
};

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

module.exports = {
    createRolePermission,
    getRolePermissionById,
    updateRolePermission,
    deleteRolePermission,
    getAllRolePermissions,
};

const express = require('express');
const router = express.Router();
const rolePermissionController = require('../controllers/rolePermission.controller');

// Routes for rolePermission CRUD operations
router.post('/role-permissions', rolePermissionController.createRolePermission);
router.get('/role-permissions/:roleId/:permissionId', rolePermissionController.getRolePermissionById);
router.put('/role-permissions/:roleId/:permissionId', rolePermissionController.updateRolePermission);
router.delete('/role-permissions/:roleId/:permissionId', rolePermissionController.deleteRolePermission);
router.get('/role-permissions', rolePermissionController.getAllRolePermissions);

module.exports = router;