feat: Pokit Flow API Connect

Projects/CoreKit/Sources/CoreNetwork/MoyaProvider+request.swift

@@ -34,4 +34,23 @@ extension MoyaProvider {
             }
         }
     }
+
+    func requestNoBody(_ target: Target) async throws -> Void {
+        return try await withCheckedThrowingContinuation { continuation in
+            self.request(target) { response in
+                switch response {
+                case .success:
+                    continuation.resume()
+
+                case .failure(let error):
+                    if let response = error.response?.data {
+                        let errorResponse = try? JSONDecoder().decode(ErrorResponse.self, from: response)
+                        continuation.resume(throwing: errorResponse ?? .base)
+                    } else {
+                        continuation.resume(throwing: error)
+                    }
+                }
+            }
+        }
+    }
 }

Projects/CoreKit/Sources/Data/DTO/Base/BasePageableRequest.swift

@@ -7,8 +7,14 @@
 
 import Foundation
 /// Pageable
-public struct BasePageableRequest: Encodable {
+public struct BasePageableRequest: Equatable, Encodable {
     let page: Int
     let size: Int
     let sort: [String]
+
+    public init(page: Int, size: Int, sort: [String]) {
+        self.page = page
+        self.size = size
+        self.sort = sort
+    }
 }

Projects/CoreKit/Sources/Data/DTO/Category/CategoryEditRequest.swift

@@ -8,6 +8,11 @@
 import Foundation
 /// 카테고리 추가 및 수정  API Request
 public struct CategoryEditRequest: Encodable {
-    let categoryName: String
-    let categoryImageId: Int
+    public let categoryName: String
+    public let categoryImageId: Int
+
+    public init(categoryName: String, categoryImageId: Int) {
+        self.categoryName = categoryName
+        self.categoryImageId = categoryImageId
+    }
 }

Projects/CoreKit/Sources/Data/Network/Category/CategoryClient.swift

@@ -18,22 +18,18 @@ extension DependencyValues {
 }
 /// Category에 관련한 API를 처리하는 Client
 public struct CategoryClient {
-    var 카테고리_삭제: @Sendable (
-        _ categoryId: String
-    ) async throws -> EmptyResponse
-    var 카테고리_수정: @Sendable (
-        _ categoryId: String,
+    public var 카테고리_삭제: @Sendable (_ categoryId: Int) async throws -> Void
+    public var 카테고리_수정: @Sendable (
+        _ categoryId: Int,
         _ model: CategoryEditRequest
     ) async throws -> CategoryEditResponse
-    var 카테고리_목록_조회: @Sendable (
-        _ model: BasePageableRequest
-    ) async throws -> CategoryListInquiryResponse
-    var 카테고리_생성: @Sendable (
+    public var 카테고리_목록_조회: @Sendable (_ model: BasePageableRequest, _ filterUncategorized: Bool) async throws -> CategoryListInquiryResponse
+    public var 카테고리_생성: @Sendable (
         _ model: CategoryEditRequest
     ) async throws -> CategoryEditResponse
-    var 카테고리_프로필_목록_조회: @Sendable (
-    ) async throws -> [CategoryImageResponse]
-    var 유저_카테고리_개수_조회: @Sendable (
+    public var 카테고리_프로필_목록_조회: @Sendable (
+) async throws -> [CategoryImageResponse]
+    public var 유저_카테고리_개수_조회: @Sendable (
     ) async throws -> CategoryCountResponse
 }
 
@@ -43,13 +39,13 @@ extension CategoryClient: DependencyKey {
 
         return Self(
             카테고리_삭제: { id in
-                try await provider.request(.카테고리_삭제(categoryId: id))
+                try await provider.requestNoBody(.카테고리_삭제(categoryId: id))
             },
             카테고리_수정: { id, model in
                 try await provider.request(.카테고리_수정(categoryId: id, model: model))
             },
-            카테고리_목록_조회: { model in
-                try await provider.request(.카테고리_목록_조회(model: model))
+            카테고리_목록_조회: { model, categoryFilter in
+                try await provider.request(.카테고리_목록_조회(model: model, filterUncategorized: categoryFilter))
             },
             카테고리_생성: { model in
                 try await provider.request(.카테고리생성(model: model))
@@ -65,9 +61,9 @@ extension CategoryClient: DependencyKey {
 
     public static let previewValue: Self = {
         Self(
-            카테고리_삭제: { _ in .init() },
+            카테고리_삭제: { _ in },
             카테고리_수정: { _, _ in .mock },
-            카테고리_목록_조회: { _ in .mock },
+            카테고리_목록_조회: { _, _ in .mock },
             카테고리_생성: { _ in .mock },
             카테고리_프로필_목록_조회: { CategoryImageResponse.mock },
             유저_카테고리_개수_조회: { .mock }

Projects/CoreKit/Sources/Data/Network/Category/CategoryEndpoint.swift

@@ -11,9 +11,9 @@ import Util
 import Moya
 /// 카테고리 전용 Endpont
 public enum CategoryEndpoint {
-    case 카테고리_삭제(categoryId: String)
-    case 카테고리_수정(categoryId: String, model: CategoryEditRequest)
-    case 카테고리_목록_조회(model: BasePageableRequest)
+    case 카테고리_삭제(categoryId: Int)
+    case 카테고리_수정(categoryId: Int, model: CategoryEditRequest)
+    case 카테고리_목록_조회(model: BasePageableRequest, filterUncategorized: Bool)
     case 카테고리생성(model: CategoryEditRequest)
     case 카테고리_프로필_목록_조회
     case 유저_카테고리_개수_조회
@@ -65,12 +65,13 @@ extension CategoryEndpoint: TargetType {
             return .requestPlain
         case let .카테고리_수정(_, model):
             return .requestJSONEncodable(model)
-        case let .카테고리_목록_조회(model):
+        case let .카테고리_목록_조회(model, categorized):
             return .requestParameters(
                 parameters: [
                     "page": model.page,
                     "size": model.size,
-                    "sort": model.sort
+                    "sort": model.sort,
+                    "filterUncategorized": categorized
                 ],
                 encoding: URLEncoding.default
             )

Projects/Domain/Sources/CategoryDetail/CategoryDetail.swift

@@ -10,7 +10,7 @@ import Foundation
 public struct CategoryDetail: Equatable {
     // - MARK: Respone
     /// 카테고리(포킷)
-    public let category: BaseCategory
+    public var category: BaseCategory
     /// - 카테고리(포킷) 리스트
     public var categoryListInQuiry: BaseCategoryListInquiry
     /// 카테고리(포킷) 내 콘텐츠(링크) 리스트

Projects/Domain/Sources/Pokit/Pokit.swift

@@ -17,10 +17,10 @@ public struct Pokit: Equatable {
     public init() {
         self.categoryList = .init(
             data: [],
-            page: 0,
+            page: -1,
             size: 10,
             sort: [],
-            hasNext: false
+            hasNext: true
         )
         self.unclassifiedContentList = .init(
             data: [],

Projects/Feature/FeatureCategoryDetail/Sources/CategoryDetailFeature.swift

@@ -17,6 +17,7 @@ public struct CategoryDetailFeature {
     /// - Dependency
     @Dependency(\.dismiss) var dismiss
     @Dependency(\.pasteboard) var pasteboard
+    @Dependency(\.categoryClient) var categoryClient
     /// - State
     @ObservableState
     public struct State: Equatable {
@@ -78,6 +79,7 @@ public struct CategoryDetailFeature {
             case pokitCategorySheetPresented(Bool)
             case pokitCategorySelectSheetPresented(Bool)
             case pokitDeleteSheetPresented(Bool)
+            case 카테고리_목록_조회_결과(BaseCategoryListInquiry)
         }
 
         public enum AsyncAction: Equatable { case doNothing }
@@ -149,7 +151,8 @@ private extension CategoryDetailFeature {
             return .send(.inner(.pokitCategorySelectSheetPresented(true)))
 
         case .categorySelected(let item):
-            /// Todo: 아이템 선택한 것 반영
+            state.domain.category = item
+            //TODO: 현재 아이템 값을 통해 카테고리 내 컨텐츠 리스트들을 뿌려줘야 함
             return .send(.inner(.pokitCategorySelectSheetPresented(false)))
 
         case .filterButtonTapped:
@@ -164,9 +167,13 @@ private extension CategoryDetailFeature {
 
         case .onAppear:
             // - MARK: 목업 데이터 조회
-            state.domain.categoryListInQuiry = CategoryListInquiryResponse.mock.toDomain()
-            state.domain.contentList = ContentListInquiryResponse.mock.toDomain()
+//            state.domain.categoryListInQuiry = CategoryListInquiryResponse.mock.toDomain()
+//            state.domain.contentList = ContentListInquiryResponse.mock.toDomain()
             return .run { send in
+                let request = BasePageableRequest(page: 0, size: 100, sort: ["desc"])
+                let response = try await categoryClient.카테고리_목록_조회(request, true).toDomain()
+                await send(.inner(.카테고리_목록_조회_결과(response)))
+
                 for await _ in self.pasteboard.changes() {
                     let url = try await pasteboard.probableWebURL()
                     await send(.delegate(.linkCopyDetected(url)), animation: .pokitSpring)
@@ -189,6 +196,14 @@ private extension CategoryDetailFeature {
         case let .pokitCategorySelectSheetPresented(presented):
             state.isCategorySelectSheetPresented = presented
             return .none
+
+        case let .카테고리_목록_조회_결과(response):
+            state.domain.categoryListInQuiry = response
+            guard let first = response.data.first(where: { item in
+                item.id == state.domain.category.id
+            }) else { return .none }
+            state.domain.category = first
+            return .none
         }
     }
 
@@ -262,7 +277,11 @@ private extension CategoryDetailFeature {
                 case .포킷삭제:
                     state.isPokitDeleteSheetPresented = false
                     state.kebobSelectedType = nil
-                    return .send(.delegate(.포킷삭제))
+                    return .run { [categoryId = state.domain.category.id] send in
+                        await send(.inner(.pokitDeleteSheetPresented(false)))
+                        await send(.delegate(.포킷삭제))
+                        try await categoryClient.카테고리_삭제(categoryId)
+                    }
                 }
             }
         /// - 필터 버튼을 눌렀을 때

Projects/Feature/FeatureCategorySetting/Sources/PokitCategorySettingFeature.swift

@@ -11,11 +11,15 @@ import Domain
 import CoreKit
 import Util
 
+/// - 사용되는 API 목록
+/// 1. Profile 🎨
+/// 2. 포킷 생성 🖨️
 @Reducer
 public struct PokitCategorySettingFeature {
     /// - Dependency
     @Dependency(\.dismiss) var dismiss
     @Dependency(\.pasteboard) var pasteboard
+    @Dependency(\.categoryClient) var categoryClient
     /// - State
     @ObservableState
     public struct State: Equatable {
@@ -79,9 +83,14 @@ public struct PokitCategorySettingFeature {
             case onAppear
         }
 
-        public enum InnerAction: Equatable { case doNothing }
+        public enum InnerAction: Equatable {
+            case 카테고리_목록_조회_결과(BaseCategoryListInquiry)
+            case 프로필_목록_조회_결과(images: [BaseCategoryImage])
+        }
 
-        public enum AsyncAction: Equatable { case doNothing }
+        public enum AsyncAction: Equatable {
+            case 프로필_목록_조회
+        }
 
         public enum ScopeAction: Equatable {
             case profile(ProfileBottomSheet.Delegate)
@@ -141,31 +150,47 @@ private extension PokitCategorySettingFeature {
             return .run { _ in await dismiss() }
 
         case .profileSettingButtonTapped:
-            /// 1. 프로필 목록 조회 API 호출
-            /// 2. 프로필 목록들을 profileImages에 할당
-            // - MARK: 목업 데이터 조회
-            state.domain.imageList = CategoryImageResponse.mock.map { $0.toDomain() }
-            /// 3. 토글 on
-            state.isProfileSheetPresented.toggle()
-            return .none
-
+            /// [Profile 🎨]1. 프로필 목록 조회 API 호출
+            return .run { send in await send(.async(.프로필_목록_조회)) }
+
         case .saveButtonTapped:
-            return .run { [domain = state.domain] send in
-                ///Todo: 네트워크 코드 추가
-//                let result = try await network
-
-                /// - mock
-                guard let imageId = domain.categoryImage?.id else { return }
-                await send(.delegate(.settingSuccess(
-                    categoryName: domain.categoryName,
-                    categoryImageId: imageId
-                )))
+            return .run { [domain = state.domain,
+                           type = state.type] send in
+                switch type {
+                case .추가:
+                    guard let image = domain.categoryImage else { return }
+                    let request = CategoryEditRequest(categoryName: domain.categoryName, categoryImageId: image.id)
+                    let response = try await categoryClient.카테고리_생성(request)
+                    await send(
+                        .delegate(
+                            .settingSuccess(
+                                categoryName: response.categoryName,
+                                categoryImageId: response.categoryImage.imageId
+                            )
+                        )
+                    )
+                case .수정:
+                    guard let categoryId = domain.categoryId else { return }
+                    guard let image = domain.categoryImage else { return }
+                    let request = CategoryEditRequest(categoryName: domain.categoryName, categoryImageId: image.id)
+                    let response = try await categoryClient.카테고리_수정(categoryId, request)
+                    await send(
+                        .delegate(
+                            .settingSuccess(
+                                categoryName: response.categoryName,
+                                categoryImageId: response.categoryImage.imageId
+                            )
+                        )
+                    )
+                }
             }
 
         case .onAppear:
-            // - MARK: 목업 데이터 조회
-            state.domain.categoryListInQuiry = CategoryListInquiryResponse.mock.toDomain()
             return .run { send in
+                let pageRequest = BasePageableRequest(page: 0, size: 100, sort: ["desc"])
+                let response = try await categoryClient.카테고리_목록_조회(pageRequest, true).toDomain()
+                await send(.inner(.카테고리_목록_조회_결과(response)))
+
                 for await _ in self.pasteboard.changes() {
                     let url = try await pasteboard.probableWebURL()
                     await send(.delegate(.linkCopyDetected(url)), animation: .pokitSpring)
@@ -176,12 +201,29 @@ private extension PokitCategorySettingFeature {
 
     /// - Inner Effect
     func handleInnerAction(_ action: Action.InnerAction, state: inout State) -> Effect<Action> {
-        return .none
+        switch action {
+        case let .프로필_목록_조회_결과(images):
+            /// [Profile 🎨] 2. 프로필 목록들을 profileImages에 할당
+            state.domain.imageList = images
+            /// [Profile 🎨] 3. 토글 on
+            state.isProfileSheetPresented.toggle()
+            return .none
+        case let .카테고리_목록_조회_결과(response):
+            state.domain.categoryListInQuiry = response
+            return .none
+        }
     }
 
     /// - Async Effect
     func handleAsyncAction(_ action: Action.AsyncAction, state: inout State) -> Effect<Action> {
-        return .none
+        switch action {
+        case .프로필_목록_조회:
+            return .run { send in
+                let a = try await categoryClient.카테고리_프로필_목록_조회()
+                let b = a.map { $0.toDomain() }
+                await send(.inner(.프로필_목록_조회_결과(images: b)))
+            }
+        }
     }
 
     /// - Scope Effect

Projects/Feature/FeatureCategorySetting/Sources/PokitCategorySettingView.swift

@@ -48,7 +48,7 @@ public extension PokitCategorySettingView {
                     delegateSend: { store.send(.scope(.profile($0))) }
                 )
             }
-            .onAppear { send(.onAppear) }
+            .task { await send(.onAppear).finish() }
         }
     }
 }

Projects/Feature/FeatureLogin/Sources/LoginRoot/LoginRootFeature.swift

@@ -172,6 +172,7 @@ private extension LoginRootFeature {
         case .registerNickname(let delegate):
             switch delegate {
             case .pushSelectFieldView(let nickname):
+                state.nickName = nickname
                 return .send(.inner(.pushSelectFieldView(nickname: nickname)))
             }
         case .selectField(let delegate):

Projects/Feature/FeatureLogin/Sources/RegisterNickname/RegisterNicknameFeature.swift

@@ -98,10 +98,10 @@ private extension RegisterNicknameFeature {
                 return .run { [nickName = state.nicknameText] send in
                     await send(.delegate(.pushSelectFieldView(nickname: nickName)))
                 }
-            return .none
         case .backButtonTapped:
             return .run { _ in await self.dismiss() }
         case .binding(\.nicknameText):
+            state.buttonActive = false
             return .run { send in
                 await send(.inner(.textChanged))
             }