async function runBatch() {
  console.log(`[배치] 시작: ${new Date().toLocaleString('ko-KR')}`);

  // 1. API에서 전체 인원 가져오기
  const apiUsers = await fetchAllUsers();
  console.log(`[배치] API 응답: ${apiUsers.length}명`);

  // 2. DB 현재 상태 가져오기
  const dbUsers = await prisma.user.findMany();
  const dbMap = new Map(dbUsers.map(u => [u.usId, u]));
  const apiMap = new Map(apiUsers.map(u => [u.usId, u]));

  const historyRecords = [];

  // 3. 입사 감지 (API에 있고 DB에 없음)
  for (const [usId, apiUser] of apiMap) {
    if (!dbMap.has(usId)) {
      historyRecords.push({
        usId,
        changeType: 'JOIN',
        fieldName: null,
        oldValue: null,
        newValue: apiUser.usName,
      });
    }
  }

  // 4. 퇴사 감지 (DB에 있고 API에 없음)
  for (const [usId, dbUser] of dbMap) {
    if (!apiMap.has(usId)) {
      historyRecords.push({
        usId,
        changeType: 'LEAVE',
        fieldName: null,
        oldValue: dbUser.usName,
        newValue: null,
      });
    }
  }

  // 5. 변동 감지 (둘 다 있는데 값이 다름)
  const TRACKED_FIELDS = ['deptName', 'usRollName', 'usPosName'];

  for (const [usId, apiUser] of apiMap) {
    const dbUser = dbMap.get(usId);
    if (!dbUser) continue;

    for (const field of TRACKED_FIELDS) {
      const oldVal = dbUser[field] ?? null;
      const newVal = apiUser[field] ?? null;
      if (oldVal !== newVal) {
        historyRecords.push({
          usId,
          changeType: field === 'deptName' ? 'DEPT_CHANGE' : 'ROLE_CHANGE',
          fieldName: field,
          oldValue: oldVal,
          newValue: newVal,
        });
      }
    }
  }

  // 6. 이력 적재
  if (historyRecords.length > 0) {
    await prisma.userHistory.createMany({ data: historyRecords });
  }

  // 7. 현재 상태 upsert
  for (const user of apiUsers) {
    await prisma.user.upsert({
      where: { usId: user.usId },
      update: { ...user, updatedAt: new Date() },
      create: user,
    });
  }

  // 8. 퇴사자 DB에서 제거 (선택)
  const leaveIds = [...dbMap.keys()].filter(id => !apiMap.has(id));
  if (leaveIds.length > 0) {
    await prisma.user.deleteMany({ where: { usId: { in: leaveIds } } });
  }

  console.log(
    `[배치] 완료 — 입사 ${historyRecords.filter(h => h.changeType === 'JOIN').length}, ` +
    `퇴사 ${historyRecords.filter(h => h.changeType === 'LEAVE').length}, ` +
    `변동 ${historyRecords.filter(h => !['JOIN','LEAVE'].includes(h.changeType)).length}`
  );
}

// 매일 오전 1시 실행 (TZ=Asia/Seoul 필수)
cron.schedule('0 1 * * *', () => {
  runBatch().catch(err => console.error('[배치] 오류:', err));
});

docker exec insa-server node -e "require('./src/batch').runBatch().catch(console.error)"

npm install ag-grid-community ag-grid-react

import { AgGridReact } from 'ag-grid-react';
import 'ag-grid-community/styles/ag-grid.css';
import 'ag-grid-community/styles/ag-theme-alpine.css';

function UserGrid() {
  const columnDefs = [
    { field: 'usName',     headerName: '이름',   width: 100 },
    { field: 'deptName',   headerName: '부서',   flex: 1 },
    { field: 'usRollName', headerName: '직책',   width: 100 },
    { field: 'usPosName',  headerName: '직위',   width: 100 },
    { field: 'usMail1',    headerName: '이메일', flex: 1 },
  ];

  return (
    <div className="ag-theme-alpine" style={{ height: 600 }}>
      <AgGridReact
        rowData={users}
        columnDefs={columnDefs}
        pagination={true}
        paginationPageSize={50}
      />
    </div>
  );
}

AG Grid: As of v33, the grid uses a new Theming API by default.
CSS file imports (ag-theme-alpine.css etc.) are not compatible...

<AgGridReact
  theme="legacy"        // ← 이거 추가
  rowData={users}
  columnDefs={columnDefs}
  pagination={true}
  paginationPageSize={50}
/>

const [filters, setFilters] = useState({ dept: '', name: '', role: '' });

const filtered = useMemo(() => {
  return users.filter(u =>
    (!filters.dept || u.deptName?.includes(filters.dept)) &&
    (!filters.name || u.usName?.includes(filters.name)) &&
    (!filters.role || u.usRollName?.includes(filters.role))
  );
}, [users, filters]);

npm install @tanstack/react-query

// api.js
export const fetchUsers = (params) =>
  fetch(`/api/users?${new URLSearchParams(params)}`).then(r => r.json());

// UserGrid.jsx
const { data: users = [], isLoading, isError } = useQuery({
  queryKey: ['users', filters],
  queryFn: () => fetchUsers(filters),
  staleTime: 1000 * 60 * 5,  // 5분간 캐시 유지
});

if (isLoading) return <div>로딩 중...</div>;
if (isError)   return <div>데이터를 불러올 수 없습니다.</div>;

const queryClient = useQueryClient();

const updateMutation = useMutation({
  mutationFn: ({ usId, data }) =>
    fetch(`/api/users/${usId}`, {
      method: 'PUT',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(data),
    }).then(r => r.json()),

  onSuccess: () => {
    // 수정 후 목록 자동 갱신
    queryClient.invalidateQueries({ queryKey: ['users'] });
  },
});

function downloadCsv(rows, filename) {
  const headers = ['이름', '부서', '직책', '직위', '이메일', '휴대폰', '내선번호'];
  const fields  = ['usName', 'deptName', 'usRollName', 'usPosName', 'usMail1', 'usCellno', 'usTelno'];

  const csv = [
    headers.join(','),
    ...rows.map(row =>
      fields.map(f => `"${(row[f] ?? '').replace(/"/g, '""')}"`).join(',')
    ),
  ].join('\n');

  const blob = new Blob(['\uFEFF' + csv], { type: 'text/csv;charset=utf-8' });
  const url = URL.createObjectURL(blob);
  const a = document.createElement('a');
  a.href = url;
  a.download = filename;
  a.click();
  URL.revokeObjectURL(url);
}

// 서버: INSERT SQL 생성 API
app.post('/api/users/sql/insert', async (req, res) => {
  const { dept, name, role } = req.body;

  const users = await prisma.user.findMany({
    where: {
      deptName:   dept ? { contains: dept } : undefined,
      usName:     name ? { contains: name } : undefined,
      usRollName: role ? { contains: role } : undefined,
    },
  });

  const values = users.map(u =>
    `  ('${u.usId}', '${u.usName}', ${nullable(u.deptId)}, ${nullable(u.deptName)}, ` +
    `${nullable(u.usRollName)}, ${nullable(u.usPosName)}, ${nullable(u.usMail1)}, ` +
    `${nullable(u.usCellno)}, ${nullable(u.usTelno)})`
  ).join(',\n');

  const sql = `INSERT INTO users (us_id, us_name, dept_id, dept_name, us_roll_name, us_pos_name, us_mail1, us_cellno, us_telno)\nVALUES\n${values}\nON CONFLICT (us_id) DO UPDATE SET\n  us_name = EXCLUDED.us_name,\n  dept_name = EXCLUDED.dept_name,\n  us_roll_name = EXCLUDED.us_roll_name;`;

  res.json({ sql });
});

const nullable = v => v ? `'${v.replace(/'/g, "''")}'` : 'NULL';

// 클라이언트: 클립보드 복사
const { data } = useMutation({
  mutationFn: () => fetch('/api/users/sql/insert', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(filters),
  }).then(r => r.json()),
  onSuccess: ({ sql }) => {
    navigator.clipboard.writeText(sql);
    alert('SQL이 클립보드에 복사됐습니다.');
  },
});

/* App.css */
:root {
  --bg: #ffffff;
  --surface: #f8f9fa;
  --text: #1a1a1a;
  --border: #e0e0e0;
}

[data-theme="dark"] {
  --bg: #1a1a1a;
  --surface: #242424;
  --text: #e0e0e0;
  --border: #3a3a3a;
}

body {
  background: var(--bg);
  color: var(--text);
}

// App.jsx
const [theme, setTheme] = useState(
  () => localStorage.getItem('theme') || 'light'
);

useEffect(() => {
  document.documentElement.setAttribute('data-theme', theme);
  localStorage.setItem('theme', theme);
}, [theme]);

const toggleTheme = () =>
  setTheme(t => t === 'light' ? 'dark' : 'light');

const CHANGE_TYPES = {
  JOIN: 'JOIN',           // 신규 입사 (DB에 없던 usId 등장)
  LEAVE: 'LEAVE',         // 퇴사 (API 응답에서 usId 사라짐)
  DEPT_CHANGE: 'DEPT_CHANGE',   // 부서 이동
  ROLE_CHANGE: 'ROLE_CHANGE',   // 직책/직위 변경
};

// 알림 타입 배지 토글
document.querySelectorAll('.alert-badge').forEach(badge => {
  badge.addEventListener('click', async () => {
    const type = badge.dataset.type;
    const teamId = badge.closest('[data-team-id]').dataset.teamId;

    badge.classList.toggle('active');

    await fetch(`/api/teams/${teamId}/alert-types`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ type, enabled: badge.classList.contains('active') }),
    });
  });
});

async function fetchSlackMembers() {
  const res = await fetch('https://slack.com/api/users.list', {
    headers: { Authorization: `Bearer ${BOT_TOKEN}` },
  });
  const data = await res.json();
  return data.members
    .filter(m => !m.is_bot && !m.deleted)
    .map(m => ({
      id: m.id,
      name: m.profile.display_name || m.real_name,
    }));
}

// 버그 있는 코드
select.value = member.slackId;  // 항상 첫 번째로 스냅됨

// 해결: selectedIndex 직접 지정
const idx = [...select.options].findIndex(o => o.value === member.slackId);
if (idx !== -1) select.selectedIndex = idx;

// 크론 재등록 API
app.patch('/api/crons/:id', async (req, res) => {
  const { id } = req.params;
  const { enabled, schedule } = req.body;

  // 기존 크론 중지
  if (cronJobs[id]) {
    cronJobs[id].stop();
    delete cronJobs[id];
  }

  // 설정 저장
  settings.crons[id] = { enabled, schedule };
  await saveSettings();

  // 활성화 상태면 재등록
  if (enabled) {
    cronJobs[id] = cron.schedule(schedule, cronHandlers[id]);
  }

  res.json({ ok: true });
});

services:
  slack-bot:
    build: .
    container_name: slack-bot
    ports:
      - "3001:3000"
    env_file:
      - .env
    volumes:
      - ./data:/app/data
    restart: unless-stopped

LOGIN_ID=포털_아이디
LOGIN_PW=포털_비밀번호
PORT=3000
DATA_DIR=/app/data
TZ=Asia/Seoul

FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

# 최초 실행 또는 코드 변경 시
docker compose up -d --build

# .env만 변경 시
docker compose restart

# 로그 확인
docker logs slack-bot -f

# 외부 노출: 슬래시 커맨드, Slack 이벤트
location /slack/ {
    proxy_pass http://localhost:3001;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-Proto $scheme;
}

# 관리자 페이지는 Nginx에 열지 않음
# → Tailscale VPN으로만 접근: http://100.109.108.36:3001/admin

# .env에 추가
TZ=Asia/Seoul

// 해결: webhook 기준으로 dedup
function dedupeByWebhook(teams) {
  const seen = new Set();
  return teams.filter(t => {
    if (seen.has(t.webhook)) return false;
    seen.add(t.webhook);
    return true;
  });
}

// 서버 시작 시 snapshot.json 로드
async function loadSnapshot() {
  try {
    const raw = await fs.readFile(SNAPSHOT_PATH, 'utf8');
    return JSON.parse(raw);
  } catch {
    return { vacations: [], rooms: [], updatedAt: null };
  }
}

{
  "vacations": [
    {
      "id": "unique-key",
      "name": "홍길동",
      "date": "2026-04-03",
      "type": "연차"
    }
  ],
  "rooms": [
    {
      "id": "unique-key",
      "title": "주간 회의",
      "room": "중회의실",
      "start": "2026-04-03T10:00:00",
      "end": "2026-04-03T11:00:00"
    }
  ],
  "updatedAt": "2026-04-03T08:50:00.000Z"
}

function detectChanges(prev, curr, keyFn) {
  const prevMap = new Map(prev.map(item => [keyFn(item), item]));
  const currMap = new Map(curr.map(item => [keyFn(item), item]));

  const added   = curr.filter(item => !prevMap.has(keyFn(item)));
  const removed = prev.filter(item => !currMap.has(keyFn(item)));

  return { added, removed };
}

// 휴가 변동 감지
const vacationChanges = detectChanges(
  snapshot.vacations,
  freshVacations,
  v => `${v.id}_${v.date}`
);

// 회의실 변동 감지
const roomChanges = detectChanges(
  snapshot.rooms,
  freshRooms,
  r => r.id
);

const snapshotDate = snapshot.updatedAt?.slice(0, 10);
const today = new Date().toISOString().slice(0, 10);

// 날짜가 같을 때만 변동 비교 (날짜 변경 시 오탐 방지)
if (snapshotDate === today) {
  const roomChanges = detectChanges(snapshot.rooms, freshRooms, r => r.id);
  if (roomChanges.added.length || roomChanges.removed.length) {
    await notifyRoomChanges(roomChanges);
  }
}

async function saveSnapshot(vacations, rooms) {
  const snapshot = {
    vacations,
    rooms,
    updatedAt: new Date().toISOString(),
  };
  await fs.writeFile(SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2));
}

const cron = require('node-cron');

// 10분마다: 변동 감지
cron.schedule('*/10 * * * *', () => syncAndCheckChanges());

// 월요일 09시: 이번 주 전체 휴가자
cron.schedule('0 9 * * 1', () => sendVacationWeekly());

// 화~금 09시: 당일 휴가자
cron.schedule('0 9 * * 2-5', () => sendVacationDaily());

// 월~금 09시: 당일 회의실 예약
cron.schedule('0 9 * * 1-5', () => sendRoomDaily());

// 월~금 09시: 출근 미등록자 DM
cron.schedule('0 9 * * 1-5', () => sendCommuteAlert());

// 30분마다: 세션 keepalive
cron.schedule('*/30 * * * *', () => keepSession());

// 월요일 00시: 로그 초기화
cron.schedule('0 0 * * 1', () => resetLog());

{
  "crons": {
    "sync":           { "enabled": true,  "schedule": "*/10 * * * *" },
    "vacationWeekly": { "enabled": true,  "schedule": "0 9 * * 1" },
    "vacationDaily":  { "enabled": true,  "schedule": "0 9 * * 2-5" },
    "roomDaily":      { "enabled": true,  "schedule": "0 9 * * 1-5" },
    "commute":        { "enabled": true,  "schedule": "0 9 * * 1-5" },
    "sessionKeep":    { "enabled": true,  "schedule": "*/30 * * * *" },
    "logReset":       { "enabled": true,  "schedule": "0 0 * * 1" }
  }
}

const settings = JSON.parse(await fs.readFile(SETTINGS_PATH));
const cronJobs = {};

for (const [id, config] of Object.entries(settings.crons)) {
  if (!config.enabled) continue;
  cronJobs[id] = cron.schedule(config.schedule, cronHandlers[id]);
}

async function sendWebhook(webhookUrl, message) {
  await axios.post(webhookUrl, { text: message });
}

{
  "teams": [
    {
      "name": "개발팀",
      "webhook": "https://hooks.slack.com/...",
      "enabled": true,
      "alertTypes": {
        "vacationChange": true,
        "vacationDaily": true,
        "roomChange": false,
        "roomDaily": true,
        "commute": false
      },
      "deptIds": ["0001", "0002"]
    }
  ]
}

async function notifyByType(type, message) {
  const teams = settings.teams.filter(
    t => t.enabled && t.alertTypes[type]
  );
  for (const team of teams) {
    await sendWebhook(team.webhook, message);
  }
}

function dedupeByWebhook(teams) {
  const seen = new Set();
  return teams.filter(team => {
    if (seen.has(team.webhook)) return false;
    seen.add(team.webhook);
    return true;
  });
}

async function notifyByType(type, message) {
  const teams = dedupeByWebhook(
    settings.teams.filter(t => t.enabled && t.alertTypes[type])
  );
  for (const team of teams) {
    await sendWebhook(team.webhook, message);
  }
}

app.post('/slack/command', async (req, res) => {
  const { command, text, channel_id } = req.body;

  // Slack에 일단 빈 응답 먼저 → 3초 타임아웃 방지
  res.json({ response_type: 'ephemeral', text: '조회 중...' });

  // 실제 처리는 비동기로
  const result = await handleCommand(command, text, channel_id);
  await axios.post(req.body.response_url, {
    response_type: 'in_channel',
    text: result,
  });
});

function parseDate(text) {
  if (!text || text === '오늘') return [today(), today()];
  if (text === '내일') return [tomorrow(), tomorrow()];
  if (text === '이번주') return [monday(), friday()];
  if (text.includes('~')) {
    const [start, end] = text.split('~').map(s => s.trim());
    return [start, end];
  }
  // 날짜 직접 입력: '2026-04-03'
  return [text.trim(), text.trim()];
}

function getTeamByChannel(channelId) {
  // 1. 채널 ID로 팀 매칭
  const team = teams.find(t => t.channelId === channelId);
  if (team) return team;

  // 2. 실패 시 → 사용자 Slack 이름에서 팀 추출
  // 3. 그것도 실패 시 → 전체 팀 그룹핑해서 표시
  return null;
}

function parseCookies(setCookieHeader) {
  if (!setCookieHeader) return '';
  const cookies = Array.isArray(setCookieHeader)
    ? setCookieHeader
    : [setCookieHeader];
  return cookies
    .map(c => c.split(';')[0])  // 'name=value; Path=/' → 'name=value'
    .join('; ');
}

const initRes = await axios.get('https://portal.company.com/login', {
  maxRedirects: 0,
  validateStatus: s => s < 400,
});
let cookie = parseCookies(initRes.headers['set-cookie']);

const loginRes = await axios.post(
  'https://portal.company.com/login/check',
  new URLSearchParams({
    id: process.env.LOGIN_ID,
    password: process.env.LOGIN_PW,
  }),
  {
    headers: {
      Cookie: cookie,
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    maxRedirects: 0,
    validateStatus: s => s < 400,
  }
);
cookie = parseCookies(loginRes.headers['set-cookie']) || cookie;

const ssoRes = await axios.get('https://portal.company.com/sso-redirect', {
  headers: { Cookie: cookie },
  maxRedirects: 0,  // 리다이렉트 수동으로 따라가야 함
  validateStatus: s => s < 400,
});

// 리다이렉트 URL에서 토큰 추출
const ssoUrl = ssoRes.headers['location'];

const domainRes = await axios.get(ssoUrl, {
  maxRedirects: 5,  // 여기서는 따라가도 됨
  validateStatus: s => s < 400,
});
const domainCookie = parseCookies(domainRes.headers['set-cookie']);

// 서버 시작 시 두 도메인 모두 로그인
let avsCookie = await login('leave');  // 휴가 도메인
let gwCookie  = await login('gw');     // 회의실 도메인

// API 호출 시 해당 도메인 쿠키 사용
async function getVacation(date) {
  return axios.post(VACATION_API_URL, payload, {
    headers: { Cookie: avsCookie, ...customHeaders },
  });
}

async function getMeetingRooms(date) {
  return axios.post(ROOM_API_URL, payload, {
    headers: { Cookie: gwCookie, ...customHeaders },
  });
}

const customHeaders = {
  '__service_id__': 'SERVICE_NAME',
  '__view_id__': 'view-identifier',
  '__menu_id__': 'MENU_CODE',
  'ajax': 'true',
  'x-requested-with': 'XMLHttpRequest',
};

cron.schedule('*/30 * * * *', async () => {
  try {
    // 세션 페이지에 GET 요청으로 keepalive
    await axios.get(SESSION_KEEP_URL, {
      headers: { Cookie: avsCookie },
    });
    await axios.get(SESSION_KEEP_URL_GW, {
      headers: { Cookie: gwCookie },
    });
  } catch (err) {
    // 실패 시 재로그인
    avsCookie = await login('leave');
    gwCookie  = await login('gw');
  }
});

const cache = new Map();
const CACHE_TTL = 15 * 60 * 1000; // 15분

async function fetchWithCache(key, fetchFn) {
  const cached = cache.get(key);
  if (cached && Date.now() - cached.time < CACHE_TTL) {
    return cached.data;
  }
  const data = await fetchFn();
  cache.set(key, { data, time: Date.now() });
  return data;
}