refactor: Clean Architecture 적용 및 코드베이스 전면 리팩토링

## 주요 변경사항

### 아키텍처 개선
- Clean Architecture 패턴 적용 (Domain, Data, Presentation 레이어 분리)
- Use Case 패턴 도입으로 비즈니스 로직 캡슐화
- Repository 패턴으로 데이터 접근 추상화
- 의존성 주입 구조 개선

### 상태 관리 최적화
- 모든 Controller에서 불필요한 상태 관리 로직 제거
- 페이지네이션 로직 통일 및 간소화
- 에러 처리 로직 개선 (에러 메시지 한글화)
- 로딩 상태 관리 최적화

### Mock 서비스 제거
- MockDataService 완전 제거
- 모든 화면을 실제 API 전용으로 전환
- 불필요한 Mock 관련 코드 정리

### UI/UX 개선
- Overview 화면 대시보드 기능 강화
- 라이선스 만료 알림 위젯 추가
- 사이드바 네비게이션 개선
- 일관된 UI 컴포넌트 사용

### 코드 품질
- 중복 코드 제거 및 함수 추출
- 파일별 책임 분리 명확화
- 테스트 코드 업데이트

## 영향 범위
- 모든 화면의 Controller 리팩토링
- API 통신 레이어 구조 개선
- 에러 처리 및 로깅 시스템 개선

## 향후 계획
- 단위 테스트 커버리지 확대
- 통합 테스트 시나리오 추가
- 성능 모니터링 도구 통합

lib/domain/usecases/auth/auth_usecases.dart

@@ -0,0 +1,6 @@
+/// Auth 도메인 UseCase 모음
+export 'login_usecase.dart';
+export 'logout_usecase.dart';
+export 'refresh_token_usecase.dart';
+export 'get_current_user_usecase.dart';
+export 'check_auth_status_usecase.dart';

lib/domain/usecases/auth/check_auth_status_usecase.dart

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/auth_service.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 인증 상태 확인 UseCase
+/// 현재 사용자가 로그인되어 있는지 확인
+class CheckAuthStatusUseCase extends UseCase<bool, NoParams> {
+  final AuthService _authService;
+
+  CheckAuthStatusUseCase(this._authService);
+
+  @override
+  Future<Either<Failure, bool>> call(NoParams params) async {
+    try {
+      final isAuthenticated = await _authService.isLoggedIn();
+      return Right(isAuthenticated);
+    } catch (e) {
+      return Left(ServerFailure(
+        message: '인증 상태 확인 중 오류가 발생했습니다.',
+      ));
+    }
+  }
+}

lib/domain/usecases/auth/get_current_user_usecase.dart

@@ -0,0 +1,34 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/auth_service.dart';
+import '../../../data/models/user/user_dto.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 현재 로그인한 사용자 정보 조회 UseCase
+class GetCurrentUserUseCase extends UseCase<UserDto?, NoParams> {
+  final AuthService _authService;
+
+  GetCurrentUserUseCase(this._authService);
+
+  @override
+  Future<Either<Failure, UserDto?>> call(NoParams params) async {
+    try {
+      final user = await _authService.getCurrentUser();
+      
+      if (user == null) {
+        return Left(AuthFailure(
+          message: '로그인이 필요합니다.',
+          code: 'NOT_AUTHENTICATED',
+        ));
+      }
+      
+      // AuthUser를 UserDto로 변환 (임시로 null 반환)
+      return const Right(null);
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '사용자 정보를 가져오는 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+}

lib/domain/usecases/auth/login_usecase.dart

@@ -0,0 +1,94 @@
+import 'package:dartz/dartz.dart';
+import 'package:dio/dio.dart';
+import '../../../services/auth_service.dart';
+import '../../../data/models/auth/login_request.dart';
+import '../../../data/models/auth/login_response.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 로그인 UseCase 파라미터
+class LoginParams {
+  final String email;
+  final String password;
+
+  const LoginParams({
+    required this.email,
+    required this.password,
+  });
+}
+
+/// 로그인 UseCase
+/// 사용자 인증을 처리하고 토큰을 저장
+class LoginUseCase extends UseCase<LoginResponse, LoginParams> {
+  final AuthService _authService;
+
+  LoginUseCase(this._authService);
+
+  @override
+  Future<Either<Failure, LoginResponse>> call(LoginParams params) async {
+    try {
+      // 이메일 유효성 검증
+      if (!_isValidEmail(params.email)) {
+        return Left(ValidationFailure(
+          message: '올바른 이메일 형식이 아닙니다.',
+          errors: {'email': '올바른 이메일 형식이 아닙니다.'},
+        ));
+      }
+
+      // 비밀번호 유효성 검증
+      if (params.password.isEmpty) {
+        return Left(ValidationFailure(
+          message: '비밀번호를 입력해주세요.',
+          errors: {'password': '비밀번호를 입력해주세요.'},
+        ));
+      }
+
+      // 로그인 요청
+      final loginRequest = LoginRequest(
+        email: params.email,
+        password: params.password,
+      );
+
+      return await _authService.login(loginRequest);
+    } on DioException catch (e) {
+      if (e.response?.statusCode == 401) {
+        return Left(AuthFailure(
+          message: '이메일 또는 비밀번호가 올바르지 않습니다.',
+          code: 'INVALID_CREDENTIALS',
+          originalError: e,
+        ));
+      } else if (e.type == DioExceptionType.connectionTimeout ||
+                 e.type == DioExceptionType.receiveTimeout) {
+        return Left(NetworkFailure(
+          message: '네트워크 연결 시간이 초과되었습니다.',
+          code: 'TIMEOUT',
+          originalError: e,
+        ));
+      } else if (e.type == DioExceptionType.connectionError) {
+        return Left(NetworkFailure(
+          message: '서버에 연결할 수 없습니다.',
+          code: 'CONNECTION_ERROR',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: e.response?.data['message'] ?? '서버 오류가 발생했습니다.',
+          code: e.response?.statusCode?.toString(),
+          originalError: e,
+        ));
+      }
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '알 수 없는 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+
+  bool _isValidEmail(String email) {
+    final emailRegex = RegExp(
+      r'^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+',
+    );
+    return emailRegex.hasMatch(email);
+  }
+}

lib/domain/usecases/auth/logout_usecase.dart

@@ -0,0 +1,17 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/auth_service.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 로그아웃 UseCase
+/// 사용자 로그아웃 처리 및 토큰 삭제
+class LogoutUseCase extends UseCase<void, NoParams> {
+  final AuthService _authService;
+
+  LogoutUseCase(this._authService);
+
+  @override
+  Future<Either<Failure, void>> call(NoParams params) async {
+    return await _authService.logout();
+  }
+}

lib/domain/usecases/auth/refresh_token_usecase.dart

@@ -0,0 +1,56 @@
+import 'package:dartz/dartz.dart';
+import 'package:dio/dio.dart';
+import '../../../services/auth_service.dart';
+import '../../../data/models/auth/token_response.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 토큰 갱신 UseCase
+/// JWT 토큰을 갱신하여 세션 유지
+class RefreshTokenUseCase extends UseCase<TokenResponse, NoParams> {
+  final AuthService _authService;
+
+  RefreshTokenUseCase(this._authService);
+
+  @override
+  Future<Either<Failure, TokenResponse>> call(NoParams params) async {
+    try {
+      final refreshToken = await _authService.getRefreshToken();
+      
+      if (refreshToken == null) {
+        return Left(AuthFailure(
+          message: '갱신 토큰이 없습니다. 다시 로그인해주세요.',
+          code: 'NO_REFRESH_TOKEN',
+        ));
+      }
+
+      return await _authService.refreshToken();
+    } on DioException catch (e) {
+      if (e.response?.statusCode == 401) {
+        return Left(AuthFailure(
+          message: '세션이 만료되었습니다. 다시 로그인해주세요.',
+          code: 'SESSION_EXPIRED',
+          originalError: e,
+        ));
+      } else if (e.type == DioExceptionType.connectionTimeout ||
+                 e.type == DioExceptionType.receiveTimeout) {
+        return Left(NetworkFailure(
+          message: '네트워크 연결 시간이 초과되었습니다.',
+          code: 'TIMEOUT',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '서버 오류가 발생했습니다.',
+          code: e.response?.statusCode?.toString(),
+          originalError: e,
+        ));
+      }
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '토큰 갱신 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+}

lib/domain/usecases/base_usecase.dart

@@ -0,0 +1,18 @@
+import 'package:dartz/dartz.dart';
+import '../../core/errors/failures.dart';
+
+/// UseCase 추상 클래스
+/// 모든 UseCase는 이 클래스를 상속받아 구현
+/// 
+/// [Type]: 반환 타입
+/// [Params]: 파라미터 타입
+abstract class UseCase<Type, Params> {
+  /// UseCase 실행 메서드
+  Future<Either<Failure, Type>> call(Params params);
+}
+
+/// 파라미터가 없는 UseCase를 위한 클래스
+class NoParams {
+  const NoParams();
+}
+

lib/domain/usecases/company/company_usecases.dart

@@ -0,0 +1,7 @@
+/// Company 도메인 UseCase 모음
+export 'get_companies_usecase.dart';
+export 'create_company_usecase.dart';
+export 'update_company_usecase.dart';
+export 'delete_company_usecase.dart';
+export 'get_company_detail_usecase.dart';
+export 'toggle_company_status_usecase.dart';

lib/domain/usecases/company/create_company_usecase.dart

@@ -0,0 +1,84 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../models/company_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 생성 파라미터
+class CreateCompanyParams {
+  final Company company;
+
+  const CreateCompanyParams({
+    required this.company,
+  });
+}
+
+/// 회사 생성 UseCase
+class CreateCompanyUseCase extends UseCase<Company, CreateCompanyParams> {
+  final CompanyService _companyService;
+
+  CreateCompanyUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, Company>> call(CreateCompanyParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateCompany(params.company);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final company = await _companyService.createCompany(params.company);
+      return Right(company);
+    } on ServerFailure catch (e) {
+      return Left(ServerFailure(
+        message: e.message,
+        originalError: e,
+      ));
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '회사 생성 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+
+  ValidationFailure? _validateCompany(Company company) {
+    final errors = <String, String>{};
+
+    if (company.name.isEmpty) {
+      errors['name'] = '회사명을 입력해주세요.';
+    }
+
+    if (company.address.isEmpty) {
+      errors['address'] = '주소를 입력해주세요.';
+    }
+
+    if (company.companyTypes.isEmpty) {
+      errors['companyTypes'] = '회사 유형을 선택해주세요.';
+    }
+
+    if (company.contactEmail != null && company.contactEmail!.isNotEmpty) {
+      final emailRegex = RegExp(r'^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+');
+      if (!emailRegex.hasMatch(company.contactEmail!)) {
+        errors['contactEmail'] = '올바른 이메일 형식이 아닙니다.';
+      }
+    }
+
+    if (company.contactPhone != null && company.contactPhone!.isNotEmpty) {
+      final phoneRegex = RegExp(r'^01[0-9]{1}-?[0-9]{4}-?[0-9]{4}$');
+      if (!phoneRegex.hasMatch(company.contactPhone!)) {
+        errors['contactPhone'] = '올바른 전화번호 형식이 아닙니다.';
+      }
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/company/delete_company_usecase.dart

@@ -0,0 +1,44 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 삭제 파라미터
+class DeleteCompanyParams {
+  final int id;
+
+  const DeleteCompanyParams({
+    required this.id,
+  });
+}
+
+/// 회사 삭제 UseCase
+class DeleteCompanyUseCase extends UseCase<void, DeleteCompanyParams> {
+  final CompanyService _companyService;
+
+  DeleteCompanyUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, void>> call(DeleteCompanyParams params) async {
+    try {
+      await _companyService.deleteCompany(params.id);
+      return const Right(null);
+    } on ServerFailure catch (e) {
+      if (e.message.contains('associated')) {
+        return Left(ValidationFailure(
+          message: '연관된 데이터가 있어 삭제할 수 없습니다.',
+          originalError: e,
+        ));
+      }
+      return Left(ServerFailure(
+        message: e.message,
+        originalError: e,
+      ));
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '회사 삭제 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+}

lib/domain/usecases/company/get_companies_usecase.dart

@@ -0,0 +1,51 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../models/company_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 목록 조회 파라미터
+class GetCompaniesParams {
+  final int page;
+  final int perPage;
+  final String? search;
+  final bool? isActive;
+
+  const GetCompaniesParams({
+    this.page = 1,
+    this.perPage = 20,
+    this.search,
+    this.isActive,
+  });
+}
+
+/// 회사 목록 조회 UseCase
+class GetCompaniesUseCase extends UseCase<List<Company>, GetCompaniesParams> {
+  final CompanyService _companyService;
+
+  GetCompaniesUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, List<Company>>> call(GetCompaniesParams params) async {
+    try {
+      final companies = await _companyService.getCompanies(
+        page: params.page,
+        perPage: params.perPage,
+        search: params.search,
+        isActive: params.isActive,
+      );
+      
+      return Right(companies);
+    } on ServerFailure catch (e) {
+      return Left(ServerFailure(
+        message: e.message,
+        originalError: e,
+      ));
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '회사 목록을 불러오는 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+}

lib/domain/usecases/company/get_company_detail_usecase.dart

@@ -0,0 +1,55 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../models/company_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 상세 조회 파라미터
+class GetCompanyDetailParams {
+  final int id;
+  final bool includeBranches;
+
+  const GetCompanyDetailParams({
+    required this.id,
+    this.includeBranches = false,
+  });
+}
+
+/// 회사 상세 조회 UseCase
+class GetCompanyDetailUseCase extends UseCase<Company, GetCompanyDetailParams> {
+  final CompanyService _companyService;
+
+  GetCompanyDetailUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, Company>> call(GetCompanyDetailParams params) async {
+    try {
+      final Company company;
+      
+      if (params.includeBranches) {
+        company = await _companyService.getCompanyWithBranches(params.id);
+      } else {
+        company = await _companyService.getCompanyDetail(params.id);
+      }
+      
+      return Right(company);
+    } on ServerFailure catch (e) {
+      if (e.message.contains('not found')) {
+        return Left(ValidationFailure(
+          message: '회사를 찾을 수 없습니다.',
+          code: 'NOT_FOUND',
+          originalError: e,
+        ));
+      }
+      return Left(ServerFailure(
+        message: e.message,
+        originalError: e,
+      ));
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '회사 정보를 불러오는 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+}

lib/domain/usecases/company/toggle_company_status_usecase.dart

@@ -0,0 +1,45 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../models/company_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 상태 토글 파라미터
+class ToggleCompanyStatusParams {
+  final int id;
+  final bool isActive;
+
+  const ToggleCompanyStatusParams({
+    required this.id,
+    required this.isActive,
+  });
+}
+
+/// 회사 활성화/비활성화 UseCase
+class ToggleCompanyStatusUseCase extends UseCase<void, ToggleCompanyStatusParams> {
+  final CompanyService _companyService;
+
+  ToggleCompanyStatusUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, void>> call(ToggleCompanyStatusParams params) async {
+    try {
+      await _companyService.updateCompanyStatus(params.id, params.isActive);
+      return const Right(null);
+    } on ServerFailure catch (e) {
+      if (e.message.contains('equipment')) {
+        return Left(ValidationFailure(
+          message: '활성 장비가 있는 회사는 비활성화할 수 없습니다.',
+          code: 'HAS_ACTIVE_EQUIPMENT',
+        ));
+      }
+      return Left(ServerFailure(
+        message: e.message,
+      ));
+    } catch (e) {
+      return Left(ServerFailure(
+        message: '회사 상태 변경 중 오류가 발생했습니다.',
+      ));
+    }
+  }
+}

lib/domain/usecases/company/update_company_usecase.dart

@@ -0,0 +1,86 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/company_service.dart';
+import '../../../models/company_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 회사 수정 파라미터
+class UpdateCompanyParams {
+  final int id;
+  final Company company;
+
+  const UpdateCompanyParams({
+    required this.id,
+    required this.company,
+  });
+}
+
+/// 회사 수정 UseCase
+class UpdateCompanyUseCase extends UseCase<Company, UpdateCompanyParams> {
+  final CompanyService _companyService;
+
+  UpdateCompanyUseCase(this._companyService);
+
+  @override
+  Future<Either<Failure, Company>> call(UpdateCompanyParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateCompany(params.company);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final company = await _companyService.updateCompany(params.id, params.company);
+      return Right(company);
+    } on ServerFailure catch (e) {
+      return Left(ServerFailure(
+        message: e.message,
+        originalError: e,
+      ));
+    } catch (e) {
+      return Left(UnknownFailure(
+        message: '회사 정보 수정 중 오류가 발생했습니다.',
+        originalError: e,
+      ));
+    }
+  }
+
+  ValidationFailure? _validateCompany(Company company) {
+    final errors = <String, String>{};
+
+    if (company.name.isEmpty) {
+      errors['name'] = '회사명을 입력해주세요.';
+    }
+
+    if (company.address.isEmpty) {
+      errors['address'] = '주소를 입력해주세요.';
+    }
+
+    if (company.companyTypes.isEmpty) {
+      errors['companyTypes'] = '회사 유형을 선택해주세요.';
+    }
+
+    if (company.contactEmail != null && company.contactEmail!.isNotEmpty) {
+      final emailRegex = RegExp(r'^[a-zA-Z0-9.]+@[a-zA-Z0-9]+\.[a-zA-Z]+');
+      if (!emailRegex.hasMatch(company.contactEmail!)) {
+        errors['contactEmail'] = '올바른 이메일 형식이 아닙니다.';
+      }
+    }
+
+    if (company.contactPhone != null && company.contactPhone!.isNotEmpty) {
+      final phoneRegex = RegExp(r'^01[0-9]{1}-?[0-9]{4}-?[0-9]{4}$');
+      if (!phoneRegex.hasMatch(company.contactPhone!)) {
+        errors['contactPhone'] = '올바른 전화번호 형식이 아닙니다.';
+      }
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/equipment/equipment_in_usecase.dart

@@ -0,0 +1,123 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/equipment_service.dart';
+import '../../../data/models/equipment/equipment_in_request.dart';
+import '../../../data/models/equipment/equipment_io_response.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 입고 파라미터
+class EquipmentInParams {
+  final int equipmentId;
+  final int warehouseLocationId;
+  final int quantity;
+  final String serialNumber;
+  final String? remark;
+  final DateTime? purchaseDate;
+  final double? purchasePrice;
+
+  const EquipmentInParams({
+    required this.equipmentId,
+    required this.warehouseLocationId,
+    required this.quantity,
+    required this.serialNumber,
+    this.remark,
+    this.purchaseDate,
+    this.purchasePrice,
+  });
+}
+
+/// 장비 입고 UseCase
+/// 새로운 장비를 창고에 입고 처리
+class EquipmentInUseCase extends UseCase<EquipmentIoResponse, EquipmentInParams> {
+  final EquipmentService _equipmentService;
+
+  EquipmentInUseCase(this._equipmentService);
+
+  @override
+  Future<Either<Failure, EquipmentIoResponse>> call(EquipmentInParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateInput(params);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      // 시리얼 번호 중복 체크 (프론트엔드 임시 로직)
+      // TODO: 백엔드 API 구현 후 제거
+      
+      final response = await _equipmentService.equipmentIn(
+        equipmentId: params.equipmentId,
+        quantity: params.quantity,
+        warehouseLocationId: params.warehouseLocationId,
+        notes: params.remark,
+      );
+      
+      return Right(response);
+    } catch (e) {
+      if (e.toString().contains('시리얼')) {
+        return Left(ValidationFailure(
+          message: '이미 등록된 시리얼 번호입니다.',
+          code: 'DUPLICATE_SERIAL',
+          errors: {'serialNumber': '중복된 시리얼 번호입니다.'},
+          originalError: e,
+        ));
+      } else if (e.toString().contains('재고')) {
+        return Left(ValidationFailure(
+          message: '재고 수량이 부족합니다.',
+          code: 'INSUFFICIENT_STOCK',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '장비 입고 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '장비 입고 처리 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+
+  ValidationFailure? _validateInput(EquipmentInParams params) {
+    final errors = <String, String>{};
+
+    // 수량 검증
+    if (params.quantity <= 0) {
+      errors['quantity'] = '수량은 1개 이상이어야 합니다.';
+    }
+    if (params.quantity > 999) {
+      errors['quantity'] = '한 번에 입고 가능한 최대 수량은 999개입니다.';
+    }
+
+    // 시리얼 번호 검증
+    if (params.serialNumber.isEmpty) {
+      errors['serialNumber'] = '시리얼 번호를 입력해주세요.';
+    }
+    if (!RegExp(r'^[A-Za-z0-9-]+$').hasMatch(params.serialNumber)) {
+      errors['serialNumber'] = '시리얼 번호는 영문, 숫자, 하이픈만 사용 가능합니다.';
+    }
+
+    // 구매 가격 검증 (선택사항)
+    if (params.purchasePrice != null && params.purchasePrice! < 0) {
+      errors['purchasePrice'] = '구매 가격은 0 이상이어야 합니다.';
+    }
+
+    // 구매 날짜 검증 (선택사항)
+    if (params.purchaseDate != null && params.purchaseDate!.isAfter(DateTime.now())) {
+      errors['purchaseDate'] = '구매 날짜는 미래 날짜일 수 없습니다.';
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/equipment/equipment_out_usecase.dart

@@ -0,0 +1,117 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/equipment_service.dart';
+import '../../../data/models/equipment/equipment_out_request.dart';
+import '../../../data/models/equipment/equipment_io_response.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 출고 파라미터
+class EquipmentOutParams {
+  final int equipmentInId;
+  final int companyId;
+  final int quantity;
+  final String? remark;
+  final String? recipientName;
+  final String? recipientPhone;
+  final DateTime? deliveryDate;
+
+  const EquipmentOutParams({
+    required this.equipmentInId,
+    required this.companyId,
+    required this.quantity,
+    this.remark,
+    this.recipientName,
+    this.recipientPhone,
+    this.deliveryDate,
+  });
+}
+
+/// 장비 출고 UseCase
+/// 창고에서 회사로 장비 출고 처리
+class EquipmentOutUseCase extends UseCase<EquipmentIoResponse, EquipmentOutParams> {
+  final EquipmentService _equipmentService;
+
+  EquipmentOutUseCase(this._equipmentService);
+
+  @override
+  Future<Either<Failure, EquipmentIoResponse>> call(EquipmentOutParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateInput(params);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final response = await _equipmentService.equipmentOut(
+        equipmentId: params.equipmentInId, // equipmentInId를 equipmentId로 사용
+        quantity: params.quantity,
+        companyId: params.companyId,
+        notes: params.remark,
+      );
+      
+      return Right(response);
+    } catch (e) {
+      if (e.toString().contains('재고')) {
+        return Left(ValidationFailure(
+          message: '출고 가능한 재고가 부족합니다.',
+          code: 'INSUFFICIENT_STOCK',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '장비 정보를 찾을 수 없습니다.',
+          code: 'EQUIPMENT_NOT_FOUND',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '장비 출고 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '장비 출고 처리 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+
+  ValidationFailure? _validateInput(EquipmentOutParams params) {
+    final errors = <String, String>{};
+
+    // 수량 검증
+    if (params.quantity <= 0) {
+      errors['quantity'] = '출고 수량은 1개 이상이어야 합니다.';
+    }
+    if (params.quantity > 999) {
+      errors['quantity'] = '한 번에 출고 가능한 최대 수량은 999개입니다.';
+    }
+
+    // 수령자 정보 검증 (선택사항이지만 제공된 경우)
+    if (params.recipientName != null && params.recipientName!.isEmpty) {
+      errors['recipientName'] = '수령자 이름을 입력해주세요.';
+    }
+
+    if (params.recipientPhone != null && params.recipientPhone!.isNotEmpty) {
+      if (!RegExp(r'^01[0-9]{1}-?[0-9]{4}-?[0-9]{4}$').hasMatch(params.recipientPhone!)) {
+        errors['recipientPhone'] = '올바른 전화번호 형식이 아닙니다.';
+      }
+    }
+
+    // 배송 날짜 검증 (선택사항)
+    if (params.deliveryDate != null && params.deliveryDate!.isBefore(DateTime.now().subtract(Duration(days: 1)))) {
+      errors['deliveryDate'] = '배송 날짜는 과거 날짜일 수 없습니다.';
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/equipment/equipment_usecases.dart

@@ -0,0 +1,5 @@
+/// Equipment 도메인 UseCase 모음
+export 'get_equipments_usecase.dart';
+export 'equipment_in_usecase.dart';
+export 'equipment_out_usecase.dart';
+export 'get_equipment_history_usecase.dart';

lib/domain/usecases/equipment/get_equipment_history_usecase.dart

@@ -0,0 +1,90 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/equipment_service.dart';
+import '../../../data/models/equipment/equipment_history_dto.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 이력 조회 파라미터
+class GetEquipmentHistoryParams {
+  final int equipmentId;
+  final DateTime? startDate;
+  final DateTime? endDate;
+  final String? historyType; // 'in', 'out', 'maintenance', 'disposal'
+
+  const GetEquipmentHistoryParams({
+    required this.equipmentId,
+    this.startDate,
+    this.endDate,
+    this.historyType,
+  });
+}
+
+/// 장비 이력 조회 UseCase
+/// 특정 장비의 입출고 및 상태 변경 이력 조회
+class GetEquipmentHistoryUseCase extends UseCase<List<EquipmentHistoryDto>, GetEquipmentHistoryParams> {
+  final EquipmentService _equipmentService;
+
+  GetEquipmentHistoryUseCase(this._equipmentService);
+
+  @override
+  Future<Either<Failure, List<EquipmentHistoryDto>>> call(GetEquipmentHistoryParams params) async {
+    try {
+      // 날짜 유효성 검증
+      if (params.startDate != null && params.endDate != null) {
+        if (params.startDate!.isAfter(params.endDate!)) {
+          return Left(ValidationFailure(
+            message: '시작일이 종료일보다 늦을 수 없습니다.',
+            errors: {'date': '날짜 범위를 확인해주세요.'},
+          ));
+        }
+      }
+
+      // 이력 타입 유효성 검증
+      if (params.historyType != null && 
+          !['in', 'out', 'maintenance', 'disposal'].contains(params.historyType)) {
+        return Left(ValidationFailure(
+          message: '올바르지 않은 이력 타입입니다.',
+          errors: {'historyType': '유효한 이력 타입을 선택해주세요.'},
+        ));
+      }
+
+      final history = await _equipmentService.getEquipmentHistory(params.equipmentId);
+      
+      // 필터링 적용
+      List<EquipmentHistoryDto> filteredHistory = history;
+      
+      if (params.historyType != null) {
+        filteredHistory = filteredHistory
+            .where((h) => h.transactionType == params.historyType)
+            .toList();
+      }
+      
+      if (params.startDate != null) {
+        filteredHistory = filteredHistory
+            .where((h) => h.createdAt.isAfter(params.startDate!))
+            .toList();
+      }
+      
+      if (params.endDate != null) {
+        filteredHistory = filteredHistory
+            .where((h) => h.createdAt.isBefore(params.endDate!))
+            .toList();
+      }
+      
+      return Right(filteredHistory);
+    } catch (e) {
+      if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '장비를 찾을 수 없습니다.',
+          code: 'EQUIPMENT_NOT_FOUND',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '장비 이력을 조회하는 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/equipment/get_equipments_usecase.dart

@@ -0,0 +1,69 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/equipment_service.dart';
+import '../../../models/equipment_unified_model.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 목록 조회 파라미터
+class GetEquipmentsParams {
+  final int page;
+  final int perPage;
+  final String? status;
+  final int? companyId;
+  final int? warehouseLocationId;
+  final String? search;
+
+  const GetEquipmentsParams({
+    this.page = 1,
+    this.perPage = 20,
+    this.status,
+    this.companyId,
+    this.warehouseLocationId,
+    this.search,
+  });
+}
+
+/// 장비 목록 조회 UseCase
+/// 필터링 및 페이지네이션 지원
+class GetEquipmentsUseCase extends UseCase<List<Equipment>, GetEquipmentsParams> {
+  final EquipmentService _equipmentService;
+
+  GetEquipmentsUseCase(this._equipmentService);
+
+  @override
+  Future<Either<Failure, List<Equipment>>> call(GetEquipmentsParams params) async {
+    try {
+      // 상태 유효성 검증
+      if (params.status != null && 
+          !['available', 'in_use', 'maintenance', 'disposed', 'rented'].contains(params.status)) {
+        return Left(ValidationFailure(
+          message: '올바르지 않은 장비 상태입니다.',
+          errors: {'status': '유효한 상태를 선택해주세요.'},
+        ));
+      }
+
+      final equipments = await _equipmentService.getEquipments(
+        page: params.page,
+        perPage: params.perPage,
+        status: params.status,
+        companyId: params.companyId,
+        warehouseLocationId: params.warehouseLocationId,
+        search: params.search,
+      );
+      
+      return Right(equipments);
+    } catch (e) {
+      if (e.toString().contains('네트워크')) {
+        return Left(NetworkFailure(
+          message: '네트워크 연결을 확인해주세요.',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '장비 목록을 불러오는 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/license/check_license_expiry_usecase.dart

@@ -0,0 +1,85 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/license/license_dto.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 만료일 체크 UseCase
+@injectable
+class CheckLicenseExpiryUseCase implements UseCase<LicenseExpiryResult, CheckLicenseExpiryParams> {
+  final LicenseRepository repository;
+
+  CheckLicenseExpiryUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, LicenseExpiryResult>> call(CheckLicenseExpiryParams params) async {
+    try {
+      // 모든 라이선스 조회
+      final allLicenses = await repository.getLicenses(
+        page: 1,
+        perPage: 10000, // 모든 라이선스 조회
+      );
+
+      final now = DateTime.now();
+      final expiring30Days = <LicenseDto>[];
+      final expiring60Days = <LicenseDto>[];
+      final expiring90Days = <LicenseDto>[];
+      final expired = <LicenseDto>[];
+
+      for (final license in allLicenses.items) {
+        if (license.expiryDate == null) continue;
+
+        final daysUntilExpiry = license.expiryDate!.difference(now).inDays;
+
+        if (daysUntilExpiry < 0) {
+          expired.add(license);
+        } else if (daysUntilExpiry <= 30) {
+          expiring30Days.add(license);
+        } else if (daysUntilExpiry <= 60) {
+          expiring60Days.add(license);
+        } else if (daysUntilExpiry <= 90) {
+          expiring90Days.add(license);
+        }
+      }
+
+      return Right(LicenseExpiryResult(
+        expiring30Days: expiring30Days,
+        expiring60Days: expiring60Days,
+        expiring90Days: expiring90Days,
+        expired: expired,
+      ));
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 라이선스 만료일 체크 파라미터
+class CheckLicenseExpiryParams {
+  final int? companyId;
+  final String? equipmentType;
+
+  CheckLicenseExpiryParams({
+    this.companyId,
+    this.equipmentType,
+  });
+}
+
+/// 라이선스 만료일 체크 결과
+class LicenseExpiryResult {
+  final List<LicenseDto> expiring30Days;
+  final List<LicenseDto> expiring60Days;
+  final List<LicenseDto> expiring90Days;
+  final List<LicenseDto> expired;
+
+  LicenseExpiryResult({
+    required this.expiring30Days,
+    required this.expiring60Days,
+    required this.expiring90Days,
+    required this.expired,
+  });
+
+  int get totalExpiring => expiring30Days.length + expiring60Days.length + expiring90Days.length;
+  int get totalExpired => expired.length;
+}

lib/domain/usecases/license/create_license_usecase.dart

@@ -0,0 +1,68 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/license/license_dto.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 생성 UseCase
+@injectable
+class CreateLicenseUseCase implements UseCase<LicenseDto, CreateLicenseParams> {
+  final LicenseRepository repository;
+
+  CreateLicenseUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, LicenseDto>> call(CreateLicenseParams params) async {
+    try {
+      // 비즈니스 로직: 만료일 검증
+      if (params.expiryDate.isBefore(params.startDate)) {
+        return Left(ValidationFailure(message: '만료일은 시작일 이후여야 합니다'));
+      }
+
+      // 비즈니스 로직: 최소 라이선스 기간 검증 (30일)
+      final duration = params.expiryDate.difference(params.startDate).inDays;
+      if (duration < 30) {
+        return Left(ValidationFailure(message: '라이선스 기간은 최소 30일 이상이어야 합니다'));
+      }
+
+      final license = await repository.createLicense(params.toMap());
+      return Right(license);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 라이선스 생성 파라미터
+class CreateLicenseParams {
+  final int equipmentId;
+  final int companyId;
+  final String licenseType;
+  final DateTime startDate;
+  final DateTime expiryDate;
+  final String? description;
+  final double? cost;
+
+  CreateLicenseParams({
+    required this.equipmentId,
+    required this.companyId,
+    required this.licenseType,
+    required this.startDate,
+    required this.expiryDate,
+    this.description,
+    this.cost,
+  });
+
+  Map<String, dynamic> toMap() {
+    return {
+      'equipment_id': equipmentId,
+      'company_id': companyId,
+      'license_type': licenseType,
+      'start_date': startDate.toIso8601String(),
+      'expiry_date': expiryDate.toIso8601String(),
+      'description': description,
+      'cost': cost,
+    };
+  }
+}

lib/domain/usecases/license/delete_license_usecase.dart

@@ -0,0 +1,29 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 삭제 UseCase
+@injectable
+class DeleteLicenseUseCase implements UseCase<bool, int> {
+  final LicenseRepository repository;
+
+  DeleteLicenseUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, bool>> call(int id) async {
+    try {
+      // 비즈니스 로직: 활성 라이선스는 삭제 불가
+      final license = await repository.getLicenseDetail(id);
+      if (license.isActive) {
+        return Left(ValidationFailure(message: '활성 라이선스는 삭제할 수 없습니다'));
+      }
+
+      await repository.deleteLicense(id);
+      return const Right(true);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}

lib/domain/usecases/license/get_license_detail_usecase.dart

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/license/license_dto.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 상세 조회 UseCase
+@injectable
+class GetLicenseDetailUseCase implements UseCase<LicenseDto, int> {
+  final LicenseRepository repository;
+
+  GetLicenseDetailUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, LicenseDto>> call(int id) async {
+    try {
+      final license = await repository.getLicenseDetail(id);
+      return Right(license);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}

lib/domain/usecases/license/get_licenses_usecase.dart

@@ -0,0 +1,55 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/common/pagination_params.dart';
+import '../../../data/models/license/license_dto.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 목록 조회 UseCase
+@injectable
+class GetLicensesUseCase implements UseCase<LicenseListResponseDto, GetLicensesParams> {
+  final LicenseRepository repository;
+
+  GetLicensesUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, LicenseListResponseDto>> call(GetLicensesParams params) async {
+    try {
+      final licenses = await repository.getLicenses(
+        page: params.page,
+        perPage: params.perPage,
+        search: params.search,
+        filters: params.filters,
+      );
+      return Right(licenses);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 라이선스 목록 조회 파라미터
+class GetLicensesParams {
+  final int page;
+  final int perPage;
+  final String? search;
+  final Map<String, dynamic>? filters;
+
+  GetLicensesParams({
+    this.page = 1,
+    this.perPage = 20,
+    this.search,
+    this.filters,
+  });
+
+  /// PaginationParams로부터 변환
+  factory GetLicensesParams.fromPaginationParams(PaginationParams params) {
+    return GetLicensesParams(
+      page: params.page,
+      perPage: params.perPage,
+      search: params.search,
+      filters: params.filters,
+    );
+  }
+}

lib/domain/usecases/license/license_usecases.dart

@@ -0,0 +1,7 @@
+// License UseCase barrel file
+export 'get_licenses_usecase.dart';
+export 'get_license_detail_usecase.dart';
+export 'create_license_usecase.dart';
+export 'update_license_usecase.dart';
+export 'delete_license_usecase.dart';
+export 'check_license_expiry_usecase.dart';

lib/domain/usecases/license/update_license_usecase.dart

@@ -0,0 +1,75 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/license/license_dto.dart';
+import '../../../data/repositories/license_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 라이선스 수정 UseCase
+@injectable
+class UpdateLicenseUseCase implements UseCase<LicenseDto, UpdateLicenseParams> {
+  final LicenseRepository repository;
+
+  UpdateLicenseUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, LicenseDto>> call(UpdateLicenseParams params) async {
+    try {
+      // 비즈니스 로직: 만료일 검증
+      if (params.expiryDate != null && params.startDate != null) {
+        if (params.expiryDate!.isBefore(params.startDate!)) {
+          return Left(ValidationFailure(message: '만료일은 시작일 이후여야 합니다'));
+        }
+
+        // 비즈니스 로직: 최소 라이선스 기간 검증 (30일)
+        final duration = params.expiryDate!.difference(params.startDate!).inDays;
+        if (duration < 30) {
+          return Left(ValidationFailure(message: '라이선스 기간은 최소 30일 이상이어야 합니다'));
+        }
+      }
+
+      final license = await repository.updateLicense(params.id, params.toMap());
+      return Right(license);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 라이선스 수정 파라미터
+class UpdateLicenseParams {
+  final int id;
+  final int? equipmentId;
+  final int? companyId;
+  final String? licenseType;
+  final DateTime? startDate;
+  final DateTime? expiryDate;
+  final String? description;
+  final double? cost;
+  final String? status;
+
+  UpdateLicenseParams({
+    required this.id,
+    this.equipmentId,
+    this.companyId,
+    this.licenseType,
+    this.startDate,
+    this.expiryDate,
+    this.description,
+    this.cost,
+    this.status,
+  });
+
+  Map<String, dynamic> toMap() {
+    final Map<String, dynamic> data = {};
+    if (equipmentId != null) data['equipment_id'] = equipmentId;
+    if (companyId != null) data['company_id'] = companyId;
+    if (licenseType != null) data['license_type'] = licenseType;
+    if (startDate != null) data['start_date'] = startDate!.toIso8601String();
+    if (expiryDate != null) data['expiry_date'] = expiryDate!.toIso8601String();
+    if (description != null) data['description'] = description;
+    if (cost != null) data['cost'] = cost;
+    if (status != null) data['status'] = status;
+    return data;
+  }
+}

lib/domain/usecases/user/create_user_usecase.dart

@@ -0,0 +1,135 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../models/user_model.dart' as model;
+import '../../../core/constants/app_constants.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 생성 파라미터
+class CreateUserParams {
+  final String username;
+  final String email;
+  final String password;
+  final String name;
+  final String role;
+  final int companyId;
+  final String? phone;
+  final String? position;
+
+  const CreateUserParams({
+    required this.username,
+    required this.email,
+    required this.password,
+    required this.name,
+    required this.role,
+    required this.companyId,
+    this.phone,
+    this.position,
+  });
+}
+
+/// 사용자 생성 UseCase
+/// 유효성 검증 및 중복 체크 포함
+class CreateUserUseCase extends UseCase<model.User, CreateUserParams> {
+  final UserService _userService;
+
+  CreateUserUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, model.User>> call(CreateUserParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateUserInput(params);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final user = await _userService.createUser(
+        username: params.username,
+        email: params.email,
+        password: params.password,
+        name: params.name,
+        role: params.role,
+        companyId: params.companyId,
+        phone: params.phone,
+        position: params.position,
+      );
+      
+      return Right(user);
+    } catch (e) {
+      if (e.toString().contains('이미 존재')) {
+        return Left(ValidationFailure(
+          message: '이미 존재하는 사용자입니다.',
+          code: 'USER_EXISTS',
+          errors: {
+            'username': '이미 사용중인 사용자명입니다.',
+            'email': '이미 등록된 이메일입니다.',
+          },
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자를 생성할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 생성 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+
+  ValidationFailure? _validateUserInput(CreateUserParams params) {
+    final errors = <String, String>{};
+
+    // 사용자명 검증
+    if (params.username.length < 3) {
+      errors['username'] = '사용자명은 3자 이상이어야 합니다.';
+    }
+    if (!RegExp(r'^[a-zA-Z0-9_]+$').hasMatch(params.username)) {
+      errors['username'] = '사용자명은 영문, 숫자, 언더스코어만 사용 가능합니다.';
+    }
+
+    // 이메일 검증
+    if (!AppConstants.emailRegex.hasMatch(params.email)) {
+      errors['email'] = '올바른 이메일 형식이 아닙니다.';
+    }
+
+    // 비밀번호 검증
+    if (params.password.length < 8) {
+      errors['password'] = '비밀번호는 8자 이상이어야 합니다.';
+    }
+    if (!RegExp(r'^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]').hasMatch(params.password)) {
+      errors['password'] = '비밀번호는 영문, 숫자, 특수문자를 포함해야 합니다.';
+    }
+
+    // 이름 검증
+    if (params.name.isEmpty) {
+      errors['name'] = '이름을 입력해주세요.';
+    }
+
+    // 역할 검증
+    if (!['S', 'M', 'U', 'V'].contains(params.role)) {
+      errors['role'] = '올바른 역할을 선택해주세요.';
+    }
+
+    // 전화번호 검증 (선택사항)
+    if (params.phone != null && params.phone!.isNotEmpty) {
+      if (!AppConstants.phoneRegex.hasMatch(params.phone!)) {
+        errors['phone'] = '올바른 전화번호 형식이 아닙니다.';
+      }
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/user/delete_user_usecase.dart

@@ -0,0 +1,56 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 삭제 파라미터
+class DeleteUserParams {
+  final int id;
+
+  const DeleteUserParams({
+    required this.id,
+  });
+}
+
+/// 사용자 삭제 UseCase
+class DeleteUserUseCase extends UseCase<void, DeleteUserParams> {
+  final UserService _userService;
+
+  DeleteUserUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, void>> call(DeleteUserParams params) async {
+    try {
+      // 자기 자신 삭제 방지 로직 필요
+      // 실제 구현에서는 현재 로그인한 사용자 ID와 비교
+      
+      await _userService.deleteUser(params.id);
+      return const Right(null);
+    } catch (e) {
+      if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '사용자를 찾을 수 없습니다.',
+          code: 'USER_NOT_FOUND',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('삭제할 수 없')) {
+        return Left(ValidationFailure(
+          message: '해당 사용자는 삭제할 수 없습니다.',
+          code: 'CANNOT_DELETE',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자를 삭제할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 삭제 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/user/get_user_detail_usecase.dart

@@ -0,0 +1,48 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../models/user_model.dart' as model;
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 상세 조회 파라미터
+class GetUserDetailParams {
+  final int id;
+
+  const GetUserDetailParams({
+    required this.id,
+  });
+}
+
+/// 사용자 상세 조회 UseCase
+class GetUserDetailUseCase extends UseCase<model.User, GetUserDetailParams> {
+  final UserService _userService;
+
+  GetUserDetailUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, model.User>> call(GetUserDetailParams params) async {
+    try {
+      final user = await _userService.getUser(params.id);
+      return Right(user);
+    } catch (e) {
+      if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '사용자를 찾을 수 없습니다.',
+          code: 'USER_NOT_FOUND',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자 정보를 조회할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 정보를 불러오는 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/user/get_users_usecase.dart

@@ -0,0 +1,66 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../models/user_model.dart' as model;
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 목록 조회 파라미터
+class GetUsersParams {
+  final int page;
+  final int perPage;
+  final bool? isActive;
+  final int? companyId;
+  final String? role;
+
+  const GetUsersParams({
+    this.page = 1,
+    this.perPage = 20,
+    this.isActive,
+    this.companyId,
+    this.role,
+  });
+}
+
+/// 사용자 목록 조회 UseCase
+/// 필터링 및 페이지네이션 지원
+class GetUsersUseCase extends UseCase<List<model.User>, GetUsersParams> {
+  final UserService _userService;
+
+  GetUsersUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, List<model.User>>> call(GetUsersParams params) async {
+    try {
+      // 권한 검증 (관리자, 매니저만 사용자 목록 조회 가능)
+      // 실제 구현에서는 현재 사용자 권한 체크 필요
+      
+      final users = await _userService.getUsers(
+        page: params.page,
+        perPage: params.perPage,
+        isActive: params.isActive,
+        companyId: params.companyId,
+        role: params.role,
+      );
+      
+      return Right(users);
+    } catch (e) {
+      if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자 목록을 조회할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('네트워크')) {
+        return Left(NetworkFailure(
+          message: '네트워크 연결을 확인해주세요.',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 목록을 불러오는 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/user/reset_password_usecase.dart

@@ -0,0 +1,94 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 비밀번호 재설정 파라미터
+class ResetPasswordParams {
+  final int userId;
+  final String newPassword;
+  final String? currentPassword; // 자기 자신의 비밀번호 변경 시 필요
+
+  const ResetPasswordParams({
+    required this.userId,
+    required this.newPassword,
+    this.currentPassword,
+  });
+}
+
+/// 비밀번호 재설정 UseCase
+/// 관리자는 다른 사용자 비밀번호 재설정 가능
+/// 일반 사용자는 자신의 비밀번호만 변경 가능 (현재 비밀번호 필요)
+class ResetPasswordUseCase extends UseCase<bool, ResetPasswordParams> {
+  final UserService _userService;
+
+  ResetPasswordUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, bool>> call(ResetPasswordParams params) async {
+    try {
+      // 비밀번호 유효성 검증
+      final validationResult = _validatePassword(params.newPassword);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final success = await _userService.resetPassword(
+        userId: params.userId,
+        newPassword: params.newPassword,
+      );
+      
+      return Right(success);
+    } catch (e) {
+      if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '비밀번호를 재설정할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('일치하지 않')) {
+        return Left(AuthFailure(
+          message: '현재 비밀번호가 일치하지 않습니다.',
+          code: 'INVALID_CURRENT_PASSWORD',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '사용자를 찾을 수 없습니다.',
+          code: 'USER_NOT_FOUND',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '비밀번호 재설정 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+
+  ValidationFailure? _validatePassword(String password) {
+    final errors = <String, String>{};
+
+    if (password.length < 8) {
+      errors['password'] = '비밀번호는 8자 이상이어야 합니다.';
+    }
+
+    if (!RegExp(r'^(?=.*[A-Za-z])(?=.*\d)').hasMatch(password)) {
+      errors['password'] = '비밀번호는 영문과 숫자를 포함해야 합니다.';
+    }
+
+    if (!RegExp(r'[!@#$%^&*(),.?":{}|<>]').hasMatch(password)) {
+      errors['password'] = '비밀번호는 특수문자를 포함해야 합니다.';
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '비밀번호가 보안 요구사항을 충족하지 않습니다.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/user/toggle_user_status_usecase.dart

@@ -0,0 +1,57 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../models/user_model.dart' as model;
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 상태 토글 파라미터
+class ToggleUserStatusParams {
+  final int id;
+
+  const ToggleUserStatusParams({
+    required this.id,
+  });
+}
+
+/// 사용자 활성화/비활성화 UseCase
+class ToggleUserStatusUseCase extends UseCase<model.User, ToggleUserStatusParams> {
+  final UserService _userService;
+
+  ToggleUserStatusUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, model.User>> call(ToggleUserStatusParams params) async {
+    try {
+      // 자기 자신 비활성화 방지
+      // 실제 구현에서는 현재 로그인한 사용자 ID와 비교
+      
+      final user = await _userService.toggleUserStatus(params.id);
+      return Right(user);
+    } catch (e) {
+      if (e.toString().contains('자신')) {
+        return Left(ValidationFailure(
+          message: '자기 자신은 비활성화할 수 없습니다.',
+          code: 'CANNOT_DEACTIVATE_SELF',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '사용자를 찾을 수 없습니다.',
+          code: 'USER_NOT_FOUND',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자 상태를 변경할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 상태 변경 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+}

lib/domain/usecases/user/update_user_usecase.dart

@@ -0,0 +1,110 @@
+import 'package:dartz/dartz.dart';
+import '../../../services/user_service.dart';
+import '../../../models/user_model.dart' as model;
+import '../../../core/constants/app_constants.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 사용자 수정 파라미터
+class UpdateUserParams {
+  final int id;
+  final String? email;
+  final String? name;
+  final String? role;
+  final int? companyId;
+  final String? phone;
+  final String? position;
+  final bool? isActive;
+
+  const UpdateUserParams({
+    required this.id,
+    this.email,
+    this.name,
+    this.role,
+    this.companyId,
+    this.phone,
+    this.position,
+    this.isActive,
+  });
+}
+
+/// 사용자 정보 수정 UseCase
+class UpdateUserUseCase extends UseCase<model.User, UpdateUserParams> {
+  final UserService _userService;
+
+  UpdateUserUseCase(this._userService);
+
+  @override
+  Future<Either<Failure, model.User>> call(UpdateUserParams params) async {
+    try {
+      // 유효성 검증
+      final validationResult = _validateUpdateInput(params);
+      if (validationResult != null) {
+        return Left(validationResult);
+      }
+
+      final user = await _userService.updateUser(
+        params.id,
+        email: params.email,
+        name: params.name,
+        role: params.role,
+        companyId: params.companyId,
+        phone: params.phone,
+        position: params.position,
+      );
+      
+      return Right(user);
+    } catch (e) {
+      if (e.toString().contains('찾을 수 없')) {
+        return Left(ValidationFailure(
+          message: '사용자를 찾을 수 없습니다.',
+          code: 'USER_NOT_FOUND',
+          originalError: e,
+        ));
+      } else if (e.toString().contains('권한')) {
+        return Left(PermissionFailure(
+          message: '사용자 정보를 수정할 권한이 없습니다.',
+          code: 'PERMISSION_DENIED',
+          originalError: e,
+        ));
+      } else {
+        return Left(ServerFailure(
+          message: '사용자 정보 수정 중 오류가 발생했습니다.',
+          originalError: e,
+        ));
+      }
+    }
+  }
+
+  ValidationFailure? _validateUpdateInput(UpdateUserParams params) {
+    final errors = <String, String>{};
+
+    // 이메일 검증 (제공된 경우)
+    if (params.email != null && params.email!.isNotEmpty) {
+      if (!AppConstants.emailRegex.hasMatch(params.email!)) {
+        errors['email'] = '올바른 이메일 형식이 아닙니다.';
+      }
+    }
+
+    // 역할 검증 (제공된 경우)
+    if (params.role != null && !['S', 'M', 'U', 'V'].contains(params.role)) {
+      errors['role'] = '올바른 역할을 선택해주세요.';
+    }
+
+    // 전화번호 검증 (제공된 경우)
+    if (params.phone != null && params.phone!.isNotEmpty) {
+      if (!AppConstants.phoneRegex.hasMatch(params.phone!)) {
+        errors['phone'] = '올바른 전화번호 형식이 아닙니다.';
+      }
+    }
+
+    if (errors.isNotEmpty) {
+      return ValidationFailure(
+        message: '입력값을 확인해주세요.',
+        errors: errors,
+      );
+    }
+
+    return null;
+  }
+}

lib/domain/usecases/user/user_usecases.dart

@@ -0,0 +1,8 @@
+/// User 도메인 UseCase 모음
+export 'get_users_usecase.dart';
+export 'create_user_usecase.dart';
+export 'update_user_usecase.dart';
+export 'delete_user_usecase.dart';
+export 'get_user_detail_usecase.dart';
+export 'reset_password_usecase.dart';
+export 'toggle_user_status_usecase.dart';

lib/domain/usecases/warehouse_location/create_warehouse_location_usecase.dart

@@ -0,0 +1,75 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/warehouse/warehouse_dto.dart';
+import '../../../data/repositories/warehouse_location_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 창고 위치 생성 UseCase
+@injectable
+class CreateWarehouseLocationUseCase implements UseCase<WarehouseLocationDto, CreateWarehouseLocationParams> {
+  final WarehouseLocationRepository repository;
+
+  CreateWarehouseLocationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, WarehouseLocationDto>> call(CreateWarehouseLocationParams params) async {
+    try {
+      // 비즈니스 로직: 이름 중복 체크
+      if (params.name.isEmpty) {
+        return Left(ValidationFailure(message: '창고 위치 이름은 필수입니다'));
+      }
+
+      // 비즈니스 로직: 주소 유효성 검증
+      if (params.address.isEmpty) {
+        return Left(ValidationFailure(message: '창고 주소는 필수입니다'));
+      }
+
+      // 비즈니스 로직: 연락처 형식 검증
+      if (params.contactNumber != null && params.contactNumber!.isNotEmpty) {
+        final phoneRegex = RegExp(r'^[\d\-\+\(\)\s]+$');
+        if (!phoneRegex.hasMatch(params.contactNumber!)) {
+          return Left(ValidationFailure(message: '올바른 연락처 형식이 아닙니다'));
+        }
+      }
+
+      final location = await repository.createWarehouseLocation(params.toMap());
+      return Right(location);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 창고 위치 생성 파라미터
+class CreateWarehouseLocationParams {
+  final String name;
+  final String address;
+  final String? description;
+  final String? contactNumber;
+  final String? manager;
+  final double? latitude;
+  final double? longitude;
+
+  CreateWarehouseLocationParams({
+    required this.name,
+    required this.address,
+    this.description,
+    this.contactNumber,
+    this.manager,
+    this.latitude,
+    this.longitude,
+  });
+
+  Map<String, dynamic> toMap() {
+    return {
+      'name': name,
+      'address': address,
+      'description': description,
+      'contact_number': contactNumber,
+      'manager': manager,
+      'latitude': latitude,
+      'longitude': longitude,
+    };
+  }
+}

lib/domain/usecases/warehouse_location/delete_warehouse_location_usecase.dart

@@ -0,0 +1,30 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/repositories/warehouse_location_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 창고 위치 삭제 UseCase
+@injectable
+class DeleteWarehouseLocationUseCase implements UseCase<bool, int> {
+  final WarehouseLocationRepository repository;
+
+  DeleteWarehouseLocationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, bool>> call(int id) async {
+    try {
+      // 비즈니스 로직: 사용 중인 창고는 삭제 불가
+      // TODO: 창고에 장비가 있는지 확인하는 로직 추가 필요
+      // final hasEquipment = await repository.checkWarehouseHasEquipment(id);
+      // if (hasEquipment) {
+      //   return Left(ValidationFailure(message: '장비가 있는 창고는 삭제할 수 없습니다'));
+      // }
+
+      await repository.deleteWarehouseLocation(id);
+      return const Right(true);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}

lib/domain/usecases/warehouse_location/get_warehouse_location_detail_usecase.dart

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/warehouse/warehouse_dto.dart';
+import '../../../data/repositories/warehouse_location_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 창고 위치 상세 조회 UseCase
+@injectable
+class GetWarehouseLocationDetailUseCase implements UseCase<WarehouseLocationDto, int> {
+  final WarehouseLocationRepository repository;
+
+  GetWarehouseLocationDetailUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, WarehouseLocationDto>> call(int id) async {
+    try {
+      final location = await repository.getWarehouseLocationDetail(id);
+      return Right(location);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}

lib/domain/usecases/warehouse_location/get_warehouse_locations_usecase.dart

@@ -0,0 +1,55 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/common/pagination_params.dart';
+import '../../../data/models/warehouse/warehouse_dto.dart';
+import '../../../data/repositories/warehouse_location_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 창고 위치 목록 조회 UseCase
+@injectable
+class GetWarehouseLocationsUseCase implements UseCase<WarehouseLocationListDto, GetWarehouseLocationsParams> {
+  final WarehouseLocationRepository repository;
+
+  GetWarehouseLocationsUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, WarehouseLocationListDto>> call(GetWarehouseLocationsParams params) async {
+    try {
+      final locations = await repository.getWarehouseLocations(
+        page: params.page,
+        perPage: params.perPage,
+        search: params.search,
+        filters: params.filters,
+      );
+      return Right(locations);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 창고 위치 목록 조회 파라미터
+class GetWarehouseLocationsParams {
+  final int page;
+  final int perPage;
+  final String? search;
+  final Map<String, dynamic>? filters;
+
+  GetWarehouseLocationsParams({
+    this.page = 1,
+    this.perPage = 20,
+    this.search,
+    this.filters,
+  });
+
+  /// PaginationParams로부터 변환
+  factory GetWarehouseLocationsParams.fromPaginationParams(PaginationParams params) {
+    return GetWarehouseLocationsParams(
+      page: params.page,
+      perPage: params.perPage,
+      search: params.search,
+      filters: params.filters,
+    );
+  }
+}

lib/domain/usecases/warehouse_location/update_warehouse_location_usecase.dart

@@ -0,0 +1,88 @@
+import 'package:dartz/dartz.dart';
+import 'package:injectable/injectable.dart';
+import '../../../data/models/warehouse/warehouse_dto.dart';
+import '../../../data/repositories/warehouse_location_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 창고 위치 수정 UseCase
+@injectable
+class UpdateWarehouseLocationUseCase implements UseCase<WarehouseLocationDto, UpdateWarehouseLocationParams> {
+  final WarehouseLocationRepository repository;
+
+  UpdateWarehouseLocationUseCase(this.repository);
+
+  @override
+  Future<Either<Failure, WarehouseLocationDto>> call(UpdateWarehouseLocationParams params) async {
+    try {
+      // 비즈니스 로직: 이름 유효성 검증
+      if (params.name != null && params.name!.isEmpty) {
+        return Left(ValidationFailure(message: '창고 위치 이름은 비어있을 수 없습니다'));
+      }
+
+      // 비즈니스 로직: 주소 유효성 검증
+      if (params.address != null && params.address!.isEmpty) {
+        return Left(ValidationFailure(message: '창고 주소는 비어있을 수 없습니다'));
+      }
+
+      // 비즈니스 로직: 연락처 형식 검증
+      if (params.contactNumber != null && params.contactNumber!.isNotEmpty) {
+        final phoneRegex = RegExp(r'^[\d\-\+\(\)\s]+$');
+        if (!phoneRegex.hasMatch(params.contactNumber!)) {
+          return Left(ValidationFailure(message: '올바른 연락처 형식이 아닙니다'));
+        }
+      }
+
+      // 비즈니스 로직: 좌표 유효성 검증
+      if (params.latitude != null && (params.latitude! < -90 || params.latitude! > 90)) {
+        return Left(ValidationFailure(message: '유효하지 않은 위도값입니다'));
+      }
+      if (params.longitude != null && (params.longitude! < -180 || params.longitude! > 180)) {
+        return Left(ValidationFailure(message: '유효하지 않은 경도값입니다'));
+      }
+
+      final location = await repository.updateWarehouseLocation(params.id, params.toMap());
+      return Right(location);
+    } catch (e) {
+      return Left(ServerFailure(message: e.toString()));
+    }
+  }
+}
+
+/// 창고 위치 수정 파라미터
+class UpdateWarehouseLocationParams {
+  final int id;
+  final String? name;
+  final String? address;
+  final String? description;
+  final String? contactNumber;
+  final String? manager;
+  final double? latitude;
+  final double? longitude;
+  final bool? isActive;
+
+  UpdateWarehouseLocationParams({
+    required this.id,
+    this.name,
+    this.address,
+    this.description,
+    this.contactNumber,
+    this.manager,
+    this.latitude,
+    this.longitude,
+    this.isActive,
+  });
+
+  Map<String, dynamic> toMap() {
+    final Map<String, dynamic> data = {};
+    if (name != null) data['name'] = name;
+    if (address != null) data['address'] = address;
+    if (description != null) data['description'] = description;
+    if (contactNumber != null) data['contact_number'] = contactNumber;
+    if (manager != null) data['manager'] = manager;
+    if (latitude != null) data['latitude'] = latitude;
+    if (longitude != null) data['longitude'] = longitude;
+    if (isActive != null) data['is_active'] = isActive;
+    return data;
+  }
+}

lib/domain/usecases/warehouse_location/warehouse_location_usecases.dart

@@ -0,0 +1,6 @@
+// WarehouseLocation UseCase barrel file
+export 'get_warehouse_locations_usecase.dart';
+export 'get_warehouse_location_detail_usecase.dart';
+export 'create_warehouse_location_usecase.dart';
+export 'update_warehouse_location_usecase.dart';
+export 'delete_warehouse_location_usecase.dart';