[Refactor] #263 - 보관함 서버 통신 함수 리팩토링

Author: 513sojin

Runnect-iOS/Runnect-iOS/Network/Service/Providers.swift

@@ -20,6 +20,17 @@ struct Providers {
   static let stampProvider = MoyaProvider<StampRouter>(withAuth: true)
 }
 
+struct Provider {
+    static let departureSearchingProvider = NetworkProvider<DepartureSearchingRouter>(withAuth: false)
+    static let authProvider = NetworkProvider<AuthRouter>(withAuth: true)
+    static let userProvider = NetworkProvider<UserRouter>(withAuth: true)
+    static let courseProvider = NetworkProvider<CourseRouter>(withAuth: true)
+    static let publicCourseProvider = NetworkProvider<PublicCourseRouter>(withAuth: true)
+    static let recordProvider = NetworkProvider<RecordRouter>(withAuth: true)
+    static let scrapProvider = NetworkProvider<ScrapRouter>(withAuth: true)
+    static let stampProvider = NetworkProvider<StampRouter>(withAuth: true)
+}
+
 extension MoyaProvider {
   convenience init(withAuth: Bool) {
     if withAuth {

Runnect-iOS/Runnect-iOS/Presentation/CourseStorage/VC/CourseStorageVC.swift

@@ -15,9 +15,9 @@ import Then
 final class CourseStorageVC: UIViewController {
 
     // MARK: - Properties
-    private let courseProvider = Providers.courseProvider
+    private let courseProvider = Provider.courseProvider
 
-    private let scrapProvider = Providers.scrapProvider
+    private let scrapProvider = Provider.scrapProvider
 
     private let cancelBag = CancelBag()
 
@@ -270,105 +270,45 @@ extension CourseStorageVC: PrivateCourseListViewDelegate {
 extension CourseStorageVC {
     private func getPrivateCourseList() {
         LoadingIndicator.showLoading()
-        courseProvider.request(.getAllPrivateCourse) { [weak self] response in
-            guard let self = self else { return }
+        
+        courseProvider.request(target: .getAllPrivateCourse, instance: BaseResponse<PrivateCourseResponseDto>.self, vc: self) { response in
             LoadingIndicator.hideLoading()
-            switch response {
-            case .success(let result):
-                let status = result.statusCode
-                if 200..<300 ~= status {
-                    do {
-                        let responseDto = try result.map(BaseResponse<PrivateCourseResponseDto>.self)
-                        guard let data = responseDto.data else { return }
-                        self.setPrivateCourseData(courseList: data.courses)
-                    } catch {
-                        print(error.localizedDescription)
-                    }
-                }
-                if status >= 400 {
-                    print("400 error")
-                    self.showNetworkFailureToast()
-                }
-            case .failure(let error):
-                print(error.localizedDescription)
-                self.showNetworkFailureToast()
-            }
+            
+            guard let data = response.data else { return }
+            self.setPrivateCourseData(courseList: data.courses)
         }
     }
 
     private func getScrapCourseList() {
         LoadingIndicator.showLoading()
-        scrapProvider.request(.getScrapCourse) { [weak self] response in
-            guard let self = self else { return }
+        
+        scrapProvider.request(target: .getScrapCourse, instance: BaseResponse<ScrapCourseResponseDto>.self, vc: self) { response in
             LoadingIndicator.hideLoading()
-            switch response {
-            case .success(let result):
-                let status = result.statusCode
-                if 200..<300 ~= status {
-                    do {
-                        let responseDto = try result.map(BaseResponse<ScrapCourseResponseDto>.self)
-                        guard let data = responseDto.data else { return }
-                        self.setScrapCourseData(courseList: data.scraps)
-                    } catch {
-                        print(error.localizedDescription)
-                    }
-                }
-                if status >= 400 {
-                    print("400 error")
-                    self.showNetworkFailureToast()
-                }
-            case .failure(let error):
-                print(error.localizedDescription)
-                self.showNetworkFailureToast()
-            }
+            
+            guard let data = response.data else { return }
+            self.setScrapCourseData(courseList: data.scraps)
         }
     }
 
     private func scrapCourse(publicCourseId: Int, scrapTF: Bool) {
         LoadingIndicator.showLoading()
-        scrapProvider.request(.createAndDeleteScrap(publicCourseId: publicCourseId, scrapTF: scrapTF)) { [weak self] response in
+        
+        scrapProvider.request(target: .createAndDeleteScrap(publicCourseId: publicCourseId, scrapTF: scrapTF), instance: BaseResponse<BlankData>.self, vc: self) { response in
             LoadingIndicator.hideLoading()
-            guard let self = self else { return }
-            switch response {
-            case .success(let result):
-                let status = result.statusCode
-                if 200..<300 ~= status {
-                    self.getScrapCourseList()
-                }
-                if status >= 400 {
-                    print("400 error")
-                    self.showNetworkFailureToast()
-                }
-            case .failure(let error):
-                print(error.localizedDescription)
-                self.showNetworkFailureToast()
-            }
+            
+            self.getScrapCourseList()
         }
     }
 
     private func deleteCourse(courseIdList: [Int]) {
         LoadingIndicator.showLoading()
-        courseProvider.request(.deleteCourse(courseIdList: courseIdList)) { [weak self] response in
+        
+        courseProvider.request(target: .deleteCourse(courseIdList: courseIdList), instance: BaseResponse<BlankData>.self, vc: self) { response in
             LoadingIndicator.hideLoading()
-            guard let self = self else { return }
+            
             self.privateCourseListView.isEditMode = false
-            switch response {
-            case .success(let result):
-                print("리절트", result)
-                let status = result.statusCode
-                if 200..<300 ~= status {
-                    print("삭제 성공")
-                    self.getPrivateCourseList()
-                    self.finishEditMode(withDuration: 0.7)
-                }
-                if status >= 400 {
-                    print("400 error")
-                    self.showNetworkFailureToast()
-                }
-            case .failure(let error):
-                print(error.localizedDescription)
-                self.showNetworkFailureToast()
-            }
+            self.getPrivateCourseList()
+            self.finishEditMode(withDuration: 0.7)
         }
     }
 }