[V0_FILE]plaintext:file=".gitignore" node_modules .next [V0_FILE]markdown:file="PRD.md" # 제품 요구사항 문서 (PRD): 세방리튬배터리 SCM 시스템 ## 1. 개요 본 문서는 '세방리튬배터리 SCM(공급망 관리) 시스템'의 제품 요구사항을 정의합니다. 이 시스템은 리튬 배터리 생산 및 공급과 관련된 전 과정을 효율적으로 관리하고, 각 담당자 간의 원활한 협업을 지원하기 위한 웹 기반 플랫폼입니다. 발주, 생산, 자재, 판매, 출하에 이르는 전체 공급망 프로세스를 통합하여 데이터 가시성을 높이고 운영 효율성을 극대화하는 것을 목표로 합니다. ## 2. 목표 - **프로세스 통합:** 파편화된 공급망 관리 업무를 단일 플랫폼에서 처리하여 데이터의 일관성을 확보하고 중복 작업을 제거합니다. - **실시간 가시성 확보:** 모든 사용자가 자신의 역할에 맞는 최신 정보를 실시간으로 확인하여 신속하고 정확한 의사결정을 내릴 수 있도록 지원합니다. - **역할 기반 접근 제어:** 각 담당자의 역할(발주사, 생산관리자, 창고관리자, 자재관리자)에 따라 명확하게 권한을 분리하여 정보 보안을 강화하고 업무 효율성을 높입니다. - **운영 효율성 증대:** 계획(발주/판매/생산)부터 실행(생산/자재/출하/배차)까지의 과정을 자동화하고 최적화하여 리드 타임을 단축하고 비용을 절감합니다. ## 3. 기술 스택 및 환경 (Technology Stack) 안정적이고 확장 가능한 시스템 구축을 위해 다음과 같은 최신 웹 기술 스택을 사용합니다. - **Frontend:** Next.js (React Framework), Tailwind CSS (Styling), Lucide React (Icons) - **Backend:** Node.js (API Server) 또는 Supabase (Backend-as-a-Service) - **Database:** PostgreSQL (Relational Database) - **Deployment:** Vercel (Frontend), AWS or Supabase (Backend/DB) - **Authentication:** Role-Based Access Control (RBAC) with JWT or Supabase Auth ## 4. 사용자 및 역할 (User Roles) 시스템은 다음과 같은 주요 사용자 역할로 구성되며, 각 역할은 특정 기능에 대한 접근 권한을 가집니다. - **발주사 (Ordering Company/Client):** - 제품을 주문하고 납기를 관리하는 외부 또는 내부 고객입니다. - **주요 관심사:** 주문 현황, 납기 일정, 출하 상태 추적. - **생산관리자 (Production Manager):** - 제품 생산 계획을 수립하고 실제 생산 실적을 관리합니다. - **주요 관심사:** 생산 목표 달성률, 생산 효율성, 생산 실적 관리. - **자재관리자 (Materials Manager):** - 생산 계획에 필요한 원자재 및 부자재의 재고를 관리하고 입출고를 담당합니다. - **주요 관심사:** 자재 재고 수준, 자재 부족 예방, 입출고 정확성, BOM 기반 소요량 예측. - **창고관리자 (Warehouse Manager):** - 판매 계획을 수립하고, 생산된 완제품의 출하 및 배차를 총괄합니다. - **주요 관심사:** 완제품 재고 관리, 정확한 출하, 효율적인 배차. - **시스템 관리자 (Admin):** (신규 추가) - 사용자 계정 생성 및 권한 관리, 기준 정보(품목, BOM 등) 관리. ## 5. 기준 정보 관리 (Master Data Management) 시스템 운영의 기반이 되는 데이터 관리 기능입니다. - **품목 관리 (Product/Item Master):** - 배터리 모델명, 규격, 단가, 품목 유형(완제품/원자재/부자재) 등록 및 수정. - **BOM (Bill of Materials) 관리:** - 완제품 1단위를 생산하는 데 필요한 원자재/부자재의 종류와 소요량 정의. - **거래처 관리 (Partner Management):** - 발주사(고객) 및 자재 공급사(Vendor) 정보 등록 및 관리. ## 6. 주요 기능 (Features) - **대시보드 (`/`):** - 모든 사용자가 공통으로 접근하는 메인 페이지. - SCM 전체 현황을 요약한 주요 지표(KPI) 및 알림을 시각적으로 제공. (예: 주문 현황, 생산 진행률, 재고 수준 등) - **발주 계획 (`/orders`):** - **사용자:** 발주사, 영업팀 - 신규 발주를 등록하고, 기존 발주 내역의 상태(접수, 생산중, 출하완료 등)를 조회. - **상태 흐름:** 접수 -> (승인/반려) -> 생산대기 -> 생산중 -> 생산완료 -> 출하대기 -> 출하중 -> 인수완료 - **판매 계획 (`/sales`):** - **사용자:** 창고관리자, 영업팀 - 시장 수요 예측 및 영업 목표에 기반하여 완제품 판매 계획을 수립. - **생산 계획 (`/production`):** - **사용자:** 생산관리자 - 발주 계획과 판매 계획을 기반으로 주간/월간 생산 계획을 수립하고 생산 라인에 작업을 할당. - 자재 가용성 체크 기능 포함. - **생산 실적 (`/production-performance`):** - **사용자:** 생산관리자 - 일별/주별 생산 실적(생산량, 불량률 등)을 등록하고 계획 대비 실적을 분석. - **자재 관리 (`/materials`):** - **사용자:** 자재관리자 - 생산 계획(BOM 기반)에 따른 자재 소요량을 예측하고 현재 재고를 관리. - 자재 입출고 내역 기록 및 안전 재고 알림. - **출하 지시 (`/shipments`):** - **사용자:** 창고관리자 - 발주사의 주문에 따라 출하할 제품, 수량, 일정을 지정하고 출하 지시를 생성. - 명세서(Packing List) 출력 기능. - **배차 관리 (`/dispatch`):** - **사용자:** 창고관리자 - 출하 지시에 따라 운송 차량을 배정하고 운송 상태를 추적. ## 7. 사용자 여정 (User Journey) ### 여정 1: 신규 배터리 주문 및 생산, 출하 프로세스 1. **[발주사]** - 시스템에 로그인하여 '발주 계획' 메뉴로 이동합니다. - 필요한 배터리 모델과 수량, 희망 납기를 입력하여 신규 발주를 등록합니다. - 대시보드 또는 '발주 계획' 메뉴에서 자신의 주문이 '접수' 상태인지 주기적으로 확인합니다. 2. **[생산관리자]** - 신규 발주가 등록되었다는 알림을 확인하고 '생산 계획' 메뉴로 이동합니다. - 발주량과 현재 재고를 고려하여 생산 계획을 수립하고 작업 지시를 내립니다. - 생산이 진행됨에 따라 '생산 실적' 메뉴에 일일 생산량과 특이사항을 기록합니다. - 생산이 완료되면 시스템에 '생산 완료' 상태를 업데이트합니다. 3. **[자재관리자]** - 수립된 '생산 계획'을 확인하고 BOM을 참조하여 필요한 원자재 소요량을 자동 계산/확인합니다. - '자재 관리' 메뉴에서 현재 자재 재고를 확인하고, 부족할 경우 추가 발주를 진행합니다. - 생산 라인에 자재가 투입될 때마다 출고 내역을 시스템에 기록합니다. 4. **[창고관리자]** - '생산 완료'된 주문을 확인하고 '출하 지시' 메뉴로 이동합니다. - 해당 주문에 대한 출하 정보를 확인하고 출하 지시를 생성합니다. - '배차 관리' 메뉴에서 출하 지시에 가장 적합한 운송 차량을 배정하고, 운송 기사에게 정보를 전달합니다. - 차량이 배정되고 제품이 상차되면, '출하 중'으로 상태를 변경합니다. 5. **[발주사]** - 자신의 주문 상태가 '출하 중'으로 변경된 것을 확인하고, 예상 도착 시간을 파악합니다. - 제품을 수령한 후 시스템에서 '인수 완료' 처리를 합니다. ## 8. 비기능적 요구사항 - **보안:** - 역할 기반 접근 제어(RBAC)를 통해 인가되지 않은 정보 접근을 엄격히 차단해야 합니다. - 모든 데이터 통신은 SSL/TLS를 통해 암호화되어야 합니다. - **성능:** - 모든 페이지는 3초 이내에 로드되어야 합니다. - 대용량 데이터 조회 시에도 시스템 응답성이 저하되지 않아야 합니다. (예: 페이지네이션, 필터링 기능 제공) - **안정성:** - 시스템은 연중무휴 24/7 운영을 목표로 하며, 99.9%의 가용성을 보장해야 합니다. - **사용성:** - 사용자가 별도의 교육 없이도 직관적으로 사용할 수 있는 UI/UX를 제공해야 합니다. - **모바일/태블릿 지원:** 현장 관리자(생산, 창고)를 위해 반응형 디자인을 적용해야 합니다. - **데이터 활용:** - 주요 데이터(주문 내역, 재고 현황 등)는 **Excel 다운로드** 기능을 제공해야 합니다. [V0_FILE]markdown:file="README.md" # SCM system build *Automatically synced with your [v0.app](https://v0.app) deployments* [![Deployed on Vercel](https://img.shields.io/badge/Deployed%20on-Vercel-black?style=for-the-badge&logo=vercel)](https://vercel.com/bbarkthongs-projects/v0-scm-system-build) [![Built with v0](https://img.shields.io/badge/Built%20with-v0.app-black?style=for-the-badge)](https://v0.app/chat/gXk3Bs43XEG) ## Overview This repository will stay in sync with your deployed chats on [v0.app](https://v0.app). Any changes you make to your deployed app will be automatically pushed to this repository from [v0.app](https://v0.app). ## Deployment Your project is live at: **[https://vercel.com/bbarkthongs-projects/v0-scm-system-build](https://vercel.com/bbarkthongs-projects/v0-scm-system-build)** ## Build your app Continue building your app on: **[https://v0.app/chat/gXk3Bs43XEG](https://v0.app/chat/gXk3Bs43XEG)** ## How It Works 1. Create and modify your project using [v0.app](https://v0.app) 2. Deploy your chats from the v0 interface 3. Changes are automatically pushed to this repository 4. Vercel deploys the latest version from this repository [V0_FILE]typescript:file="app/api/business-plan/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const year = searchParams.get("year") try { if (year) { const plan = db.businessPlans.getByYear(parseInt(year)) return NextResponse.json({ success: true, data: plan || null }) } else { const plans = db.businessPlans.getAll() return NextResponse.json({ success: true, data: plans }) } } catch (error) { console.error("[v0] Failed to fetch business plans:", error) return NextResponse.json({ success: false, error: "Failed to fetch business plans" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body if (!id) { return NextResponse.json({ success: false, error: "ID is required" }, { status: 400 }) } const updated = db.businessPlans.update(id, data) if (!updated) { return NextResponse.json({ success: false, error: "Business plan not found" }, { status: 404 }) } return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update business plan:", error) return NextResponse.json({ success: false, error: "Failed to update business plan" }, { status: 500 }) } } export async function POST(request: Request) { initializeDatabase() try { const body = await request.json() const plan = db.businessPlans.create({ id: `BP-${body.year}`, year: body.year, totalTarget: body.totalTarget, totalRevenue: body.totalRevenue, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), }) return NextResponse.json({ success: true, data: plan }) } catch (error) { console.error("[v0] Failed to create business plan:", error) return NextResponse.json({ success: false, error: "Failed to create business plan" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/dispatch/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET() { initializeDatabase() try { const dispatch = db.dispatch.getAll() console.log("[v0] Fetched dispatch:", dispatch.length) return NextResponse.json({ success: true, data: dispatch }) } catch (error) { console.error("[v0] Failed to fetch dispatch:", error) return NextResponse.json({ success: false, error: "Failed to fetch dispatch" }, { status: 500 }) } } export async function POST(request: Request) { initializeDatabase() try { const dispatch = await request.json() const created = db.dispatch.create(dispatch) // Update inventory dispatch.products.forEach((product: { product: string; quantity: number }) => { const currentInventory = db.inventory.getByProduct(product.product) if (currentInventory) { db.inventory.update(product.product, currentInventory.quantity - product.quantity) } }) console.log("[v0] Created dispatch:", created.id) return NextResponse.json({ success: true, data: created }) } catch (error) { console.error("[v0] Failed to create dispatch:", error) return NextResponse.json({ success: false, error: "Failed to create dispatch" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body const updated = db.dispatch.update(id, data) if (!updated) { return NextResponse.json({ success: false, error: "Dispatch not found" }, { status: 404 }) } console.log("[v0] Updated dispatch:", id) return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update dispatch:", error) return NextResponse.json({ success: false, error: "Failed to update dispatch" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/init/route.ts" import { NextResponse } from "next/server" import { initializeDatabase } from "@/lib/db" export async function GET() { try { const data = initializeDatabase() return NextResponse.json({ success: true, message: "Database initialized successfully", stats: { orders: data.orders.length, productions: data.productions.length, materials: data.materials.length, inventory: data.inventory.length, dispatch: data.dispatch.length, shipments: data.shipments.length, }, }) } catch (error) { console.error("[v0] Database initialization error:", error) return NextResponse.json({ success: false, error: "Failed to initialize database" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/inventory/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET() { initializeDatabase() try { const inventory = db.inventory.getAll() console.log("[v0] Fetched inventory:", inventory.length) return NextResponse.json({ success: true, data: inventory }) } catch (error) { console.error("[v0] Failed to fetch inventory:", error) return NextResponse.json({ success: false, error: "Failed to fetch inventory" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { product, quantity } = body const updated = db.inventory.update(product, quantity) if (!updated) { return NextResponse.json({ success: false, error: "Inventory not found" }, { status: 404 }) } console.log("[v0] Updated inventory:", product, quantity) return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update inventory:", error) return NextResponse.json({ success: false, error: "Failed to update inventory" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/material-requirements/route.ts" import { NextResponse } from "next/server" import { initializeDatabase, db } from "@/lib/db" export async function GET() { try { initializeDatabase() console.log("[v0] Calculating material requirements...") const productions = db.productions.getAll().filter((p) => p.status === "planned" || p.status === "in_progress") const materials = db.materials.getAll() const orders = db.orders.getAll() const bom = db.bom.getAll() console.log("[v0] Productions for MRP:", productions.length) console.log("[v0] Materials available:", materials.length) // Calculate total requirements const requirements = materials.map((material) => { let totalRequired = 0 // Calculate from all planned and in-progress productions productions.forEach((production) => { const order = orders.find((o) => o.id === production.orderId) if (!order) return const productBom = bom.find((b) => b.productCode === order.product) if (!productBom) return const materialReq = productBom.materials.find((m) => m.materialCode === material.code) if (materialReq) { totalRequired += materialReq.quantity * production.plannedQuantity } }) const shortage = Math.max(0, totalRequired - material.currentStock) return { material, required: totalRequired, available: material.currentStock, shortage, orderNeeded: shortage > 0, } }) console.log("[v0] Material requirements calculated:", requirements.length) return NextResponse.json({ success: true, data: requirements, }) } catch (error) { console.error("[v0] Material requirements error:", error) return NextResponse.json( { success: false, error: "Failed to calculate material requirements", }, { status: 500 }, ) } } [V0_FILE]typescript:file="app/api/materials/route.ts" import { NextResponse } from "next/server" import { initializeDatabase, db } from "@/lib/db" export async function GET() { initializeDatabase() try { const materials = db.materials.getAll() console.log("[v0] Fetched materials:", materials.length) return NextResponse.json({ success: true, data: materials }) } catch (error) { console.error("[v0] Failed to fetch materials:", error) return NextResponse.json({ success: false, error: "Failed to fetch materials" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { code, currentStock } = body if (!code || currentStock === undefined) { return NextResponse.json({ success: false, error: "Missing required fields" }, { status: 400 }) } const updated = db.materials.update(code, { currentStock }) if (!updated) { return NextResponse.json({ success: false, error: "Material not found" }, { status: 404 }) } console.log("[v0] Updated material:", code, currentStock) return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update material:", error) return NextResponse.json({ success: false, error: "Failed to update material" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/mrp/route.ts" import { NextResponse } from "next/server" import { initializeDatabase, db } from "@/lib/db" // Calculate Material Requirements Planning export async function POST(request: Request) { initializeDatabase() const body = await request.json() const { productionId } = body if (!productionId) { return NextResponse.json({ error: "Production ID required" }, { status: 400 }) } const production = db.productions.getById(productionId) if (!production) { return NextResponse.json({ error: "Production not found" }, { status: 404 }) } const order = db.orders.getById(production.orderId) if (!order) { return NextResponse.json({ error: "Order not found" }, { status: 404 }) } const bom = db.bom.getByProduct(order.product) if (!bom) { return NextResponse.json({ error: "BOM not found for product" }, { status: 404 }) } // Calculate required materials const requirements = bom.materials.map((bomItem) => { const material = db.materials.getByCode(bomItem.materialCode) const requiredQuantity = bomItem.quantity * production.plannedQuantity const currentStock = material?.currentStock || 0 const shortage = Math.max(0, requiredQuantity - currentStock) const isShortage = shortage > 0 return { materialCode: bomItem.materialCode, materialName: material?.name || "", unit: material?.unit || "", requiredPerUnit: bomItem.quantity, totalRequired: requiredQuantity, currentStock, shortage, isShortage, supplier: material?.supplier || "", leadTimeDays: material?.leadTimeDays || 0, unitPrice: material?.unitPrice || 0, totalCost: shortage * (material?.unitPrice || 0), } }) const hasShortage = requirements.some((r) => r.isShortage) const maxLeadTime = Math.max(...requirements.filter((r) => r.isShortage).map((r) => r.leadTimeDays), 0) // Update production status db.productions.update(productionId, { materialShortage: hasShortage }) return NextResponse.json({ productionId, product: order.product, plannedQuantity: production.plannedQuantity, requirements, hasShortage, maxLeadTime, estimatedProductionStart: hasShortage ? new Date(Date.now() + maxLeadTime * 24 * 60 * 60 * 1000).toISOString().split("T")[0] : production.estimatedStartDate, }) } // Confirm material order export async function PUT(request: Request) { initializeDatabase() const body = await request.json() const { materials } = body if (!materials || !Array.isArray(materials)) { return NextResponse.json({ error: "Materials array required" }, { status: 400 }) } const results = materials.map((item: { materialCode: string; orderQuantity: number }) => { const material = db.materials.getByCode(item.materialCode) if (material) { const newStock = material.currentStock + item.orderQuantity db.materials.update(item.materialCode, { currentStock: newStock }) return { materialCode: item.materialCode, previousStock: material.currentStock, orderedQuantity: item.orderQuantity, newStock, leadTimeDays: material.leadTimeDays, expectedArrival: new Date(Date.now() + material.leadTimeDays * 24 * 60 * 60 * 1000).toISOString().split("T")[0], } } return null }) return NextResponse.json({ success: true, results: results.filter(Boolean) }) } [V0_FILE]typescript:file="app/api/orders/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const month = searchParams.get("month") try { const orders = month ? db.orders.getByMonth(month) : db.orders.getAll() console.log("[v0] Fetched orders:", orders.length) return NextResponse.json({ success: true, data: orders }) } catch (error) { console.error("[v0] Failed to fetch orders:", error) return NextResponse.json({ success: false, error: "Failed to fetch orders" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body const updatedOrder = db.orders.update(id, data) if (!updatedOrder) { return NextResponse.json({ success: false, error: "Order not found" }, { status: 404 }) } console.log("[v0] Updated order:", id) return NextResponse.json({ success: true, data: updatedOrder }) } catch (error) { console.error("[v0] Failed to update order:", error) return NextResponse.json({ success: false, error: "Failed to update order" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/productions/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET() { initializeDatabase() try { const productions = db.productions.getAll() console.log("[v0] Fetched productions:", productions.length) return NextResponse.json({ success: true, data: productions }) } catch (error) { console.error("[v0] Failed to fetch productions:", error) return NextResponse.json({ success: false, error: "Failed to fetch productions" }, { status: 500 }) } } export async function POST(request: Request) { initializeDatabase() try { const production = await request.json() const created = db.productions.create(production) console.log("[v0] Created production:", created.id) return NextResponse.json({ success: true, data: created }) } catch (error) { console.error("[v0] Failed to create production:", error) return NextResponse.json({ success: false, error: "Failed to create production" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body const updated = db.productions.update(id, data) if (!updated) { return NextResponse.json({ success: false, error: "Production not found" }, { status: 404 }) } console.log("[v0] Updated production:", id) return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update production:", error) return NextResponse.json({ success: false, error: "Failed to update production" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/sales-plan/approve/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function POST(request: Request) { initializeDatabase() try { const body = await request.json() const { ids, approvalComment } = body // 승인할 판매계획 ID 배열 및 승인 의견 if (!ids || !Array.isArray(ids) || ids.length === 0) { return NextResponse.json({ success: false, error: "IDs array is required" }, { status: 400 }) } const approvedPlans = [] for (const id of ids) { const plan = db.salesPlans.getById(id) if (plan && plan.status === "draft") { const updated = db.salesPlans.update(id, { status: "approved", approvalComment: approvalComment || undefined, }) if (updated) { approvedPlans.push(updated) } } } return NextResponse.json({ success: true, data: approvedPlans, message: `${approvedPlans.length}건의 판매계획이 승인되었습니다.`, }) } catch (error) { console.error("[v0] Failed to approve sales plans:", error) return NextResponse.json({ success: false, error: "Failed to approve sales plans" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/sales-plan/export/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const year = searchParams.get("year") try { const plans = year ? db.salesPlans.getByYear(parseInt(year)) : db.salesPlans.getAll() // CSV 형식으로 변환 const csv = [ ["연월", "업체", "제품코드", "제품명", "카테고리", "계획수량", "계획매출(만원)", "상태"].join(","), ...plans.map((plan) => [ plan.yearMonth, plan.customer, plan.productCode, plan.product, plan.category, plan.plannedQuantity, plan.plannedRevenue, plan.status, ].join(","), ), ].join("\n") return new NextResponse("\uFEFF" + csv, { headers: { "Content-Type": "text/csv;charset=utf-8;", "Content-Disposition": `attachment; filename="sales_plan_${year || "all"}.csv"`, }, }) } catch (error) { console.error("[v0] Failed to export sales plan:", error) return NextResponse.json({ success: false, error: "Failed to export sales plan" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/sales-plan/history/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const salesPlanId = searchParams.get("salesPlanId") const yearMonth = searchParams.get("yearMonth") try { if (salesPlanId) { const history = db.salesPlanHistory.getBySalesPlanId(salesPlanId) return NextResponse.json({ success: true, data: history }) } else if (yearMonth) { const history = db.salesPlanHistory.getByYearMonth(yearMonth) return NextResponse.json({ success: true, data: history }) } else { const history = db.salesPlanHistory.getAll() return NextResponse.json({ success: true, data: history }) } } catch (error) { console.error("[v0] Failed to fetch sales plan history:", error) return NextResponse.json({ success: false, error: "Failed to fetch sales plan history" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/sales-plan/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const yearMonth = searchParams.get("yearMonth") const year = searchParams.get("year") const customer = searchParams.get("customer") const status = searchParams.get("status") try { let plans if (yearMonth) { plans = db.salesPlans.getByYearMonth(yearMonth) } else if (year) { plans = db.salesPlans.getByYear(parseInt(year)) } else { plans = db.salesPlans.getAll() } // 필터링 if (customer) { plans = plans.filter((p) => p.customer === customer) } if (status) { plans = plans.filter((p) => p.status === status) } return NextResponse.json({ success: true, data: plans }) } catch (error) { console.error("[v0] Failed to fetch sales plans:", error) return NextResponse.json({ success: false, error: "Failed to fetch sales plans" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body if (!id) { return NextResponse.json({ success: false, error: "ID is required" }, { status: 400 }) } const updated = db.salesPlans.update(id, data) if (!updated) { return NextResponse.json({ success: false, error: "Sales plan not found" }, { status: 404 }) } return NextResponse.json({ success: true, data: updated }) } catch (error) { console.error("[v0] Failed to update sales plan:", error) return NextResponse.json({ success: false, error: "Failed to update sales plan" }, { status: 500 }) } } export async function POST(request: Request) { initializeDatabase() try { const body = await request.json() // 단일 계획 생성 또는 bulk 업데이트 if (Array.isArray(body)) { const updated = db.salesPlans.bulkUpdate(body) return NextResponse.json({ success: true, data: updated }) } else { const plan = db.salesPlans.create({ id: body.id || `SP-${body.yearMonth}-${body.customer}-${body.productCode}`, yearMonth: body.yearMonth, customer: body.customer, productCode: body.productCode, product: body.product, category: body.category, plannedQuantity: body.plannedQuantity, plannedRevenue: body.plannedRevenue, status: body.status || "draft", createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), }) return NextResponse.json({ success: true, data: plan }) } } catch (error) { console.error("[v0] Failed to create/update sales plan:", error) return NextResponse.json({ success: false, error: "Failed to create/update sales plan" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/sales-plan/upload/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function POST(request: Request) { initializeDatabase() try { const formData = await request.formData() const file = formData.get("file") as File if (!file) { return NextResponse.json({ success: false, error: "No file provided" }, { status: 400 }) } const text = await file.text() // BOM 제거 (UTF-8 BOM) const cleanText = text.replace(/^\uFEFF/, "") const lines = cleanText.split("\n").filter((line) => line.trim()) // 첫 번째 줄은 헤더이므로 제외 const dataLines = lines.slice(1) const plans = [] for (const line of dataLines) { // CSV 파싱: 쉼표로 분리하되, 따옴표 안의 쉼표는 무시 const parts: string[] = [] let current = "" let inQuotes = false for (let i = 0; i < line.length; i++) { const char = line[i] if (char === '"') { inQuotes = !inQuotes } else if (char === "," && !inQuotes) { parts.push(current.trim()) current = "" } else { current += char } } parts.push(current.trim()) const [yearMonth, customer, productCode, product, category, plannedQuantity, plannedRevenue, status] = parts if (!yearMonth || !productCode || !customer) continue plans.push({ id: `SP-${yearMonth.trim()}-${customer.trim()}-${productCode.trim()}`, yearMonth: yearMonth.trim(), customer: customer.trim() as any, productCode: productCode.trim(), product: product?.trim() || productCode.trim(), category: (category?.trim() || "EV") as any, plannedQuantity: parseInt(plannedQuantity?.trim() || "0") || 0, plannedRevenue: parseInt(plannedRevenue?.trim() || "0") || 0, status: (status?.trim() === "approved" ? "approved" : "draft") as any, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), }) } const updated = db.salesPlans.bulkUpdate(plans) return NextResponse.json({ success: true, data: updated, message: `${plans.length}건의 판매계획이 업로드되었습니다.` }) } catch (error) { console.error("[v0] Failed to upload sales plan:", error) return NextResponse.json({ success: false, error: "Failed to upload sales plan" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/shipment-plan/history/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const shipmentId = searchParams.get("shipmentId") const customer = searchParams.get("customer") try { if (shipmentId) { const history = db.shipmentPlanHistory.getByShipmentId(shipmentId) return NextResponse.json({ success: true, data: history }) } else if (customer) { const history = db.shipmentPlanHistory.getByCustomer(customer) return NextResponse.json({ success: true, data: history }) } else { const history = db.shipmentPlanHistory.getAll() return NextResponse.json({ success: true, data: history }) } } catch (error) { console.error("[v0] Failed to fetch shipment plan history:", error) return NextResponse.json({ success: false, error: "Failed to fetch shipment plan history" }, { status: 500 }) } } [V0_FILE]typescript:file="app/api/shipments/route.ts" import { NextResponse } from "next/server" import { db, initializeDatabase } from "@/lib/db" export async function GET(request: Request) { initializeDatabase() const { searchParams } = new URL(request.url) const month = searchParams.get("month") const dispatchId = searchParams.get("dispatchId") try { let shipments = db.shipments.getAll() if (month) { shipments = shipments.filter((s) => s.shipmentDate.startsWith(month)) } if (dispatchId) { shipments = db.shipments.getByDispatchId(dispatchId) } console.log("[v0] Fetched shipments:", shipments.length) return NextResponse.json({ success: true, data: shipments }) } catch (error) { console.error("[v0] Failed to fetch shipments:", error) return NextResponse.json({ success: false, error: "Failed to fetch shipments" }, { status: 500 }) } } export async function POST(request: Request) { initializeDatabase() try { const body = await request.json() const shipment = db.shipments.create(body) console.log("[v0] Created shipment:", shipment.id) return NextResponse.json({ success: true, data: shipment }) } catch (error) { console.error("[v0] Failed to create shipment:", error) return NextResponse.json({ success: false, error: "Failed to create shipment" }, { status: 500 }) } } export async function PUT(request: Request) { initializeDatabase() try { const body = await request.json() const { id, ...data } = body const updatedShipment = db.shipments.update(id, data) if (!updatedShipment) { return NextResponse.json({ success: false, error: "Shipment not found" }, { status: 404 }) } console.log("[v0] Updated shipment:", id) return NextResponse.json({ success: true, data: updatedShipment }) } catch (error) { console.error("[v0] Failed to update shipment:", error) return NextResponse.json({ success: false, error: "Failed to update shipment" }, { status: 500 }) } } [V0_FILE]typescriptreact:file="app/dispatch/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import type { Dispatch, Inventory } from "@/lib/db" import { Truck, Plus, Weight } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { Toaster } from "@/components/ui/toaster" import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" const VEHICLE_CAPACITIES = { "5톤": 5000, "11톤": 11000, "25톤": 25000, } const PRODUCT_WEIGHTS = { EV: 2.5, // tons per unit SUV: 2.0, // tons per unit } export default function DispatchPage() { const [dispatches, setDispatches] = useState([]) const [inventory, setInventory] = useState([]) const [loading, setLoading] = useState(true) const [showCreateDialog, setShowCreateDialog] = useState(false) const [showWeightDialog, setShowWeightDialog] = useState(false) const [selectedDispatch, setSelectedDispatch] = useState(null) const { toast } = useToast() const [newDispatch, setNewDispatch] = useState({ vehicleNumber: "", vehicleSize: "11톤" as "5톤" | "11톤" | "25톤", destination: "", products: [] as { product: "EV" | "SUV"; quantity: number; weight: number }[], }) const [actualWeight, setActualWeight] = useState(0) useEffect(() => { fetchData() }, []) const fetchData = async () => { setLoading(true) try { const [dispatchResponse, inventoryResponse] = await Promise.all([fetch("/api/dispatch"), fetch("/api/inventory")]) const [dispatchData, inventoryData] = await Promise.all([dispatchResponse.json(), inventoryResponse.json()]) if (dispatchData.success && inventoryData.success) { setDispatches(dispatchData.data) setInventory(inventoryData.data) } } catch (error) { console.error("[v0] Failed to fetch data:", error) toast({ title: "오류", description: "데이터를 불러오는데 실패했습니다.", variant: "destructive", }) } finally { setLoading(false) } } const addProductToDispatch = (product: "EV" | "SUV") => { const productInventory = inventory.find((i) => i.product === product) if (!productInventory || productInventory.quantity === 0) { toast({ title: "재고 부족", description: `${product} 재고가 부족합니다.`, variant: "destructive", }) return } setNewDispatch((prev) => ({ ...prev, products: [ ...prev.products, { product, quantity: 0, weight: 0, }, ], })) } const updateProductQuantity = (index: number, quantity: number) => { const product = newDispatch.products[index] const weight = quantity * PRODUCT_WEIGHTS[product.product] setNewDispatch((prev) => ({ ...prev, products: prev.products.map((p, i) => (i === index ? { ...p, quantity, weight } : p)), })) } const removeProduct = (index: number) => { setNewDispatch((prev) => ({ ...prev, products: prev.products.filter((_, i) => i !== index), })) } const calculateEstimatedWeight = () => { return newDispatch.products.reduce((sum, p) => sum + p.weight, 0) } const handleCreateDispatch = async () => { if (!newDispatch.vehicleNumber || !newDispatch.destination || newDispatch.products.length === 0) { toast({ title: "입력 오류", description: "모든 필수 항목을 입력해주세요.", variant: "destructive", }) return } const estimatedWeight = calculateEstimatedWeight() const capacity = VEHICLE_CAPACITIES[newDispatch.vehicleSize] if (estimatedWeight > capacity) { toast({ title: "중량 초과", description: `차량 용량(${capacity}kg)을 초과했습니다. (${estimatedWeight.toFixed(1)}kg)`, variant: "destructive", }) return } try { const dispatchId = `DSP-${Date.now()}` const dispatch: Dispatch = { id: dispatchId, dispatchNumber: `DN-${Date.now().toString().slice(-8)}`, vehicleNumber: newDispatch.vehicleNumber, vehicleSize: newDispatch.vehicleSize, destination: newDispatch.destination, products: newDispatch.products, estimatedWeight, actualWeight: null, dispatchDate: new Date().toISOString().split("T")[0], status: "planned", createdAt: new Date().toISOString(), } const response = await fetch("/api/dispatch", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(dispatch), }) const result = await response.json() if (result.success) { toast({ title: "배차 생성 완료", description: "배차가 성공적으로 생성되었습니다.", }) setShowCreateDialog(false) setNewDispatch({ vehicleNumber: "", vehicleSize: "11톤", destination: "", products: [], }) await fetchData() } } catch (error) { console.error("[v0] Failed to create dispatch:", error) toast({ title: "오류", description: "배차 생성에 실패했습니다.", variant: "destructive", }) } } const handleUpdateWeight = async () => { if (!selectedDispatch || !actualWeight) { return } try { const response = await fetch("/api/dispatch", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id: selectedDispatch.id, actualWeight, status: "completed", }), }) const result = await response.json() if (result.success) { const variance = actualWeight - selectedDispatch.estimatedWeight const variancePercent = ((variance / selectedDispatch.estimatedWeight) * 100).toFixed(1) toast({ title: "계근 데이터 입력 완료", description: `실제 중량: ${actualWeight.toFixed(1)}kg (오차: ${variancePercent}%)`, }) setShowWeightDialog(false) setSelectedDispatch(null) setActualWeight(0) await fetchData() } } catch (error) { console.error("[v0] Failed to update weight:", error) toast({ title: "오류", description: "계근 데이터 업데이트에 실패했습니다.", variant: "destructive", }) } } const stats = { total: dispatches.length, planned: dispatches.filter((d) => d.status === "planned").length, dispatched: dispatches.filter((d) => d.status === "dispatched").length, completed: dispatches.filter((d) => d.status === "completed").length, totalWeight: dispatches.reduce((sum, d) => sum + d.estimatedWeight, 0), } const plannedDispatches = dispatches.filter((d) => d.status === "planned") const dispatchedDispatches = dispatches.filter((d) => d.status === "dispatched") const completedDispatches = dispatches.filter((d) => d.status === "completed") return (

배차 관리

출하 계획을 수립하고 차량 배차를 관리합니다

현재 재고 현황 총 {inventory.reduce((sum, i) => sum + i.quantity, 0).toLocaleString()}대

{inventory.map((inv) => (

{inv.product}

{inv.quantity.toLocaleString()}

))}

총 배차 {stats.total}

전체 배차 건수

계획 중 {stats.planned}

배차 대기

배차 완료 {stats.completed}

계근 완료

총 중량 {(stats.totalWeight / 1000).toFixed(1)}

톤

계획 중 ({plannedDispatches.length}) 배차 완료 ({dispatchedDispatches.length}) 출하 완료 ({completedDispatches.length}) {loading ? (

데이터를 불러오는 중...

) : plannedDispatches.length === 0 ? (

배차 계획이 없습니다.

) : (

배차번호 차량번호 차량크기 목적지 출하품목 예상중량 실제중량 오차 상태 작업 {plannedDispatches.map((dispatch) => { const variance = dispatch.actualWeight ? dispatch.actualWeight - dispatch.estimatedWeight : null const variancePercent = variance ? ((variance / dispatch.estimatedWeight) * 100).toFixed(1) : null return ( {dispatch.dispatchNumber} {dispatch.vehicleNumber} {dispatch.vehicleSize} {dispatch.destination}

{dispatch.products.map((p, i) => (

{p.product}: {p.quantity}대

))}

{dispatch.estimatedWeight.toFixed(1)}kg {dispatch.actualWeight ? `${dispatch.actualWeight.toFixed(1)}kg` : "-"} {variancePercent ? ( 5 ? "destructive" : "secondary"} > {Number.parseFloat(variancePercent) > 0 ? "+" : ""} {variancePercent}% ) : ( "-" )} {dispatch.status === "planned" && 계획} {dispatch.status === "dispatched" && 배차중} {dispatch.status === "completed" && 완료} {dispatch.status !== "completed" && ( )} ) })}

)} {loading ? (

데이터를 불러오는 중...

) : dispatchedDispatches.length === 0 ? (

배차 완료된 배차가 없습니다.

) : (

배차번호 차량번호 차량크기 목적지 출하품목 예상중량 실제중량 오차 상태 작업 {dispatchedDispatches.map((dispatch) => { const variance = dispatch.actualWeight ? dispatch.actualWeight - dispatch.estimatedWeight : null const variancePercent = variance ? ((variance / dispatch.estimatedWeight) * 100).toFixed(1) : null return ( {dispatch.dispatchNumber} {dispatch.vehicleNumber} {dispatch.vehicleSize} {dispatch.destination}

{dispatch.products.map((p, i) => (

{p.product}: {p.quantity}대

))}

)} {loading ? (

데이터를 불러오는 중...

) : completedDispatches.length === 0 ? (

출하 완료된 배차가 없습니다.

) : (

배차번호 차량번호 차량크기 목적지 출하품목 예상중량 실제중량 오차 상태 작업 {completedDispatches.map((dispatch) => { const variance = dispatch.actualWeight ? dispatch.actualWeight - dispatch.estimatedWeight : null const variancePercent = variance ? ((variance / dispatch.estimatedWeight) * 100).toFixed(1) : null return ( {dispatch.dispatchNumber} {dispatch.vehicleNumber} {dispatch.vehicleSize} {dispatch.destination}

{dispatch.products.map((p, i) => (

{p.product}: {p.quantity}대

))}

)} {/* Create Dispatch Dialog */} {/* Weight Input Dialog */}

) } [V0_FILE]css:file="app/globals.css" @import "tailwindcss"; @import "tw-animate-css"; @custom-variant dark (&:is(.dark *)); :root { /* Converting oklch to RGB colors - Primary: #28424E (40, 66, 78), Secondary: #00A0B1 (0, 160, 177) */ --background: rgb(255 255 255); --foreground: rgb(40 66 78); --card: rgb(255 255 255); --card-foreground: rgb(40 66 78); --popover: rgb(255 255 255); --popover-foreground: rgb(40 66 78); --primary: rgb(40 66 78); --primary-foreground: rgb(255 255 255); --secondary: rgb(0 160 177); --secondary-foreground: rgb(255 255 255); --muted: rgb(237 242 247); --muted-foreground: rgb(107 114 128); --accent: rgb(0 160 177); --accent-foreground: rgb(255 255 255); --destructive: rgb(220 38 38); --destructive-foreground: rgb(255 255 255); --border: rgb(226 232 240); --input: rgb(226 232 240); --ring: rgb(40 66 78); --chart-1: rgb(40 66 78); --chart-2: rgb(0 160 177); --chart-3: rgb(79 172 254); --chart-4: rgb(34 197 94); --chart-5: rgb(168 85 247); --radius: 0.5rem; --sidebar: rgb(248 250 252); --sidebar-foreground: rgb(40 66 78); --sidebar-primary: rgb(40 66 78); --sidebar-primary-foreground: rgb(255 255 255); --sidebar-accent: rgb(0 160 177); --sidebar-accent-foreground: rgb(255 255 255); --sidebar-border: rgb(226 232 240); --sidebar-ring: rgb(40 66 78); } .dark { /* Dark mode RGB colors */ --background: rgb(20 24 28); --foreground: rgb(243 244 246); --card: rgb(31 41 55); --card-foreground: rgb(243 244 246); --popover: rgb(31 41 55); --popover-foreground: rgb(243 244 246); --primary: rgb(59 130 246); --primary-foreground: rgb(255 255 255); --secondary: rgb(0 160 177); --secondary-foreground: rgb(255 255 255); --muted: rgb(55 65 81); --muted-foreground: rgb(156 163 175); --accent: rgb(0 160 177); --accent-foreground: rgb(255 255 255); --destructive: rgb(239 68 68); --destructive-foreground: rgb(243 244 246); --border: rgb(55 65 81); --input: rgb(55 65 81); --ring: rgb(59 130 246); --chart-1: rgb(59 130 246); --chart-2: rgb(0 160 177); --chart-3: rgb(79 172 254); --chart-4: rgb(34 197 94); --chart-5: rgb(168 85 247); --sidebar: rgb(31 41 55); --sidebar-foreground: rgb(243 244 246); --sidebar-primary: rgb(59 130 246); --sidebar-primary-foreground: rgb(255 255 255); --sidebar-accent: rgb(0 160 177); --sidebar-accent-foreground: rgb(255 255 255); --sidebar-border: rgb(55 65 81); --sidebar-ring: rgb(59 130 246); } @theme inline { --font-sans: "Geist", "Geist Fallback"; --font-mono: "Geist Mono", "Geist Mono Fallback"; --color-background: var(--background); --color-foreground: var(--foreground); --color-card: var(--card); --color-card-foreground: var(--card-foreground); --color-popover: var(--popover); --color-popover-foreground: var(--popover-foreground); --color-primary: var(--primary); --color-primary-foreground: var(--primary-foreground); --color-secondary: var(--secondary); --color-secondary-foreground: var(--secondary-foreground); --color-muted: var(--muted); --color-muted-foreground: var(--muted-foreground); --color-accent: var(--accent); --color-accent-foreground: var(--accent-foreground); --color-destructive: var(--destructive); --color-destructive-foreground: var(--destructive-foreground); --color-border: var(--border); --color-input: var(--input); --color-ring: var(--ring); --color-chart-1: var(--chart-1); --color-chart-2: var(--chart-2); --color-chart-3: var(--chart-3); --color-chart-4: var(--chart-4); --color-chart-5: var(--chart-5); --radius-sm: calc(var(--radius) - 4px); --radius-md: calc(var(--radius) - 2px); --radius-lg: var(--radius); --radius-xl: calc(var(--radius) + 4px); --color-sidebar: var(--sidebar); --color-sidebar-foreground: var(--sidebar-foreground); --color-sidebar-primary: var(--sidebar-primary); --color-sidebar-primary-foreground: var(--sidebar-primary-foreground); --color-sidebar-accent: var(--sidebar-accent); --color-sidebar-accent-foreground: var(--sidebar-accent-foreground); --color-sidebar-border: var(--sidebar-border); --color-sidebar-ring: var(--sidebar-ring); } @layer base { * { @apply border-border outline-ring/50; } body { @apply bg-background text-foreground; } } [V0_FILE]typescriptreact:file="app/layout.tsx" import type React from "react" import type { Metadata } from "next" import { Geist, Geist_Mono } from "next/font/google" import { Analytics } from "@vercel/analytics/next" import "./globals.css" import { AuthProvider } from "@/components/auth-provider" const _geist = Geist({ subsets: ["latin"] }) const _geistMono = Geist_Mono({ subsets: ["latin"] }) export const metadata: Metadata = { title: "세방리튬배터리 통합 SCM 시스템", description: "발주-생산-출하 관리 시스템", generator: "v0.app", icons: { icon: [ { url: "/icon-light-32x32.png", media: "(prefers-color-scheme: light)", }, { url: "/icon-dark-32x32.png", media: "(prefers-color-scheme: dark)", }, { url: "/icon.svg", type: "image/svg+xml", }, ], apple: "/apple-icon.png", }, } export default function RootLayout({ children, }: Readonly<{ children: React.ReactNode }>) { return ( {children} ) } [V0_FILE]typescriptreact:file="app/login/page.tsx" "use client" import { useState } from "react" import { useRouter } from "next/navigation" import { useAuth } from "@/components/auth-provider" import { testAccounts, type User } from "@/lib/auth" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Label } from "@/components/ui/label" import { Input } from "@/components/ui/input" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Collapsible, CollapsibleContent, CollapsibleTrigger } from "@/components/ui/collapsible" import { ChevronDown, LogIn } from "lucide-react" export default function LoginPage() { const [selectedAccount, setSelectedAccount] = useState(null) const [username, setUsername] = useState("") const [password, setPassword] = useState("") const [isTestAccountsOpen, setIsTestAccountsOpen] = useState(false) const { login } = useAuth() const router = useRouter() const handleTestAccountSelect = (accountId: string) => { const account = testAccounts.find((acc) => acc.id === accountId) if (account) { setSelectedAccount(account) setUsername(account.username) setPassword(account.password) } } const handleLogin = () => { // Verify credentials const account = testAccounts.find((acc) => acc.username === username && acc.password === password) if (account) { login(account) router.push("/") } else { alert("로그인 정보가 올바르지 않습니다.") } } return (

세방리튬배터리 SCM 시스템 통합 공급망 관리 시스템 {/* Test Accounts Selector */}

테스트 계정 선택

테스트 계정 {selectedAccount && (

이름: {selectedAccount.fullName}

역할: {selectedAccount.role}

회사: {selectedAccount.company}

로그인 정보가 자동으로 입력되었습니다.

)}

{/* Login Form */}

사용자명 setUsername(e.target.value)} onKeyDown={(e) => e.key === "Enter" && handleLogin()} />

비밀번호 setPassword(e.target.value)} onKeyDown={(e) => e.key === "Enter" && handleLogin()} />

{/* Info */}

테스트 계정을 선택하면 자동으로 로그인 정보가 입력됩니다.

모든 테스트 계정 비밀번호: test123

) } [V0_FILE]typescriptreact:file="app/materials/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import type { Material } from "@/lib/db" import { AlertTriangle, Package, CheckCircle, TruckIcon, Download, Calendar } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { Toaster } from "@/components/ui/toaster" import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog" interface MaterialRequirement { material: Material required: number available: number shortage: number orderNeeded: boolean } interface PurchaseOrder { id: string materialCode: string materialName: string quantity: number supplier: string orderDate: string expectedDeliveryDate: string status: "ordered" | "in_transit" | "received" createdAt: string unitPrice: number totalAmount: number } export default function MaterialsPage() { const [materials, setMaterials] = useState([]) const [requirements, setRequirements] = useState([]) const [purchaseOrders, setPurchaseOrders] = useState([]) const [selectedMonth, setSelectedMonth] = useState("2025-12") const [loading, setLoading] = useState(true) const [showOrderDialog, setShowOrderDialog] = useState(false) const [showReceiveDialog, setShowReceiveDialog] = useState(false) const [selectedMaterial, setSelectedMaterial] = useState(null) const [selectedPO, setSelectedPO] = useState(null) const [receiveQuantity, setReceiveQuantity] = useState(0) const { toast } = useToast() useEffect(() => { fetchData() }, []) const fetchData = async () => { setLoading(true) try { const [materialsRes, requirementsRes] = await Promise.all([ fetch("/api/materials"), fetch("/api/material-requirements"), ]) const [materialsData, requirementsData] = await Promise.all([materialsRes.json(), requirementsRes.json()]) if (materialsData.success) { setMaterials(materialsData.data) } if (requirementsData.success) { setRequirements(requirementsData.data) } // Load purchase orders from localStorage const savedPOs = localStorage.getItem("purchaseOrders") if (savedPOs) { setPurchaseOrders(JSON.parse(savedPOs)) } } catch (error) { console.error("[v0] Failed to fetch materials:", error) toast({ title: "오류", description: "자재 데이터를 불러오는데 실패했습니다.", variant: "destructive", }) } finally { setLoading(false) } } const handleCreatePurchaseOrder = async (material: MaterialRequirement) => { const orderDate = new Date() const expectedDeliveryDate = new Date() expectedDeliveryDate.setDate(expectedDeliveryDate.getDate() + material.material.leadTimeDays) const totalAmount = material.shortage * material.material.unitPrice const newPO: PurchaseOrder = { id: `PO-${Date.now()}`, materialCode: material.material.code, materialName: material.material.name, quantity: material.shortage, supplier: material.material.supplier, orderDate: orderDate.toISOString().split("T")[0], expectedDeliveryDate: expectedDeliveryDate.toISOString().split("T")[0], status: "ordered", createdAt: new Date().toISOString(), unitPrice: material.material.unitPrice, totalAmount, } const updatedPOs = [...purchaseOrders, newPO] setPurchaseOrders(updatedPOs) localStorage.setItem("purchaseOrders", JSON.stringify(updatedPOs)) // Calculate production start date const productionStartDate = new Date(expectedDeliveryDate) productionStartDate.setDate(productionStartDate.getDate() + 1) toast({ title: "발주 완료", description: `${material.material.name} ${material.shortage}${material.material.unit} 발주가 완료되었습니다.\n예상 입고일: ${newPO.expectedDeliveryDate}\n생산 가능일: ${productionStartDate.toISOString().split("T")[0]}`, duration: 5000, }) setShowOrderDialog(false) setSelectedMaterial(null) } const handleReceiveMaterial = async () => { if (!selectedPO || !receiveQuantity) return try { // Update material stock const material = materials.find((m) => m.code === selectedPO.materialCode) if (material) { const response = await fetch("/api/materials", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ code: material.code, currentStock: material.currentStock + receiveQuantity, }), }) if (response.ok) { // Update PO status const updatedPOs = purchaseOrders.map((po) => po.id === selectedPO.id ? { ...po, status: "received" as const } : po, ) setPurchaseOrders(updatedPOs) localStorage.setItem("purchaseOrders", JSON.stringify(updatedPOs)) toast({ title: "입고 완료", description: `${selectedPO.materialName} ${receiveQuantity}${material.unit} 입고가 완료되었습니다.`, }) setShowReceiveDialog(false) setSelectedPO(null) setReceiveQuantity(0) await fetchData() } } } catch (error) { console.error("[v0] Failed to receive material:", error) toast({ title: "오류", description: "입고 처리에 실패했습니다.", variant: "destructive", }) } } const handleExportExcel = () => { const csv = [ ["발주번호", "자재명", "수량", "단가(원)", "금액(원)", "공급업체", "발주일", "예상입고일", "상태"].join(","), ...purchaseOrders.map((po) => [ po.id, po.materialName, po.quantity, po.unitPrice, po.totalAmount, po.supplier, po.orderDate, po.expectedDeliveryDate, po.status, ].join(","), ), ].join("\n") const blob = new Blob(["\uFEFF" + csv], { type: "text/csv;charset=utf-8;" }) const link = document.createElement("a") link.href = URL.createObjectURL(blob) link.download = `material_orders_${selectedMonth}.csv` link.click() } const shortageAlerts = requirements.filter((r) => r.orderNeeded) const lowStockMaterials = materials.filter((m) => m.currentStock < m.minStock) const stats = { totalMaterials: materials.length, lowStock: lowStockMaterials.length, shortages: shortageAlerts.length, pendingOrders: purchaseOrders.filter((po) => po.status === "ordered" || po.status === "in_transit").length, totalOrderAmount: purchaseOrders.reduce((sum, po) => sum + po.totalAmount, 0), monthlyAverage: purchaseOrders.length > 0 ? purchaseOrders.reduce((sum, po) => sum + po.totalAmount, 0) / 1 : 0, } return (

자재 관리

생산에 필요한 자재를 관리하고 발주합니다

{shortageAlerts.length > 0 && (

자재 부족 알림

{shortageAlerts.length}개 자재에 대한 발주가 필요합니다. 생산 차질이 예상됩니다.

)}

총 자재 품목 {stats.totalMaterials}

관리 중인 자재

발주 필요 {stats.shortages}

긴급 발주 필요

발주 진행 중 {stats.pendingOrders}

입고 대기

총 발주 금액 {(stats.totalOrderAmount / 10000).toLocaleString()}만원

누적 발주액

월평균 금액 {(stats.monthlyAverage / 10000).toLocaleString()}만원

월별 평균

자재 발주 계획 {shortageAlerts.length > 0 && ( {shortageAlerts.length} )} 발주 내역 {purchaseOrders.length} 재고 현황

자재 소요량 (MRP) 생산 계획 기반 자재 소요량 자동 계산 결과

{loading ? (

데이터를 불러오는 중...

) : requirements.length === 0 ? (

자재 소요량 정보가 없습니다.

) : (

자재코드 자재명 필요수량 현재고 부족수량 단가(원) 발주금액(만원) 공급업체 리드타임 상태 작업 {requirements.map((req) => ( {req.material.code} {req.material.name} {req.required.toLocaleString()} {req.material.unit} {req.available.toLocaleString()} {req.material.unit} {req.shortage > 0 ? ( {req.shortage.toLocaleString()} {req.material.unit} ) : ( - )} {req.material.unitPrice.toLocaleString()}원 {req.shortage > 0 ? ((req.shortage * req.material.unitPrice) / 10000).toLocaleString() : "-"} 만원 {req.material.supplier}

{req.material.leadTimeDays}일

{req.orderNeeded ? ( 발주필요 ) : ( 충분 )} {req.orderNeeded && ( )} ))}

)}

발주 내역 자재 발주 및 입고 관리

{purchaseOrders.length === 0 ? (

발주 내역이 없습니다.

) : (

발주번호 발주일 자재명 수량 단가(원) 금액(만원) 공급업체 예상입고일 상태 작업 {purchaseOrders.map((po) => { const material = materials.find((m) => m.code === po.materialCode) return ( {po.id} {po.orderDate} {po.materialName} {po.quantity.toLocaleString()} {material?.unit || "EA"} {po.unitPrice.toLocaleString()}원 {(po.totalAmount / 10000).toLocaleString()}만원 {po.supplier} {po.expectedDeliveryDate} {po.status === "ordered" && 발주완료} {po.status === "in_transit" && ( 배송중 )} {po.status === "received" && 입고완료} {po.status !== "received" && ( )} ) })}

)} 실시간 재고 현황 자재별 현재고 및 최소 재고 수준

자재코드 자재명 현재고 최소재고 재고율 공급업체 단가(원) 상태 {materials.map((material) => { const stockRate = (material.currentStock / material.minStock) * 100 const isLowStock = material.currentStock < material.minStock return ( {material.code} {material.name} {material.currentStock.toLocaleString()} {material.unit} {material.minStock.toLocaleString()} {material.unit}

= 100 ? "bg-green-600" : stockRate >= 50 ? "bg-orange-500" : "bg-destructive" }`} style={{ width: `${Math.min(stockRate, 100)}%` }} />

{stockRate.toFixed(0)}%

{material.supplier} {material.unitPrice.toLocaleString()}원 {isLowStock ? ( 부족 ) : ( 정상 )} ) })}

{/* Purchase Order Dialog */} {/* Receive Material Dialog */} ) } [V0_FILE]typescriptreact:file="app/orders/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { OrderTable } from "@/components/order-table" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import type { Order } from "@/lib/db" import { Download, Upload, Save, Package, TruckIcon, Clock } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { Toaster } from "@/components/ui/toaster" import { useAuth } from "@/components/auth-provider" import { Pagination } from "@/components/pagination" export default function OrdersPage() { const { user } = useAuth() const [orders, setOrders] = useState([]) const [selectedMonth, setSelectedMonth] = useState("2025-12") const [selectedCustomer, setSelectedCustomer] = useState("all") const [loading, setLoading] = useState(true) const { toast } = useToast() const [currentPage, setCurrentPage] = useState(1) const [deliveryPage, setDeliveryPage] = useState(1) const itemsPerPage = 10 useEffect(() => { initializeData() }, []) useEffect(() => { fetchOrders() }, [selectedMonth, selectedCustomer, user]) const initializeData = async () => { try { const response = await fetch("/api/init") const data = await response.json() if (data.success) { console.log("[v0] Database initialized:", data.stats) } } catch (error) { console.error("[v0] Failed to initialize database:", error) } } const fetchOrders = async () => { setLoading(true) try { let url = "/api/orders" const params = new URLSearchParams() if (selectedMonth !== "all") { params.append("month", selectedMonth) } if (user?.role === "customer") { params.append("customer", user.company) } else if (selectedCustomer !== "all") { params.append("customer", selectedCustomer) } if (params.toString()) { url += `?${params.toString()}` } const response = await fetch(url) const data = await response.json() if (data.success) { setOrders(data.data) } } catch (error) { console.error("[v0] Failed to fetch orders:", error) toast({ title: "오류", description: "발주 데이터를 불러오는데 실패했습니다.", variant: "destructive", }) } finally { setLoading(false) } } const handleUpdate = async (id: string, data: Partial) => { try { const response = await fetch("/api/orders", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id, ...data }), }) const result = await response.json() if (result.success) { await fetchOrders() toast({ title: "저장 완료", description: "발주 데이터가 업데이트되었습니다.", }) } } catch (error) { console.error("[v0] Failed to update order:", error) toast({ title: "오류", description: "발주 데이터 업데이트에 실패했습니다.", variant: "destructive", }) } } const handleConfirmAll = async () => { try { const pendingOrders = orders.filter((o) => o.status === "predicted") for (const order of pendingOrders) { await handleUpdate(order.id, { confirmedQuantity: order.predictedQuantity, status: "confirmed", }) } toast({ title: "일괄 확정 완료", description: `${pendingOrders.length}건의 발주가 확정되었습니다.`, }) } catch (error) { console.error("[v0] Failed to confirm orders:", error) } } const handleExportExcel = () => { const csv = [ ["주문번호", "발주월", "발주사", "품목", "예측수량", "확정수량", "단가(만원)", "금액(만원)", "상태"].join(","), ...orders.map((o) => [ o.id, o.orderDate, o.customer, o.product, o.predictedQuantity, o.confirmedQuantity, o.unitPrice, o.confirmedQuantity * o.unitPrice, o.status, ].join(","), ), ].join("\n") const blob = new Blob(["\uFEFF" + csv], { type: "text/csv;charset=utf-8;" }) const link = document.createElement("a") link.href = URL.createObjectURL(blob) link.download = `orders_${selectedMonth}.csv` link.click() } const filteredOrders = orders.filter((order) => selectedCustomer === "all" ? true : order.customer === selectedCustomer, ) const totalPages = Math.ceil(filteredOrders.length / itemsPerPage) const paginatedOrders = filteredOrders.slice((currentPage - 1) * itemsPerPage, currentPage * itemsPerPage) const stats = { total: filteredOrders.reduce((sum, o) => sum + o.predictedQuantity, 0), confirmed: filteredOrders.reduce((sum, o) => sum + o.confirmedQuantity, 0), pending: filteredOrders.filter((o) => o.status === "predicted").length, predictedAmount: filteredOrders.reduce((sum, o) => sum + o.predictedQuantity * o.unitPrice, 0), confirmedAmount: filteredOrders.reduce((sum, o) => sum + o.confirmedQuantity * o.unitPrice, 0), shipped: filteredOrders.filter((o) => o.status === "shipped" || o.status === "delivered").length, } const monthlyAverage = Math.round(stats.confirmedAmount / Math.max(1, filteredOrders.length)) const deliveryOrders = orders.filter( (o) => o.status === "approved" || o.status === "in_production" || o.status === "shipped" || o.status === "delivered", ) const deliveryTotalPages = Math.ceil(deliveryOrders.length / itemsPerPage) const paginatedDeliveryOrders = deliveryOrders.slice((deliveryPage - 1) * itemsPerPage, deliveryPage * itemsPerPage) return (

발주 계획

예측 발주 데이터를 확인하고 최종 발주를 확정합니다

총 예측 수량 {stats.total.toLocaleString()}

{stats.predictedAmount.toLocaleString()}만원

확정 수량 {stats.confirmed.toLocaleString()}

{stats.confirmedAmount.toLocaleString()}만원

대기 중인 발주 {stats.pending} 출하 완료 {stats.shipped} 월평균 금액 {monthlyAverage.toLocaleString()}만원

발주 계획 배송 현황 {deliveryOrders.length}

발주 데이터

{user?.role !== "customer" && ( )}

{loading ? (

데이터를 불러오는 중...

) : ( <> )} 배송 현황 주문부터 배송까지 전체 프로세스를 추적합니다 {loading ? (

데이터를 불러오는 중...

) : ( <>

주문번호 발주사 품목 수량 금액 리드타임 예상 도착일 상태 {paginatedDeliveryOrders.length === 0 ? ( 배송 중인 주문이 없습니다. ) : ( paginatedDeliveryOrders.map((order) => { const leadTime = (() => { const leadTimes = { ESS: 30, EV: 21, SV: 14, PLBM: 18 } return leadTimes[order.category] })() return ( {order.id} {order.customer} {order.product} {order.confirmedQuantity.toLocaleString()} {(order.confirmedQuantity * order.unitPrice).toLocaleString()}만원

{leadTime}일

{order.estimatedDeliveryDate} {order.status === "approved" && ( 승인완료 )} {order.status === "in_production" && ( 생산중 )} {order.status === "shipped" && ( 출하완료 )} {order.status === "delivered" && ( 배송완료 )} ) }) )}

)}

) } [V0_FILE]typescriptreact:file="app/page.tsx" "use client" import type React from "react" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { BarChart3, Package, Factory, Truck, AlertCircle } from "lucide-react" import Link from "next/link" import type { Order, Production, Inventory, Dispatch } from "@/lib/db" import { Progress } from "@/components/ui/progress" import { Bar, BarChart, CartesianGrid, Legend, Pie, PieChart, ResponsiveContainer, Tooltip, XAxis, YAxis, Cell, Line, LineChart, } from "recharts" const COLORS = { hyundai: "#004B91", samsung: "#0066CC", EV: "#0088FE", SUV: "#00C49F", factory1: "#FF8042", factory2: "#FFBB28", } export default function HomePage() { const [orders, setOrders] = useState([]) const [productions, setProductions] = useState([]) const [inventory, setInventory] = useState([]) const [dispatches, setDispatches] = useState([]) const [loading, setLoading] = useState(true) useEffect(() => { initializeData() }, []) const initializeData = async () => { try { // Initialize database await fetch("/api/init") // Fetch all data const [ordersRes, productionsRes, inventoryRes, dispatchesRes] = await Promise.all([ fetch("/api/orders"), fetch("/api/productions"), fetch("/api/inventory"), fetch("/api/dispatch"), ]) const [ordersData, productionsData, inventoryData, dispatchesData] = await Promise.all([ ordersRes.json(), productionsRes.json(), inventoryRes.json(), dispatchesRes.json(), ]) if (ordersData.success) setOrders(ordersData.data) if (productionsData.success) setProductions(productionsData.data) if (inventoryData.success) setInventory(inventoryData.data) if (dispatchesData.success) setDispatches(dispatchesData.data) setLoading(false) } catch (error) { console.error("[v0] Failed to initialize:", error) setLoading(false) } } // Calculate statistics const stats = { totalOrders: orders.length, totalProductions: productions.length, totalInventory: inventory.reduce((sum, i) => sum + i.quantity, 0), totalDispatch: dispatches.length, pendingOrders: orders.filter((o) => o.status === "confirmed").length, completedProductions: productions.filter((p) => p.status === "inspected").length, pendingDispatches: dispatches.filter((d) => d.status === "planned").length, } // Customer share data const customerData = [ { name: "현대차", value: orders.filter((o) => o.customer === "현대차").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, { name: "삼성SDI", value: orders.filter((o) => o.customer === "삼성SDI").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, ] // Product distribution const productData = [ { name: "ESS", value: orders.filter((o) => o.category === "ESS").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, { name: "EV", value: orders.filter((o) => o.category === "EV").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, { name: "SV", value: orders.filter((o) => o.category === "SV").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, { name: "PLBM", value: orders.filter((o) => o.category === "PLBM").reduce((sum, o) => sum + o.confirmedQuantity, 0), }, ] // Factory production const factoryData = [ { name: "광주1공장", planned: productions .filter((p) => p.productionLine === "광주1공장") .reduce((sum, p) => sum + p.plannedQuantity, 0), completed: productions .filter((p) => p.productionLine === "광주1공장") .reduce((sum, p) => sum + p.inspectedQuantity, 0), }, { name: "광주2공장", planned: productions .filter((p) => p.productionLine === "광주2공장") .reduce((sum, p) => sum + p.plannedQuantity, 0), completed: productions .filter((p) => p.productionLine === "광주2공장") .reduce((sum, p) => sum + p.inspectedQuantity, 0), }, ] // Monthly trend (last 6 months) const monthlyData = (() => { const months = ["2025-07", "2025-08", "2025-09", "2025-10", "2025-11", "2025-12"] return months.map((month) => ({ month: month.slice(5), orders: orders.filter((o) => o.orderDate === month).reduce((sum, o) => sum + o.confirmedQuantity, 0), })) })() const quickActions = [ { title: "발주 계획", description: "당월 발주 예측 데이터 확인 및 수정", icon: BarChart3, href: "/orders", color: "text-blue-600", alert: stats.pendingOrders > 0 ? `${stats.pendingOrders}건 대기` : null, }, { title: "판매 계획", description: "발주 승인 및 생산 이관", icon: Package, href: "/sales", color: "text-green-600", alert: stats.pendingOrders > 0 ? `${stats.pendingOrders}건 승인 필요` : null, }, { title: "생산 계획", description: "공장별 생산 수량 입력", icon: Factory, href: "/production", color: "text-orange-600", alert: productions.filter((p) => p.status === "planned").length > 0 ? `${productions.filter((p) => p.status === "planned").length}건 생산 계획` : null, }, { title: "배차 관리", description: "출하 계획 및 배차 현황", icon: Truck, href: "/dispatch", color: "text-purple-600", alert: stats.pendingDispatches > 0 ? `${stats.pendingDispatches}건 대기` : null, }, ] if (loading) { return (

데이터를 불러오는 중...

) } return (

세방리튬배터리 통합 SCM 시스템

발주-생산-출하 관리를 한 곳에서

총 발주 건수 {stats.totalOrders}

2024-2025 누적

생산 완료 건수 {stats.completedProductions}

검수 완료 기준

배차 완료 {stats.totalDispatch}

총 배차 건수

발주사별 점유율 확정 수량 기준 `${entry.name}: ${((entry.value / customerData.reduce((s, d) => s + d.value, 0)) * 100).toFixed(1)}%` } outerRadius={80} fill="#8884d8" dataKey="value" > 품목별 분포 제품 카테고리별 발주 수량 공장별 생산 현황 계획 대비 실적 월별 발주 추이 최근 6개월

빠른 작업

{quickActions.map((action) => { const Icon = action.icon return ( {action.alert && (

{action.alert}

)} {action.title} {action.description} ) })}

시스템 안내

발주사 (현대차, 삼성SDI)

발주 계획 화면에서 예측 데이터를 확인하고 수정하여 최종 발주를 확정합니다.

창고관리자

판매 계획에서 발주를 승인하고, 출하 계획과 배차 관리를 수행합니다.

생산관리자

생산 계획 화면에서 광주1공장/2공장별 일자별 입고 수량을 입력합니다.

) } [V0_FILE]typescriptreact:file="app/production-performance/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Badge } from "@/components/ui/badge" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Bar, BarChart, CartesianGrid, Legend, ResponsiveContainer, Tooltip, XAxis, YAxis, Line, LineChart, Area, AreaChart, } from "recharts" import { Factory, AlertTriangle, CheckCircle2 } from "lucide-react" import { Progress } from "@/components/ui/progress" type PeriodType = "year" | "month" | "week" | "day" type ProductionLine = "광주1공장" | "광주2공장" interface QualityData { date: string line: ProductionLine target: number input: number goodOutput: number defectOutput: number defectRate: number } interface LossData { date: string line: ProductionLine plannedLoss: { maintenance: number // 정비 changeover: number // 교체 setup: number // 준비 } unplannedLoss: { stop: number // 정지 deviation: number // 이탈 performance: number // 성능 } operationRate: number // 종합가동율 (%) } export default function ProductionPerformancePage() { const [period, setPeriod] = useState("day") const [selectedLine, setSelectedLine] = useState<"all" | ProductionLine>("all") const [qualityData, setQualityData] = useState([]) const [lossData, setLossData] = useState([]) useEffect(() => { generateMockData() }, [period, selectedLine]) const generateMockData = () => { const lines: ProductionLine[] = selectedLine === "all" ? ["광주1공장", "광주2공장"] : [selectedLine] const periods = getPeriods(period) const quality: QualityData[] = [] const loss: LossData[] = [] periods.forEach((date) => { lines.forEach((line) => { const target = line === "광주1공장" ? 1000 : 800 const input = Math.floor(target * (0.95 + Math.random() * 0.1)) const defectOutput = Math.floor(input * (0.02 + Math.random() * 0.03)) const goodOutput = input - defectOutput quality.push({ date, line, target, input, goodOutput, defectRate: (defectOutput / input) * 100, defectOutput, }) const plannedLossTotal = 5 + Math.random() * 10 // 5-15% const unplannedLossTotal = 5 + Math.random() * 15 // 5-20% const operationRate = 100 - plannedLossTotal - unplannedLossTotal loss.push({ date, line, plannedLoss: { maintenance: plannedLossTotal * 0.4, changeover: plannedLossTotal * 0.35, setup: plannedLossTotal * 0.25, }, unplannedLoss: { stop: unplannedLossTotal * 0.4, deviation: unplannedLossTotal * 0.35, performance: unplannedLossTotal * 0.25, }, operationRate: Math.round(operationRate * 10) / 10, }) }) }) setQualityData(quality) setLossData(loss) } const getPeriods = (type: PeriodType): string[] => { const now = new Date() switch (type) { case "year": return Array.from({ length: 12 }, (_, i) => `${now.getFullYear()}년 ${i + 1}월`) case "month": return Array.from({ length: 4 }, (_, i) => `${i + 1}주차`) case "week": return Array.from({ length: 7 }, (_, i) => { const date = new Date(now) date.setDate(date.getDate() - (6 - i)) return date.toLocaleDateString("ko-KR", { month: "short", day: "numeric" }) }) case "day": return Array.from({ length: 24 }, (_, i) => `${i}시`) default: return [] } } // Calculate overall statistics const stats = { totalInput: qualityData.reduce((sum, d) => sum + d.input, 0), totalGood: qualityData.reduce((sum, d) => sum + d.goodOutput, 0), totalDefect: qualityData.reduce((sum, d) => sum + d.defectOutput, 0), avgDefectRate: qualityData.length > 0 ? qualityData.reduce((sum, d) => sum + d.defectRate, 0) / qualityData.length : 0, avgOperationRate: lossData.length > 0 ? lossData.reduce((sum, d) => sum + d.operationRate, 0) / lossData.length : 0, totalPlannedLoss: lossData.length > 0 ? lossData.reduce( (sum, d) => sum + d.plannedLoss.maintenance + d.plannedLoss.changeover + d.plannedLoss.setup, 0, ) / lossData.length : 0, totalUnplannedLoss: lossData.length > 0 ? lossData.reduce( (sum, d) => sum + d.unplannedLoss.stop + d.unplannedLoss.deviation + d.unplannedLoss.performance, 0, ) / lossData.length : 0, } // Chart data aggregation const chartData = qualityData.map((q) => { const loss = lossData.find((l) => l.date === q.date && l.line === q.line) return { period: q.date, line: q.line, target: q.target, input: q.input, good: q.goodOutput, defect: q.defectOutput, defectRate: q.defectRate, operationRate: loss?.operationRate || 0, } }) const lossBreakdownData = lossData.map((l) => ({ period: l.date, line: l.line, 정비: l.plannedLoss.maintenance, 교체: l.plannedLoss.changeover, 준비: l.plannedLoss.setup, 정지: l.unplannedLoss.stop, 이탈: l.unplannedLoss.deviation, 성능: l.unplannedLoss.performance, })) const COLORS = { factory1: "#004B91", factory2: "#0066CC", good: "#10b981", defect: "#ef4444", planned: "#f59e0b", unplanned: "#dc2626", } return (

생산 실적 대시보드

양품/불량 현황과 라인 가동율을 실시간으로 모니터링합니다

총 투입 {stats.totalInput.toLocaleString()}

생산라인 투입량

양품 생산 {stats.totalGood.toLocaleString()}

{((stats.totalGood / stats.totalInput) * 100).toFixed(1)}%

불량 발생 {stats.totalDefect.toLocaleString()}

{stats.avgDefectRate.toFixed(2)}%

종합가동율 {stats.avgOperationRate.toFixed(1)}% 계획 Loss {stats.totalPlannedLoss.toFixed(1)}%

정비/교체/준비

일반 Loss {stats.totalUnplannedLoss.toFixed(1)}%

정지/이탈/성능

생산 투입 vs 산출 목표 대비 투입 및 양품/불량 현황 종합가동율 추이 시간별 라인 가동율 변화 불량률 추이 투입 대비 불량 발생 비율 Loss 분석 계획/일반 Loss 상세 사유별 분석

상세 생산 실적 라인별 생산 실적 상세 내역 품질 실적 Loss 상세

기간 생산라인 목표 투입 양품 불량 불량률 달성률 {qualityData.map((data, idx) => { const achievementRate = (data.goodOutput / data.target) * 100 return ( {data.date} {data.line} {data.target.toLocaleString()} {data.input.toLocaleString()} {data.goodOutput.toLocaleString()} {data.defectOutput.toLocaleString()} {data.defectRate.toFixed(2)}%

{achievementRate.toFixed(0)}%

) })}

기간 생산라인 가동율 계획 Loss 일반 Loss 정비 교체 준비 정지 이탈 성능 {lossData.map((data, idx) => ( {data.date} {data.line} = 80 ? "bg-green-600" : "bg-orange-600"}> {data.operationRate.toFixed(1)}% {data.plannedLoss.maintenance.toFixed(1)}% {data.plannedLoss.changeover.toFixed(1)}% {data.plannedLoss.setup.toFixed(1)}% {data.unplannedLoss.stop.toFixed(1)}% {data.unplannedLoss.deviation.toFixed(1)}% {data.unplannedLoss.performance.toFixed(1)}% ))}

) } [V0_FILE]typescriptreact:file="app/production/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Badge } from "@/components/ui/badge" import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert" import type { Production, Order } from "@/lib/db" import { AlertTriangle, Package } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { Toaster } from "@/components/ui/toaster" import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs" import { Pagination } from "@/components/ui/pagination" interface ProductionWithOrder extends Production { order?: Order } interface MaterialRequirement { materialCode: string materialName: string unit: string requiredPerUnit: number totalRequired: number currentStock: number shortage: number isShortage: boolean supplier: string leadTimeDays: number unitPrice: number totalCost: number } interface MRPResult { productionId: string product: string plannedQuantity: number requirements: MaterialRequirement[] hasShortage: boolean maxLeadTime: number estimatedProductionStart: string } export default function ProductionPage() { const [productions, setProductions] = useState([]) const [orders, setOrders] = useState([]) const [editValues, setEditValues] = useState>({}) const [mrpResults, setMrpResults] = useState>({}) const [selectedProduction, setSelectedProduction] = useState(null) const [loading, setLoading] = useState(true) const { toast } = useToast() const [plannedPage, setPlannedPage] = useState(1) const [completedPage, setCompletedPage] = useState(1) const [inspectedPage, setInspectedPage] = useState(1) const [showMrpDialog, setShowMrpDialog] = useState(false) const itemsPerPage = 10 useEffect(() => { fetchData() }, []) useEffect(() => { const checkMRP = async () => { for (const production of productions.filter((p) => p.status === "planned")) { if (!mrpResults[production.id]) { await calculateMRP(production.id) } } } if (productions.length > 0) { checkMRP() } }, [productions]) const fetchData = async () => { setLoading(true) try { const [prodResponse, orderResponse] = await Promise.all([fetch("/api/productions"), fetch("/api/orders")]) const [prodData, orderData] = await Promise.all([prodResponse.json(), orderResponse.json()]) if (prodData.success && orderData.success) { const ordersMap = new Map(orderData.data.map((o: Order) => [o.id, o])) const productionsWithOrders = prodData.data.map((p: Production) => ({ ...p, order: ordersMap.get(p.orderId), })) setProductions(productionsWithOrders) setOrders(orderData.data) } } catch (error) { console.error("[v0] Failed to fetch data:", error) toast({ title: "오류", description: "데이터를 불러오는데 실패했습니다.", variant: "destructive", }) } finally { setLoading(false) } } const calculateMRP = async (productionId: string) => { try { const response = await fetch("/api/mrp", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ productionId }), }) const result = await response.json() setMrpResults((prev) => ({ ...prev, [productionId]: result })) if (result.hasShortage) { toast({ title: "자재 부족 알림", description: `${result.product} 생산을 위한 자재가 부족합니다.`, variant: "destructive", }) } } catch (error) { console.error("[v0] Failed to calculate MRP:", error) } } const handleConfirmMaterialOrder = async (productionId: string) => { const mrp = mrpResults[productionId] if (!mrp || !mrp.hasShortage) return try { const materialsToOrder = mrp.requirements .filter((r) => r.isShortage) .map((r) => ({ materialCode: r.materialCode, orderQuantity: r.shortage, })) const response = await fetch("/api/mrp", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ materials: materialsToOrder }), }) const result = await response.json() if (result.success) { toast({ title: "자재 발주 완료", description: `${mrp.maxLeadTime}일 후 생산 가능합니다. (${mrp.estimatedProductionStart})`, }) // Refresh MRP calculation await calculateMRP(productionId) await fetchData() } } catch (error) { console.error("[v0] Failed to order materials:", error) toast({ title: "오류", description: "자재 발주에 실패했습니다.", variant: "destructive", }) } } const handleUpdateProduction = async (productionId: string, inspectedQuantity: number) => { try { const response = await fetch("/api/productions", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id: productionId, inspectedQuantity, status: "completed", }), }) const result = await response.json() if (result.success) { toast({ title: "저장 완료", description: "생산 수량이 업데이트되었습니다.", }) await fetchData() } } catch (error) { console.error("[v0] Failed to update production:", error) toast({ title: "오류", description: "생산 수량 업데이트에 실패했습니다.", variant: "destructive", }) } } const handleInspectProduction = async (productionId: string) => { const inspectedQty = editValues[productionId] if (!inspectedQty || inspectedQty <= 0) { toast({ title: "입력 오류", description: "검수 수량을 입력해주세요.", variant: "destructive", }) return } try { const response = await fetch("/api/productions", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id: productionId, inspectedQuantity: inspectedQty, status: "inspected", }), }) const result = await response.json() if (result.success) { const production = productions.find((p) => p.id === productionId) if (production?.order) { const invResponse = await fetch("/api/inventory") const invData = await invResponse.json() const currentInventory = invData.data.find( (i: { product: string }) => i.product === production.order?.product, ) if (currentInventory) { await fetch("/api/inventory", { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ product: production.order.product, quantity: currentInventory.quantity + inspectedQty, }), }) } } toast({ title: "검수 완료", description: "생산 수량이 검수되어 재고에 반영되었습니다.", }) setEditValues((prev) => { const newValues = { ...prev } delete newValues[productionId] return newValues }) await fetchData() } } catch (error) { console.error("[v0] Failed to inspect production:", error) toast({ title: "오류", description: "검수 처리에 실패했습니다.", variant: "destructive", }) } } const plannedProductions = productions.filter((p) => p.status === "planned") const completedProductions = productions.filter((p) => p.status === "completed") const inspectedProductions = productions.filter((p) => p.status === "inspected") const factory1Productions = plannedProductions.filter((p) => p.productionLine === "광주1공장") const factory2Productions = plannedProductions.filter((p) => p.productionLine === "광주2공장") const stats = { planned: plannedProductions.reduce((sum, p) => sum + p.plannedQuantity, 0), factory1: productions .filter((p) => p.productionLine === "광주1공장") .reduce((sum, p) => sum + p.plannedQuantity, 0), factory2: productions .filter((p) => p.productionLine === "광주2공장") .reduce((sum, p) => sum + p.plannedQuantity, 0), completed: completedProductions.reduce((sum, p) => sum + p.inspectedQuantity, 0), inspected: inspectedProductions.reduce((sum, p) => sum + p.inspectedQuantity, 0), materialShortages: plannedProductions.filter((p) => p.materialShortage).length, } const plannedTotalPages = Math.ceil(plannedProductions.length / itemsPerPage) const paginatedPlannedProductions = plannedProductions.slice( (plannedPage - 1) * itemsPerPage, plannedPage * itemsPerPage, ) const completedTotalPages = Math.ceil(completedProductions.length / itemsPerPage) const paginatedCompletedProductions = completedProductions.slice( (completedPage - 1) * itemsPerPage, completedPage * itemsPerPage, ) const inspectedTotalPages = Math.ceil(inspectedProductions.length / itemsPerPage) const paginatedInspectedProductions = inspectedProductions.slice( (inspectedPage - 1) * itemsPerPage, inspectedPage * itemsPerPage, ) return (

생산 계획

공장별 생산 계획을 확인하고 자재 소요량(MRP)을 관리합니다

{stats.materialShortages > 0 && ( 자재 부족 알림 {stats.materialShortages}건의 생산 계획에 필요한 자재가 부족합니다. 자재 발주를 진행해주세요. )}

계획 수량 {stats.planned.toLocaleString()}

{plannedProductions.length}건

광주1공장 {stats.factory1.toLocaleString()}

EV 생산

광주2공장 {stats.factory2.toLocaleString()}

SUV 생산

생산 완료 {stats.completed.toLocaleString()}

{completedProductions.length}건

검수 완료 {stats.inspected.toLocaleString()}

재고 반영

0 ? "border-red-500" : ""}> 자재 부족 {stats.materialShortages}

발주 필요

생산 관리 {loading ? (

데이터를 불러오는 중...

) : ( 생산 계획 ({plannedProductions.length}) {stats.materialShortages > 0 && ( {stats.materialShortages} )} 생산 완료 ({completedProductions.length}) 검수 완료 ({inspectedProductions.length})

{paginatedPlannedProductions.map((production) => { const order = orders.find((o) => o.id === production.orderId) if (!order) return null const cardClassName = production.materialShortage ? "border-2 border-red-500 bg-red-50" : "" return (

{production.id} - {order.product} {production.materialShortage && ( 자재부족 )} {production.productionLine} | 주문번호: {order.id} | 고객: {order.customer}

{production.status === "planned" && 계획중} {production.status === "completed" && 생산완료} {production.status === "inspected" && 검수완료} {production.materialShortage && ( 자재부족 )}

) })}

{paginatedCompletedProductions.map((production) => { return ( {production.id} {production.productionLine} | 주문번호: {production.orderId} | 고객:{" "} {production.order?.customer || "-"}

품목: {production.order?.product || "-"}

계획수량: {production.plannedQuantity.toLocaleString()}

검수수량: {production.inspectedQuantity.toLocaleString()}

) })}

{paginatedInspectedProductions.map((production) => { return ( {production.id} {production.productionLine} | 주문번호: {production.orderId} | 고객:{" "} {production.order?.customer || "-"}

품목: {production.order?.product || "-"}

계획수량: {production.plannedQuantity.toLocaleString()}

검수수량: {production.inspectedQuantity.toLocaleString()}

) })}

)}

) } [V0_FILE]typescriptreact:file="app/sales-management/page.tsx" "use client" import { useEffect, useState } from "react" import { LayoutWrapper } from "@/components/layout-wrapper" import { Button } from "@/components/ui/button" import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card" import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from "@/components/ui/table" import { Badge } from "@/components/ui/badge" import { Input } from "@/components/ui/input" import { Label } from "@/components/ui/label" import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "@/components/ui/select" import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle, } from "@/components/ui/dialog" import { Download, Upload, Edit2, History, Save, CheckCircle2 } from "lucide-react" import { useToast } from "@/hooks/use-toast" import { Toaster } from "@/components/ui/toaster" import { Textarea } from "@/components/ui/textarea" import type { SalesPlan, SalesPlanHistory } from "@/lib/db" export default function SalesManagementPage() { const [salesPlans, setSalesPlans] = useState([]) const [selectedYear, setSelectedYear] = useState(2026) const [selectedMonth, setSelectedMonth] = useState("03") const [selectedCustomer, setSelectedCustomer] = useState("all") const [selectedStatus, setSelectedStatus] = useState("all") const [loading, setLoading] = useState(true) const [editingPlan, setEditingPlan] = useState(null) const [showHistoryDialog, setShowHistoryDialog] = useState(false) const [showApprovalDialog, setShowApprovalDialog] = useState(false) const [approvalPlans, setApprovalPlans] = useState([]) const [approvalComment, setApprovalComment] = useState("") const [planHistory, setPlanHistory] = useState([]) const [editingMode, setEditingMode] = useState(false) const [selectedPlans, setSelectedPlans] = useState([]) const [historyPage, setHistoryPage] = useState(1) const historyItemsPerPage = 10 const { toast } = useToast() useEffect(() => { fetchSalesPlans() }, [selectedYear, selectedMonth, selectedCustomer, selectedStatus]) const fetchSalesPlans = async () => { setLoading(true) try { const params = new URLSearchParams() params.append("year", String(selectedYear)) if (selectedMonth) { params.append("yearMonth", `${selectedYear}-${selectedMonth.padStart(2, "0")}`) } if (selectedCustomer && selectedCustomer !== "all") { params.append("customer", selectedCustomer) } if (selectedStatus && selectedStatus !== "all") { params.append("status", selectedStatus) } const response = await fetch(`/api/sales-plan?${params.toString()}`) const data = await response.json() if (data.success) { setSalesPlans(data.data) } } catch (error) { console.error("[v0] Failed to fetch sales plans:", error) toast({ title: "오류", description: "판매계획 데이터를 불러오는데 실패했습니다.", variant: "destructive", }) } finally { setLoading(false) } } const handleSelectPlan = (planId: string, checked: boolean) => { if (checked) { setSelectedPlans([...selectedPlans, planId]) } else { setSelectedPlans(selectedPlans.filter((id) => id !== planId)) } } const handleSelectAll = (e: React.ChangeEvent) => { if (e.target.checked) { setSelectedPlans(salesPlans.map((p) => p.id)) } else { setSelectedPlans([]) } } const handlePlanChange = (planId: string, field: string, value: number) => { setSalesPlans( salesPlans.map((p) => (p.id === planId ? { ...p, [field]: value } : p)), ) } const handleSavePlan = async (plan: SalesPlan) => { try { const response = await fetch(`/api/sales-plan`, { method: "PUT", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ id: plan.id, plannedQuantity: plan.plannedQuantity, plannedRevenue: plan.plannedRevenue, changeRequestComment: plan.changeRequestComment, }), }) const data = await response.json() if (data.success) { toast({ title: "성공", description: "판매계획이 수정되었습니다.", }) setEditingPlan(null) fetchSalesPlans() } } catch (error) { console.error("[v0] Failed to update sales plan:", error) toast({ title: "오류", description: "판매계획 수정에 실패했습니다.", variant: "destructive", }) } } const handleBulkSave = async () => { try { const response = await fetch(`/api/sales-plan`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ plans: salesPlans.map((p) => ({ id: p.id, plannedQuantity: p.plannedQuantity, plannedRevenue: p.plannedRevenue, })), }), }) const data = await response.json() if (data.success) { toast({ title: "성공", description: "판매계획이 일괄 수정되었습니다.", }) setEditingMode(false) fetchSalesPlans() } } catch (error) { console.error("[v0] Failed to bulk update sales plans:", error) toast({ title: "오류", description: "판매계획 일괄 수정에 실패했습니다.", variant: "destructive", }) } } const handleApprovePlans = () => { const plansToApprove = salesPlans.filter((p) => selectedPlans.includes(p.id)) if (plansToApprove.length === 0) { toast({ title: "알림", description: "승인할 판매계획을 선택해주세요.", variant: "destructive", }) return } setApprovalPlans(plansToApprove) setShowApprovalDialog(true) } const handleConfirmApproval = async () => { try { const response = await fetch(`/api/sales-plan/approve`, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ salesPlanIds: selectedPlans, approvalComment, }), }) const data = await response.json() if (data.success) { toast({ title: "성공", description: data.message || "판매계획이 승인되었습니다.", }) setShowApprovalDialog(false) setSelectedPlans([]) setApprovalComment("") fetchSalesPlans() } } catch (error) { console.error("[v0] Failed to approve sales plans:", error) toast({ title: "오류", description: "판매계획 승인에 실패했습니다.", variant: "destructive", }) } } const fetchPlanHistory = async (planId: string) => { try { const response = await fetch(`/api/sales-plan/history?planId=${planId}`) const data = await response.json() if (data.success) { setPlanHistory(data.data) setShowHistoryDialog(true) } } catch (error) { console.error("[v0] Failed to fetch plan history:", error) toast({ title: "오류", description: "판매계획 이력을 불러오는데 실패했습니다.", variant: "destructive", }) } } const handleExportExcel = async () => { try { const params = new URLSearchParams() params.append("year", String(selectedYear)) if (selectedMonth) { params.append("yearMonth", `${selectedYear}-${selectedMonth.padStart(2, "0")}`) } if (selectedCustomer && selectedCustomer !== "all") { params.append("customer", selectedCustomer) } if (selectedStatus && selectedStatus !== "all") { params.append("status", selectedStatus) } const response = await fetch(`/api/sales-plan/export?${params.toString()}`) const blob = await response.blob() const url = window.URL.createObjectURL(blob) const a = document.createElement("a") a.href = url a.download = `판매계획_${selectedYear}년_${selectedMonth}월.csv` document.body.appendChild(a) a.click() window.URL.revokeObjectURL(url) document.body.removeChild(a) toast({ title: "성공", description: "엑셀 파일이 다운로드되었습니다.", }) } catch (error) { console.error("[v0] Failed to export excel:", error) toast({ title: "오류", description: "엑셀 다운로드에 실패했습니다.", variant: "destructive", }) } } const handleUploadExcel = async (e: React.ChangeEvent) => { const file = e.target.files?.[0] if (!file) return try { const formData = new FormData() formData.append("file", file) const response = await fetch("/api/sales-plan/upload", { method: "POST", body: formData, }) const data = await response.json() if (data.success) { toast({ title: "성공", description: "엑셀 파일이 업로드되었습니다.", }) fetchSalesPlans() } } catch (error) { console.error("[v0] Failed to upload excel:", error) toast({ title: "오류", description: "엑셀 업로드에 실패했습니다.", variant: "destructive", }) } } const filteredPlans = salesPlans return (

판매계획 관리

업체별 판매계획을 관리하고 승인합니다

{/* 업체별 판매계획 */}

업체별 판매계획 {selectedYear}년 {selectedMonth}월 판매계획 상세

{editingMode ? ( <> ) : ( <> )}

{loading ? (

데이터를 불러오는 중...

) : filteredPlans.length === 0 ? (

판매계획 데이터가 없습니다.

) : (

{!editingMode && ( selectedPlans.includes(p.id)) && filteredPlans.length > 0} onChange={handleSelectAll} className="rounded border-input" /> )} 업체 연월 제품코드 제품명 카테고리 계획수량 계획매출(만원) 상태 작업 {filteredPlans .sort((a, b) => a.yearMonth.localeCompare(b.yearMonth) || a.customer.localeCompare(b.customer)) .map((plan) => ( {!editingMode && ( handleSelectPlan(plan.id, e.target.checked)} className="rounded border-input" /> )} {plan.customer} {plan.yearMonth} {plan.productCode} {plan.product} {plan.category} {editingMode ? ( handlePlanChange(plan.id, "plannedQuantity", parseInt(e.target.value) || 0) } className="w-24" /> ) : ( plan.plannedQuantity.toLocaleString() )} {editingMode ? ( handlePlanChange(plan.id, "plannedRevenue", parseInt(e.target.value) || 0) } className="w-32" /> ) : ( plan.plannedRevenue.toLocaleString() )} {plan.status === "approved" ? "승인" : "변경요청"}

{!editingMode && ( <> )}

))}

)} {/* 수정 다이얼로그 */}