feat(purchase): 소모품 신청 시스템 v2 — 모바일 최적화, 스마트 검색, 그룹화, 입고 알림

- 4단계 상태 플로우: pending → grouped → purchased → received
- 한국어 스마트 검색: 초성 매칭(ㅁㅈㄱ→면장갑), 별칭 테이블, 인메모리 캐시
- 모바일 전용 신청 페이지: 바텀시트 UI, FAB, 카드 리스트, 스크롤 페이지네이션
- 인라인 품목 등록: 미등록 품목 검색→등록→신청 단일 트랜잭션
- 관리자 그룹화: 체크박스 다중 선택, 구매 그룹(batch) 생성/일괄 구매/입고
- 입고 처리: 사진+보관위치 등록, 부분 입고 허용, batch 자동 상태 전환
- 알림: notifyHelper에 target_user_ids 추가, 구매진행중/입고완료 시 신청자 ntfy+push

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

system1-factory/api/config/routes.js

@@ -53,6 +53,8 @@ function setupRoutes(app) {
   const purchaseRequestRoutes = require('../routes/purchaseRequestRoutes');
   const purchaseRoutes = require('../routes/purchaseRoutes');
   const settlementRoutes = require('../routes/settlementRoutes');
+  const itemAliasRoutes = require('../routes/itemAliasRoutes');
+  const purchaseBatchRoutes = require('../routes/purchaseBatchRoutes');
   const scheduleRoutes = require('../routes/scheduleRoutes');
   const meetingRoutes = require('../routes/meetingRoutes');
   const proxyInputRoutes = require('../routes/proxyInputRoutes');
@@ -166,6 +168,8 @@ function setupRoutes(app) {
   app.use('/api/purchase-requests', purchaseRequestRoutes); // 구매신청
   app.use('/api/purchases', purchaseRoutes); // 구매 내역
   app.use('/api/settlements', settlementRoutes); // 월간 정산
+  app.use('/api/item-aliases', itemAliasRoutes); // 품목 별칭
+  app.use('/api/purchase-batches', purchaseBatchRoutes); // 구매 그룹
   app.use('/api/schedule', scheduleRoutes); // 공정표
   app.use('/api/meetings', meetingRoutes); // 생산회의록
   app.use('/api/proxy-input', proxyInputRoutes); // 대리입력 + 일별현황

system1-factory/api/controllers/itemAliasController.js

@@ -0,0 +1,47 @@
+const ItemAliasModel = require('../models/itemAliasModel');
+const koreanSearch = require('../utils/koreanSearch');
+const logger = require('../utils/logger');
+
+const ItemAliasController = {
+  getAll: async (req, res) => {
+    try {
+      const rows = await ItemAliasModel.getAll();
+      res.json({ success: true, data: rows });
+    } catch (err) {
+      logger.error('ItemAlias getAll error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  create: async (req, res) => {
+    try {
+      const { item_id, alias_name } = req.body;
+      if (!item_id || !alias_name || !alias_name.trim()) {
+        return res.status(400).json({ success: false, message: '품목 ID와 별칭을 입력해주세요.' });
+      }
+      const id = await ItemAliasModel.create(item_id, alias_name);
+      koreanSearch.clearCache();
+      res.status(201).json({ success: true, data: { alias_id: id }, message: '별칭이 등록되었습니다.' });
+    } catch (err) {
+      if (err.code === 'ER_DUP_ENTRY') {
+        return res.status(400).json({ success: false, message: '이미 등록된 별칭입니다.' });
+      }
+      logger.error('ItemAlias create error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  delete: async (req, res) => {
+    try {
+      const deleted = await ItemAliasModel.delete(req.params.id);
+      if (!deleted) return res.status(404).json({ success: false, message: '별칭을 찾을 수 없습니다.' });
+      koreanSearch.clearCache();
+      res.json({ success: true, message: '별칭이 삭제되었습니다.' });
+    } catch (err) {
+      logger.error('ItemAlias delete error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  }
+};
+
+module.exports = ItemAliasController;

system1-factory/api/controllers/purchaseBatchController.js

@@ -0,0 +1,175 @@
+const PurchaseBatchModel = require('../models/purchaseBatchModel');
+const PurchaseRequestModel = require('../models/purchaseRequestModel');
+const { saveBase64Image } = require('../services/imageUploadService');
+const logger = require('../utils/logger');
+const notifyHelper = require('../../../shared/utils/notifyHelper');
+
+const PurchaseBatchController = {
+  getAll: async (req, res) => {
+    try {
+      const { status } = req.query;
+      const rows = await PurchaseBatchModel.getAll({ status });
+      res.json({ success: true, data: rows });
+    } catch (err) {
+      logger.error('PurchaseBatch getAll error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  getById: async (req, res) => {
+    try {
+      const batch = await PurchaseBatchModel.getById(req.params.id);
+      if (!batch) return res.status(404).json({ success: false, message: '그룹을 찾을 수 없습니다.' });
+      // 포함된 요청 목록도 함께 반환
+      const requests = await PurchaseRequestModel.getAll({ batch_id: req.params.id });
+      res.json({ success: true, data: { ...batch, requests } });
+    } catch (err) {
+      logger.error('PurchaseBatch getById error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  // 그룹 생성 + 요청 포함
+  create: async (req, res) => {
+    try {
+      const { batch_name, category, vendor_id, notes, request_ids } = req.body;
+      if (!request_ids || !request_ids.length) {
+        return res.status(400).json({ success: false, message: '그룹에 포함할 신청 건을 선택해주세요.' });
+      }
+
+      const batchId = await PurchaseBatchModel.create({
+        batchName: batch_name,
+        category,
+        vendorId: vendor_id,
+        notes,
+        createdBy: req.user.id
+      });
+
+      await PurchaseBatchModel.addRequests(batchId, request_ids);
+
+      // 신청자들에게 알림
+      const requesterIds = await PurchaseRequestModel.getRequesterIdsByBatch(batchId);
+      if (requesterIds.length > 0) {
+        notifyHelper.send({
+          type: 'purchase',
+          title: '구매 진행 안내',
+          message: '신청하신 소모품 구매가 진행됩니다.',
+          link_url: '/pages/purchase/request-mobile.html',
+          target_user_ids: requesterIds,
+          created_by: req.user.id
+        }).catch(() => {});
+      }
+
+      const batch = await PurchaseBatchModel.getById(batchId);
+      res.status(201).json({ success: true, data: batch, message: '그룹이 생성되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseBatch create error:', err);
+      res.status(400).json({ success: false, message: err.message || '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  update: async (req, res) => {
+    try {
+      const { batch_name, category, vendor_id, notes, add_request_ids, remove_request_ids } = req.body;
+      const batch = await PurchaseBatchModel.getById(req.params.id);
+      if (!batch) return res.status(404).json({ success: false, message: '그룹을 찾을 수 없습니다.' });
+
+      if (batch_name !== undefined || category !== undefined || vendor_id !== undefined || notes !== undefined) {
+        await PurchaseBatchModel.update(req.params.id, {
+          batchName: batch_name !== undefined ? batch_name : batch.batch_name,
+          category: category !== undefined ? category : batch.category,
+          vendorId: vendor_id !== undefined ? vendor_id : batch.vendor_id,
+          notes: notes !== undefined ? notes : batch.notes
+        });
+      }
+
+      if (add_request_ids && add_request_ids.length) {
+        await PurchaseBatchModel.addRequests(req.params.id, add_request_ids);
+      }
+      if (remove_request_ids && remove_request_ids.length) {
+        await PurchaseBatchModel.removeRequests(req.params.id, remove_request_ids);
+      }
+
+      const updated = await PurchaseBatchModel.getById(req.params.id);
+      res.json({ success: true, data: updated, message: '그룹이 수정되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseBatch update error:', err);
+      res.status(400).json({ success: false, message: err.message || '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  delete: async (req, res) => {
+    try {
+      const deleted = await PurchaseBatchModel.delete(req.params.id);
+      if (!deleted) return res.status(400).json({ success: false, message: '대기 상태의 그룹만 삭제할 수 있습니다.' });
+      res.json({ success: true, message: '그룹이 삭제되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseBatch delete error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  // 그룹 일괄 구매 처리
+  purchase: async (req, res) => {
+    try {
+      const batch = await PurchaseBatchModel.getById(req.params.id);
+      if (!batch) return res.status(404).json({ success: false, message: '그룹을 찾을 수 없습니다.' });
+      if (batch.status !== 'pending') {
+        return res.status(400).json({ success: false, message: '대기 상태의 그룹만 구매 처리할 수 있습니다.' });
+      }
+
+      // batch 내 모든 요청 purchased 전환
+      await PurchaseRequestModel.markBatchPurchased(req.params.id);
+      await PurchaseBatchModel.markPurchased(req.params.id, req.user.id);
+
+      res.json({ success: true, message: '일괄 구매 처리가 완료되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseBatch purchase error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  // 그룹 일괄 입고 처리
+  receive: async (req, res) => {
+    try {
+      const batch = await PurchaseBatchModel.getById(req.params.id);
+      if (!batch) return res.status(404).json({ success: false, message: '그룹을 찾을 수 없습니다.' });
+      if (batch.status !== 'purchased') {
+        return res.status(400).json({ success: false, message: '구매완료 상태의 그룹만 입고 처리할 수 있습니다.' });
+      }
+
+      const { received_location, photo } = req.body;
+      let receivedPhotoPath = null;
+      if (photo) {
+        receivedPhotoPath = await saveBase64Image(photo, 'received', 'purchase_received');
+      }
+
+      await PurchaseRequestModel.receiveBatch(req.params.id, {
+        receivedPhotoPath,
+        receivedLocation: received_location,
+        receivedBy: req.user.id
+      });
+      await PurchaseBatchModel.markReceived(req.params.id, req.user.id);
+
+      // 신청자들에게 입고 알림
+      const requesterIds = await PurchaseRequestModel.getRequesterIdsByBatch(req.params.id);
+      if (requesterIds.length > 0) {
+        notifyHelper.send({
+          type: 'purchase',
+          title: '소모품 입고 완료',
+          message: `소모품이 입고되었습니다.${received_location ? ' 보관위치: ' + received_location : ''}`,
+          link_url: '/pages/purchase/request-mobile.html',
+          target_user_ids: requesterIds,
+          created_by: req.user.id
+        }).catch(() => {});
+      }
+
+      res.json({ success: true, message: '일괄 입고 처리가 완료되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseBatch receive error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  }
+};
+
+module.exports = PurchaseBatchController;

system1-factory/api/controllers/purchaseRequestController.js

@@ -2,14 +2,16 @@ const PurchaseRequestModel = require('../models/purchaseRequestModel');
 const PurchaseModel = require('../models/purchaseModel');
 const { saveBase64Image } = require('../services/imageUploadService');
 const logger = require('../utils/logger');
+const notifyHelper = require('../../../shared/utils/notifyHelper');
+const koreanSearch = require('../utils/koreanSearch');
 
 const PurchaseRequestController = {
   // 구매신청 목록
   getAll: async (req, res) => {
     try {
-      const { status, category, from_date, to_date } = req.query;
+      const { status, category, from_date, to_date, batch_id } = req.query;
       const isAdmin = req.user && ['admin', 'system'].includes(req.user.access_level);
-      const filters = { status, category, from_date, to_date };
+      const filters = { status, category, from_date, to_date, batch_id };
       if (!isAdmin) filters.requester_id = req.user.id;
       const rows = await PurchaseRequestModel.getAll(filters);
       res.json({ success: true, data: rows });
@@ -113,6 +115,83 @@ const PurchaseRequestController = {
     }
   },
 
+  // 품목 등록 + 신청 동시 처리 (단일 트랜잭션)
+  registerAndRequest: async (req, res) => {
+    const { getDb } = require('../dbPool');
+    let conn;
+    try {
+      const { item_name, spec, maker, category, quantity, notes, photo } = req.body;
+      if (!item_name || !item_name.trim()) {
+        return res.status(400).json({ success: false, message: '품목명을 입력해주세요.' });
+      }
+      if (!quantity || quantity < 1) {
+        return res.status(400).json({ success: false, message: '수량은 1 이상이어야 합니다.' });
+      }
+
+      const db = await getDb();
+      conn = await db.getConnection();
+      await conn.beginTransaction();
+
+      // 1. 소모품 마스터 등록 (중복 확인)
+      const [existing] = await conn.query(
+        `SELECT item_id FROM consumable_items
+         WHERE item_name = ? AND (spec = ? OR (spec IS NULL AND ? IS NULL))
+           AND (maker = ? OR (maker IS NULL AND ? IS NULL))`,
+        [item_name.trim(), spec || null, spec || null, maker || null, maker || null]
+      );
+
+      let itemId;
+      if (existing.length > 0) {
+        itemId = existing[0].item_id;
+      } else {
+        const [insertResult] = await conn.query(
+          `INSERT INTO consumable_items (item_name, spec, maker, category, is_active) VALUES (?, ?, ?, ?, 1)`,
+          [item_name.trim(), spec || null, maker || null, category || 'consumable']
+        );
+        itemId = insertResult.insertId;
+      }
+
+      // 2. 사진 업로드 (트랜잭션 외부 — 파일 저장은 DB 롤백 불가이므로 마지막에)
+      let photo_path = null;
+      if (photo) {
+        photo_path = await saveBase64Image(photo, 'pr', 'purchase_requests');
+      }
+
+      // 3. 구매 신청 생성
+      const [reqResult] = await conn.query(
+        `INSERT INTO purchase_requests (item_id, quantity, requester_id, request_date, notes, photo_path)
+         VALUES (?, ?, ?, CURDATE(), ?, ?)`,
+        [itemId, quantity, req.user.id, notes || null, photo_path]
+      );
+
+      await conn.commit();
+
+      // 검색 캐시 무효화
+      koreanSearch.clearCache();
+
+      const request = await PurchaseRequestModel.getById(reqResult.insertId);
+      res.status(201).json({ success: true, data: request, message: '품목 등록 및 신청이 완료되었습니다.' });
+    } catch (err) {
+      if (conn) await conn.rollback().catch(() => {});
+      logger.error('registerAndRequest error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    } finally {
+      if (conn) conn.release();
+    }
+  },
+
+  // 스마트 검색 (초성 + 별칭 + substring)
+  search: async (req, res) => {
+    try {
+      const { q } = req.query;
+      const results = await koreanSearch.search(q || '');
+      res.json({ success: true, data: results });
+    } catch (err) {
+      logger.error('PurchaseRequest search error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
   // 소모품 목록 (select용)
   getConsumableItems: async (req, res) => {
     try {
@@ -133,6 +212,71 @@ const PurchaseRequestController = {
       logger.error('Vendors get error:', err);
       res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
     }
+  },
+
+  // 내 신청 목록 (모바일용, 페이지네이션)
+  getMyRequests: async (req, res) => {
+    try {
+      const page = parseInt(req.query.page) || 1;
+      const limit = parseInt(req.query.limit) || 20;
+      const { status } = req.query;
+      const result = await PurchaseRequestModel.getMyRequests(req.user.id, { page, limit, status });
+      res.json({ success: true, ...result });
+    } catch (err) {
+      logger.error('PurchaseRequest getMyRequests error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
+  },
+
+  // 개별 입고 처리 (admin)
+  receive: async (req, res) => {
+    try {
+      const existing = await PurchaseRequestModel.getById(req.params.id);
+      if (!existing) return res.status(404).json({ success: false, message: '신청 건을 찾을 수 없습니다.' });
+      if (existing.status !== 'purchased') {
+        return res.status(400).json({ success: false, message: '구매완료 상태의 신청만 입고 처리할 수 있습니다.' });
+      }
+
+      const { received_location, photo } = req.body;
+      let receivedPhotoPath = null;
+      if (photo) {
+        receivedPhotoPath = await saveBase64Image(photo, 'received', 'purchase_received');
+      }
+
+      const updated = await PurchaseRequestModel.receive(req.params.id, {
+        receivedPhotoPath,
+        receivedLocation: received_location || null,
+        receivedBy: req.user.id
+      });
+
+      // batch 내 전체 입고 완료 시 batch.status 자동 전환
+      if (existing.batch_id) {
+        const allReceived = await PurchaseRequestModel.checkBatchAllReceived(existing.batch_id);
+        if (allReceived) {
+          const { getDb } = require('../dbPool');
+          const db = await getDb();
+          await db.query(
+            `UPDATE purchase_batches SET status = 'received', received_at = NOW(), received_by = ? WHERE batch_id = ?`,
+            [req.user.id, existing.batch_id]
+          );
+        }
+      }
+
+      // 신청자에게 입고 알림
+      notifyHelper.send({
+        type: 'purchase',
+        title: '소모품 입고 완료',
+        message: `${existing.item_name || existing.custom_item_name} 입고 완료${received_location ? '. 보관위치: ' + received_location : ''}`,
+        link_url: '/pages/purchase/request-mobile.html?view=' + req.params.id,
+        target_user_ids: [existing.requester_id],
+        created_by: req.user.id
+      }).catch(() => {});
+
+      res.json({ success: true, data: updated, message: '입고 처리가 완료되었습니다.' });
+    } catch (err) {
+      logger.error('PurchaseRequest receive error:', err);
+      res.status(500).json({ success: false, message: '서버 오류가 발생했습니다.' });
+    }
   }
 };
 

system1-factory/api/db/migrations/20260401_purchase_system_v2.sql

@@ -0,0 +1,63 @@
+-- 소모품 구매 관리 시스템 v2: 상태 확장 + 그룹화 + 별칭 + 입고
+
+-- 1. purchase_requests.status ENUM 확장
+ALTER TABLE purchase_requests
+  MODIFY COLUMN status ENUM('pending','grouped','purchased','received','hold') DEFAULT 'pending'
+  COMMENT '대기, 구매진행중, 구매완료, 입고완료, 보류';
+
+-- 2. 입고/그룹 관련 컬럼 추가
+ALTER TABLE purchase_requests
+  ADD COLUMN batch_id INT NULL COMMENT '구매 묶음 ID' AFTER photo_path,
+  ADD COLUMN received_photo_path VARCHAR(255) NULL COMMENT '입고 사진' AFTER batch_id,
+  ADD COLUMN received_location VARCHAR(200) NULL COMMENT '입고 보관 위치' AFTER received_photo_path,
+  ADD COLUMN received_at TIMESTAMP NULL COMMENT '입고 확인 시각' AFTER received_location,
+  ADD COLUMN received_by INT NULL COMMENT '입고 확인자' AFTER received_at,
+  ADD CONSTRAINT fk_pr_received_by FOREIGN KEY (received_by) REFERENCES sso_users(user_id);
+
+-- 3. 구매 묶음(그룹) 테이블
+CREATE TABLE IF NOT EXISTS purchase_batches (
+  batch_id INT AUTO_INCREMENT PRIMARY KEY,
+  batch_name VARCHAR(100) COMMENT '묶음 이름',
+  category ENUM('consumable','safety','repair','equipment') NULL COMMENT '분류',
+  vendor_id INT NULL COMMENT '예정 업체',
+  status ENUM('pending','purchased','received') DEFAULT 'pending'
+    COMMENT '진행중, 구매완료, 입고완료',
+  notes TEXT,
+  created_by INT NOT NULL COMMENT '생성자',
+  purchased_at TIMESTAMP NULL COMMENT '구매 처리 시점',
+  purchased_by INT NULL COMMENT '구매 처리자',
+  received_at TIMESTAMP NULL COMMENT '입고 확인 시점',
+  received_by INT NULL COMMENT '입고 확인자',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  FOREIGN KEY (vendor_id) REFERENCES vendors(vendor_id),
+  FOREIGN KEY (created_by) REFERENCES sso_users(user_id),
+  FOREIGN KEY (purchased_by) REFERENCES sso_users(user_id),
+  FOREIGN KEY (received_by) REFERENCES sso_users(user_id)
+);
+
+-- 4. batch FK
+ALTER TABLE purchase_requests
+  ADD CONSTRAINT fk_pr_batch FOREIGN KEY (batch_id)
+  REFERENCES purchase_batches(batch_id) ON DELETE SET NULL;
+
+-- 5. 품목 별칭 테이블 (한국어 동의어/약어 매핑)
+CREATE TABLE IF NOT EXISTS item_aliases (
+  alias_id INT AUTO_INCREMENT PRIMARY KEY,
+  item_id INT NOT NULL COMMENT 'FK → consumable_items',
+  alias_name VARCHAR(100) NOT NULL COMMENT '별칭/축약어',
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+  FOREIGN KEY (item_id) REFERENCES consumable_items(item_id) ON DELETE CASCADE,
+  UNIQUE KEY uq_item_alias (item_id, alias_name),
+  INDEX idx_alias_name (alias_name)
+);
+
+-- 6. notification_recipients ENUM에 'purchase' 추가
+ALTER TABLE notification_recipients
+  MODIFY COLUMN notification_type
+  ENUM('repair','safety','nonconformity','equipment','maintenance','system','purchase')
+  NOT NULL COMMENT '알림 유형';
+
+-- 7. 페이지 키 등록
+INSERT IGNORE INTO pages (page_key, page_name, page_path, category, is_admin_only, display_order) VALUES
+('purchase.request_mobile', '소모품 신청 (모바일)', '/pages/purchase/request-mobile.html', 'purchase', 0, 42);

system1-factory/api/models/itemAliasModel.js

@@ -0,0 +1,35 @@
+// models/itemAliasModel.js
+const { getDb } = require('../dbPool');
+
+const ItemAliasModel = {
+  async getAll() {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT ia.*, ci.item_name, ci.spec, ci.maker, ci.category
+       FROM item_aliases ia
+       JOIN consumable_items ci ON ia.item_id = ci.item_id
+       ORDER BY ci.item_name, ia.alias_name`
+    );
+    return rows;
+  },
+
+  async create(itemId, aliasName) {
+    const db = await getDb();
+    const [result] = await db.query(
+      `INSERT INTO item_aliases (item_id, alias_name) VALUES (?, ?)`,
+      [itemId, aliasName.trim()]
+    );
+    return result.insertId;
+  },
+
+  async delete(aliasId) {
+    const db = await getDb();
+    const [result] = await db.query(
+      `DELETE FROM item_aliases WHERE alias_id = ?`,
+      [aliasId]
+    );
+    return result.affectedRows > 0;
+  }
+};
+
+module.exports = ItemAliasModel;

system1-factory/api/models/purchaseBatchModel.js

@@ -0,0 +1,117 @@
+// models/purchaseBatchModel.js
+const { getDb } = require('../dbPool');
+
+const PurchaseBatchModel = {
+  async getAll(filters = {}) {
+    const db = await getDb();
+    let sql = `
+      SELECT pb.*, su.name AS created_by_name,
+             v.vendor_name,
+             (SELECT COUNT(*) FROM purchase_requests WHERE batch_id = pb.batch_id) AS request_count
+      FROM purchase_batches pb
+      LEFT JOIN sso_users su ON pb.created_by = su.user_id
+      LEFT JOIN vendors v ON pb.vendor_id = v.vendor_id
+      WHERE 1=1
+    `;
+    const params = [];
+    if (filters.status) { sql += ' AND pb.status = ?'; params.push(filters.status); }
+    sql += ' ORDER BY pb.created_at DESC';
+    const [rows] = await db.query(sql, params);
+    return rows;
+  },
+
+  async getById(batchId) {
+    const db = await getDb();
+    const [rows] = await db.query(`
+      SELECT pb.*, su.name AS created_by_name, v.vendor_name
+      FROM purchase_batches pb
+      LEFT JOIN sso_users su ON pb.created_by = su.user_id
+      LEFT JOIN vendors v ON pb.vendor_id = v.vendor_id
+      WHERE pb.batch_id = ?
+    `, [batchId]);
+    return rows[0] || null;
+  },
+
+  async create({ batchName, category, vendorId, notes, createdBy }) {
+    const db = await getDb();
+    const [result] = await db.query(
+      `INSERT INTO purchase_batches (batch_name, category, vendor_id, notes, created_by)
+       VALUES (?, ?, ?, ?, ?)`,
+      [batchName || null, category || null, vendorId || null, notes || null, createdBy]
+    );
+    return result.insertId;
+  },
+
+  async update(batchId, { batchName, category, vendorId, notes }) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_batches SET batch_name = ?, category = ?, vendor_id = ?, notes = ?
+       WHERE batch_id = ? AND status = 'pending'`,
+      [batchName || null, category || null, vendorId || null, notes || null, batchId]
+    );
+    return this.getById(batchId);
+  },
+
+  async delete(batchId) {
+    const db = await getDb();
+    // pending 상태만 삭제 가능
+    const [batch] = await db.query('SELECT status FROM purchase_batches WHERE batch_id = ?', [batchId]);
+    if (!batch.length || batch[0].status !== 'pending') return false;
+
+    // 포함된 요청 복원
+    await db.query(
+      `UPDATE purchase_requests SET batch_id = NULL, status = 'pending' WHERE batch_id = ?`,
+      [batchId]
+    );
+    await db.query('DELETE FROM purchase_batches WHERE batch_id = ?', [batchId]);
+    return true;
+  },
+
+  async markPurchased(batchId, purchasedBy) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_batches SET status = 'purchased', purchased_at = NOW(), purchased_by = ?
+       WHERE batch_id = ? AND status = 'pending'`,
+      [purchasedBy, batchId]
+    );
+  },
+
+  async markReceived(batchId, receivedBy) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_batches SET status = 'received', received_at = NOW(), received_by = ?
+       WHERE batch_id = ? AND status = 'purchased'`,
+      [receivedBy, batchId]
+    );
+  },
+
+  // batch에 요청 추가 (검증: pending이고 다른 batch에 속하지 않음)
+  async addRequests(batchId, requestIds) {
+    const db = await getDb();
+    const [existing] = await db.query(
+      `SELECT request_id, batch_id, status FROM purchase_requests WHERE request_id IN (?)`,
+      [requestIds]
+    );
+    const invalid = existing.filter(r => r.status !== 'pending' || r.batch_id !== null);
+    if (invalid.length > 0) {
+      const ids = invalid.map(r => r.request_id);
+      throw new Error(`다음 요청은 추가할 수 없습니다 (이미 그룹 소속이거나 대기 상태가 아님): ${ids.join(', ')}`);
+    }
+
+    const PurchaseRequestModel = require('./purchaseRequestModel');
+    await PurchaseRequestModel.groupIntoBatch(requestIds, batchId);
+  },
+
+  // batch에서 요청 제거
+  async removeRequests(batchId, requestIds) {
+    const db = await getDb();
+    const [batch] = await db.query('SELECT status FROM purchase_batches WHERE batch_id = ?', [batchId]);
+    if (!batch.length || batch[0].status !== 'pending') {
+      throw new Error('진행중인 그룹에서만 요청을 제거할 수 있습니다.');
+    }
+    const PurchaseRequestModel = require('./purchaseRequestModel');
+    await PurchaseRequestModel.removeFromBatch(requestIds);
+  }
+};
+
+module.exports = PurchaseBatchModel;

system1-factory/api/models/purchaseRequestModel.js

@@ -2,17 +2,19 @@
 const { getDb } = require('../dbPool');
 
 const PurchaseRequestModel = {
-  // 구매신청 목록 (소모품 정보 LEFT JOIN — item_id NULL 허용)
+  // 구매신청 목록 (소모품 정보 LEFT JOIN — item_id NULL 허용, batch 정보 포함)
   async getAll(filters = {}) {
     const db = await getDb();
     let sql = `
       SELECT pr.*, ci.item_name, ci.spec, ci.maker, ci.category, ci.base_price, ci.unit,
              ci.photo_path AS ci_photo_path, pr.photo_path AS pr_photo_path,
              pr.custom_item_name, pr.custom_category,
-             su.name AS requester_name
+             su.name AS requester_name,
+             pb.batch_name, pb.status AS batch_status, pb.category AS batch_category
       FROM purchase_requests pr
       LEFT JOIN consumable_items ci ON pr.item_id = ci.item_id
       LEFT JOIN sso_users su ON pr.requester_id = su.user_id
+      LEFT JOIN purchase_batches pb ON pr.batch_id = pb.batch_id
       WHERE 1=1
     `;
     const params = [];
@@ -25,23 +27,28 @@ const PurchaseRequestModel = {
     }
     if (filters.from_date) { sql += ' AND pr.request_date >= ?'; params.push(filters.from_date); }
     if (filters.to_date) { sql += ' AND pr.request_date <= ?'; params.push(filters.to_date); }
+    if (filters.batch_id) { sql += ' AND pr.batch_id = ?'; params.push(filters.batch_id); }
 
     sql += ' ORDER BY pr.created_at DESC';
     const [rows] = await db.query(sql, params);
     return rows;
   },
 
-  // 단건 조회
+  // 단건 조회 (batch 정보 포함)
   async getById(requestId) {
     const db = await getDb();
     const [rows] = await db.query(`
       SELECT pr.*, ci.item_name, ci.spec, ci.maker, ci.category, ci.base_price, ci.unit,
              ci.photo_path AS ci_photo_path, pr.photo_path AS pr_photo_path,
              pr.custom_item_name, pr.custom_category,
-             su.name AS requester_name
+             su.name AS requester_name,
+             pb.batch_name, pb.status AS batch_status, pb.category AS batch_category,
+             rsu.name AS received_by_name
       FROM purchase_requests pr
       LEFT JOIN consumable_items ci ON pr.item_id = ci.item_id
       LEFT JOIN sso_users su ON pr.requester_id = su.user_id
+      LEFT JOIN purchase_batches pb ON pr.batch_id = pb.batch_id
+      LEFT JOIN sso_users rsu ON pr.received_by = rsu.user_id
       WHERE pr.request_id = ?
     `, [requestId]);
     return rows[0] || null;
@@ -105,6 +112,127 @@ const PurchaseRequestModel = {
       [requestId]
     );
     return result.affectedRows > 0;
+  },
+
+  // 내 신청 목록 (모바일용, 페이지네이션)
+  async getMyRequests(userId, { page = 1, limit = 20, status } = {}) {
+    const db = await getDb();
+    const offset = (page - 1) * limit;
+    let where = 'WHERE pr.requester_id = ?';
+    const params = [userId];
+
+    if (status) { where += ' AND pr.status = ?'; params.push(status); }
+
+    const [[{ total }]] = await db.query(
+      `SELECT COUNT(*) AS total FROM purchase_requests pr ${where}`, params
+    );
+
+    const [rows] = await db.query(`
+      SELECT pr.*, ci.item_name, ci.spec, ci.maker, ci.category, ci.base_price, ci.unit,
+             ci.photo_path AS ci_photo_path, pr.photo_path AS pr_photo_path,
+             pr.custom_item_name, pr.custom_category,
+             pb.batch_name, pb.status AS batch_status,
+             rsu.name AS received_by_name
+      FROM purchase_requests pr
+      LEFT JOIN consumable_items ci ON pr.item_id = ci.item_id
+      LEFT JOIN purchase_batches pb ON pr.batch_id = pb.batch_id
+      LEFT JOIN sso_users rsu ON pr.received_by = rsu.user_id
+      ${where}
+      ORDER BY pr.created_at DESC
+      LIMIT ? OFFSET ?
+    `, [...params, limit, offset]);
+
+    return {
+      data: rows,
+      pagination: { page, limit, total, totalPages: Math.ceil(total / limit) }
+    };
+  },
+
+  // batch에 요청 그룹화 (status → grouped)
+  async groupIntoBatch(requestIds, batchId) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests SET batch_id = ?, status = 'grouped'
+       WHERE request_id IN (?) AND status = 'pending' AND batch_id IS NULL`,
+      [batchId, requestIds]
+    );
+  },
+
+  // batch에서 제거 (status → pending 복원)
+  async removeFromBatch(requestIds) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests SET batch_id = NULL, status = 'pending'
+       WHERE request_id IN (?) AND status = 'grouped'`,
+      [requestIds]
+    );
+  },
+
+  // batch 내 전체 요청 purchased 전환
+  async markBatchPurchased(batchId) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests SET status = 'purchased' WHERE batch_id = ? AND status = 'grouped'`,
+      [batchId]
+    );
+  },
+
+  // 개별 입고 처리
+  async receive(requestId, { receivedPhotoPath, receivedLocation, receivedBy }) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests
+       SET status = 'received', received_photo_path = ?, received_location = ?,
+           received_at = NOW(), received_by = ?
+       WHERE request_id = ? AND status = 'purchased'`,
+      [receivedPhotoPath || null, receivedLocation || null, receivedBy, requestId]
+    );
+    return this.getById(requestId);
+  },
+
+  // batch 내 전체 입고 처리
+  async receiveBatch(batchId, { receivedPhotoPath, receivedLocation, receivedBy }) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests
+       SET status = 'received', received_photo_path = ?, received_location = ?,
+           received_at = NOW(), received_by = ?
+       WHERE batch_id = ? AND status = 'purchased'`,
+      [receivedPhotoPath || null, receivedLocation || null, receivedBy, batchId]
+    );
+  },
+
+  // batch 내 모든 요청이 received인지 확인
+  async checkBatchAllReceived(batchId) {
+    const db = await getDb();
+    const [[{ total, received }]] = await db.query(
+      `SELECT COUNT(*) AS total,
+              SUM(CASE WHEN status = 'received' THEN 1 ELSE 0 END) AS received
+       FROM purchase_requests WHERE batch_id = ?`,
+      [batchId]
+    );
+    return total > 0 && total === received;
+  },
+
+  // grouped 상태에서 hold (batch에서 자동 제거)
+  async holdFromGrouped(requestId, holdReason) {
+    const db = await getDb();
+    await db.query(
+      `UPDATE purchase_requests SET status = 'hold', hold_reason = ?, batch_id = NULL
+       WHERE request_id = ? AND status = 'grouped'`,
+      [holdReason || null, requestId]
+    );
+    return this.getById(requestId);
+  },
+
+  // batch 내 신청자 ID 목록 조회
+  async getRequesterIdsByBatch(batchId) {
+    const db = await getDb();
+    const [rows] = await db.query(
+      `SELECT DISTINCT requester_id FROM purchase_requests WHERE batch_id = ?`,
+      [batchId]
+    );
+    return rows.map(r => r.requester_id);
   }
 };
 

system1-factory/api/routes/itemAliasRoutes.js

@@ -0,0 +1,12 @@
+const express = require('express');
+const router = express.Router();
+const ctrl = require('../controllers/itemAliasController');
+const { createRequirePage } = require('../../../shared/middleware/pagePermission');
+const { getDb } = require('../dbPool');
+const requirePage = createRequirePage(getDb);
+
+router.get('/', requirePage('factory_purchases'), ctrl.getAll);
+router.post('/', requirePage('factory_purchases'), ctrl.create);
+router.delete('/:id', requirePage('factory_purchases'), ctrl.delete);
+
+module.exports = router;

system1-factory/api/routes/purchaseBatchRoutes.js

@@ -0,0 +1,16 @@
+const express = require('express');
+const router = express.Router();
+const ctrl = require('../controllers/purchaseBatchController');
+const { createRequirePage } = require('../../../shared/middleware/pagePermission');
+const { getDb } = require('../dbPool');
+const requirePage = createRequirePage(getDb);
+
+router.get('/', requirePage('factory_purchases'), ctrl.getAll);
+router.get('/:id', requirePage('factory_purchases'), ctrl.getById);
+router.post('/', requirePage('factory_purchases'), ctrl.create);
+router.put('/:id', requirePage('factory_purchases'), ctrl.update);
+router.delete('/:id', requirePage('factory_purchases'), ctrl.delete);
+router.post('/:id/purchase', requirePage('factory_purchases'), ctrl.purchase);
+router.put('/:id/receive', requirePage('factory_purchases'), ctrl.receive);
+
+module.exports = router;

system1-factory/api/routes/purchaseRequestRoutes.js

@@ -8,6 +8,13 @@ const requirePage = createRequirePage(getDb);
 // 보조 데이터
 router.get('/consumable-items', ctrl.getConsumableItems);
 router.get('/vendors', ctrl.getVendors);
+router.get('/search', ctrl.search);
+
+// 내 신청 (모바일용 페이지네이션) — /:id 보다 먼저 등록
+router.get('/my-requests', ctrl.getMyRequests);
+
+// 품목 등록 + 신청 동시 (트랜잭션)
+router.post('/register-and-request', ctrl.registerAndRequest);
 
 // 구매신청 CRUD
 router.get('/', ctrl.getAll);
@@ -15,6 +22,7 @@ router.get('/:id', ctrl.getById);
 router.post('/', ctrl.create);
 router.put('/:id/hold', requirePage('factory_purchases'), ctrl.hold);
 router.put('/:id/revert', requirePage('factory_purchases'), ctrl.revert);
+router.put('/:id/receive', requirePage('factory_purchases'), ctrl.receive);
 router.delete('/:id', ctrl.delete);
 
 module.exports = router;

system1-factory/api/services/imageUploadService.js

@@ -23,7 +23,8 @@ try {
 const UPLOAD_DIRS = {
   issues: path.join(__dirname, '../uploads/issues'),
   equipments: path.join(__dirname, '../uploads/equipments'),
-  purchase_requests: path.join(__dirname, '../uploads/purchase_requests')
+  purchase_requests: path.join(__dirname, '../uploads/purchase_requests'),
+  purchase_received: path.join(__dirname, '../uploads/purchase_received')
 };
 const UPLOAD_DIR = UPLOAD_DIRS.issues; // 기존 호환성 유지
 const MAX_SIZE = { width: 1920, height: 1920 };

system1-factory/api/utils/koreanSearch.js

@@ -0,0 +1,156 @@
+/**
+ * 한국어 스마트 검색 유틸리티
+ * - 초성 추출 및 매칭
+ * - 별칭(alias) 매칭
+ * - 인메모리 캐시 (5분 TTL)
+ */
+const { getDb } = require('../dbPool');
+
+// 초성 목록 (19개)
+const CHOSUNG = [
+  'ㄱ','ㄲ','ㄴ','ㄷ','ㄸ','ㄹ','ㅁ','ㅂ','ㅃ','ㅅ',
+  'ㅆ','ㅇ','ㅈ','ㅉ','ㅊ','ㅋ','ㅌ','ㅍ','ㅎ'
+];
+
+// 자음 문자 집합 (초성 판별용)
+const JAMO_SET = new Set([
+  'ㄱ','ㄲ','ㄴ','ㄷ','ㄸ','ㄹ','ㅁ','ㅂ','ㅃ','ㅅ',
+  'ㅆ','ㅇ','ㅈ','ㅉ','ㅊ','ㅋ','ㅌ','ㅍ','ㅎ'
+]);
+
+// 캐시
+let cache = null;
+let cacheTime = 0;
+const CACHE_TTL = 5 * 60 * 1000; // 5분
+
+/**
+ * 한글 완성형 문자에서 초성 추출
+ * @param {string} str
+ * @returns {string} 초성 문자열
+ */
+function extractChosung(str) {
+  let result = '';
+  for (const ch of str) {
+    const code = ch.charCodeAt(0);
+    if (code >= 0xAC00 && code <= 0xD7A3) {
+      const idx = Math.floor((code - 0xAC00) / (21 * 28));
+      result += CHOSUNG[idx];
+    } else {
+      result += ch;
+    }
+  }
+  return result;
+}
+
+/**
+ * 검색어가 모두 자음(초성)인지 판별
+ * @param {string} query
+ * @returns {boolean}
+ */
+function isChosungOnly(query) {
+  if (query.length < 2) return false;
+  for (const ch of query) {
+    if (!JAMO_SET.has(ch)) return false;
+  }
+  return true;
+}
+
+/**
+ * 캐시 로드 (consumable_items + item_aliases)
+ */
+async function loadCache() {
+  if (cache && (Date.now() - cacheTime < CACHE_TTL)) return cache;
+
+  const db = await getDb();
+  const [items] = await db.query(
+    `SELECT item_id, item_name, spec, maker, category, base_price, unit, photo_path
+     FROM consumable_items WHERE is_active = 1`
+  );
+  const [aliases] = await db.query(
+    `SELECT alias_id, item_id, alias_name FROM item_aliases`
+  );
+
+  // 아이템별 별칭 맵 생성
+  const aliasMap = {};
+  for (const a of aliases) {
+    if (!aliasMap[a.item_id]) aliasMap[a.item_id] = [];
+    aliasMap[a.item_id].push(a.alias_name);
+  }
+
+  // 초성 미리 계산
+  const enriched = items.map(item => ({
+    ...item,
+    aliases: aliasMap[item.item_id] || [],
+    chosung_name: extractChosung(item.item_name),
+    chosung_aliases: (aliasMap[item.item_id] || []).map(a => extractChosung(a))
+  }));
+
+  cache = enriched;
+  cacheTime = Date.now();
+  return cache;
+}
+
+/**
+ * 캐시 무효화
+ */
+function clearCache() {
+  cache = null;
+  cacheTime = 0;
+}
+
+/**
+ * 스마트 검색
+ * @param {string} query - 검색어
+ * @returns {Promise<Array>} 스코어 기준 상위 20건
+ */
+async function search(query) {
+  if (!query || query.trim().length === 0) return [];
+  const items = await loadCache();
+  const q = query.trim().toLowerCase();
+  const qChosung = isChosungOnly(q) ? q : null;
+
+  const scored = [];
+  for (const item of items) {
+    let score = 0;
+    let matchType = '';
+
+    const nameLower = item.item_name.toLowerCase();
+    const specLower = (item.spec || '').toLowerCase();
+    const makerLower = (item.maker || '').toLowerCase();
+
+    // exact match (이름 완전 일치)
+    if (nameLower === q) {
+      score = 100; matchType = 'exact';
+    }
+    // substring match (이름)
+    else if (nameLower.includes(q)) {
+      score = 80; matchType = 'name';
+    }
+    // alias match
+    else if (item.aliases.some(a => a.toLowerCase().includes(q))) {
+      score = 75; matchType = 'alias';
+    }
+    // spec/maker match
+    else if (specLower.includes(q) || makerLower.includes(q)) {
+      score = 70; matchType = 'spec';
+    }
+    // 초성 매칭 (이름)
+    else if (qChosung && item.chosung_name.includes(qChosung)) {
+      score = 50; matchType = 'chosung';
+    }
+    // 초성 매칭 (별칭)
+    else if (qChosung && item.chosung_aliases.some(ca => ca.includes(qChosung))) {
+      score = 40; matchType = 'chosung_alias';
+    }
+
+    if (score > 0) {
+      scored.push({ ...item, _score: score, _matchType: matchType });
+    }
+  }
+
+  // 점수 높은 순, 같은 점수면 이름 짧은 순 (더 구체적)
+  scored.sort((a, b) => b._score - a._score || a.item_name.length - b.item_name.length);
+  return scored.slice(0, 20);
+}
+
+module.exports = { search, clearCache, extractChosung, isChosungOnly };