429 lines
15 KiB
Swift
429 lines
15 KiB
Swift
import SwiftUI
|
|
import UniformTypeIdentifiers
|
|
import UIKit
|
|
|
|
struct ImportDataView: View {
|
|
enum ImportContext {
|
|
case settings
|
|
case onboarding
|
|
}
|
|
|
|
enum AccountSelection: String, CaseIterable, Identifiable {
|
|
case existing
|
|
case new
|
|
|
|
var id: String { rawValue }
|
|
}
|
|
|
|
let importContext: ImportContext
|
|
|
|
@EnvironmentObject private var iapService: IAPService
|
|
@EnvironmentObject private var accountStore: AccountStore
|
|
@EnvironmentObject private var tabSelection: TabSelectionStore
|
|
@Environment(\.dismiss) private var dismiss
|
|
|
|
@State private var selectedFormat: ImportService.ImportFormat = .csv
|
|
@State private var showingImporter = false
|
|
@State private var resultMessage: String?
|
|
@State private var errorMessage: String?
|
|
@State private var isImporting = false
|
|
@State private var importProgress: Double = 0
|
|
@State private var importStatus = "Preparing import"
|
|
@State private var accountSelection: AccountSelection = .existing
|
|
@State private var selectedAccountId: UUID?
|
|
@State private var newAccountName = ""
|
|
@State private var accountErrorMessage: String?
|
|
|
|
private let accountRepository = AccountRepository()
|
|
|
|
init(importContext: ImportContext = .settings) {
|
|
self.importContext = importContext
|
|
}
|
|
|
|
var body: some View {
|
|
NavigationStack {
|
|
List {
|
|
if shouldShowAccountSelection {
|
|
accountSection
|
|
}
|
|
|
|
Section {
|
|
Picker("Format", selection: $selectedFormat) {
|
|
Text("CSV").tag(ImportService.ImportFormat.csv)
|
|
Text("JSON").tag(ImportService.ImportFormat.json)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
.disabled(isImporting)
|
|
|
|
Button {
|
|
showingImporter = true
|
|
} label: {
|
|
Label("Choose File", systemImage: "doc")
|
|
}
|
|
.disabled(isImporting)
|
|
|
|
Button {
|
|
importFromClipboard()
|
|
} label: {
|
|
Label("Paste from Clipboard", systemImage: "doc.on.clipboard")
|
|
}
|
|
.disabled(isImporting)
|
|
|
|
if isImporting {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
ProgressView(value: importProgress)
|
|
Text(importStatus)
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
.padding(.top, 8)
|
|
}
|
|
} header: {
|
|
Text("Import")
|
|
} footer: {
|
|
Text("Your data will be merged with existing categories and sources.")
|
|
}
|
|
|
|
Section {
|
|
if selectedFormat == .csv {
|
|
csvDocs
|
|
} else {
|
|
jsonDocs
|
|
}
|
|
} header: {
|
|
Text("Format Guide")
|
|
} footer: {
|
|
Text(importFooterText)
|
|
}
|
|
|
|
Section {
|
|
Button {
|
|
shareSampleFile()
|
|
} label: {
|
|
Label("Share Sample \(selectedFormat == .csv ? "CSV" : "JSON")", systemImage: "square.and.arrow.up")
|
|
}
|
|
} footer: {
|
|
Text("Use this sample file to email yourself a template.")
|
|
}
|
|
}
|
|
.navigationTitle("Import Data")
|
|
.navigationBarTitleDisplayMode(.inline)
|
|
.toolbar {
|
|
ToolbarItem(placement: .navigationBarTrailing) {
|
|
Button("Done") { dismiss() }
|
|
.disabled(isImporting)
|
|
}
|
|
}
|
|
.fileImporter(
|
|
isPresented: $showingImporter,
|
|
allowedContentTypes: selectedFormat == .csv
|
|
? [.commaSeparatedText, .plainText, .text]
|
|
: [.json, .plainText, .text],
|
|
allowsMultipleSelection: false
|
|
) { result in
|
|
handleImport(result)
|
|
}
|
|
.alert(
|
|
"Import Complete",
|
|
isPresented: Binding(
|
|
get: { resultMessage != nil },
|
|
set: { if !$0 { resultMessage = nil } }
|
|
)
|
|
) {
|
|
Button("OK") { resultMessage = nil }
|
|
} message: {
|
|
Text(resultMessage ?? "")
|
|
}
|
|
.alert(
|
|
"Import Error",
|
|
isPresented: Binding(
|
|
get: { errorMessage != nil },
|
|
set: { if !$0 { errorMessage = nil } }
|
|
)
|
|
) {
|
|
Button("OK") { errorMessage = nil }
|
|
} message: {
|
|
Text(errorMessage ?? "")
|
|
}
|
|
.onAppear {
|
|
if selectedAccountId == nil {
|
|
selectedAccountId = accountStore.selectedAccount?.id ?? accountStore.accounts.first?.id
|
|
}
|
|
}
|
|
.onChange(of: accountSelection) { _, _ in
|
|
accountErrorMessage = nil
|
|
}
|
|
.onChange(of: newAccountName) { _, _ in
|
|
guard accountSelection == .new else { return }
|
|
accountErrorMessage = validateNewAccountName()
|
|
}
|
|
}
|
|
.presentationDetents([.large])
|
|
}
|
|
|
|
private var csvDocs: some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Headers")
|
|
.font(.headline)
|
|
Text("Account,Category,Source,Date,Value,Contribution,Notes")
|
|
.font(.caption.monospaced())
|
|
|
|
Text("Example")
|
|
.font(.headline)
|
|
Text("""
|
|
Personal,Stocks,Index Fund,2024-01-01,15000,12000,Long-term
|
|
,Crypto,BTC,01/15/2024 14:30,3200,,Cold storage
|
|
""")
|
|
.font(.caption.monospaced())
|
|
Text("Account, Contribution, and Notes are optional. Dates accept / or - and 24h/12h time.")
|
|
.font(.caption)
|
|
.foregroundColor(.secondary)
|
|
}
|
|
}
|
|
|
|
private var jsonDocs: some View {
|
|
VStack(alignment: .leading, spacing: 8) {
|
|
Text("Top-level keys")
|
|
.font(.headline)
|
|
Text("version, currency, accounts")
|
|
.font(.caption.monospaced())
|
|
|
|
Text("Example")
|
|
.font(.headline)
|
|
Text("""
|
|
{
|
|
"version": 2,
|
|
"currency": "EUR",
|
|
"accounts": [{
|
|
"name": "Personal",
|
|
"inputMode": "simple",
|
|
"notificationFrequency": "monthly",
|
|
"categories": [{
|
|
"name": "Stocks",
|
|
"color": "#3B82F6",
|
|
"icon": "chart.line.uptrend.xyaxis",
|
|
"sources": [{
|
|
"name": "Index Fund",
|
|
"snapshots": [{
|
|
"date": "2024-01-01T00:00:00Z",
|
|
"value": 15000,
|
|
"contribution": 12000
|
|
}]
|
|
}]
|
|
}]
|
|
}]
|
|
}
|
|
""")
|
|
.font(.caption.monospaced())
|
|
}
|
|
}
|
|
|
|
private var shouldShowAccountSelection: Bool {
|
|
importContext == .onboarding
|
|
}
|
|
|
|
private var importFooterText: String {
|
|
if importContext == .onboarding {
|
|
return iapService.isPremium
|
|
? "Import will be added to the selected account."
|
|
: "Free users import into the existing account."
|
|
}
|
|
return iapService.isPremium
|
|
? "Accounts are imported as provided."
|
|
: "Free users import into the selected account."
|
|
}
|
|
|
|
private var accountSection: some View {
|
|
Section {
|
|
if iapService.isPremium {
|
|
Picker("Account", selection: $accountSelection) {
|
|
Text("Existing").tag(AccountSelection.existing)
|
|
Text("New").tag(AccountSelection.new)
|
|
}
|
|
.pickerStyle(.segmented)
|
|
.disabled(isImporting)
|
|
|
|
if accountSelection == .existing {
|
|
Picker("Import into", selection: $selectedAccountId) {
|
|
ForEach(accountStore.accounts) { account in
|
|
Text(account.name).tag(Optional(account.id))
|
|
}
|
|
}
|
|
.disabled(isImporting)
|
|
} else {
|
|
TextField("New account name", text: $newAccountName)
|
|
.disabled(isImporting)
|
|
}
|
|
} else {
|
|
HStack {
|
|
Text("Account")
|
|
Spacer()
|
|
Text(selectedAccountName ?? "Personal")
|
|
.foregroundColor(.secondary)
|
|
}
|
|
}
|
|
} header: {
|
|
Text("Account")
|
|
} footer: {
|
|
if let accountErrorMessage {
|
|
Text(accountErrorMessage)
|
|
.foregroundColor(.negativeRed)
|
|
}
|
|
}
|
|
}
|
|
|
|
private var selectedAccountName: String? {
|
|
accountStore.accounts.first { $0.id == selectedAccountId }?.name
|
|
?? accountStore.selectedAccount?.name
|
|
?? accountStore.accounts.first?.name
|
|
}
|
|
|
|
private func validateNewAccountName() -> String? {
|
|
let trimmed = newAccountName.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !trimmed.isEmpty else {
|
|
return "Enter a name for the new account."
|
|
}
|
|
let normalized = trimmed.lowercased()
|
|
let exists = accountStore.accounts.contains {
|
|
$0.name.trimmingCharacters(in: .whitespacesAndNewlines).lowercased() == normalized
|
|
}
|
|
return exists ? "An account with this name already exists." : nil
|
|
}
|
|
|
|
private func handleImport(_ result: Result<[URL], Error>) {
|
|
do {
|
|
let urls = try result.get()
|
|
guard let url = urls.first else { return }
|
|
let content = try readFileContents(from: url)
|
|
handleImportContent(content)
|
|
} catch {
|
|
errorMessage = "Could not read the selected file. \(error.localizedDescription)"
|
|
}
|
|
}
|
|
|
|
private func readFileContents(from url: URL) throws -> String {
|
|
let accessing = url.startAccessingSecurityScopedResource()
|
|
defer {
|
|
if accessing {
|
|
url.stopAccessingSecurityScopedResource()
|
|
}
|
|
}
|
|
|
|
var coordinatorError: NSError?
|
|
var contentError: NSError?
|
|
var content = ""
|
|
let coordinator = NSFileCoordinator()
|
|
coordinator.coordinate(readingItemAt: url, options: [], error: &coordinatorError) { fileURL in
|
|
do {
|
|
if let isUbiquitous = try? fileURL.resourceValues(forKeys: [.isUbiquitousItemKey]).isUbiquitousItem,
|
|
isUbiquitous {
|
|
try? FileManager.default.startDownloadingUbiquitousItem(at: fileURL)
|
|
}
|
|
let data = try Data(contentsOf: fileURL)
|
|
if let decoded = String(data: data, encoding: .utf8)
|
|
?? String(data: data, encoding: .utf16)
|
|
?? String(data: data, encoding: .isoLatin1) {
|
|
content = decoded
|
|
} else {
|
|
throw NSError(
|
|
domain: "ImportDataView",
|
|
code: 1,
|
|
userInfo: [NSLocalizedDescriptionKey: "Unsupported text encoding."]
|
|
)
|
|
}
|
|
} catch {
|
|
contentError = error as NSError
|
|
}
|
|
}
|
|
|
|
if let coordinatorError {
|
|
throw coordinatorError
|
|
}
|
|
if let contentError {
|
|
throw contentError
|
|
}
|
|
return content
|
|
}
|
|
|
|
private func importFromClipboard() {
|
|
guard let content = UIPasteboard.general.string,
|
|
!content.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
|
|
errorMessage = "Clipboard is empty."
|
|
return
|
|
}
|
|
handleImportContent(content)
|
|
}
|
|
|
|
private func handleImportContent(_ content: String) {
|
|
let shouldForceSingleAccount = importContext == .onboarding
|
|
let allowMultipleAccounts = iapService.isPremium && !shouldForceSingleAccount
|
|
var defaultAccountName = accountStore.selectedAccount?.name
|
|
?? accountStore.accounts.first?.name
|
|
|
|
if shouldForceSingleAccount && iapService.isPremium {
|
|
if accountSelection == .new {
|
|
accountErrorMessage = validateNewAccountName()
|
|
guard accountErrorMessage == nil else { return }
|
|
let trimmed = newAccountName.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
let currency = AppSettings.getOrCreate(in: CoreDataStack.shared.viewContext).currency
|
|
let account = accountRepository.createAccount(
|
|
name: trimmed,
|
|
currency: currency,
|
|
inputMode: .simple,
|
|
notificationFrequency: .monthly,
|
|
customFrequencyMonths: 1
|
|
)
|
|
defaultAccountName = account.name
|
|
} else {
|
|
defaultAccountName = selectedAccountName
|
|
}
|
|
}
|
|
|
|
isImporting = true
|
|
importProgress = 0
|
|
importStatus = "Parsing file"
|
|
|
|
Task {
|
|
let importResult = await ImportService.shared.importDataAsync(
|
|
content: content,
|
|
format: selectedFormat,
|
|
allowMultipleAccounts: allowMultipleAccounts,
|
|
defaultAccountName: defaultAccountName
|
|
) { progress in
|
|
importProgress = progress.fraction
|
|
importStatus = progress.message
|
|
}
|
|
|
|
isImporting = false
|
|
|
|
if importResult.errors.isEmpty {
|
|
resultMessage = "Imported \(importResult.sourcesCreated) sources and \(importResult.snapshotsCreated) snapshots."
|
|
tabSelection.selectedTab = 0
|
|
dismiss()
|
|
} else {
|
|
errorMessage = importResult.errors.joined(separator: "\n")
|
|
}
|
|
}
|
|
}
|
|
|
|
private func shareSampleFile() {
|
|
if selectedFormat == .csv {
|
|
ShareService.shared.shareTextFile(
|
|
content: ImportService.sampleCSV(),
|
|
fileName: "investment_tracker_sample.csv"
|
|
)
|
|
} else {
|
|
ShareService.shared.shareTextFile(
|
|
content: ImportService.sampleJSON(),
|
|
fileName: "investment_tracker_sample.json"
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
#Preview {
|
|
ImportDataView()
|
|
.environmentObject(IAPService())
|
|
.environmentObject(AccountStore(iapService: IAPService()))
|
|
}
|