421 lines
13 KiB
Swift
421 lines
13 KiB
Swift
import Models
|
|
import Services
|
|
import SwiftUI
|
|
import Transmission
|
|
import Views
|
|
|
|
enum OperationStatus {
|
|
case none
|
|
case isPerforming
|
|
case success
|
|
case failure
|
|
}
|
|
|
|
@MainActor
|
|
struct ToastOperationHandler {
|
|
let performOperation: (_: Sendable?) -> Void
|
|
let update: (_: OperationStatus, _: String) -> Void
|
|
}
|
|
|
|
typealias OperationStatusHandler = (_: OperationStatus) -> Void
|
|
|
|
@MainActor final class SubscriptionsViewModel: ObservableObject {
|
|
@Published var isLoading = true
|
|
@Published var feeds = [Subscription]()
|
|
@Published var newsletters = [Subscription]()
|
|
@Published var hasNetworkError = false
|
|
@Published var subscriptionNameToCancel: String?
|
|
@Published var presentingSubscription: Subscription?
|
|
|
|
@Published var showOperationToast = false
|
|
@Published var operationStatus: OperationStatus = .none
|
|
@Published var operationMessage: String?
|
|
|
|
func loadSubscriptions(dataService: DataService) async {
|
|
isLoading = true
|
|
|
|
do {
|
|
let subscriptions = try await dataService.subscriptions().filter { $0.status == SubscriptionStatus.active }
|
|
feeds = subscriptions.filter { $0.type == .feed }
|
|
newsletters = subscriptions.filter { $0.type == .newsletter }
|
|
} catch {
|
|
hasNetworkError = true
|
|
}
|
|
|
|
isLoading = false
|
|
}
|
|
|
|
func cancelSubscription(dataService: DataService, subscription: Subscription) async {
|
|
operationMessage = "Unsubscribing..."
|
|
operationStatus = .isPerforming
|
|
|
|
do {
|
|
try await dataService.deleteSubscription(subscriptionName: subscription.name, subscriptionId: subscription.subscriptionID)
|
|
var list = subscription.type == .feed ? feeds : newsletters
|
|
let index = list.firstIndex { $0.subscriptionID == subscription.subscriptionID }
|
|
if let index = index {
|
|
list.remove(at: index)
|
|
switch subscription.type {
|
|
case .feed:
|
|
feeds = list
|
|
case .newsletter:
|
|
newsletters = list
|
|
}
|
|
}
|
|
operationMessage = "Unsubscribed"
|
|
operationStatus = .success
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(2000)) {
|
|
self.showOperationToast = false
|
|
}
|
|
} catch {
|
|
appLogger.debug("failed to remove subscription")
|
|
operationMessage = "Failed to unsubscribe"
|
|
operationStatus = .failure
|
|
}
|
|
}
|
|
|
|
func updateSubscription(dataService: DataService, subscription: Subscription, folder: String? = nil, fetchContent: Bool? = nil) async {
|
|
operationMessage = "Updating subscription..."
|
|
operationStatus = .isPerforming
|
|
do {
|
|
try await dataService.updateSubscription(subscription.subscriptionID, folder: folder, fetchContent: fetchContent)
|
|
operationMessage = "Subscription updated"
|
|
operationStatus = .success
|
|
} catch {
|
|
operationMessage = "Failed to update subscription"
|
|
operationStatus = .failure
|
|
}
|
|
}
|
|
}
|
|
|
|
struct OperationToast: View {
|
|
@ObservedObject var viewModel: SubscriptionsViewModel
|
|
|
|
var body: some View {
|
|
VStack {
|
|
HStack {
|
|
if viewModel.operationStatus == .isPerforming {
|
|
Text(viewModel.operationMessage ?? "Performing...")
|
|
Spacer()
|
|
ProgressView()
|
|
} else if viewModel.operationStatus == .success {
|
|
Text(viewModel.operationMessage ?? "Success")
|
|
Spacer()
|
|
} else if viewModel.operationStatus == .failure {
|
|
Text(viewModel.operationMessage ?? "Failure")
|
|
Spacer()
|
|
Button(action: { viewModel.showOperationToast = false }, label: {
|
|
Text("Done").bold()
|
|
})
|
|
}
|
|
}
|
|
.padding(10)
|
|
.frame(minHeight: 50)
|
|
.frame(maxWidth: .infinity)
|
|
.background(Color(hex: "2A2A2A"))
|
|
.cornerRadius(4.0)
|
|
.tint(Color.green)
|
|
}
|
|
.padding(.bottom, 70)
|
|
.padding(.horizontal, 10)
|
|
.ignoresSafeArea(.all, edges: .bottom)
|
|
}
|
|
}
|
|
|
|
struct SubscriptionsView: View {
|
|
@EnvironmentObject var dataService: DataService
|
|
@StateObject var viewModel = SubscriptionsViewModel()
|
|
@State private var deleteConfirmationShown = false
|
|
@State private var showDeleteCompleted = false
|
|
|
|
@State private var showAddFeedView = false
|
|
@State private var showSubscriptionsSheet = false
|
|
|
|
var body: some View {
|
|
Group {
|
|
WindowLink(level: .alert, transition: .move(edge: .bottom), isPresented: $viewModel.showOperationToast) {
|
|
OperationToast(viewModel: viewModel)
|
|
} label: {
|
|
EmptyView()
|
|
}
|
|
if viewModel.isLoading {
|
|
ProgressView()
|
|
} else if viewModel.hasNetworkError {
|
|
VStack {
|
|
Text(LocalText.subscriptionsErrorRetrieving).multilineTextAlignment(.center)
|
|
Button(
|
|
action: { Task { await viewModel.loadSubscriptions(dataService: dataService) } },
|
|
label: { Text(LocalText.genericRetry) }
|
|
)
|
|
.buttonStyle(RoundedRectButtonStyle())
|
|
}
|
|
} else if viewModel.feeds.isEmpty, viewModel.newsletters.isEmpty {
|
|
VStack(alignment: .center) {
|
|
Spacer()
|
|
Text(LocalText.subscriptionsNone)
|
|
Spacer()
|
|
}
|
|
} else {
|
|
#if os(iOS)
|
|
Form {
|
|
innerBody
|
|
}
|
|
#elseif os(macOS)
|
|
List {
|
|
innerBody
|
|
}
|
|
.listStyle(InsetListStyle())
|
|
#endif
|
|
}
|
|
}
|
|
.sheet(isPresented: $showAddFeedView) {
|
|
let handler = ToastOperationHandler(performOperation: { sendable in
|
|
self.viewModel.showOperationToast = true
|
|
|
|
Task {
|
|
_ = await sendable
|
|
viewModel.isLoading = true
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(2000)) {
|
|
Task {
|
|
await self.viewModel.loadSubscriptions(dataService: dataService)
|
|
self.viewModel.showOperationToast = false
|
|
}
|
|
}
|
|
}
|
|
}, update: { state, text in
|
|
viewModel.operationStatus = state
|
|
viewModel.operationMessage = text
|
|
})
|
|
|
|
NavigationView {
|
|
LibraryAddFeedView(dismiss: {
|
|
showAddFeedView = false
|
|
}, toastOperationHandler: handler)
|
|
}
|
|
}
|
|
.formSheet(isPresented: $showSubscriptionsSheet) {
|
|
if let presentingSubscription = viewModel.presentingSubscription {
|
|
SubscriptionSettingsView(
|
|
subscription: presentingSubscription,
|
|
viewModel: viewModel,
|
|
dataService: dataService,
|
|
prefetchContent: presentingSubscription.fetchContent,
|
|
folderSelection: presentingSubscription.folder,
|
|
dismiss: { showSubscriptionsSheet = false },
|
|
unsubscribe: { subscription in
|
|
showSubscriptionsSheet = false
|
|
|
|
viewModel.operationStatus = .isPerforming
|
|
viewModel.showOperationToast = true
|
|
Task {
|
|
await viewModel.cancelSubscription(dataService: dataService, subscription: subscription)
|
|
}
|
|
}
|
|
)
|
|
}
|
|
}
|
|
.task {
|
|
await viewModel.loadSubscriptions(dataService: dataService)
|
|
}
|
|
.navigationTitle("Subscriptions")
|
|
#if os(iOS)
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
#endif
|
|
}
|
|
|
|
private var innerBody: some View {
|
|
Group {
|
|
Section("Feeds") {
|
|
if viewModel.feeds.count <= 0, !viewModel.isLoading {
|
|
VStack(alignment: .center, spacing: 20) {
|
|
Text("You don't have any Feed items.")
|
|
.font(Font.system(size: 18, weight: .bold))
|
|
|
|
Text("Add an RSS/Atom feed")
|
|
.foregroundColor(Color.blue)
|
|
.onTapGesture {
|
|
showAddFeedView = true
|
|
}
|
|
}
|
|
.frame(minHeight: 80)
|
|
.frame(maxWidth: .infinity)
|
|
.padding()
|
|
} else {
|
|
ForEach(viewModel.feeds, id: \.subscriptionID) { subscription in
|
|
Button(action: {
|
|
viewModel.presentingSubscription = subscription
|
|
showSubscriptionsSheet = true
|
|
}, label: {
|
|
SubscriptionCell(subscription: subscription)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
if viewModel.newsletters.count > 0, !viewModel.isLoading {
|
|
Section("Newsletters") {
|
|
ForEach(viewModel.newsletters, id: \.subscriptionID) { subscription in
|
|
Button(action: {
|
|
viewModel.presentingSubscription = subscription
|
|
showSubscriptionsSheet = true
|
|
}, label: {
|
|
SubscriptionCell(subscription: subscription)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
.navigationTitle(LocalText.subscriptionsGeneric)
|
|
}
|
|
}
|
|
|
|
struct SubscriptionRow<Content: View>: View {
|
|
let subscription: Subscription
|
|
let useImageSpacer: Bool
|
|
|
|
@ViewBuilder let trailingButton: Content
|
|
|
|
var body: some View {
|
|
HStack {
|
|
Group {
|
|
if let icon = subscription.icon, let imageURL = URL(string: icon) {
|
|
AsyncImage(url: imageURL) { phase in
|
|
if let image = phase.image {
|
|
image
|
|
.resizable()
|
|
.aspectRatio(contentMode: .fill)
|
|
.frame(width: 40, height: 40)
|
|
.cornerRadius(6)
|
|
} else if phase.error != nil {
|
|
Color.clear.frame(width: 40, height: 40, alignment: .top)
|
|
} else {
|
|
Color.clear
|
|
.frame(width: 40, height: 40)
|
|
.cornerRadius(2)
|
|
}
|
|
}
|
|
} else if useImageSpacer {
|
|
Color.clear
|
|
.frame(width: 40, height: 40)
|
|
.cornerRadius(2)
|
|
}
|
|
}.padding(.trailing, 10)
|
|
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Text(subscription.name)
|
|
.font(.appCallout)
|
|
.lineSpacing(1.25)
|
|
.foregroundColor(.appGrayTextContrast)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
|
|
if let updatedDate = subscription.updatedAt {
|
|
Text("Last received: \(updatedDate.formatted())")
|
|
.font(.appCaption)
|
|
.foregroundColor(.appGrayText)
|
|
.fixedSize(horizontal: false, vertical: true)
|
|
}
|
|
}
|
|
.multilineTextAlignment(.leading)
|
|
.padding(.vertical, 8)
|
|
|
|
Spacer()
|
|
|
|
trailingButton
|
|
}.frame(minHeight: 50)
|
|
}
|
|
}
|
|
|
|
struct SubscriptionCell: View {
|
|
let subscription: Subscription
|
|
|
|
var body: some View {
|
|
SubscriptionRow(subscription: subscription, useImageSpacer: true, trailingButton: {
|
|
Image(systemName: "ellipsis")
|
|
})
|
|
}
|
|
}
|
|
|
|
struct SubscriptionSettingsView: View {
|
|
let subscription: Subscription
|
|
let viewModel: SubscriptionsViewModel
|
|
let dataService: DataService
|
|
|
|
@State var prefetchContent = false
|
|
@State var deleteConfirmationShown = false
|
|
@State var showDeleteCompleted = false
|
|
@State var folderSelection: String = ""
|
|
|
|
let dismiss: () -> Void
|
|
let unsubscribe: (_: Subscription) -> Void
|
|
|
|
var body: some View {
|
|
VStack {
|
|
SubscriptionRow(subscription: subscription, useImageSpacer: false, trailingButton: {
|
|
Button(action: {
|
|
dismiss()
|
|
}, label: {
|
|
ZStack {
|
|
Circle()
|
|
.foregroundColor(Color.circleButtonBackground)
|
|
.frame(width: 30, height: 30)
|
|
|
|
Image(systemName: "xmark")
|
|
.resizable(resizingMode: Image.ResizingMode.stretch)
|
|
.foregroundColor(Color.circleButtonForeground)
|
|
.aspectRatio(contentMode: .fit)
|
|
.font(Font.title.weight(.bold))
|
|
.frame(width: 12, height: 12)
|
|
}
|
|
})
|
|
})
|
|
.padding(.top, 15)
|
|
.padding(.horizontal, 15)
|
|
|
|
List {
|
|
Toggle(isOn: $prefetchContent, label: { Text("Prefetch Content:") })
|
|
.onAppear {
|
|
prefetchContent = subscription.fetchContent
|
|
}
|
|
HStack {
|
|
Picker("Destination Folder", selection: $folderSelection) {
|
|
Text("Inbox").tag("inbox")
|
|
Text("Following").tag("following")
|
|
}
|
|
.pickerStyle(MenuPickerStyle())
|
|
.onChange(of: folderSelection) { newValue in
|
|
Task {
|
|
viewModel.showOperationToast = true
|
|
await viewModel.updateSubscription(dataService: dataService, subscription: subscription, folder: newValue)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(1500)) {
|
|
viewModel.showOperationToast = false
|
|
}
|
|
}
|
|
}
|
|
.onChange(of: prefetchContent) { newValue in
|
|
Task {
|
|
viewModel.showOperationToast = true
|
|
await viewModel.updateSubscription(dataService: dataService, subscription: subscription, fetchContent: newValue)
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(1500)) {
|
|
viewModel.showOperationToast = false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}.listStyle(.insetGrouped)
|
|
|
|
Spacer()
|
|
Button("Unsubscribe", role: .destructive) { deleteConfirmationShown = true }
|
|
.frame(maxWidth: .infinity)
|
|
.buttonStyle(RoundedRectButtonStyle(color: Color.red, textColor: Color.white))
|
|
}
|
|
.frame(minWidth: 200, minHeight: 200)
|
|
.alert("Are you sure you want to cancel this subscription?", isPresented: $deleteConfirmationShown) {
|
|
Button("Yes", role: .destructive) {
|
|
unsubscribe(subscription)
|
|
}
|
|
Button("No", role: .cancel) {
|
|
viewModel.subscriptionNameToCancel = nil
|
|
}
|
|
}
|
|
}
|
|
}
|