Feature/user use case

DailyQuest/DailyQuest/Application/DIContainer/SettingsSceneDIContainer.swift

@@ -8,27 +8,54 @@
 import UIKit
 
 final class SettingsSceneDIContainer {
-
+
+    lazy var userInfoStorage: UserInfoStorage = RealmUserInfoStorage()
+
     // MARK: - Repositories
     func makeAuthRepository() -> AuthRepository {
         return DefaultAuthRepository()
     }
-
+
+    func makeUserRepository() -> UserRepository {
+        return DefaultUserRepository(persistentStorage: userInfoStorage)
+    }
+
     // MARK: - Use Cases
     func makeAuthUseCase() -> AuthUseCase {
         return DefaultAuthUseCase(authRepository: makeAuthRepository())
     }
-
+
+    func makeSettingsUseCase() -> SettingsUseCase {
+        return DefaultSettingsUseCase(userRepository: makeUserRepository(),
+                                      authRepository: makeAuthRepository())
+    }
+
     // MARK: - View Models
     func makeLoginViewModel() -> LoginViewModel {
         return LoginViewModel(authUseCase: makeAuthUseCase())
     }
+
+    func makeSignUpViewModel() -> SignUpViewModel {
+        return SignUpViewModel(authUseCase: makeAuthUseCase())
+    }
 
+    func makeSettingsViewModel() -> SettingsViewModel {
+        return SettingsViewModel(settingsUseCase: makeSettingsUseCase())
+    }
+
     // MARK: - View Controller
     func makeLoginViewController() -> LoginViewController {
         return LoginViewController.create(with: makeLoginViewModel())
     }
+
+    func makeSignUpViewController() -> SignUpViewController {
+        return SignUpViewController.create(with: makeSignUpViewModel())
+    }
 
+    func makeSettingsViewController() -> SettingsViewController {
+        return SettingsViewController.create(with: makeSettingsViewModel())
+    }
+
     // MARK: - Flow
     func makeSettingsCoordinator(navigationController: UINavigationController,
                                  settingsSceneDIContainer: SettingsSceneDIContainer) -> SettingsCoordinator {

DailyQuest/DailyQuest/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -1,6 +1,15 @@
 {
   "colors" : [
     {
+      "color" : {
+        "color-space" : "srgb",
+        "components" : {
+          "alpha" : "1.000",
+          "blue" : "0.490",
+          "green" : "0.871",
+          "red" : "1.000"
+        }
+      },
       "idiom" : "universal"
     }
   ],

DailyQuest/DailyQuest/Data/Network/DataMapping/UserDTO+Mapping.swift

@@ -32,6 +32,15 @@ struct UserDTO: DTO {
         self.description = user.description
         self.allow = user.allow
     }
+
+    init(uuid: String, userDto: UserDTO) {
+        self.uuid = uuid
+        self.nickName = userDto.nickName
+        self.profileURL = userDto.profileURL
+        self.backgroundImageURL = userDto.backgroundImageURL
+        self.description = userDto.description
+        self.allow = userDto.allow
+    }
 }
 
 extension UserDTO {

DailyQuest/DailyQuest/Data/PersistentStorages/RealmStorage/RealmStorage.swift

@@ -77,6 +77,7 @@ final class RealmStorage {
         return entity
     }
 
+    @discardableResult
     func deleteAllEntity<O: Object>(type: O.Type) throws -> [O] {
         guard let persistentContainer = persistentContainer else {
             print(#function)

DailyQuest/DailyQuest/Data/Repositories/DefaultAuthRepository.swift

@@ -25,4 +25,8 @@ extension DefaultAuthRepository: AuthRepository {
     func signOut() -> Single<Bool> {
         return self.networkService.signOut()
     }
+
+    func signUp(email: String, password: String, user: User) -> Single<Bool> {
+        return self.networkService.signUp(email: email, password: password, userDto: user.toDTO())
+    }
 }

DailyQuest/DailyQuest/Data/Repositories/DefaultBrowseRepository.swift

@@ -12,15 +12,12 @@ final class DefaultBrowseRepository {
 
     private let persistentStorage: BrowseQuestsStorage
     private let networkService: NetworkService
-
-    private let disposeBag: DisposeBag
+    private let disposeBag: DisposeBag = DisposeBag()
 
     init(persistentStorage: BrowseQuestsStorage,
-         networkService: NetworkService = FirebaseService.shared,
-         repositoryManager: RepositoryManager = RepositoryManager.shared) {
+         networkService: NetworkService = FirebaseService.shared) {
         self.persistentStorage = persistentStorage
         self.networkService = networkService
-        self.disposeBag = repositoryManager.disposeBag
     }
 }
 
@@ -32,36 +29,39 @@ extension DefaultBrowseRepository: BrowseRepository {
     func fetch() -> Observable<[BrowseQuest]> {
         return self.networkService.getAllowUsers(limit: 10)
             .map { $0.toDomain() }
-            .flatMap { user in
-            self.networkService
-                .read(type: QuestDTO.self, userCase: .anotherUser(user.uuid), access: .quests, filter: .today(Date()))
-                .map { $0.toDomain() }
-                .toArray()
-                .asObservable()
-                .map { questList in
-                return BrowseQuest(user: user, quests: questList)
-            }
-        }
-
+            .flatMap(fetchBrowseQuestNetworkService(user:))
             .filter { !$0.quests.isEmpty }
             .toArray()
             .asObservable()
-            .do(afterNext: { browseQuests in
+            .do(afterNext: { [weak self] browseQuests in
+            guard let self = self else { return }
             self.persistentStorage.deleteBrowseQuests()
                 .asObservable()
                 .concatMap { _ in
                 Observable.from(browseQuests)
-                    .flatMap { browseQuest in
-                    self.persistentStorage.saveBrowseQuest(browseQuest: browseQuest)
-                        .asObservable()
-                }
+                    .flatMap (self.saveBrowseQuestPersistentStorage(browseQuest:))
             }
-                .subscribe(onError: { error in
-                print(error)
-                }).disposed(by: self.disposeBag)
+                .subscribe()
+                .disposed(by: self.disposeBag)
         })
             .catch { error in
             return self.persistentStorage.fetchBrowseQuests()
         }
     }
 }
+
+private extension DefaultBrowseRepository {
+    func fetchBrowseQuestNetworkService(user: User) -> Observable<BrowseQuest> {
+        networkService
+            .read(type: QuestDTO.self, userCase: .anotherUser(user.uuid), access: .quests, filter: .today(Date()))
+            .map { $0.toDomain() }
+            .toArray()
+            .asObservable()
+            .map { return BrowseQuest(user: user, quests: $0) }
+    }
+
+    func saveBrowseQuestPersistentStorage(browseQuest: BrowseQuest) -> Observable<BrowseQuest> {
+        persistentStorage.saveBrowseQuest(browseQuest: browseQuest)
+            .asObservable()
+    }
+}

DailyQuest/DailyQuest/Data/Repositories/DefaultQuestsRepository.swift

@@ -9,10 +9,10 @@ import RxSwift
 import Foundation
 
 final class DefaultQuestsRepository {
-    
+
     private let persistentStorage: QuestsStorage
     private let networkService: NetworkService
-    
+
     init(persistentStorage: QuestsStorage, networkService: NetworkService = FirebaseService.shared) {
         self.persistentStorage = persistentStorage
         self.networkService = networkService
@@ -22,74 +22,86 @@ final class DefaultQuestsRepository {
 extension DefaultQuestsRepository: QuestsRepository {
     func save(with quest: [Quest]) -> Single<[Quest]> {
         return persistentStorage.saveQuests(with: quest)
-            .flatMap { quests in
-                return Observable.from(quests)
-                    .withUnretained(self)
-                    .concatMap { (owner, quest) in
-                        return owner.networkService.create(userCase: .currentUser,
-                                                          access: .quests,
-                                                          dto: quest.toDTO())
-                        .map { $0.toDomain() }
-                        .catchAndReturn(quest)
-                    }
-                    .toArray()
+            .flatMap (saveNetworkService(quests:))
+            .do{ event in
+                print("save", event)
             }
     }
-    
+
     func fetch(by date: Date) -> Observable<[Quest]> {
         return persistentStorage.fetchQuests(by: date)
-            .catch { _ in
-                self.networkService.read(type: QuestDTO.self, userCase: .currentUser, access: .quests, filter: .today(date))
-                    .map { $0.toDomain() }
-                    .toArray()
-                    .asObservable()
-            }
+            .catch { [weak self] _ in
+            guard let self = self else { return Observable.just([]) }
+            return self.fetchNetworkService(date: date)
+        }
+            .catchAndReturn([])
     }
-    
+
     func update(with quest: Quest) -> Single<Quest> {
         return persistentStorage.updateQuest(with: quest)
             .flatMap(updateNetworkService(quest:))
     }
-    
+
     func delete(with questId: UUID) -> Single<Quest> {
         return persistentStorage.deleteQuest(with: questId)
-            .flatMap { quest in
-                self.networkService.delete(userCase: .currentUser, access: .quests, dto: quest.toDTO())
-            }
-            .map { $0.toDomain() }
-            .asObservable()
-            .asSingle()
+            .flatMap(deleteNetworkService(quest:))
     }
-    
+
     func deleteAll(with groupId: UUID) -> Single<[Quest]> {
         return persistentStorage.deleteQuestGroup(with: groupId)
-            .flatMap { quests in
-                return Observable.from(quests)
-                    .concatMap { quest in
-                        self.networkService.delete(userCase: .currentUser,
-                                                   access: .quests,
-                                                   dto: quest.toDTO())
-                    }
-                    .map { $0.toDomain() }
-                    .toArray()
-            }
+            .flatMap(deleteAllNetworkService(quests:))
     }
-    
-    func fetch(by uuid: String, date: Date) -> Observable<[Quest]> { // 받을 날짜까지 받아와야함
-        return self.networkService.read(type: QuestDTO.self,
-                                        userCase: .anotherUser(uuid),
-                                        access: .quests,
-                                        filter: .today(date))
-        .map { $0.toDomain() }
-        .toArray()
-        .asObservable()
+
+    func fetch(by uuid: String, date: Date) -> Observable<[Quest]> {
+        return networkService.read(type: QuestDTO.self,
+                                   userCase: .anotherUser(uuid),
+                                   access: .quests,
+                                   filter: .today(date))
+            .map { $0.toDomain() }
+            .toArray()
+            .asObservable()
     }
 }
 
 private extension DefaultQuestsRepository {
+    func saveNetworkService(quests: [Quest]) -> Single<[Quest]> {
+        return Observable.from(quests)
+            .withUnretained(self)
+            .concatMap { (owner, quest) in
+            return owner.networkService.create(userCase: .currentUser,
+                                               access: .quests,
+                                               dto: quest.toDTO())
+                .map { $0.toDomain() }
+                .catchAndReturn(quest)
+        }
+            .toArray()
+    }
+
+    func fetchNetworkService(date: Date) -> Observable<[Quest]> {
+        return networkService.read(type: QuestDTO.self, userCase: .currentUser, access: .quests, filter: .today(date))
+            .map { $0.toDomain() }
+            .toArray()
+            .asObservable()
+            .catchAndReturn([])
+    }
+
     func updateNetworkService(quest: Quest) -> Single<Quest> {
         return networkService.update(userCase: .currentUser, access: .quests, dto: quest.toDTO())
             .map { $0.toDomain() }
             .catchAndReturn(quest)
     }
+
+    func deleteNetworkService(quest: Quest) -> Single<Quest> {
+        self.networkService.delete(userCase: .currentUser, access: .quests, dto: quest.toDTO())
+            .map { $0.toDomain() }
+            .catchAndReturn(quest)
+    }
+
+    func deleteAllNetworkService(quests: [Quest]) -> Single<[Quest]> {
+        Observable.from(quests)
+            .concatMap(deleteNetworkService(quest:))
+            .toArray()
+            .catchAndReturn(quests)
+    }
+
 }