사람인 iOS App Refactoring

struct Analysis: Codable {
    struct Result: Codable {
        var result: Report?
    }
    
    struct Report: Codable {
        var tips: Tips?
        var character: Character?
        var aptitude: Aptitude?
        var keywords: [String]?
        
        enum CodingKeys: String, CodingKey {
            case tips
            case character
            case aptitude
            case keywords = "keyword"
        }
    }
//...

protocol AnalysisResultUseCase {
    func requestAnalysisReport(token: String, termNo: UInt) -> Observable<Model.Analysis.Result>
}

// DomainLayer 정의된 AnalysisResultUseCase 실제 구현 
class NetworkAnalysisResultUseCase: AnalysisResultUseCase {

    private let network: Network<Model.Analysis.Result>

    init(network: Network<Model.Analysis.Result>) {
        self.network = network
    }
    
    func requestAnalysisReport(token: String, termNo: UInt) -> Observable<Model.Analysis.Result> {
        let router = Router.analysisReport(token: token, termNo: termNo)
        return network.getItem(router.path, parameters: router.parameters, headers: router.headers)
    }
}

class Network<T: Decodable> {
    
    private let endPoint: String
    private let scheduler: ConcurrentDispatchQueueScheduler
    
    init(_ endPoint: String) {
        self.endPoint = endPoint
        self.scheduler = ConcurrentDispatchQueueScheduler(qos: DispatchQoS(qosClass: DispatchQoS.QoSClass.background, relativePriority: 1))
    }
    
    private func makeHeaders(headers: HTTPHeaders? = nil) -> HTTPHeaders? {
        var makeHeaders = headers
        if let userAgent = HTTPHeaders.default.dictionary["User-Agent"]  {
            makeHeaders?.add(name: "User-Agent", value: userAgent)
        }
        return makeHeaders
    }
    
    func getItem(_ path: String,
                 parameters: [String: Any]? = nil,
                 encoding: ParameterEncoding = URLEncoding.default,
                 headers: HTTPHeaders? = nil) -> Observable<T> {
        let absolutePath = "\(endPoint)\(path)"
        return RxAlamofire
            .request(.get,
                     absolutePath,
                     parameters: parameters,
                     encoding: encoding,
                     headers: makeHeaders(headers: headers))
            .observeOn(scheduler)
            .responseData()
            .flatMap { response, data -> Observable<(String, [String: Any]?, HTTPHeaders?, HTTPURLResponse, Data)> in
                let temp = (absolutePath, parameters, headers, response, data)
                return Observable.just(temp)
            }
            .validationResultThrowError(ofType: T.self)
    }
//...

class ReportViewController: BaseViewController {
    
    @IBOutlet private weak var tableView: UITableView!
    
    private var dataSource: RxReloadDataSource<Section>!
    private var disposeBag = DisposeBag()
    
    var viewModel: ReportViewModel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
    }
    
    override func layout() {
        tableView.registerCell(AnalysisReportTitleTableViewCell.self)
        //...
    }

    override func bindView() {
        initDataSource()
        //...
    }

    override func bindViewModel() {
        
        let loadTrigger = Observable.just(())
        let totalReport = analysisReportSectionView.rx.segmentIndex
            .filter { $0 == 0 }
            .mapToVoid()

        let input = ReportViewModel.Input(loadTrigger: loadTrigger.asDriverOnErrorJustComplete(),
                                          totalReportTrigger: totalReport.asDriverOnErrorJustComplete(),
																					//...
                                          toHintTrigger: hintButtonClicked.asDriverOnErrorJustComplete())

        let output = viewModel.transform(input: input)

        output.sections
            .debug("sections")
            .drive(tableView.rx.items(dataSource: self.dataSource))
            .disposed(by: disposeBag)
        //...
    }
//...

final class ReportViewModel: BaseViewModel {

    // protocol
    private let navigator: CompletedInterviewNavigatorType
    private let popupNavigator: PopupNavigatorType
    private let analysisUseCase: AnalysisResultUseCase
    //...
    private var auth: AppAuthProtocol
    private var data: CompletedInterviewData
    
    private var disposeBag = DisposeBag()
		
    // 의존성 주입
    init(navigator: CompletedInterviewNavigatorType,
         popupNavigator: PopupNavigatorType,
         analysisUseCase: AnalysisResultUseCase,
         //...
         auth: AppAuthProtocol,
         data: CompletedInterviewData) {
        
        self.navigator = navigator
        self.popupNavigator = popupNavigator
        self.analysisUseCase = analysisUseCase
        //...
        self.auth = auth
        self.data = data
        super.init(serviceCheckUseCase: serviceCheckUseCase)
    }
}

extension ReportViewModel: ViewModel {
    
    enum InputTrigger: Trigger {
        case totalReport
    }
    
    struct Input {
        let loadTrigger: Driver<Void>
        let totalReportTrigger: Driver<Void>
        //...
        let toHintTrigger: Driver<HintType>
    }
    
    struct Output {
        let sections: Driver<[Section]>
        //...
        let error: Driver<(Trigger, Swift.Error)>
    }
    
    func transform(input: Input) -> Output {
        
        let activityIndicator = ActivityIndicator()
        activityIndicator.drive(App.progress.rx.animation).disposed(by: disposeBag)

        let sectionsBehaviorRelay = BehaviorRelay<[Section]>(value: [])
        let videoReportPublishRelay = PublishRelay<Void>()
        
        // MARK: API
        let refreshToken: ( (_ trigger: InputTrigger) -> Observable<Model.Auth>)
            = { [weak self] trigger in
                guard let `self` = self else { return Observable.empty() }
                return self.requestRefreshToken(authManager: self.auth,
                                           authUseCase: self.authUseCase,
                                           userUseCase: self.userUseCase,
                                           msgTokenUseCase: self.msgTokenUseCase,
                                           trigger: trigger,
                                           activityIndicator: activityIndicator,
                                           errorPublishRelay: self.errorPublishRelay)
            }
        
        let requestTotalReport = refreshToken(.totalReport)
            .flatMapLatest { [weak self] auth -> Observable<Model.Analysis.Result> in
                guard let `self` = self else {
                    return Observable.empty()
                }
                return self.analysisUseCase
                    .requestAnalysisReport(token: auth.accessToken,
                                           termNo: self.data.termNo)
                    .debug("requestAnalysisReport, 미디어 파일 요청")
                    .trackActivity(activityIndicator)
                    .catchErrorAcceptComplete(self.errorPublishRelay, InputTrigger.totalReport)
            }

        // MARK: Trigger
        input.loadTrigger
            .debug("loadTrigger")
            .drive(onNext: { [weak self] _ in
                guard let `self` = self else { return }
                let items: [Section] = [.section(items: [.title(self.data)])]
                sectionsBehaviorRelay.accept(items)
            }).disposed(by: disposeBag)
        
        input.totalReportTrigger.asObservable()
            .debug("totalReportTrigger")
            .flatMapLatest { _ in
                return requestTotalReport
            }.subscribe(onNext: { [weak self] result in
                guard let `self` = self, let result = result.result else { return }
                let reportDatas = ReportViewType.total(report: result, itemTypeCode: self.data.itemTypeCode).datas
                let section = self.createSection(interview: self.data, reportDatas: reportDatas)
                sectionsBehaviorRelay.accept(section)
                scrollPublishRelay.accept((section: 0, row: 0))
            }).disposed(by: disposeBag)
        
        //...
        return Output(sections: sectionsBehaviorRelay.asDriverOnErrorJustComplete(),
																					 error: errorPublishRelay.asDriverOnErrorJustComplete())
    }
//...

class AppDelegate: UIResponder, UIApplicationDelegate {

    var window: UIWindow?
    
    private var disposeBag = DisposeBag()

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        
        //...
        AppNavigator.shared.start(window: window)
    }
//...

final class AppNavigator {
    
    static let shared = AppNavigator()
    // ViewModel에 의존성 주입하기 위한 객체 정의 (API, DB, Socket 등..) 
    private let networkProvider: UseCaseProvider
    
    private init() {
        networkProvider = NetworkUseCaseProvider()
    }
    
    func start(window: UIWindow) {
        let intro = UIStoryboard.init(storyboard: .main).instantiateViewController(ofType: RIntroViewController.self)
        
        let navigationController = BaseNavigationController(rootViewController: intro)
        
        let homeNavigator = HomeNavigator(networkProvider: networkProvider,
                                          parentNavigationController: navigationController,
                                          navigationController: nil,
                                          storyBoard: .init(storyboard: .home))
        
        let popupNavigator = PopupNavigator(networkProvider: networkProvider,
                                            parentNavigationController: navigationController,
                                            navigationController: nil,
                                            storyBoard: .init(storyboard: .popup))
        
        intro.viewModel = IntroViewModel(homeNavigator: homeNavigator,
                                         popupNavigator: popupNavigator,
                                         serviceCheckUseCase: networkProvider.makeServiceCheckUseCase(),
                                         authUseCase: networkProvider.makeAuthUseCase(),
                                         versionsUseCase: networkProvider.makeVersionsUseCase(),
                                         //...
                                         remoteConfig: RemoteConfigManager())
        window.rootViewController = navigationController
        window.makeKeyAndVisible()
    }
}

protocol HomeNavigatorType {
    func pop(animated: Bool, completion: @escaping () -> Void)
    func dismissToMain(animated: Bool, completion: (() -> Void)?)
    
    func toHome(_ type: TransitionType)
    func toLogin(_ type: TransitionType)
    //...
}

final class HomeNavigator: BaseNavigator, HomeNavigatorType {
    
    override init(networkProvider: UseCaseProvider,
                  parentNavigationController: UINavigationController?,
                  navigationController: BaseNavigationController?,
                  storyBoard: UIStoryboard) {

        super.init(networkProvider: networkProvider,
                   parentNavigationController: parentNavigationController,
                   navigationController: navigationController,
                   storyBoard: storyBoard)
    }
    
    func toHome(_ type: TransitionType) {
        
        let home = storyBoard.instantiateViewController(ofType: HomeViewController.self)
    
        //...
        let contentViewControllers: [BaseViewController] = [interview, main, msgList]
        home.viewModel = HomeViewModel(navigator: self,
                                       serviceCheckUseCase: networkProvider.makeServiceCheckUseCase(),
                                       msgTokenUseCase: networkProvider.makeMsgTokenUseCase(),
                                       authUseCase: networkProvider.makeAuthUseCase(),
                                       userUseCase: networkProvider.makeUserUseCase(),
                                       homeUseCase: networkProvider.makeHomeUseCase(),
                                       msgUnreadUseCase: networkProvider.makeMsgUnreadUseCase(),
                                       freeApplyUseCase: networkProvider.makeFreeApplyUseCase(),
                                       auth: App.rAuth,
                                       homeDataManager: App.homeManager,
                                       contentViewControllers: contentViewControllers)
        toNavigation(type, home)
    }

    func toLogin(_ type: TransitionType) {
        let navigator = PopupNavigator(networkProvider: networkProvider,
                                       parentNavigationController: navigationController,
                                       navigationController: nil,
                                       storyBoard: .init(storyboard: .popup))
        navigator.toLogin(type, loginFromEvent: nil, dismissIntro: nil)
    }
//...
}

final class HomeViewModel: BaseViewModel {
    
  private let navigator: HomeNavigatorType
	private let homeUseCase: HomeUseCase
	private var auth: AppAuthProtocol
	//...
 
    init(navigator: HomeNavigatorType,
         serviceCheckUseCase: ServiceCheckUseCase,
         homeUseCase: HomeUseCase,
         //...
         auth: AppAuthProtocol) {
        
        self.navigator = navigator
        self.authUseCase = authUseCase
        self.homeUseCase = homeUseCase
        //...
        self.auth = auth
        super.init(serviceCheckUseCase: serviceCheckUseCase)
    }
}

extension HomeViewModel: ViewModel {
    
    enum InputTrigger: Trigger {
        case home
        //...
    }

    struct Input {
        let loadHomeTrigger: Driver<Bool>
        let unreadMsgTrigger: Driver<Bool>
        let retryFreeApplyTrigger: Observable<Void>
        let deepLinkWithLoginTrigger: BehaviorSubject<TargetType?>
        //...
    }

    struct Output {
        //...
        let error: Driver<(Trigger, Swift.Error)>
    }

    func transform(input: Input) -> Output {
        let activityIndicator = ActivityIndicator()
        activityIndicator.drive(App.progress.rx.animation).disposed(by: disposeBag)
       
        //...
        input.deepLinkWithLoginTrigger
            .filter { $0 != nil }
            .map { $0! }
            .subscribe(onNext: { [weak self] type in
                guard let `self` = self, let user = self.auth.getUser(), self.auth.isValid() else {
                    self?.navigator.dismissToMain(animated: true, completion: nil)
                    return
                }
                
                switch type {
                case .analysisComplete(let memIdx, let termNo):
                    guard let memIdx = memIdx, let termNo = termNo, user.memIdx == memIdx else {
                        self.navigator.dismissToMain(animated: true, completion: nil)
                        return
                    }
                    let data = CompletedInterviewData(termNo: termNo,
                                                      careerName: nil,
                                                      occupationName: nil,
                                                      companyName: nil,
                                                      regDateString: nil,
                                                      itemTypeCode: nil,
                                                      programLevel: nil)
                    self.navigator.toCompletedInterview(.present(true),
                                                        data: data,
                                                        accessDeepLink: true)

                case .expirataion1d, .expirataion3d, .expirataion7d:
                    self.navigator.toMyPage(.present(true), accessDeepLink: true)
                //...
                default:
                    break
                }
            }).disposed(by: disposeBag)
        
        return Output(error: errorPublishRelay.asDriverOnErrorJustComplete())
    }
    //...
}

class MsgViewController: BaseViewController {
   
    @IBOutlet weak var tableView: MsgTableView!
    private let msgDeclarePublishRelay = PublishRelay<MessageObject>()
    //...

    private var disposeBag = DisposeBag()
    
    var viewModel: MsgViewModel!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        //...
    }

    override func layout() {
        tableView.refreshControlInit()
        tableView.registerCell(MsgDateCell.self)
        //...
    }
    
    override func bindView() {
        //...
        tableView.declareClosure = { [weak self] cellData in
            guard let message = cellData.message else { return }
            self?.msgDeclarePublishRelay.accept(message)
        }
    }
    
    override func bindViewModel() {
        //...
        let input = MsgViewModel.Input(messageTrigger: messagePublishRelay.asDriverOnErrorJustComplete(),
																																									 //...
																																									 declareTrigger: msgDeclarePublishRelay.asDriverOnErrorJustComplete())

        let output = viewModel.transform(input: input)
        
        output.openWeb
            .drive(onNext: { [weak self] url in
                UIApplication.shared.open(url, options: [:], completionHandler: nil)
            }).disposed(by: disposeBag)
        
        output.alert.asObservable()
            .flatMap{ [weak self] type -> Observable<Bool> in
                guard let `self` = self else { return Observable.empty() }
                return App.showAlert(type: type, onView: self)
            }.subscribe(onNext: { _ in
                
            }).disposed(by: disposeBag)
        //...
    }
    //...
}

final class MsgViewModel: BaseViewModel {
    
    //...
    private var disposeBag = DisposeBag()
    
    init(navigator: MsgNavigatorType,
         popupNavigator: PopupNavigatorType,
         serviceCheckUseCase: ServiceCheckUseCase,
         //...
         msgMessageUseCase: MsgMessageUseCase,
         room: Model.Room) {
        
        self.navigator = navigator
        self.popupNavigator = popupNavigator
        //...
        self.msgMessageUseCase = msgMessageUseCase
        self.room = room
        super.init(serviceCheckUseCase: serviceCheckUseCase)
    }
}

extension MsgViewModel: ViewModel {
    enum InputTrigger: Trigger {
        case msgList(index: Int)
        //...
    }

    struct Input {
        var messageTrigger: Driver<Int> //index
        var declareTrigger: Driver<MessageObject>
        //...
    }

    struct Output {
        let roomInfo: Driver<Model.Room>
        //...
        let openWeb: Driver<URL>
        let alert: Driver<AlertMessageType>
        let error: Driver<(Trigger, Swift.Error)>
    }

    func transform(input: Input) -> Output {
        let activityIndicator = ActivityIndicator()
        activityIndicator.drive(App.progress.rx.animation).disposed(by: disposeBag)

        let openWebPublishRelay = PublishRelay<URL>()
        let alertPublishRelay = PublishRelay<AlertMessageType>()
        //...

        let compeleDeclareBlock: ((_ url: URL?) -> ()) = { [weak self] url in
            self?.navigator.pop(animated: true)
            if let url = url {
                openWebPublishRelay.accept(url)
            } else {
                alertPublishRelay.accept(.declareComplete)
            }
        }
        
        input.declareTrigger.asObservable()
            .subscribe(onNext: { [weak self] message in
                guard let `self` = self else { return }
                self.navigator.toDeclare(.push(true, .push), message: message, completeDeclare: compeleDeclareBlock)
         }).disposed(by: disposeBag)
        //...

        return Output(roomInfo: Observable.just(room).asDriverOnErrorJustComplete(),
                      //...
                      openWeb: openWebPublishRelay.asDriverOnErrorJustComplete(),
                      alert: alertPublishRelay.asDriverOnErrorJustComplete(),
                      error: errorPublishRelay.asDriverOnErrorJustComplete())
    }
}