fix: API 응답 파싱 오류 수정 및 에러 처리 개선

주요 변경사항:
- 창고 관리 API 응답 구조와 DTO 불일치 수정
  - WarehouseLocationDto에 code, manager_phone 필드 추가
  - RemoteDataSource에서 API 응답을 DTO 구조에 맞게 변환
- 회사 관리 API 응답 파싱 오류 수정
  - CompanyResponse의 필수 필드를 nullable로 변경
  - PaginatedResponse 구조 매핑 로직 개선
- 에러 처리 및 로깅 개선
  - Service Layer에 상세 에러 로깅 추가
  - Controller에서 에러 타입별 처리
- 새로운 유틸리티 추가
  - ResponseInterceptor: API 응답 정규화
  - DebugLogger: 디버깅 도구
  - HealthCheckService: 서버 상태 확인
- 문서화
  - API 통합 테스트 가이드
  - 에러 분석 보고서
  - 리팩토링 계획서

lib/services/auth_service.dart

@@ -12,6 +12,8 @@ import 'package:superport/data/models/auth/login_response.dart';
 import 'package:superport/data/models/auth/logout_request.dart';
 import 'package:superport/data/models/auth/refresh_token_request.dart';
 import 'package:superport/data/models/auth/token_response.dart';
+import 'package:superport/core/config/environment.dart' as env;
+import 'package:superport/services/mock_data_service.dart';
 
 abstract class AuthService {
   Future<Either<Failure, LoginResponse>> login(LoginRequest request);
@@ -45,6 +47,16 @@ class AuthServiceImpl implements AuthService {
   @override
   Future<Either<Failure, LoginResponse>> login(LoginRequest request) async {
     try {
+      print('[AuthService] login 시작 - useApi: ${env.Environment.useApi}');
+      
+      // Mock 모드일 때
+      if (!env.Environment.useApi) {
+        print('[AuthService] Mock 모드로 로그인 처리');
+        return _mockLogin(request);
+      }
+      
+      // API 모드일 때
+      print('[AuthService] API 모드로 로그인 처리');
       final result = await _authRemoteDataSource.login(request);
       
       return await result.fold(
@@ -68,6 +80,61 @@ class AuthServiceImpl implements AuthService {
       return Left(ServerFailure(message: '로그인 처리 중 오류가 발생했습니다.'));
     }
   }
+  
+  Future<Either<Failure, LoginResponse>> _mockLogin(LoginRequest request) async {
+    try {
+      // Mock 데이터 서비스의 사용자 확인
+      final mockService = MockDataService();
+      final users = mockService.getAllUsers();
+      
+      // 사용자 찾기
+      final user = users.firstWhere(
+        (u) => u.email == request.email,
+        orElse: () => throw Exception('사용자를 찾을 수 없습니다.'),
+      );
+      
+      // 비밀번호 확인 (Mock에서는 간단하게 처리)
+      if (request.password != 'admin123' && request.password != 'password123') {
+        return Left(AuthenticationFailure(message: '잘못된 비밀번호입니다.'));
+      }
+      
+      // Mock 토큰 생성
+      final mockAccessToken = 'mock_access_token_${DateTime.now().millisecondsSinceEpoch}';
+      final mockRefreshToken = 'mock_refresh_token_${DateTime.now().millisecondsSinceEpoch}';
+      
+      // Mock 로그인 응답 생성
+      final loginResponse = LoginResponse(
+        accessToken: mockAccessToken,
+        refreshToken: mockRefreshToken,
+        tokenType: 'Bearer',
+        expiresIn: 3600,
+        user: AuthUser(
+          id: user.id ?? 0,
+          username: user.username ?? '',
+          email: user.email ?? request.email ?? '',
+          name: user.name,
+          role: user.role,
+        ),
+      );
+      
+      // 토큰 및 사용자 정보 저장
+      await _saveTokens(
+        loginResponse.accessToken,
+        loginResponse.refreshToken,
+        loginResponse.expiresIn,
+      );
+      await _saveUser(loginResponse.user);
+      
+      // 인증 상태 변경 알림
+      _authStateController.add(true);
+      
+      print('[AuthService] Mock 로그인 성공');
+      return Right(loginResponse);
+    } catch (e) {
+      print('[AuthService] Mock 로그인 실패: $e');
+      return Left(ServerFailure(message: '로그인 처리 중 오류가 발생했습니다.'));
+    }
+  }
 
   @override
   Future<Either<Failure, void>> logout() async {
@@ -164,8 +231,17 @@ class AuthServiceImpl implements AuthService {
   @override
   Future<String?> getAccessToken() async {
     try {
-      return await _secureStorage.read(key: _accessTokenKey);
+      final token = await _secureStorage.read(key: _accessTokenKey);
+      if (token != null && token.length > 20) {
+        print('[AuthService] getAccessToken: Found (${token.substring(0, 20)}...)');
+      } else if (token != null) {
+        print('[AuthService] getAccessToken: Found (${token})');
+      } else {
+        print('[AuthService] getAccessToken: Not found');
+      }
+      return token;
     } catch (e) {
+      print('[AuthService] getAccessToken error: $e');
       return null;
     }
   }
@@ -199,6 +275,13 @@ class AuthServiceImpl implements AuthService {
     String refreshToken,
     int expiresIn,
   ) async {
+    print('[AuthService] Saving tokens...');
+    final accessTokenPreview = accessToken.length > 20 ? '${accessToken.substring(0, 20)}...' : accessToken;
+    final refreshTokenPreview = refreshToken.length > 20 ? '${refreshToken.substring(0, 20)}...' : refreshToken;
+    print('[AuthService] Access token: $accessTokenPreview');
+    print('[AuthService] Refresh token: $refreshTokenPreview');
+    print('[AuthService] Expires in: $expiresIn seconds');
+    
     await _secureStorage.write(key: _accessTokenKey, value: accessToken);
     await _secureStorage.write(key: _refreshTokenKey, value: refreshToken);
     
@@ -208,6 +291,8 @@ class AuthServiceImpl implements AuthService {
       key: _tokenExpiryKey,
       value: expiry.toIso8601String(),
     );
+    
+    print('[AuthService] Tokens saved successfully');
   }
 
   Future<void> _saveUser(AuthUser user) async {

lib/services/company_service.dart

@@ -31,8 +31,11 @@ class CompanyService {
 
       return response.items.map((dto) => _convertListDtoToCompany(dto)).toList();
     } on ApiException catch (e) {
+      print('[CompanyService] ApiException: ${e.message}');
       throw ServerFailure(message: e.message);
-    } catch (e) {
+    } catch (e, stackTrace) {
+      print('[CompanyService] Error loading companies: $e');
+      print('[CompanyService] Stack trace: $stackTrace');
       throw ServerFailure(message: 'Failed to fetch company list: $e');
     }
   }
@@ -263,6 +266,7 @@ class CompanyService {
       contactName: dto.contactName,
       contactPhone: dto.contactPhone,
       companyTypes: [CompanyType.customer], // 기본값, 실제로는 API에서 받아와야 함
+      branches: [], // branches는 빈 배열로 초기화
     );
   }
 
@@ -282,6 +286,7 @@ class CompanyService {
       contactEmail: dto.contactEmail,
       companyTypes: companyTypes.isEmpty ? [CompanyType.customer] : companyTypes,
       remark: dto.remark,
+      branches: [], // branches는 빈 배열로 초기화
     );
   }
 

lib/services/equipment_service.dart

@@ -14,6 +14,31 @@ import 'package:superport/models/equipment_unified_model.dart';
 class EquipmentService {
   final EquipmentRemoteDataSource _remoteDataSource = GetIt.instance<EquipmentRemoteDataSource>();
 
+  // 장비 목록 조회 (DTO 형태로 반환하여 status 정보 유지)
+  Future<List<EquipmentListDto>> getEquipmentsWithStatus({
+    int page = 1,
+    int perPage = 20,
+    String? status,
+    int? companyId,
+    int? warehouseLocationId,
+  }) async {
+    try {
+      final dtoList = await _remoteDataSource.getEquipments(
+        page: page,
+        perPage: perPage,
+        status: status,
+        companyId: companyId,
+        warehouseLocationId: warehouseLocationId,
+      );
+
+      return dtoList;
+    } on ServerException catch (e) {
+      throw ServerFailure(message: e.message);
+    } catch (e) {
+      throw ServerFailure(message: 'Failed to fetch equipment list: $e');
+    }
+  }
+
   // 장비 목록 조회
   Future<List<Equipment>> getEquipments({
     int page = 1,

lib/services/health_check_service.dart

@@ -0,0 +1,99 @@
+import 'package:dio/dio.dart';
+import '../core/config/environment.dart';
+import '../data/datasources/remote/api_client.dart';
+
+/// API 헬스체크 테스트를 위한 서비스
+class HealthCheckService {
+  final ApiClient _apiClient;
+  
+  HealthCheckService({ApiClient? apiClient}) 
+    : _apiClient = apiClient ?? ApiClient();
+  
+  /// 헬스체크 API 호출
+  Future<Map<String, dynamic>> checkHealth() async {
+    try {
+      print('=== 헬스체크 시작 ===');
+      print('API Base URL: ${Environment.apiBaseUrl}');
+      print('Full URL: ${Environment.apiBaseUrl}/health');
+      
+      final response = await _apiClient.get('/health');
+      
+      print('응답 상태 코드: ${response.statusCode}');
+      print('응답 데이터: ${response.data}');
+      
+      return {
+        'success': true,
+        'data': response.data,
+        'statusCode': response.statusCode,
+      };
+    } on DioException catch (e) {
+      print('=== DioException 발생 ===');
+      print('에러 타입: ${e.type}');
+      print('에러 메시지: ${e.message}');
+      print('에러 응답: ${e.response?.data}');
+      print('에러 상태 코드: ${e.response?.statusCode}');
+      
+      // CORS 에러인지 확인
+      if (e.type == DioExceptionType.connectionError || 
+          e.type == DioExceptionType.unknown) {
+        print('⚠️  CORS 또는 네트워크 연결 문제일 가능성이 있습니다.');
+      }
+      
+      return {
+        'success': false,
+        'error': e.message ?? '알 수 없는 에러',
+        'errorType': e.type.toString(),
+        'statusCode': e.response?.statusCode,
+        'responseData': e.response?.data,
+      };
+    } catch (e) {
+      print('=== 일반 에러 발생 ===');
+      print('에러: $e');
+      
+      return {
+        'success': false,
+        'error': e.toString(),
+      };
+    }
+  }
+  
+  /// 직접 Dio로 테스트 (인터셉터 없이)
+  Future<Map<String, dynamic>> checkHealthDirect() async {
+    try {
+      print('=== 직접 Dio 헬스체크 시작 ===');
+      
+      final dio = Dio(BaseOptions(
+        baseUrl: Environment.apiBaseUrl,
+        connectTimeout: const Duration(seconds: 10),
+        receiveTimeout: const Duration(seconds: 10),
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        },
+      ));
+      
+      // 로깅 인터셉터만 추가
+      dio.interceptors.add(LogInterceptor(
+        requestBody: true,
+        responseBody: true,
+        requestHeader: true,
+        responseHeader: true,
+        error: true,
+      ));
+      
+      final response = await dio.get('/health');
+      
+      return {
+        'success': true,
+        'data': response.data,
+        'statusCode': response.statusCode,
+      };
+    } catch (e) {
+      print('직접 Dio 에러: $e');
+      return {
+        'success': false,
+        'error': e.toString(),
+      };
+    }
+  }
+}

lib/services/health_test_service.dart

@@ -0,0 +1,193 @@
+import 'package:get_it/get_it.dart';
+import 'package:superport/services/auth_service.dart';
+import 'package:superport/services/dashboard_service.dart';
+import 'package:superport/services/equipment_service.dart';
+import 'package:superport/services/warehouse_service.dart';
+import 'package:superport/services/company_service.dart';
+import 'package:superport/core/utils/debug_logger.dart';
+import 'package:superport/models/company_model.dart';
+
+/// API 상태 테스트 서비스
+class HealthTestService {
+  final AuthService _authService = GetIt.instance<AuthService>();
+  final DashboardService _dashboardService = GetIt.instance<DashboardService>();
+  final EquipmentService _equipmentService = GetIt.instance<EquipmentService>();
+  final WarehouseService _warehouseService = GetIt.instance<WarehouseService>();
+  final CompanyService _companyService = GetIt.instance<CompanyService>();
+  
+  /// 모든 주요 API 엔드포인트 테스트
+  Future<Map<String, dynamic>> checkAllEndpoints() async {
+    final results = <String, dynamic>{};
+    
+    // 1. 인증 상태 확인
+    try {
+      final isAuthenticated = await _authService.isLoggedIn();
+      final accessToken = await _authService.getAccessToken();
+      final refreshToken = await _authService.getRefreshToken();
+      
+      results['auth'] = {
+        'success': isAuthenticated,
+        'accessToken': accessToken != null,
+        'refreshToken': refreshToken != null,
+      };
+      DebugLogger.log('인증 상태', tag: 'HEALTH_TEST', data: results['auth']);
+    } catch (e) {
+      results['auth'] = {'success': false, 'error': e.toString()};
+    }
+    
+    // 2. 대시보드 API 체크
+    try {
+      DebugLogger.log('대시보드 API 체크 시작', tag: 'HEALTH_TEST');
+      
+      // Overview Stats
+      final statsResult = await _dashboardService.getOverviewStats();
+      results['dashboard_stats'] = {
+        'success': statsResult.isRight(),
+        'error': statsResult.fold((l) => l.message, (r) => null),
+        'data': statsResult.fold((l) => null, (r) => {
+          'totalEquipment': r.totalEquipment,
+          'totalCompanies': r.totalCompanies,
+          'totalUsers': r.totalUsers,
+          'availableEquipment': r.availableEquipment,
+        }),
+      };
+      
+      // Equipment Status Distribution
+      final statusResult = await _dashboardService.getEquipmentStatusDistribution();
+      results['equipment_status_distribution'] = {
+        'success': statusResult.isRight(),
+        'error': statusResult.fold((l) => l.message, (r) => null),
+        'data': statusResult.fold((l) => null, (r) => {
+          'available': r.available,
+          'inUse': r.inUse,
+          'maintenance': r.maintenance,
+          'disposed': r.disposed,
+        }),
+      };
+      
+      DebugLogger.log('대시보드 API 결과', tag: 'HEALTH_TEST', data: results);
+    } catch (e) {
+      results['dashboard'] = {'success': false, 'error': e.toString()};
+    }
+    
+    // 3. 장비 API 체크
+    try {
+      DebugLogger.log('장비 API 체크 시작', tag: 'HEALTH_TEST');
+      
+      final equipments = await _equipmentService.getEquipments(page: 1, perPage: 5);
+      results['equipments'] = {
+        'success': true,
+        'count': equipments.length,
+        'sample': equipments.take(2).map((e) => {
+          'id': e.id,
+          'name': e.name,
+          'manufacturer': e.manufacturer,
+          'category': e.category,
+        }).toList(),
+      };
+      
+      DebugLogger.log('장비 API 결과', tag: 'HEALTH_TEST', data: results['equipments']);
+    } catch (e) {
+      results['equipments'] = {'success': false, 'error': e.toString()};
+    }
+    
+    // 4. 입고지 API 체크
+    try {
+      DebugLogger.log('입고지 API 체크 시작', tag: 'HEALTH_TEST');
+      
+      final warehouses = await _warehouseService.getWarehouseLocations();
+      results['warehouses'] = {
+        'success': true,
+        'count': warehouses.length,
+        'sample': warehouses.take(2).map((w) => {
+          'id': w.id,
+          'name': w.name,
+          'address': w.address.toString(),
+        }).toList(),
+      };
+      
+      DebugLogger.log('입고지 API 결과', tag: 'HEALTH_TEST', data: results['warehouses']);
+    } catch (e) {
+      results['warehouses'] = {'success': false, 'error': e.toString()};
+    }
+    
+    // 5. 회사 API 체크
+    try {
+      DebugLogger.log('회사 API 체크 시작', tag: 'HEALTH_TEST');
+      
+      final companies = await _companyService.getCompanies();
+      results['companies'] = {
+        'success': true,
+        'count': companies.length,
+        'sample': companies.take(2).map((c) => {
+          'id': c.id,
+          'name': c.name,
+          'companyTypes': c.companyTypes.map((t) => companyTypeToString(t)).toList(),
+        }).toList(),
+      };
+      
+      DebugLogger.log('회사 API 결과', tag: 'HEALTH_TEST', data: results['companies']);
+    } catch (e) {
+      results['companies'] = {'success': false, 'error': e.toString()};
+    }
+    
+    return results;
+  }
+  
+  /// 특정 엔드포인트만 체크
+  Future<Map<String, dynamic>> checkEndpoint(String endpoint) async {
+    switch (endpoint) {
+      case 'dashboard':
+        final result = await _dashboardService.getOverviewStats();
+        return {
+          'success': result.isRight(),
+          'error': result.fold((l) => l.message, (r) => null),
+          'data': result.fold((l) => null, (r) => r.toJson()),
+        };
+      
+      case 'equipments':
+        try {
+          final equipments = await _equipmentService.getEquipments(page: 1, perPage: 10);
+          return {
+            'success': true,
+            'count': equipments.length,
+            'data': equipments.map((e) => e.toJson()).toList(),
+          };
+        } catch (e) {
+          return {'success': false, 'error': e.toString()};
+        }
+        
+      case 'warehouses':
+        try {
+          final warehouses = await _warehouseService.getWarehouseLocations();
+          return {
+            'success': true,
+            'count': warehouses.length,
+            'data': warehouses.map((w) => {
+              'id': w.id,
+              'name': w.name,
+              'address': w.address.toString(),
+              'remark': w.remark,
+            }).toList(),
+          };
+        } catch (e) {
+          return {'success': false, 'error': e.toString()};
+        }
+        
+      case 'companies':
+        try {
+          final companies = await _companyService.getCompanies();
+          return {
+            'success': true,
+            'count': companies.length,
+            'data': companies.map((c) => c.toJson()).toList(),
+          };
+        } catch (e) {
+          return {'success': false, 'error': e.toString()};
+        }
+        
+      default:
+        return {'success': false, 'error': 'Unknown endpoint: $endpoint'};
+    }
+  }
+}

lib/services/mock_data_service.dart

@@ -273,6 +273,7 @@ class MockDataService {
         companyId: 1,
         name: '홍길동',
         role: 'S', // 관리자
+        email: 'admin@superport.com',
       ),
     );
 
@@ -281,6 +282,7 @@ class MockDataService {
         companyId: 1,
         name: '김철수',
         role: 'M', // 멤버
+        email: 'kim.cs@samsung.com',
       ),
     );
 

lib/services/warehouse_service.dart

@@ -26,8 +26,11 @@ class WarehouseService {
 
       return response.items.map((dto) => _convertDtoToWarehouseLocation(dto)).toList();
     } on ApiException catch (e) {
+      print('[WarehouseService] ApiException: ${e.message}');
       throw ServerFailure(message: e.message);
-    } catch (e) {
+    } catch (e, stackTrace) {
+      print('[WarehouseService] Error loading warehouse locations: $e');
+      print('[WarehouseService] Stack trace: $stackTrace');
       throw ServerFailure(message: '창고 위치 목록을 불러오는 데 실패했습니다: $e');
     }
   }
@@ -149,29 +152,30 @@ class WarehouseService {
 
   // DTO를 Flutter 모델로 변환
   WarehouseLocation _convertDtoToWarehouseLocation(WarehouseLocationDto dto) {
-    // 주소 조합
-    final addressParts = <String>[];
-    if (dto.address != null && dto.address!.isNotEmpty) {
-      addressParts.add(dto.address!);
-    }
-    if (dto.city != null && dto.city!.isNotEmpty) {
-      addressParts.add(dto.city!);
-    }
-    if (dto.state != null && dto.state!.isNotEmpty) {
-      addressParts.add(dto.state!);
-    }
-
+    // API에 주소 정보가 없으므로 기본값 사용
     final address = Address(
       zipCode: dto.postalCode ?? '',
       region: dto.city ?? '',
-      detailAddress: addressParts.join(' '),
+      detailAddress: dto.address ?? '주소 정보 없음',
     );
+    
+    // 담당자 정보 조합
+    final remarkParts = <String>[];
+    if (dto.code != null) {
+      remarkParts.add('코드: ${dto.code}');
+    }
+    if (dto.managerName != null) {
+      remarkParts.add('담당자: ${dto.managerName}');
+    }
+    if (dto.managerPhone != null) {
+      remarkParts.add('연락처: ${dto.managerPhone}');
+    }
 
     return WarehouseLocation(
       id: dto.id,
       name: dto.name,
       address: address,
-      remark: dto.managerName != null ? '담당자: ${dto.managerName}' : null,
+      remark: remarkParts.isNotEmpty ? remarkParts.join(', ') : null,
     );
   }