refactor: systemController.js 새로운 유틸리티 적용

- 새로운 에러 처리 시스템 적용:
  * asyncHandler로 비동기 함수 래핑
  * ApiError 클래스 사용으로 일관된 에러 처리
  * handleDatabaseError로 DB 에러 표준화

- 새로운 응답 포맷터 적용:
  * res.health() - 시스템 상태 응답
  * res.success() - 일반 성공 응답
  * res.list() - 목록 조회 응답
  * res.created() - 생성 성공 응답

- 유효성 검사 시스템 적용:
  * validateSchema로 스키마 기반 검증
  * schemas.createUser 스키마 사용

- 함수별 개선사항:
  * getSystemStatus: 헬스체크 포맷터 적용
  * getDatabaseStatus: 성공 응답 포맷터 적용
  * getAllUsers: 목록 응답 포맷터 적용
  * createUser: 스키마 검증 및 생성 응답 포맷터 적용

api.hyungi.net/controllers/systemController.js

@@ -1,11 +1,13 @@
 // 시스템 관리 컨트롤러
 const { getDb } = require('../dbPool');
 const bcrypt = require('bcryptjs');
+const { ApiError, asyncHandler, handleDatabaseError } = require('../utils/errorHandler');
+const { validateSchema, schemas } = require('../utils/validator');
 
 /**
  * 시스템 상태 확인
  */
-exports.getSystemStatus = async (req, res) => {
+exports.getSystemStatus = asyncHandler(async (req, res) => {
   try {
     const db = await getDb();
     
@@ -15,31 +17,20 @@ exports.getSystemStatus = async (req, res) => {
     // 시스템 상태 정보
     const systemStatus = {
       server: 'online',
-      database: dbStatus.length > 0 ? 'online' : 'offline',
-      timestamp: new Date().toISOString(),
-      uptime: process.uptime(),
-      memory: process.memoryUsage(),
-      version: process.version
+      database: dbStatus.length > 0 ? 'online' : 'offline'
     };
     
-    res.json({
-      success: true,
-      data: systemStatus
-    });
+    res.health('healthy', systemStatus);
     
   } catch (error) {
-    console.error('시스템 상태 확인 오류:', error);
-    res.status(500).json({
-      success: false,
-      error: '시스템 상태를 확인할 수 없습니다.'
-    });
+    handleDatabaseError(error, '시스템 상태 확인');
   }
-};
+});
 
 /**
  * 데이터베이스 상태 확인
  */
-exports.getDatabaseStatus = async (req, res) => {
+exports.getDatabaseStatus = asyncHandler(async (req, res) => {
   try {
     const db = await getDb();
     
@@ -55,24 +46,19 @@ exports.getDatabaseStatus = async (req, res) => {
       WHERE table_schema = DATABASE()
     `);
     
-    res.json({
-      success: true,
-      data: {
-        status: 'online',
-        connections: parseInt(connections[0]?.Value || 0),
-        max_connections: parseInt(maxConnections[0]?.Value || 0),
-        size_mb: dbSize[0]?.size_mb || 0
-      }
-    });
+    const dbStatus = {
+      status: 'online',
+      connections: parseInt(connections[0]?.Value || 0),
+      max_connections: parseInt(maxConnections[0]?.Value || 0),
+      size_mb: dbSize[0]?.size_mb || 0
+    };
+    
+    res.success(dbStatus, '데이터베이스 상태 조회 성공');
     
   } catch (error) {
-    console.error('데이터베이스 상태 확인 오류:', error);
-    res.status(500).json({
-      success: false,
-      error: '데이터베이스 상태를 확인할 수 없습니다.'
-    });
+    handleDatabaseError(error, '데이터베이스 상태 확인');
   }
-};
+});
 
 /**
  * 시스템 알림 조회
@@ -252,7 +238,7 @@ exports.getUserStats = async (req, res) => {
 /**
  * 모든 사용자 목록 조회 (시스템 관리자용)
  */
-exports.getAllUsers = async (req, res) => {
+exports.getAllUsers = asyncHandler(async (req, res) => {
   try {
     const db = await getDb();
     
@@ -275,53 +261,36 @@ exports.getAllUsers = async (req, res) => {
       ORDER BY created_at DESC
     `);
     
-    res.json({
-      success: true,
-      data: users
-    });
+    res.list(users, '사용자 목록 조회 성공');
     
   } catch (error) {
-    console.error('사용자 목록 조회 오류:', error);
-    res.status(500).json({
-      success: false,
-      error: '사용자 목록을 조회할 수 없습니다.'
-    });
+    handleDatabaseError(error, '사용자 목록 조회');
   }
-};
+});
 
 /**
  * 사용자 생성
  */
-exports.createUser = async (req, res) => {
+exports.createUser = asyncHandler(async (req, res) => {
+  const { username, password, name, email, role, access_level, worker_id } = req.body;
+  
+  // 스키마 기반 유효성 검사
+  validateSchema(req.body, schemas.createUser);
+  
   try {
-    const { username, password, name, email, role, access_level, worker_id } = req.body;
     const db = await getDb();
     
-    // 필수 필드 검증
-    if (!username || !password || !name || !role) {
-      return res.status(400).json({
-        success: false,
-        error: '필수 정보가 누락되었습니다.'
-      });
-    }
-    
     // 사용자명 중복 확인
     const [existing] = await db.query('SELECT user_id FROM users WHERE username = ?', [username]);
     if (existing.length > 0) {
-      return res.status(409).json({
-        success: false,
-        error: '이미 존재하는 사용자명입니다.'
-      });
+      throw new ApiError('이미 존재하는 사용자명입니다.', 409);
     }
     
     // 이메일 중복 확인 (이메일이 제공된 경우)
     if (email) {
       const [existingEmail] = await db.query('SELECT user_id FROM users WHERE email = ?', [email]);
       if (existingEmail.length > 0) {
-        return res.status(409).json({
-          success: false,
-          error: '이미 사용 중인 이메일입니다.'
-        });
+        throw new ApiError('이미 사용 중인 이메일입니다.', 409);
       }
     }
     
@@ -340,20 +309,12 @@ exports.createUser = async (req, res) => {
       VALUES (?, ?, NOW(), 'initial')
     `, [result.insertId, req.user.user_id]);
     
-    res.status(201).json({
-      success: true,
-      message: '사용자가 성공적으로 생성되었습니다.',
-      user_id: result.insertId
-    });
+    res.created({ user_id: result.insertId }, '사용자가 성공적으로 생성되었습니다.');
     
   } catch (error) {
-    console.error('사용자 생성 오류:', error);
-    res.status(500).json({
-      success: false,
-      error: '사용자 생성 중 오류가 발생했습니다.'
-    });
+    handleDatabaseError(error, '사용자 생성');
   }
-};
+});
 
 /**
  * 사용자 수정