feat - 온보딩 리뉴얼 (#76)

* feat(Setup): Initial setup Page settings

* feat(PolicyAgreement):  로고 배치

* feat(PolicyDocumentSheet): UI 개선

* feat(NameSetup): UI 개선

* feat(Name,Tag): 이름, 태그 UI 및 텍스트 수정

* feat(InitialSetupFlow): 건너뛰기 버튼 UI 통일

* feat(Setup): 튜토리얼 페이지 UI/UX 최종 업데이트

Author: mark77234

.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(awk '/private struct TutorialDiaryDetailScreen/,/private struct TutorialNotificationScreen/' /Users/ibyeongchan/Desktop/KillingPart/KillingPoint-iOS/KillingPart/Views/Screens/Setup/InitialSetupFlowView.swift)"
+    ]
+  }
+}

KillingPart/Info.plist

@@ -10,6 +10,8 @@
 	<string>$(KAKAO_NATIVE_APP_KEY)</string>
 	<key>MUSIC_BASE_URL</key>
 	<string>$(MUSIC_BASE_URL)</string>
+	<key>APP_STORE_URL</key>
+	<string>$(APP_STORE_URL)</string>
 	<key>LSApplicationQueriesSchemes</key>
 	<array>
 		<string>kakaokompassauth</string>

KillingPart/Models/AppFlowStep.swift

@@ -2,7 +2,7 @@ import Foundation
 
 enum AppFlowStep {
     case splash
-    case onboarding
     case login
+    case setup
     case main
 }

KillingPart/Models/UserModel.swift

@@ -153,6 +153,55 @@ struct UpdateMyTagRequest: Encodable {
     let tag: String
 }
 
+struct UpdateMyUsernameRequest: Encodable {
+    let username: String
+}
+
+struct UserInitSettingsResponse: Decodable {
+    let app: UserAppUpdateStatus
+    let needsPolicyAgreement: Bool
+    let needsTagSetup: Bool
+    let policies: [UserPolicyStatus]
+}
+
+struct UserAppUpdateStatus: Decodable {
+    let needsForceUpdate: Bool
+    let needsOptionalUpdate: Bool
+}
+
+struct UserPolicyStatus: Decodable, Identifiable {
+    let policyType: UserPolicyType
+    let required: Bool
+    let agreed: Bool
+    let currentRevision: Int
+    let latestRevision: Int
+
+    var id: UserPolicyType { policyType }
+}
+
+enum UserPolicyType: String, Codable, CaseIterable {
+    case serviceTerms = "SERVICE_TERMS"
+    case privacy = "PRIVACY"
+
+    var displayTitle: String {
+        switch self {
+        case .serviceTerms:
+            return "서비스 이용약관"
+        case .privacy:
+            return "개인정보 처리방침"
+        }
+    }
+}
+
+struct PolicyAgreementRequest: Encodable {
+    let agreements: [PolicyAgreementItem]
+}
+
+struct PolicyAgreementItem: Encodable {
+    let policyType: UserPolicyType
+    let agreed: Bool
+}
+
 private extension KeyedDecodingContainer {
     func decodeFlexibleBoolIfPresent(forKey key: K) -> Bool? {
         if let boolValue = try? decodeIfPresent(Bool.self, forKey: key) {

KillingPart/Services/UserService.swift

@@ -2,12 +2,15 @@ import Foundation
 
 protocol UserServicing {
     func fetchMyUser() async throws -> UserModel
+    func fetchInitSettings() async throws -> UserInitSettingsResponse
+    func submitPolicyAgreement(agreements: [PolicyAgreementItem]) async throws
     func fetchUserStatics(userId: Int) async throws -> UserStaticsModel
     func searchUsers(searchCond: String?, page: Int, size: Int) async throws -> UserSearchResponse
     func deleteMyProfileImage() async throws -> UserModel
     func issuePresignedURL() async throws -> PresignedURLResponse
     func uploadImageToPresignedURL(imageData: Data, presignedURL: URL) async throws
     func updateMyProfileImage(request: UpdateMyProfileImageRequest) async throws -> UserModel
+    func updateMyUsername(username: String) async throws -> UserModel
     func updateMyTag(tag: String) async throws -> UserModel
 }
 
@@ -70,6 +73,47 @@ struct UserService: UserServicing {
         }
     }
 
+    func fetchInitSettings() async throws -> UserInitSettingsResponse {
+        do {
+            let request = APIRequest(
+                path: "/users/init-settings",
+                method: .get,
+                queryItems: [
+                    URLQueryItem(name: "clientVersion", value: Self.clientVersion),
+                    URLQueryItem(name: "clientType", value: Self.clientType)
+                ],
+                requiresAuthorization: true
+            )
+            return try await apiClient.request(request, responseType: UserInitSettingsResponse.self)
+        } catch {
+            throw mapError(error)
+        }
+    }
+
+    func submitPolicyAgreement(agreements: [PolicyAgreementItem]) async throws {
+        let requestBody: Data
+        do {
+            requestBody = try JSONEncoder().encode(PolicyAgreementRequest(agreements: agreements))
+        } catch {
+            throw UserServiceError.requestEncodingFailed
+        }
+
+        do {
+            var request = APIRequest(
+                path: "/users/policy-agreement",
+                method: .post,
+                requiresAuthorization: true,
+                body: requestBody
+            )
+            request.headers["Accept"] = "application/json"
+            request.headers["Content-Type"] = "application/json"
+            try await apiClient.request(request)
+        } catch {
+            if isRequestCancelled(error) { throw error }
+            throw mapError(error)
+        }
+    }
+
     func fetchUserStatics(userId: Int) async throws -> UserStaticsModel {
         do {
             let request = APIRequest(
@@ -221,6 +265,31 @@ struct UserService: UserServicing {
         }
     }
 
+    func updateMyUsername(username: String) async throws -> UserModel {
+        let requestBody: Data
+        do {
+            requestBody = try JSONEncoder().encode(UpdateMyUsernameRequest(username: username))
+        } catch {
+            throw UserServiceError.requestEncodingFailed
+        }
+
+        do {
+            var request = APIRequest(
+                path: "/users/my/names",
+                method: .patch,
+                requiresAuthorization: true,
+                body: requestBody
+            )
+            request.headers["Accept"] = "application/json"
+            request.headers["Content-Type"] = "application/json"
+            let response = try await apiClient.request(request, responseType: UserResponseDTO.self)
+            return response.toModel()
+        } catch {
+            if isRequestCancelled(error) { throw error }
+            throw mapError(error)
+        }
+    }
+
     private func mapError(_ error: Error) -> UserServiceError {
         if let userServiceError = error as? UserServiceError {
             return userServiceError
@@ -299,6 +368,17 @@ struct UserService: UserServicing {
         let nsError = error as NSError
         return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorCancelled
     }
+
+    private static var clientVersion: String {
+        let shortVersion = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+        let buildVersion = Bundle.main.object(forInfoDictionaryKey: "CFBundleVersion") as? String
+        let resolved = (shortVersion?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false
+            ? shortVersion
+            : buildVersion) ?? "0.0.0"
+        return resolved
+    }
+
+    private static let clientType = "IOS"
 }
 
 private struct UserServiceErrorResponse: Decodable {

KillingPart/ViewModels/AppViewModel.swift

@@ -2,22 +2,68 @@ import Foundation
 
 @MainActor
 final class AppViewModel: ObservableObject {
+    enum UpdatePrompt: Identifiable, Equatable {
+        case force
+        case optional
+
+        var id: String {
+            switch self {
+            case .force:
+                return "force"
+            case .optional:
+                return "optional"
+            }
+        }
+
+        var title: String {
+            switch self {
+            case .force:
+                return "업데이트 필요"
+            case .optional:
+                return "업데이트 권장"
+            }
+        }
+
+        var message: String {
+            switch self {
+            case .force:
+                return "안정적인 서비스 이용을 위해 최신 버전으로 업데이트해 주세요."
+            case .optional:
+                return "새 버전이 출시되었어요. 지금 업데이트하면 더 나은 경험을 이용할 수 있어요."
+            }
+        }
+    }
+
     @Published var currentStep: AppFlowStep = .splash
+    @Published var updatePrompt: UpdatePrompt?
+    @Published var setupFlowViewModel: InitialSetupFlowViewModel?
+    @Published var isResolvingPostLoginFlow = false
 
     let loginViewModel: LoginViewModel
 
     private let tokenStore: TokenStoring
+    private let userService: UserServicing
+    private let diaryService: DiaryServicing
+    private let calendarService: CalendarServicing
     private let notificationCenter: NotificationCenter
+    private let appStoreURL: URL?
     private var sessionExpiredObserver: NSObjectProtocol?
 
     init(
         authenticationService: AuthenticationServicing = AuthenticationService(),
         authService: AuthServicing = AuthService(),
+        userService: UserServicing = UserService(),
+        diaryService: DiaryServicing = DiaryService(),
+        calendarService: CalendarServicing = CalendarService(),
         tokenStore: TokenStoring = TokenStore.shared,
         notificationCenter: NotificationCenter = .default
     ) {
         self.tokenStore = tokenStore
+        self.userService = userService
+        self.diaryService = diaryService
+        self.calendarService = calendarService
         self.notificationCenter = notificationCenter
+        self.appStoreURL = Self.resolveAppStoreURL()
 
         let loginViewModel = LoginViewModel(
             authenticationService: authenticationService,
@@ -26,7 +72,9 @@ final class AppViewModel: ObservableObject {
 
         self.loginViewModel = loginViewModel
         self.loginViewModel.onLoginSuccess = { [weak self] _ in
-            self?.currentStep = .main
+            Task { @MainActor [weak self] in
+                await self?.resolvePostLoginFlow()
+            }
         }
 
         sessionExpiredObserver = notificationCenter.addObserver(
@@ -47,15 +95,115 @@ final class AppViewModel: ObservableObject {
     }
 
     func completeSplash() {
-        currentStep = tokenStore.hasSessionTokens ? .main : .onboarding
+        guard tokenStore.hasSessionTokens else {
+            currentStep = .login
+            return
+        }
+
+        Task {
+            await resolvePostLoginFlow()
+        }
+    }
+
+    func resolvePostLoginFlow() async {
+        guard !isResolvingPostLoginFlow else { return }
+
+        isResolvingPostLoginFlow = true
+        loginViewModel.loginErrorMessage = nil
+        defer { isResolvingPostLoginFlow = false }
+
+        do {
+            let settings = try await userService.fetchInitSettings()
+            applyRoute(for: settings)
+
+            if settings.app.needsForceUpdate {
+                updatePrompt = .force
+            } else if settings.app.needsOptionalUpdate {
+                updatePrompt = .optional
+            }
+        } catch {
+            if isRequestCancelled(error) { return }
+            currentStep = .login
+            setupFlowViewModel = nil
+            loginViewModel.loginErrorMessage = resolveErrorMessage(from: error)
+        }
+    }
+
+    func openAppStoreURLForUpdate() -> URL? {
+        appStoreURL
     }
 
-    func completeOnboarding() {
-        currentStep = tokenStore.hasSessionTokens ? .main : .login
+    func dismissOptionalUpdatePrompt() {
+        guard updatePrompt == .optional else { return }
+        updatePrompt = nil
     }
 
     func logout() {
         loginViewModel.resetState()
+        setupFlowViewModel = nil
+        updatePrompt = nil
         currentStep = .login
     }
+
+    private func applyRoute(for settings: UserInitSettingsResponse) {
+        if settings.needsPolicyAgreement || settings.needsTagSetup {
+            let setupViewModel = InitialSetupFlowViewModel(
+                settings: settings,
+                userService: userService,
+                diaryService: diaryService,
+                calendarService: calendarService
+            )
+            setupViewModel.onComplete = { [weak self] in
+                self?.enterMainFlow()
+            }
+            setupFlowViewModel = setupViewModel
+            currentStep = .setup
+            return
+        }
+
+        enterMainFlow()
+    }
+
+    private func enterMainFlow() {
+        setupFlowViewModel = nil
+        currentStep = .main
+    }
+
+    private func resolveErrorMessage(from error: Error) -> String {
+        if let userServiceError = error as? UserServiceError {
+            return userServiceError.errorDescription ?? "초기 설정 정보를 불러오지 못했어요."
+        }
+
+        if let apiError = error as? APIClientError {
+            return apiError.errorDescription ?? "초기 설정 정보를 불러오지 못했어요."
+        }
+
+        if let localizedError = error as? LocalizedError {
+            return localizedError.errorDescription ?? "초기 설정 정보를 불러오지 못했어요."
+        }
+
+        return "초기 설정 정보를 불러오지 못했어요."
+    }
+
+    private func isRequestCancelled(_ error: Error) -> Bool {
+        if error is CancellationError { return true }
+
+        let nsError = error as NSError
+        return nsError.domain == NSURLErrorDomain && nsError.code == NSURLErrorCancelled
+    }
+
+    private static func resolveAppStoreURL() -> URL? {
+        guard
+            let rawValue = Bundle.main.object(forInfoDictionaryKey: "APP_STORE_URL") as? String
+        else {
+            return nil
+        }
+
+        let trimmed = rawValue.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty, let url = URL(string: trimmed) else {
+            return nil
+        }
+
+        return url
+    }
 }