refactor: Repository 패턴 적용 및 Clean Architecture 완성
Some checks failed
Flutter Test & Quality Check / Test on macos-latest (push) Has been cancelled
Flutter Test & Quality Check / Test on ubuntu-latest (push) Has been cancelled
Flutter Test & Quality Check / Build APK (push) Has been cancelled

## 주요 변경사항

### 🏗️ Architecture
- Repository 패턴 전면 도입 (인터페이스/구현체 분리)
- Domain Layer에 Repository 인터페이스 정의
- Data Layer에 Repository 구현체 배치
- UseCase 의존성을 Service에서 Repository로 전환

### 📦 Dependency Injection
- GetIt 기반 DI Container 재구성 (lib/injection_container.dart)
- Repository 인터페이스와 구현체 등록
- Service와 Repository 공존 (마이그레이션 기간)

### 🔄 Migration Status
완료:
- License 모듈 (6개 UseCase)
- Warehouse Location 모듈 (5개 UseCase)

진행중:
- Auth 모듈 (2/5 UseCase)
- Company 모듈 (1/6 UseCase)

대기:
- User 모듈 (7개 UseCase)
- Equipment 모듈 (4개 UseCase)

### 🎯 Controller 통합
- 중복 Controller 제거 (with_usecase 버전)
- 단일 Controller로 통합
- UseCase 패턴 직접 적용

### 🧹 코드 정리
- 임시 파일 제거 (test_*.md, task.md)
- Node.js 아티팩트 제거 (package.json)
- 불필요한 테스트 파일 정리

###  테스트 개선
- Real API 중심 테스트 구조
- Mock 제거, 실제 API 엔드포인트 사용
- 통합 테스트 프레임워크 강화

## 기술적 영향
- 의존성 역전 원칙 적용
- 레이어 간 결합도 감소
- 테스트 용이성 향상
- 확장성 및 유지보수성 개선

## 다음 단계
1. User/Equipment 모듈 Repository 마이그레이션
2. Service Layer 점진적 제거
3. 캐싱 전략 구현
4. 성능 최적화
This commit is contained in:
JiWoong Sul
2025-08-11 20:14:10 +09:00
parent d64aa26157
commit 731dcd816b
105 changed files with 5225 additions and 3941 deletions

View File

@@ -0,0 +1,369 @@
import 'package:dartz/dartz.dart';
import 'package:injectable/injectable.dart';
import '../../core/errors/failures.dart';
import '../../domain/repositories/user_repository.dart';
import '../../models/user_model.dart';
import '../datasources/remote/user_remote_datasource.dart';
import '../models/common/paginated_response.dart';
import '../models/user/user_dto.dart';
/// 사용자 관리 Repository 구현체
/// 사용자 계정 CRUD 및 권한 관리 작업을 처리하며 도메인 모델과 API DTO 간 변환을 담당
@Injectable(as: UserRepository)
class UserRepositoryImpl implements UserRepository {
final UserRemoteDataSource remoteDataSource;
UserRepositoryImpl({required this.remoteDataSource});
@override
Future<Either<Failure, PaginatedResponse<User>>> getUsers({
int? page,
int? limit,
String? search,
String? role,
int? companyId,
bool? isActive,
String? sortBy,
String? sortOrder,
}) async {
try {
final result = await remoteDataSource.getUsers(
page: page ?? 1,
perPage: limit ?? 20,
isActive: isActive,
companyId: companyId,
role: role,
);
// DTO를 도메인 모델로 변환
final users = result.items.map((dto) => _mapDtoToDomain(dto)).toList();
// 검색 필터링 (서버에서 지원하지 않는 경우 클라이언트 측에서 처리)
if (search != null && search.isNotEmpty) {
final filteredUsers = users.where((user) {
final searchLower = search.toLowerCase();
return (user.username?.toLowerCase().contains(searchLower) ?? false) ||
user.name.toLowerCase().contains(searchLower) ||
(user.email?.toLowerCase().contains(searchLower) ?? false);
}).toList();
final paginatedResult = PaginatedResponse<User>(
items: filteredUsers,
page: result.page,
size: result.size,
totalElements: filteredUsers.length,
totalPages: (filteredUsers.length / result.size).ceil(),
first: result.first,
last: result.last,
);
return Right(paginatedResult);
}
final paginatedResult = PaginatedResponse<User>(
items: users,
page: result.page,
size: result.size,
totalElements: result.totalElements,
totalPages: result.totalPages,
first: result.first,
last: result.last,
);
return Right(paginatedResult);
} catch (e) {
return Left(ServerFailure(
message: '사용자 목록 조회 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, User>> getUserById(int id) async {
try {
final result = await remoteDataSource.getUser(id);
final user = _mapDtoToDomain(result);
return Right(user);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '해당 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
return Left(ServerFailure(
message: '사용자 상세 정보 조회 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, User>> createUser(User user, String password) async {
try {
final request = _mapDomainToCreateRequest(user, password);
final result = await remoteDataSource.createUser(request);
final createdUser = _mapDtoToDomain(result);
return Right(createdUser);
} catch (e) {
if (e.toString().contains('중복')) {
return Left(DuplicateFailure(
message: '이미 사용 중인 이메일입니다.',
field: 'username',
value: user.username ?? '',
));
}
if (e.toString().contains('유효성')) {
return Left(ValidationFailure(
message: '입력 데이터가 올바르지 않습니다.',
));
}
return Left(ServerFailure(
message: '사용자 생성 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, User>> updateUser(int id, User user) async {
try {
final request = _mapDomainToUpdateRequest(user);
final result = await remoteDataSource.updateUser(id, request);
final updatedUser = _mapDtoToDomain(result);
return Right(updatedUser);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '수정할 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
if (e.toString().contains('중복')) {
return Left(DuplicateFailure(
message: '이미 사용 중인 이메일입니다.',
field: 'username',
value: user.username ?? '',
));
}
return Left(ServerFailure(
message: '사용자 정보 수정 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, void>> deleteUser(int id) async {
try {
await remoteDataSource.deleteUser(id);
return const Right(null);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '삭제할 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
if (e.toString().contains('참조')) {
return Left(BusinessFailure(
message: '해당 사용자에 연결된 데이터가 있어 삭제할 수 없습니다.',
));
}
return Left(ServerFailure(
message: '사용자 삭제 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, User>> toggleUserStatus(int id) async {
try {
// 현재 사용자 정보 조회
final currentUser = await remoteDataSource.getUser(id);
final newStatus = !currentUser.isActive;
// 상태 업데이트
final request = ChangeStatusRequest(isActive: newStatus);
final updatedUser = await remoteDataSource.changeUserStatus(id, request);
final user = _mapDtoToDomain(updatedUser);
return Right(user);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '상태를 변경할 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
return Left(ServerFailure(
message: '사용자 상태 변경 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, void>> resetPassword(int id, String newPassword) async {
try {
// resetPassword 메서드가 데이터소스에 없으므로 changePassword 사용
final request = ChangePasswordRequest(currentPassword: '', newPassword: newPassword);
await remoteDataSource.changePassword(id, request);
return const Right(null);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '비밀번호를 재설정할 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
return Left(ServerFailure(
message: '비밀번호 재설정 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, User>> changeUserRole(int id, String newRole) async {
try {
// changeUserRole 메서드가 데이터소스에 없으므로 updateUser 사용
final request = UpdateUserRequest(role: newRole);
final updatedUser = await remoteDataSource.updateUser(id, request);
final user = _mapDtoToDomain(updatedUser);
return Right(user);
} catch (e) {
if (e.toString().contains('404')) {
return Left(NotFoundFailure(
message: '역할을 변경할 사용자를 찾을 수 없습니다.',
resourceType: 'User',
resourceId: id.toString(),
));
}
return Left(ServerFailure(
message: '사용자 역할 변경 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, bool>> isDuplicateUsername(String username, {int? excludeId}) async {
try {
final isDuplicate = await remoteDataSource.checkDuplicateUsername(username);
// excludeId가 있는 경우 해당 ID 제외 로직 추가 필요
return Right(isDuplicate);
} catch (e) {
return Left(ServerFailure(
message: '중복 사용자명 확인 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, List<User>>> getUsersByCompany(int companyId, {bool includeInactive = false}) async {
try {
// getUsersByCompany 메서드가 없으므로 getUsers로 대체
final result = await remoteDataSource.getUsers(
companyId: companyId,
isActive: includeInactive ? null : true,
);
final users = result.users.map((dto) => _mapDtoToDomain(dto)).toList();
return Right(users);
} catch (e) {
return Left(ServerFailure(
message: '회사별 사용자 조회 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, Map<String, int>>> getUserCountByRole() async {
// TODO: API에서 역할별 사용자 수 통계 기능이 구현되면 추가
return const Left(ServerFailure(
message: '역할별 사용자 수 통계 기능이 아직 구현되지 않았습니다.',
));
}
@override
Future<Either<Failure, List<User>>> searchUsers(String query, {int? companyId, int? limit}) async {
try {
final result = await remoteDataSource.searchUsers(
query: query,
companyId: companyId,
perPage: limit ?? 10,
);
final users = result.users.map((dto) => _mapDtoToDomain(dto)).toList();
return Right(users);
} catch (e) {
return Left(ServerFailure(
message: '사용자 검색 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
@override
Future<Either<Failure, void>> updateLastLoginTime(int id) async {
try {
// updateLastLoginTime 메서드가 데이터소스에 없으므로 비어있는 구현
// TODO: API에서 지원되면 구현
throw UnimplementedError('마지막 로그인 시간 업데이트 기능이 아직 구현되지 않았습니다.');
return const Right(null);
} catch (e) {
return Left(ServerFailure(
message: '마지막 로그인 시간 업데이트 중 오류가 발생했습니다: ${e.toString()}',
));
}
}
// Private 매퍼 메서드들
User _mapDtoToDomain(UserDto dto) {
return User(
id: dto.id,
companyId: dto.companyId ?? 0,
branchId: dto.branchId,
name: dto.name,
role: dto.role,
email: dto.email,
phoneNumbers: dto.phone != null ? [{'type': 'primary', 'number': dto.phone!}] : [],
username: dto.username,
isActive: dto.isActive,
createdAt: dto.createdAt,
updatedAt: dto.updatedAt,
);
}
// _mapDetailDtoToDomain 함수는 더 이상 사용하지 않음 - _mapDtoToDomain 사용
// _mapResponseToDomain 함수는 더 이상 사용하지 않음 - _mapDtoToDomain 사용
// UserRole enum은 더 이상 필요하지 않음 - String role을 직접 사용
CreateUserRequest _mapDomainToCreateRequest(User user, String password) {
return CreateUserRequest(
username: user.username ?? user.email ?? '',
password: password,
name: user.name,
email: user.email,
phone: user.phoneNumbers.isNotEmpty ? user.phoneNumbers.first['number'] : null,
role: user.role,
companyId: user.companyId,
branchId: user.branchId,
);
}
UpdateUserRequest _mapDomainToUpdateRequest(User user) {
return UpdateUserRequest(
name: user.name,
email: user.email,
phone: user.phoneNumbers.isNotEmpty ? user.phoneNumbers.first['number'] : null,
role: user.role,
companyId: user.companyId,
branchId: user.branchId,
isActive: user.isActive,
);
}
// _mapRoleToString 함수는 더 이상 필요하지 않음 - role을 직접 String으로 사용
}