1.Role

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

module.exports = new EntitySchema({
    name: 'Role',
    tableName: 'roles',
    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,
        },
    },
});

const { AppDataSource } = require('../../../index'); // Ensure the path is correct
const Role = require('../entities/role.entity');

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

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

const getRoles = async () => {
    try {
        const roles = await AppDataSource.getRepository(Role).find();
        return roles.map(formatRoleResponse);
    } catch (error) {
        throw new Error(`Failed to get roles: ${error.message}`);
    }
};

const getRoleById = async (id) => {
    try {
        const role = await AppDataSource.getRepository(Role).findOneBy({ id });
        return formatRoleResponse(role);
    } catch (error) {
        throw new Error(`Failed to get role by ID: ${error.message}`);
    }
};

const createRole = async (data) => {
    try {
        const roleRepository = AppDataSource.getRepository(Role);
        const newRole = roleRepository.create(data);
        const savedRole = await roleRepository.save(newRole);
        return formatRoleResponse(savedRole);
    } catch (error) {
        throw new Error(`Failed to create role: ${error.message}`);
    }
};

const updateRole = async (id, data) => {
    try {
        const roleRepository = AppDataSource.getRepository(Role);
        const role = await roleRepository.findOneBy({ id });

        if (!role) return null;

        roleRepository.merge(role, data);
        const updatedRole = await roleRepository.save(role);
        return formatRoleResponse(updatedRole);
    } catch (error) {
        throw new Error(`Failed to update role: ${error.message}`);
    }
};

const deleteRole = async (id) => {
    try {
        const roleRepository = AppDataSource.getRepository(Role);
        const role = await roleRepository.findOneBy({ id });

        if (!role) return 0;

        await roleRepository.delete(id);
        return 1; // Return 1 to indicate successful deletion
    } catch (error) {
        throw new Error(`Failed to delete role: ${error.message}`);
    }
};

const createDefaultRoles = async () => {
    try {
        const roleRepository = AppDataSource.getRepository(Role);

        const rolesToCreate = [
            { name: 'Admin', description: 'Full access to all resources.' },
            { name: 'Moderator', description: 'Can moderate user content.' },
            { name: 'Editor', description: 'Can edit and publish content.' },
            { name: 'Author', description: 'Can create and publish own content.' },
            { name: 'Subscriber', description: 'Can view content and manage own profile.' }
        ];

        for (const roleData of rolesToCreate) {
            const existingRole = await roleRepository.findOne({ where: { name: roleData.name } });

            if (!existingRole) {
                const newRole = roleRepository.create(roleData);
                await roleRepository.save(newRole);
                console.log(`Role created: ${roleData.name}`);
            } else {
                console.log(`Role already exists: ${roleData.name}`);
            }
        }
    } catch (error) {
        throw new Error(`Failed to create default roles: ${error.message}`);
    }
};

module.exports = {
    getRoles,
    getRoleById,
    createRole,
    updateRole,
    deleteRole,
    createDefaultRoles,
};

const roleService = require('../services/role.service');

/**
 * @function getRoles
 * @description Retrieves all roles.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const getRoles = async (req, res) => {
    try {
        const roles = await roleService.getRoles();
        if (!roles.length) {
            return res.status(404).json({ message: 'No roles found' });
        }
        res.status(200).json(roles);
    } catch (error) {
        res.status(500).json({ message: 'Failed to get roles', error: error.message });
    }
};

/**
 * @function getRoleById
 * @description Retrieves a role by ID.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const getRoleById = async (req, res) => {
    try {
        const role = await roleService.getRoleById(req.params.id);
        if (!role) {
            return res.status(404).json({ message: 'Role not found' });
        }
        res.status(200).json(role);
    } catch (error) {
        res.status(500).json({ message: 'Failed to get role', error: error.message });
    }
};

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

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

/**
 * @function deleteRole
 * @description Deletes a role by ID.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const deleteRole = async (req, res) => {
    try {
        const result = await roleService.deleteRole(req.params.id);
        if (result === 0) {
            return res.status(404).json({ message: 'Role not found' });
        }
        res.status(200).json({ message: 'Role deleted successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Failed to delete role', error: error.message });
    }
};

/**
 * @function createDefaultRoles
 * @description Creates default roles if they don't already exist.
 * @param {object} req - Request object.
 * @param {object} res - Response object.
 */
const createDefaultRoles = async (req, res) => {
    try {
        await roleService.createDefaultRoles();
        res.status(200).json({ message: 'Default roles created successfully' });
    } catch (error) {
        res.status(500).json({ message: 'Failed to create default roles', error: error.message });
    }
};

module.exports = {
    getRoles,
    getRoleById,
    createRole,
    updateRole,
    deleteRole,
    createDefaultRoles,
};

const express = require('express');
const router = express.Router();
const roleController = require('../controllers/role.controller');

// Define routes with corresponding controller methods
router.get('/roles', roleController.getRoles);
router.post('/roles', roleController.createRole); // Create a new role
router.get('/roles/:id', roleController.getRoleById); // Get role by ID
router.put('/roles/:id', roleController.updateRole); // Update role by ID
router.delete('/roles/:id', roleController.deleteRole); // Delete role by ID

// Route for creating default roles
router.post('/roles/default', roleController.createDefaultRoles);

module.exports = router;