tk-factory-services/user-management/api/controllers/permissionController.js

/**
 * Permission Controller
 *
 * 페이지 권한 관리 (system3 page_permissions.py 포팅)
 */

const permissionModel = require('../models/permissionModel');
const userModel = require('../models/userModel');

/**
 * GET /api/users/:id/page-permissions - 사용자 권한 조회
 */
async function getUserPermissions(req, res, next) {
  try {
    const userId = parseInt(req.params.id);
    const requesterId = req.user.user_id || req.user.id;

    // 관리자이거나 본인만 조회 가능
    if (req.user.role !== 'admin' && requesterId !== userId) {
      return res.status(403).json({ success: false, error: '권한이 없습니다' });
    }

    const user = await userModel.findById(userId);
    if (!user) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다' });
    }

    const permissions = await permissionModel.getUserPermissions(userId);
    res.json(permissions);
  } catch (err) {
    next(err);
  }
}

/**
 * POST /api/permissions/grant - 단건 권한 부여
 */
async function grantPermission(req, res, next) {
  try {
    const { user_id, page_name, can_access, notes } = req.body;
    const grantedById = req.user.user_id || req.user.id;

    // 대상 사용자 확인
    const targetUser = await userModel.findById(user_id);
    if (!targetUser) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다' });
    }

    // 유효한 페이지명 확인
    if (!permissionModel.DEFAULT_PAGES[page_name]) {
      return res.status(400).json({ success: false, error: '유효하지 않은 페이지명입니다' });
    }

    const result = await permissionModel.grantPermission({
      user_id,
      page_name,
      can_access,
      granted_by_id: grantedById,
      notes
    });

    res.json({ success: true, message: '권한이 설정되었습니다', data: result });
  } catch (err) {
    next(err);
  }
}

/**
 * POST /api/permissions/bulk-grant - 일괄 권한 부여
 */
async function bulkGrant(req, res, next) {
  try {
    const { user_id, permissions } = req.body;
    const grantedById = req.user.user_id || req.user.id;

    // 대상 사용자 확인
    const targetUser = await userModel.findById(user_id);
    if (!targetUser) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다' });
    }

    const result = await permissionModel.bulkGrant({
      user_id,
      permissions,
      granted_by_id: grantedById
    });

    res.json({
      success: true,
      message: `${result.updated_count}개의 권한이 설정되었습니다`,
      updated_count: result.updated_count
    });
  } catch (err) {
    next(err);
  }
}

/**
 * GET /api/permissions/check/:uid/:page - 접근 권한 확인
 */
async function checkAccess(req, res, next) {
  try {
    const userId = parseInt(req.params.uid);
    const pageName = req.params.page;

    // 사용자 확인
    const user = await userModel.findById(userId);
    if (!user) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다' });
    }

    // admin은 모든 페이지 접근 가능
    if (user.role === 'admin') {
      return res.json({ can_access: true, reason: 'admin_role' });
    }

    const result = await permissionModel.checkAccess(userId, pageName);
    res.json(result);
  } catch (err) {
    next(err);
  }
}

/**
 * GET /api/permissions/available-pages - 설정 가능 페이지 목록
 */
async function getAvailablePages(req, res) {
  res.json({
    pages: permissionModel.DEFAULT_PAGES,
    total_count: Object.keys(permissionModel.DEFAULT_PAGES).length
  });
}

/**
 * DELETE /api/permissions/:id - 권한 삭제
 */
async function deletePermission(req, res, next) {
  try {
    const permissionId = parseInt(req.params.id);
    const deleted = await permissionModel.deletePermission(permissionId);

    if (!deleted) {
      return res.status(404).json({ success: false, error: '권한을 찾을 수 없습니다' });
    }

    res.json({ success: true, message: '권한이 삭제되었습니다. 기본값이 적용됩니다.' });
  } catch (err) {
    next(err);
  }
}

/**
 * GET /api/permissions/departments/:deptId/permissions - 부서 권한 조회
 */
async function getDepartmentPermissions(req, res, next) {
  try {
    const deptId = parseInt(req.params.deptId);
    const permissions = await permissionModel.getDepartmentPermissions(deptId);
    res.json({ success: true, data: permissions });
  } catch (err) {
    next(err);
  }
}

/**
 * POST /api/permissions/departments/:deptId/bulk-set - 부서 권한 일괄 설정
 * 저장 후 소속 사용자의 중복 개인 레코드 정리
 */
async function bulkSetDepartmentPermissions(req, res, next) {
  try {
    const deptId = parseInt(req.params.deptId);
    const { permissions } = req.body;
    const grantedById = req.user.user_id || req.user.id;

    const result = await permissionModel.bulkSetDepartmentPermissions({
      department_id: deptId,
      permissions,
      granted_by_id: grantedById
    });

    // 소속 사용자의 중복 개인 레코드 정리
    const { getPool } = require('../models/userModel');
    const db = getPool();
    const [deptUsers] = await db.query(
      'SELECT user_id FROM sso_users WHERE department_id = ?', [deptId]
    );

    // 부서가 허용한 페이지 목록
    const grantedPages = (permissions || [])
      .filter(p => p.can_access)
      .map(p => p.page_name);

    let syncedUsers = 0;
    if (grantedPages.length > 0 && deptUsers.length > 0) {
      for (const u of deptUsers) {
        const [delResult] = await db.query(
          `DELETE FROM user_page_permissions WHERE user_id = ? AND page_name IN (${grantedPages.map(() => '?').join(',')})`,
          [u.user_id, ...grantedPages]
        );
        if (delResult.affectedRows > 0) syncedUsers++;
      }
    }

    res.json({
      success: true,
      message: `${result.updated_count}개 부서 권한 설정 (${deptUsers.length}명 적용)`,
      updated_count: result.updated_count,
      synced_users: deptUsers.length
    });
  } catch (err) {
    next(err);
  }
}

/**
 * GET /api/permissions/users/:userId/effective-permissions - 출처 포함 권한 조회
 */
async function getUserPermissionsWithSource(req, res, next) {
  try {
    const userId = parseInt(req.params.userId);
    const requesterId = req.user.user_id || req.user.id;

    // 관리자이거나 본인만 조회 가능
    if (req.user.role !== 'admin' && requesterId !== userId) {
      return res.status(403).json({ success: false, error: '권한이 없습니다' });
    }

    const user = await userModel.findById(userId);
    if (!user) {
      return res.status(404).json({ success: false, error: '사용자를 찾을 수 없습니다' });
    }

    const result = await permissionModel.getUserPermissionsWithSource(userId);
    res.json({ success: true, ...result });
  } catch (err) {
    next(err);
  }
}

module.exports = {
  getUserPermissions,
  grantPermission,
  bulkGrant,
  checkAccess,
  getAvailablePages,
  deletePermission,
  getDepartmentPermissions,
  bulkSetDepartmentPermissions,
  getUserPermissionsWithSource
};