DevLog_iOS/Application/DevLogPresentation/Sources/Home/List/TodoListFeature+Effects.swift at e6587df8f1288842dd17f896bb7e0e193f9d6dbf · opficdev/DevLog_iOS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
//
//  TodoListFeature+Effects.swift
//  DevLogPresentation
//
//  Created by opfic on 6/12/26.
//

import ComposableArchitecture
import DevLogCore
import DevLogDomain
import Foundation

extension TodoListFeature {
    func searchEffect(
        _ keyword: String,
        category: TodoCategory
    ) -> Effect<Action> {
        .run { [fetchTodosUseCase] send in
            do {
                let query = TodoQuery(categoryId: category.storageValue, keyword: keyword)
                let page = try await fetchTodosUseCase.execute(query, cursor: nil)
                try Task.checkCancellation()
                await send(.store(.fetchSearchResults(page.items.compactMap(TodoListItem.init(from:)))))
                await send(.loading(.end(target: .default, mode: .immediate)))
            } catch is CancellationError {
                return
            } catch {
                await send(.store(.setAlert(true)))
                await send(.loading(.end(target: .default, mode: .immediate)))
            }
        }
        .cancellable(id: CancelID.request, cancelInFlight: true)
    }

    func toggleCompletedEffect(_ item: TodoListItem) -> Effect<Action> {
        .concatenate(
            .send(.loading(.begin(target: .default, mode: .delayed))),
            .run { [fetchTodoByIdUseCase, upsertTodoUseCase, trackAnalyticsEventUseCase] send in
                do {
                    var todo = try await fetchTodoByIdUseCase.execute(item.id)
                    let now = Date()
                    todo.isCompleted.toggle()
                    todo.completedAt = todo.isCompleted ? now : nil
                    todo.updatedAt = now
                    try await upsertTodoUseCase.execute(todo)
                    if todo.isCompleted {
                        trackAnalyticsEventUseCase?.execute(.todoComplete)
                    }
                    guard let todoListItem = TodoListItem(from: todo) else {
                        await send(.store(.setAlert(true)))
                        await send(.loading(.end(target: .default, mode: .delayed)))
                        return
                    }
                    await send(.store(.didToggleCompleted(todoListItem)))
                    await send(.loading(.end(target: .default, mode: .delayed)))
                } catch {
                    await send(.store(.setAlert(true)))
                    await send(.loading(.end(target: .default, mode: .delayed)))
                }
            }
        )
    }

    func togglePinnedEffect(_ item: TodoListItem) -> Effect<Action> {
        .concatenate(
            .send(.loading(.begin(target: .default, mode: .delayed))),
            .run { [fetchTodoByIdUseCase, upsertTodoUseCase] send in
                do {
                    var todo = try await fetchTodoByIdUseCase.execute(item.id)
                    todo.isPinned.toggle()
                    todo.updatedAt = Date()
                    try await upsertTodoUseCase.execute(todo)
                    guard let todoListItem = TodoListItem(from: todo) else {
                        await send(.store(.setAlert(true)))
                        await send(.loading(.end(target: .default, mode: .delayed)))
                        return
                    }
                    await send(.store(.didTogglePinned(todoListItem)))
                    await send(.loading(.end(target: .default, mode: .delayed)))
                } catch {
                    await send(.store(.setAlert(true)))
                    await send(.loading(.end(target: .default, mode: .delayed)))
                }
            }
        )
    }

    func swipeTodoEffect(_ todo: TodoListItem, state: inout State) -> Effect<Action> {
        guard state.todos.contains(where: { $0.id == todo.id }) else { return .none }
        state.undoTodoId = todo.id
        state.deleteToastTodoId = todo.id
        Self.setTodoHidden(&state, todoId: todo.id, isHidden: true)
        return deleteEffect(todo)
    }

    func deleteEffect(_ item: TodoListItem) -> Effect<Action> {
        .run { [deleteTodoUseCase] send in
            do {
                try await deleteTodoUseCase.execute(item.id)
            } catch {
                await send(.store(.setTodoHidden(item.id, false)))
                await send(.store(.setAlert(true)))
            }
        }
    }

    func undoDeleteEffect(_ todoId: String) -> Effect<Action> {
        .run { [undoDeleteTodoUseCase] send in
            do {
                try await undoDeleteTodoUseCase.execute(todoId)
            } catch {
                await send(.store(.setTodoHidden(todoId, true)))
                await send(.store(.setAlert(true)))
            }
        }
    }

    static func setAlert(
        _ state: inout State,
        isPresented: Bool
    ) {
        state.alert = isPresented ? Self.alertState() : nil
    }

    static func alertState() -> AlertState<Never> {
        AlertState {
            TextState(String(localized: "common_error_title"))
        } actions: {
            ButtonState(role: .cancel) {
                TextState(String(localized: "common_close"))
            }
        } message: {
            TextState(String(localized: "common_error_message"))
        }
    }

    static func setTodoHidden(
        _ state: inout State,
        todoId: String,
        isHidden: Bool
    ) {
        if let todoIndex = state.todos.firstIndex(where: { $0.id == todoId }) {
            state.todos[todoIndex].isHidden = isHidden
        }

        if let searchResultIndex = state.searchResults.firstIndex(where: { $0.id == todoId }) {
            state.searchResults[searchResultIndex].isHidden = isHidden
        }
    }
}