feat: 작업보고서 시스템 완성

- 일일 공수 입력 기능
- 부적합 사항 등록 (이미지 선택사항)
- 날짜별 부적합 조회 (시간순 나열)
- 목록 관리 (인라인 편집, 작업시간 확인 버튼)
- 보고서 생성 (총 공수/부적합 시간 분리)
- JWT 인증 및 권한 관리
- Docker 기반 배포 환경 구성

backend/routers/auth.py

@@ -0,0 +1,131 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from sqlalchemy.orm import Session
+from typing import List
+
+from database.database import get_db
+from database.models import User, UserRole
+from database import schemas
+from services.auth_service import (
+    authenticate_user, create_access_token, verify_token,
+    get_password_hash, verify_password
+)
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    token_data = verify_token(token, credentials_exception)
+    user = db.query(User).filter(User.username == token_data.username).first()
+    if user is None:
+        raise credentials_exception
+    if not user.is_active:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return user
+
+async def get_current_admin(current_user: User = Depends(get_current_user)):
+    if current_user.role != UserRole.ADMIN:
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Not enough permissions"
+        )
+    return current_user
+
+@router.post("/login", response_model=schemas.Token)
+async def login(login_data: schemas.LoginRequest, db: Session = Depends(get_db)):
+    user = authenticate_user(db, login_data.username, login_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token = create_access_token(data={"sub": user.username})
+    return {
+        "access_token": access_token,
+        "token_type": "bearer",
+        "user": user
+    }
+
+@router.get("/me", response_model=schemas.User)
+async def read_users_me(current_user: User = Depends(get_current_user)):
+    return current_user
+
+@router.post("/users", response_model=schemas.User)
+async def create_user(
+    user: schemas.UserCreate,
+    current_admin: User = Depends(get_current_admin),
+    db: Session = Depends(get_db)
+):
+    # 중복 확인
+    db_user = db.query(User).filter(User.username == user.username).first()
+    if db_user:
+        raise HTTPException(status_code=400, detail="Username already registered")
+    
+    # 사용자 생성
+    db_user = User(
+        username=user.username,
+        hashed_password=get_password_hash(user.password),
+        full_name=user.full_name,
+        role=user.role
+    )
+    db.add(db_user)
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.get("/users", response_model=List[schemas.User])
+async def read_users(
+    skip: int = 0,
+    limit: int = 100,
+    current_admin: User = Depends(get_current_admin),
+    db: Session = Depends(get_db)
+):
+    users = db.query(User).offset(skip).limit(limit).all()
+    return users
+
+@router.put("/users/{user_id}", response_model=schemas.User)
+async def update_user(
+    user_id: int,
+    user_update: schemas.UserUpdate,
+    current_admin: User = Depends(get_current_admin),
+    db: Session = Depends(get_db)
+):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    # 업데이트
+    update_data = user_update.dict(exclude_unset=True)
+    if "password" in update_data:
+        update_data["hashed_password"] = get_password_hash(update_data.pop("password"))
+    
+    for field, value in update_data.items():
+        setattr(db_user, field, value)
+    
+    db.commit()
+    db.refresh(db_user)
+    return db_user
+
+@router.delete("/users/{user_id}")
+async def delete_user(
+    user_id: int,
+    current_admin: User = Depends(get_current_admin),
+    db: Session = Depends(get_db)
+):
+    db_user = db.query(User).filter(User.id == user_id).first()
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    
+    # 관리자는 삭제 불가
+    if db_user.role == UserRole.ADMIN:
+        raise HTTPException(status_code=400, detail="Cannot delete admin user")
+    
+    db.delete(db_user)
+    db.commit()
+    return {"detail": "User deleted successfully"}

backend/routers/daily_work.py

@@ -0,0 +1,163 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Optional
+from datetime import datetime, date
+
+from database.database import get_db
+from database.models import DailyWork, User, UserRole
+from database import schemas
+from routers.auth import get_current_user
+
+router = APIRouter(prefix="/api/daily-work", tags=["daily-work"])
+
+@router.post("/", response_model=schemas.DailyWork)
+async def create_daily_work(
+    work: schemas.DailyWorkCreate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    # 중복 확인 (같은 날짜)
+    existing = db.query(DailyWork).filter(
+        DailyWork.date == work.date.date()
+    ).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Daily work for this date already exists")
+    
+    # 계산
+    regular_hours = work.worker_count * 8  # 정규 근무 8시간
+    overtime_total = work.overtime_workers * work.overtime_hours
+    total_hours = regular_hours + overtime_total
+    
+    # 생성
+    db_work = DailyWork(
+        date=work.date,
+        worker_count=work.worker_count,
+        regular_hours=regular_hours,
+        overtime_workers=work.overtime_workers,
+        overtime_hours=work.overtime_hours,
+        overtime_total=overtime_total,
+        total_hours=total_hours,
+        created_by_id=current_user.id
+    )
+    db.add(db_work)
+    db.commit()
+    db.refresh(db_work)
+    return db_work
+
+@router.get("/", response_model=List[schemas.DailyWork])
+async def read_daily_works(
+    skip: int = 0,
+    limit: int = 100,
+    start_date: Optional[date] = None,
+    end_date: Optional[date] = None,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    query = db.query(DailyWork)
+    
+    if start_date:
+        query = query.filter(DailyWork.date >= start_date)
+    if end_date:
+        query = query.filter(DailyWork.date <= end_date)
+    
+    works = query.order_by(DailyWork.date.desc()).offset(skip).limit(limit).all()
+    return works
+
+@router.get("/{work_id}", response_model=schemas.DailyWork)
+async def read_daily_work(
+    work_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    work = db.query(DailyWork).filter(DailyWork.id == work_id).first()
+    if not work:
+        raise HTTPException(status_code=404, detail="Daily work not found")
+    return work
+
+@router.put("/{work_id}", response_model=schemas.DailyWork)
+async def update_daily_work(
+    work_id: int,
+    work_update: schemas.DailyWorkUpdate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    work = db.query(DailyWork).filter(DailyWork.id == work_id).first()
+    if not work:
+        raise HTTPException(status_code=404, detail="Daily work not found")
+    
+    # 업데이트
+    update_data = work_update.dict(exclude_unset=True)
+    
+    # 재계산 필요한 경우
+    if any(key in update_data for key in ["worker_count", "overtime_workers", "overtime_hours"]):
+        worker_count = update_data.get("worker_count", work.worker_count)
+        overtime_workers = update_data.get("overtime_workers", work.overtime_workers)
+        overtime_hours = update_data.get("overtime_hours", work.overtime_hours)
+        
+        regular_hours = worker_count * 8
+        overtime_total = overtime_workers * overtime_hours
+        total_hours = regular_hours + overtime_total
+        
+        update_data["regular_hours"] = regular_hours
+        update_data["overtime_total"] = overtime_total
+        update_data["total_hours"] = total_hours
+    
+    for field, value in update_data.items():
+        setattr(work, field, value)
+    
+    db.commit()
+    db.refresh(work)
+    return work
+
+@router.delete("/{work_id}")
+async def delete_daily_work(
+    work_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    work = db.query(DailyWork).filter(DailyWork.id == work_id).first()
+    if not work:
+        raise HTTPException(status_code=404, detail="Daily work not found")
+    
+    # 권한 확인 (관리자만 삭제 가능)
+    if current_user.role != UserRole.ADMIN:
+        raise HTTPException(status_code=403, detail="Only admin can delete daily work")
+    
+    db.delete(work)
+    db.commit()
+    return {"detail": "Daily work deleted successfully"}
+
+@router.get("/stats/summary")
+async def get_daily_work_stats(
+    start_date: Optional[date] = None,
+    end_date: Optional[date] = None,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """일일 공수 통계"""
+    query = db.query(DailyWork)
+    
+    if start_date:
+        query = query.filter(DailyWork.date >= start_date)
+    if end_date:
+        query = query.filter(DailyWork.date <= end_date)
+    
+    works = query.all()
+    
+    if not works:
+        return {
+            "total_days": 0,
+            "total_hours": 0,
+            "total_overtime": 0,
+            "average_daily_hours": 0
+        }
+    
+    total_hours = sum(w.total_hours for w in works)
+    total_overtime = sum(w.overtime_total for w in works)
+    
+    return {
+        "total_days": len(works),
+        "total_hours": total_hours,
+        "total_overtime": total_overtime,
+        "average_daily_hours": total_hours / len(works)
+    }

backend/routers/issues.py

@@ -0,0 +1,164 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.orm import Session
+from typing import List, Optional
+from datetime import datetime
+
+from database.database import get_db
+from database.models import Issue, IssueStatus, User, UserRole
+from database import schemas
+from routers.auth import get_current_user
+from services.file_service import save_base64_image, delete_file
+
+router = APIRouter(prefix="/api/issues", tags=["issues"])
+
+@router.post("/", response_model=schemas.Issue)
+async def create_issue(
+    issue: schemas.IssueCreate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    # 이미지 저장
+    photo_path = None
+    if issue.photo:
+        photo_path = save_base64_image(issue.photo)
+    
+    # Issue 생성
+    db_issue = Issue(
+        category=issue.category,
+        description=issue.description,
+        photo_path=photo_path,
+        reporter_id=current_user.id,
+        status=IssueStatus.NEW
+    )
+    db.add(db_issue)
+    db.commit()
+    db.refresh(db_issue)
+    return db_issue
+
+@router.get("/", response_model=List[schemas.Issue])
+async def read_issues(
+    skip: int = 0,
+    limit: int = 100,
+    status: Optional[IssueStatus] = None,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    query = db.query(Issue)
+    
+    # 일반 사용자는 자신의 이슈만 조회
+    if current_user.role == UserRole.USER:
+        query = query.filter(Issue.reporter_id == current_user.id)
+    
+    if status:
+        query = query.filter(Issue.status == status)
+    
+    issues = query.offset(skip).limit(limit).all()
+    return issues
+
+@router.get("/{issue_id}", response_model=schemas.Issue)
+async def read_issue(
+    issue_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    issue = db.query(Issue).filter(Issue.id == issue_id).first()
+    if not issue:
+        raise HTTPException(status_code=404, detail="Issue not found")
+    
+    # 권한 확인
+    if current_user.role == UserRole.USER and issue.reporter_id != current_user.id:
+        raise HTTPException(status_code=403, detail="Not authorized to view this issue")
+    
+    return issue
+
+@router.put("/{issue_id}", response_model=schemas.Issue)
+async def update_issue(
+    issue_id: int,
+    issue_update: schemas.IssueUpdate,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    issue = db.query(Issue).filter(Issue.id == issue_id).first()
+    if not issue:
+        raise HTTPException(status_code=404, detail="Issue not found")
+    
+    # 권한 확인
+    if current_user.role == UserRole.USER and issue.reporter_id != current_user.id:
+        raise HTTPException(status_code=403, detail="Not authorized to update this issue")
+    
+    # 업데이트
+    update_data = issue_update.dict(exclude_unset=True)
+    
+    # 사진이 업데이트되는 경우 처리
+    if "photo" in update_data:
+        # 기존 사진 삭제
+        if issue.photo_path:
+            delete_file(issue.photo_path)
+        
+        # 새 사진 저장
+        if update_data["photo"]:
+            photo_path = save_base64_image(update_data["photo"])
+            update_data["photo_path"] = photo_path
+        else:
+            update_data["photo_path"] = None
+        
+        # photo 필드는 제거 (DB에는 photo_path만 저장)
+        del update_data["photo"]
+    
+    # work_hours가 입력되면 자동으로 상태를 complete로 변경
+    if "work_hours" in update_data and update_data["work_hours"] > 0:
+        if issue.status == IssueStatus.NEW:
+            update_data["status"] = IssueStatus.COMPLETE
+    
+    for field, value in update_data.items():
+        setattr(issue, field, value)
+    
+    db.commit()
+    db.refresh(issue)
+    return issue
+
+@router.delete("/{issue_id}")
+async def delete_issue(
+    issue_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    issue = db.query(Issue).filter(Issue.id == issue_id).first()
+    if not issue:
+        raise HTTPException(status_code=404, detail="Issue not found")
+    
+    # 권한 확인 (관리자만 삭제 가능)
+    if current_user.role != UserRole.ADMIN:
+        raise HTTPException(status_code=403, detail="Only admin can delete issues")
+    
+    # 이미지 파일 삭제
+    if issue.photo_path:
+        delete_file(issue.photo_path)
+    
+    db.delete(issue)
+    db.commit()
+    return {"detail": "Issue deleted successfully"}
+
+@router.get("/stats/summary")
+async def get_issue_stats(
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """이슈 통계 조회"""
+    query = db.query(Issue)
+    
+    # 일반 사용자는 자신의 이슈만
+    if current_user.role == UserRole.USER:
+        query = query.filter(Issue.reporter_id == current_user.id)
+    
+    total = query.count()
+    new = query.filter(Issue.status == IssueStatus.NEW).count()
+    progress = query.filter(Issue.status == IssueStatus.PROGRESS).count()
+    complete = query.filter(Issue.status == IssueStatus.COMPLETE).count()
+    
+    return {
+        "total": total,
+        "new": new,
+        "progress": progress,
+        "complete": complete
+    }

backend/routers/reports.py

@@ -0,0 +1,130 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from datetime import datetime
+from typing import List
+
+from database.database import get_db
+from database.models import Issue, DailyWork, IssueStatus, IssueCategory, User, UserRole
+from database import schemas
+from routers.auth import get_current_user
+
+router = APIRouter(prefix="/api/reports", tags=["reports"])
+
+@router.post("/summary", response_model=schemas.ReportSummary)
+async def generate_report_summary(
+    report_request: schemas.ReportRequest,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """보고서 요약 생성"""
+    start_date = report_request.start_date
+    end_date = report_request.end_date
+    
+    # 일일 공수 합계
+    daily_works = db.query(DailyWork).filter(
+        DailyWork.date >= start_date.date(),
+        DailyWork.date <= end_date.date()
+    ).all()
+    total_hours = sum(w.total_hours for w in daily_works)
+    
+    # 이슈 통계
+    issues_query = db.query(Issue).filter(
+        Issue.report_date >= start_date,
+        Issue.report_date <= end_date
+    )
+    
+    # 일반 사용자는 자신의 이슈만
+    if current_user.role == UserRole.USER:
+        issues_query = issues_query.filter(Issue.reporter_id == current_user.id)
+    
+    issues = issues_query.all()
+    
+    # 카테고리별 통계
+    category_stats = schemas.CategoryStats()
+    completed_issues = 0
+    total_resolution_time = 0
+    resolved_count = 0
+    
+    for issue in issues:
+        # 카테고리별 카운트
+        if issue.category == IssueCategory.MATERIAL_MISSING:
+            category_stats.material_missing += 1
+        elif issue.category == IssueCategory.DIMENSION_DEFECT:
+            category_stats.dimension_defect += 1
+        elif issue.category == IssueCategory.INCOMING_DEFECT:
+            category_stats.incoming_defect += 1
+        
+        # 완료된 이슈
+        if issue.status == IssueStatus.COMPLETE:
+            completed_issues += 1
+            if issue.work_hours > 0:
+                total_resolution_time += issue.work_hours
+                resolved_count += 1
+    
+    # 평균 해결 시간
+    average_resolution_time = total_resolution_time / resolved_count if resolved_count > 0 else 0
+    
+    return schemas.ReportSummary(
+        start_date=start_date,
+        end_date=end_date,
+        total_hours=total_hours,
+        total_issues=len(issues),
+        category_stats=category_stats,
+        completed_issues=completed_issues,
+        average_resolution_time=average_resolution_time
+    )
+
+@router.get("/issues")
+async def get_report_issues(
+    start_date: datetime,
+    end_date: datetime,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """보고서용 이슈 상세 목록"""
+    query = db.query(Issue).filter(
+        Issue.report_date >= start_date,
+        Issue.report_date <= end_date
+    )
+    
+    # 일반 사용자는 자신의 이슈만
+    if current_user.role == UserRole.USER:
+        query = query.filter(Issue.reporter_id == current_user.id)
+    
+    issues = query.order_by(Issue.report_date).all()
+    
+    return [{
+        "id": issue.id,
+        "photo_path": issue.photo_path,
+        "category": issue.category,
+        "description": issue.description,
+        "status": issue.status,
+        "reporter_name": issue.reporter.full_name or issue.reporter.username,
+        "report_date": issue.report_date,
+        "work_hours": issue.work_hours,
+        "detail_notes": issue.detail_notes
+    } for issue in issues]
+
+@router.get("/daily-works")
+async def get_report_daily_works(
+    start_date: datetime,
+    end_date: datetime,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """보고서용 일일 공수 목록"""
+    works = db.query(DailyWork).filter(
+        DailyWork.date >= start_date.date(),
+        DailyWork.date <= end_date.date()
+    ).order_by(DailyWork.date).all()
+    
+    return [{
+        "date": work.date,
+        "worker_count": work.worker_count,
+        "regular_hours": work.regular_hours,
+        "overtime_workers": work.overtime_workers,
+        "overtime_hours": work.overtime_hours,
+        "overtime_total": work.overtime_total,
+        "total_hours": work.total_hours
+    } for work in works]