사용하지 않는 파일 정리 전 백업 (Phase 10 완료 후 상태)

lib/domain/usecases/equipment/create_equipment_usecase.dart

@@ -0,0 +1,54 @@
+import 'package:dartz/dartz.dart';
+import '../../repositories/equipment_repository.dart';
+import '../../../data/models/equipment/equipment_dto.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 생성 UseCase
+class CreateEquipmentUseCase extends UseCase<EquipmentDto, EquipmentRequestDto> {
+  final EquipmentRepository _equipmentRepository;
+
+  CreateEquipmentUseCase(this._equipmentRepository);
+
+  @override
+  Future<Either<Failure, EquipmentDto>> call(EquipmentRequestDto params) async {
+    // 입력 검증
+    if (params.companiesId <= 0) {
+      return Left(ValidationFailure(
+        message: '회사를 선택해주세요.',
+        errors: {'companiesId': '회사는 필수 선택 항목입니다.'},
+      ));
+    }
+
+    if (params.modelsId <= 0) {
+      return Left(ValidationFailure(
+        message: '모델을 선택해주세요.',
+        errors: {'modelsId': '모델은 필수 선택 항목입니다.'},
+      ));
+    }
+
+    if (params.serialNumber.trim().isEmpty) {
+      return Left(ValidationFailure(
+        message: '시리얼 번호를 입력해주세요.',
+        errors: {'serialNumber': '시리얼 번호는 필수 입력 항목입니다.'},
+      ));
+    }
+
+    if (params.warrantyNumber.trim().isEmpty) {
+      return Left(ValidationFailure(
+        message: '워런티 번호를 입력해주세요.',
+        errors: {'warrantyNumber': '워런티 번호는 필수 입력 항목입니다.'},
+      ));
+    }
+
+    // 워런티 기간 검증
+    if (params.warrantyStartedAt.isAfter(params.warrantyEndedAt)) {
+      return Left(ValidationFailure(
+        message: '워런티 시작일이 종료일보다 늦을 수 없습니다.',
+        errors: {'warrantyPeriod': '워런티 기간을 올바르게 설정해주세요.'},
+      ));
+    }
+
+    return await _equipmentRepository.createEquipment(params);
+  }
+}

lib/domain/usecases/equipment/delete_equipment_usecase.dart

@@ -0,0 +1,23 @@
+import 'package:dartz/dartz.dart';
+import '../../repositories/equipment_repository.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 삭제 UseCase
+class DeleteEquipmentUseCase extends UseCase<void, int> {
+  final EquipmentRepository _equipmentRepository;
+
+  DeleteEquipmentUseCase(this._equipmentRepository);
+
+  @override
+  Future<Either<Failure, void>> call(int equipmentId) async {
+    if (equipmentId <= 0) {
+      return Left(ValidationFailure(
+        message: '올바르지 않은 장비 ID입니다.',
+        errors: {'equipmentId': '장비 ID는 0보다 커야 합니다.'},
+      ));
+    }
+
+    return await _equipmentRepository.deleteEquipment(equipmentId);
+  }
+}

lib/domain/usecases/equipment/equipment_in_usecase.dart

@@ -1,39 +1,35 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/equipment_service.dart';
-import '../../../data/models/equipment/equipment_io_response.dart';
+import '../../../data/models/equipment_history_dto.dart';
 import '../../../core/errors/failures.dart';
+import '../equipment_history_usecase.dart';
 import '../base_usecase.dart';
 
-/// 장비 입고 파라미터
+/// 장비 입고 파라미터 (백엔드 스키마 기반)
 class EquipmentInParams {
-  final int equipmentId;
-  final int warehouseLocationId;
+  final int equipmentsId;
+  final int warehousesId;
   final int quantity;
-  final String serialNumber;
+  final DateTime? transactedAt;
   final String? remark;
-  final DateTime? purchaseDate;
-  final double? purchasePrice;
 
   const EquipmentInParams({
-    required this.equipmentId,
-    required this.warehouseLocationId,
+    required this.equipmentsId,
+    required this.warehousesId,
     required this.quantity,
-    required this.serialNumber,
+    this.transactedAt,
     this.remark,
-    this.purchaseDate,
-    this.purchasePrice,
   });
 }
 
-/// 장비 입고 UseCase
+/// 장비 입고 UseCase (백엔드 스키마 기반)
 /// 새로운 장비를 창고에 입고 처리
-class EquipmentInUseCase extends UseCase<EquipmentIoResponse, EquipmentInParams> {
-  final EquipmentService _equipmentService;
+class EquipmentInUseCase extends UseCase<EquipmentHistoryDto, EquipmentInParams> {
+  final EquipmentHistoryUseCase _equipmentHistoryUseCase;
 
-  EquipmentInUseCase(this._equipmentService);
+  EquipmentInUseCase(this._equipmentHistoryUseCase);
 
   @override
-  Future<Either<Failure, EquipmentIoResponse>> call(EquipmentInParams params) async {
+  Future<Either<Failure, EquipmentHistoryDto>> call(EquipmentInParams params) async {
     try {
       // 유효성 검증
       final validationResult = _validateInput(params);
@@ -41,29 +37,21 @@ class EquipmentInUseCase extends UseCase<EquipmentIoResponse, EquipmentInParams>
         return Left(validationResult);
       }
 
-      // 시리얼 번호 중복 체크 (프론트엔드 임시 로직)
-      // TODO: 백엔드 API 구현 후 제거
-      
-      final response = await _equipmentService.equipmentIn(
-        equipmentId: params.equipmentId,
+      // 백엔드 EquipmentHistoryUseCase를 통한 입고 처리
+      final response = await _equipmentHistoryUseCase.createStockIn(
+        equipmentsId: params.equipmentsId,
+        warehousesId: params.warehousesId,
         quantity: params.quantity,
-        warehouseLocationId: params.warehouseLocationId,
-        notes: params.remark,
+        transactedAt: params.transactedAt,
+        remark: params.remark,
       );
       
       return Right(response);
     } catch (e) {
-      if (e.toString().contains('시리얼')) {
+      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',
+          message: '입고 수량을 확인해주세요.',
+          code: 'INVALID_QUANTITY',
           originalError: e,
         ));
       } else if (e.toString().contains('권한')) {
@@ -92,22 +80,9 @@ class EquipmentInUseCase extends UseCase<EquipmentIoResponse, EquipmentInParams>
       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 (params.transactedAt != null && params.transactedAt!.isAfter(DateTime.now())) {
+      errors['transactedAt'] = '입고 날짜는 미래 날짜일 수 없습니다.';
     }
 
     if (errors.isNotEmpty) {

lib/domain/usecases/equipment/equipment_out_usecase.dart

@@ -1,39 +1,35 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/equipment_service.dart';
-import '../../../data/models/equipment/equipment_io_response.dart';
+import '../../../data/models/equipment_history_dto.dart';
 import '../../../core/errors/failures.dart';
+import '../equipment_history_usecase.dart';
 import '../base_usecase.dart';
 
-/// 장비 출고 파라미터
+/// 장비 출고 파라미터 (백엔드 스키마 기반)
 class EquipmentOutParams {
-  final int equipmentInId;
-  final int companyId;
+  final int equipmentsId;
+  final int warehousesId;
   final int quantity;
+  final DateTime? transactedAt;
   final String? remark;
-  final String? recipientName;
-  final String? recipientPhone;
-  final DateTime? deliveryDate;
 
   const EquipmentOutParams({
-    required this.equipmentInId,
-    required this.companyId,
+    required this.equipmentsId,
+    required this.warehousesId,
     required this.quantity,
+    this.transactedAt,
     this.remark,
-    this.recipientName,
-    this.recipientPhone,
-    this.deliveryDate,
   });
 }
 
-/// 장비 출고 UseCase
-/// 창고에서 회사로 장비 출고 처리
-class EquipmentOutUseCase extends UseCase<EquipmentIoResponse, EquipmentOutParams> {
-  final EquipmentService _equipmentService;
+/// 장비 출고 UseCase (백엔드 스키마 기반)
+/// 창고에서 장비 출고 처리
+class EquipmentOutUseCase extends UseCase<EquipmentHistoryDto, EquipmentOutParams> {
+  final EquipmentHistoryUseCase _equipmentHistoryUseCase;
 
-  EquipmentOutUseCase(this._equipmentService);
+  EquipmentOutUseCase(this._equipmentHistoryUseCase);
 
   @override
-  Future<Either<Failure, EquipmentIoResponse>> call(EquipmentOutParams params) async {
+  Future<Either<Failure, EquipmentHistoryDto>> call(EquipmentOutParams params) async {
     try {
       // 유효성 검증
       final validationResult = _validateInput(params);
@@ -41,11 +37,13 @@ class EquipmentOutUseCase extends UseCase<EquipmentIoResponse, EquipmentOutParam
         return Left(validationResult);
       }
 
-      final response = await _equipmentService.equipmentOut(
-        equipmentId: params.equipmentInId, // equipmentInId를 equipmentId로 사용
+      // 백엔드 EquipmentHistoryUseCase를 통한 출고 처리
+      final response = await _equipmentHistoryUseCase.createStockOut(
+        equipmentsId: params.equipmentsId,
+        warehousesId: params.warehousesId,
         quantity: params.quantity,
-        companyId: params.companyId,
-        notes: params.remark,
+        transactedAt: params.transactedAt,
+        remark: params.remark,
       );
       
       return Right(response);
@@ -56,10 +54,10 @@ class EquipmentOutUseCase extends UseCase<EquipmentIoResponse, EquipmentOutParam
           code: 'INSUFFICIENT_STOCK',
           originalError: e,
         ));
-      } else if (e.toString().contains('찾을 수 없')) {
+      } else if (e.toString().contains('수량')) {
         return Left(ValidationFailure(
-          message: '장비 정보를 찾을 수 없습니다.',
-          code: 'EQUIPMENT_NOT_FOUND',
+          message: '출고 수량을 확인해주세요.',
+          code: 'INVALID_QUANTITY',
           originalError: e,
         ));
       } else if (e.toString().contains('권한')) {
@@ -88,20 +86,9 @@ class EquipmentOutUseCase extends UseCase<EquipmentIoResponse, EquipmentOutParam
       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 (params.transactedAt != null && params.transactedAt!.isAfter(DateTime.now())) {
+      errors['transactedAt'] = '출고 날짜는 미래 날짜일 수 없습니다.';
     }
 
     if (errors.isNotEmpty) {

lib/domain/usecases/equipment/equipment_usecases.dart

@@ -1,5 +1,7 @@
 /// Equipment 도메인 UseCase 모음
+library;
 export 'get_equipments_usecase.dart';
-export 'equipment_in_usecase.dart';
-export 'equipment_out_usecase.dart';
-export 'get_equipment_history_usecase.dart';
+export 'get_equipment_detail_usecase.dart';
+export 'create_equipment_usecase.dart';
+export 'update_equipment_usecase.dart';
+export 'delete_equipment_usecase.dart';

lib/domain/usecases/equipment/get_equipment_detail_usecase.dart

@@ -0,0 +1,24 @@
+import 'package:dartz/dartz.dart';
+import '../../repositories/equipment_repository.dart';
+import '../../../data/models/equipment/equipment_dto.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 상세 조회 UseCase
+class GetEquipmentDetailUseCase extends UseCase<EquipmentDto, int> {
+  final EquipmentRepository _equipmentRepository;
+
+  GetEquipmentDetailUseCase(this._equipmentRepository);
+
+  @override
+  Future<Either<Failure, EquipmentDto>> call(int equipmentId) async {
+    if (equipmentId <= 0) {
+      return Left(ValidationFailure(
+        message: '올바르지 않은 장비 ID입니다.',
+        errors: {'equipmentId': '장비 ID는 0보다 커야 합니다.'},
+      ));
+    }
+
+    return await _equipmentRepository.getEquipmentDetail(equipmentId);
+  }
+}

lib/domain/usecases/equipment/get_equipment_history_usecase.dart

@@ -1,8 +1,8 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/equipment_service.dart';
-import '../../../data/models/equipment/equipment_history_dto.dart';
+import '../../../data/models/equipment_history_dto.dart';
 import '../../../core/errors/failures.dart';
 import '../base_usecase.dart';
+import '../equipment_history_usecase.dart';
 
 /// 장비 이력 조회 파라미터
 class GetEquipmentHistoryParams {
@@ -19,12 +19,12 @@ class GetEquipmentHistoryParams {
   });
 }
 
-/// 장비 이력 조회 UseCase
-/// 특정 장비의 입출고 및 상태 변경 이력 조회
+/// 장비 이력 조회 UseCase (백엔드 스키마 기반)
+/// 특정 장비의 입출고 이력 조회
 class GetEquipmentHistoryUseCase extends UseCase<List<EquipmentHistoryDto>, GetEquipmentHistoryParams> {
-  final EquipmentService _equipmentService;
+  final EquipmentHistoryUseCase _equipmentHistoryUseCase;
 
-  GetEquipmentHistoryUseCase(this._equipmentService);
+  GetEquipmentHistoryUseCase(this._equipmentHistoryUseCase);
 
   @override
   Future<Either<Failure, List<EquipmentHistoryDto>>> call(GetEquipmentHistoryParams params) async {
@@ -48,7 +48,7 @@ class GetEquipmentHistoryUseCase extends UseCase<List<EquipmentHistoryDto>, GetE
         ));
       }
 
-      final history = await _equipmentService.getEquipmentHistory(params.equipmentId);
+      final history = await _equipmentHistoryUseCase.getEquipmentHistoriesByEquipmentId(params.equipmentId);
       
       // 필터링 적용
       List<EquipmentHistoryDto> filteredHistory = history;

lib/domain/usecases/equipment/get_equipments_usecase.dart

@@ -1,6 +1,6 @@
 import 'package:dartz/dartz.dart';
-import '../../../services/equipment_service.dart';
-import '../../../models/equipment_unified_model.dart';
+import '../../repositories/equipment_repository.dart';
+import '../../../data/models/equipment/equipment_dto.dart';
 import '../../../core/errors/failures.dart';
 import '../../../data/models/common/paginated_response.dart';
 import '../base_usecase.dart';
@@ -9,62 +9,27 @@ 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<PaginatedResponse<Equipment>, GetEquipmentsParams> {
-  final EquipmentService _equipmentService;
+class GetEquipmentsUseCase extends UseCase<PaginatedResponse<EquipmentDto>, GetEquipmentsParams> {
+  final EquipmentRepository _equipmentRepository;
 
-  GetEquipmentsUseCase(this._equipmentService);
+  GetEquipmentsUseCase(this._equipmentRepository);
 
   @override
-  Future<Either<Failure, PaginatedResponse<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,
-        ));
-      }
-    }
+  Future<Either<Failure, PaginatedResponse<EquipmentDto>>> call(GetEquipmentsParams params) async {
+    return await _equipmentRepository.getEquipments(
+      page: params.page,
+      limit: params.perPage,
+      search: params.search,
+    );
   }
 }

lib/domain/usecases/equipment/update_equipment_usecase.dart

@@ -0,0 +1,68 @@
+import 'package:dartz/dartz.dart';
+import '../../repositories/equipment_repository.dart';
+import '../../../data/models/equipment/equipment_dto.dart';
+import '../../../core/errors/failures.dart';
+import '../base_usecase.dart';
+
+/// 장비 수정 파라미터
+class UpdateEquipmentParams {
+  final int id;
+  final EquipmentUpdateRequestDto request;
+
+  const UpdateEquipmentParams({
+    required this.id,
+    required this.request,
+  });
+}
+
+/// 장비 수정 UseCase
+class UpdateEquipmentUseCase extends UseCase<EquipmentDto, UpdateEquipmentParams> {
+  final EquipmentRepository _equipmentRepository;
+
+  UpdateEquipmentUseCase(this._equipmentRepository);
+
+  @override
+  Future<Either<Failure, EquipmentDto>> call(UpdateEquipmentParams params) async {
+    // ID 검증
+    if (params.id <= 0) {
+      return Left(ValidationFailure(
+        message: '올바르지 않은 장비 ID입니다.',
+        errors: {'id': '장비 ID는 0보다 커야 합니다.'},
+      ));
+    }
+
+    // 입력 검증 (값이 제공된 경우만)
+    if (params.request.companiesId != null && params.request.companiesId! <= 0) {
+      return Left(ValidationFailure(
+        message: '회사를 선택해주세요.',
+        errors: {'companiesId': '올바른 회사를 선택해주세요.'},
+      ));
+    }
+
+    if (params.request.modelsId != null && params.request.modelsId! <= 0) {
+      return Left(ValidationFailure(
+        message: '모델을 선택해주세요.',
+        errors: {'modelsId': '올바른 모델을 선택해주세요.'},
+      ));
+    }
+
+    if (params.request.serialNumber != null && params.request.serialNumber!.trim().isEmpty) {
+      return Left(ValidationFailure(
+        message: '시리얼 번호를 입력해주세요.',
+        errors: {'serialNumber': '시리얼 번호는 비어있을 수 없습니다.'},
+      ));
+    }
+
+    // 워런티 기간 검증
+    if (params.request.warrantyStartedAt != null && 
+        params.request.warrantyEndedAt != null &&
+        params.request.warrantyStartedAt!.isAfter(params.request.warrantyEndedAt!)) {
+      return Left(ValidationFailure(
+        message: '워런티 시작일이 종료일보다 늦을 수 없습니다.',
+        errors: {'warrantyPeriod': '워런티 기간을 올바르게 설정해주세요.'},
+      ));
+    }
+
+    return await _equipmentRepository.updateEquipment(params.id, params.request);
+  }
+}