Rework storage structs, link preview

CHDataManagement/Model/Loading/LoadingContext.swift

@@ -0,0 +1,110 @@
+
+final class LoadingContext {
+
+    let content: Content
+
+    var files: [String: FileResource] = [:]
+
+    var pages: [String : Page] = [:]
+
+    var tags: [String : Tag] = [:]
+
+    var posts: [String : Post] = [:]
+
+    var errors: Set<String> = []
+
+    var tagOverview: TagOverview?
+
+    var settings: Settings?
+
+    init(content: Content) {
+        self.content = content
+    }
+
+    func results() -> LoadingResult {
+        .init(
+            settings: settings ?? .default,
+            posts: posts.values.sorted(ascending: false) { $0.startDate },
+            pages: pages.values.sorted(ascending: false) { $0.startDate },
+            tags: tags.values.sorted(),
+            files: files.values.sorted { $0.id },
+            tagOverview: tagOverview,
+            errors: errors.sorted())
+    }
+
+    func error(_ message: String) {
+        errors.insert(message)
+    }
+
+    func post(_ postId: String) -> Post? {
+        if let post = posts[postId] {
+            return post
+        }
+        error("Missing post \(postId)")
+        return nil
+    }
+
+    func tag(_ tagId: String) -> Tag? {
+        if let tag = tags[tagId] {
+            return tag
+        }
+        error("Missing tag \(tagId)")
+        return nil
+    }
+
+    func page(_ pageId: String) -> Page? {
+        if let page = pages[pageId] {
+            return page
+        }
+        error("Missing page \(pageId)")
+        return nil
+    }
+
+    func file(_ fileId: String) -> FileResource? {
+        if let file = files[fileId] {
+            return file
+        }
+        error("Missing file \(fileId)")
+        return nil
+    }
+
+    func image(_ imageId: String) -> FileResource? {
+        guard let image = file(imageId) else {
+            return nil
+        }
+        if image.type.isImage {
+            return image
+        }
+        error("Image \(imageId) is not an image")
+        return nil
+    }
+
+    func item(itemId: ItemId) -> Item? {
+        switch itemId.type {
+        case .post:
+            guard let id = itemId.id else {
+                error("Missing post id in itemId")
+                return nil
+            }
+            return post(id)
+        case .page:
+            guard let id = itemId.id else {
+                error("Missing page id in itemId")
+                return nil
+            }
+            return page(id)
+        case .tag:
+            guard let id = itemId.id else {
+                error("Missing tag id in itemId")
+                return nil
+            }
+            return tag(id)
+        case .tagOverview:
+            guard let tagOverview else {
+                error("Missing tag overview")
+                return nil
+            }
+            return tagOverview
+        }
+    }
+}

CHDataManagement/Model/Loading/LoadingResult.swift

@@ -0,0 +1,17 @@
+
+struct LoadingResult {
+
+    let settings: Settings
+
+    let posts: [Post]
+
+    let pages: [Page]
+
+    let tags: [Tag]
+
+    let files: [FileResource]
+
+    let tagOverview: Tag?
+
+    let errors: [String]
+}

CHDataManagement/Model/Loading/ModelLoader.swift

@@ -0,0 +1,96 @@
+
+final class ModelLoader {
+
+    let content: Content
+
+    let storage: Storage
+
+    let context: LoadingContext
+
+    init(content: Content, storage: Storage) {
+        self.content = content
+        self.storage = storage
+        self.context = .init(content: content)
+    }
+
+    func load() -> LoadingResult {
+        loadInternal()
+        return context.results()
+    }
+
+    private func loadInternal() {
+        guard storage.contentScope != nil else {
+            context.error("Storage not initialized, not loading content")
+            return
+        }
+
+        loadFiles()
+        loadTags()
+        loadPages()
+        loadPosts()
+        loadSettings()
+    }
+
+    private func loadFiles() {
+        guard let files = storage.loadAllFiles() else {
+            context.error("Failed to load file list")
+            return
+        }
+        if files.isEmpty { print("No files loaded") }
+
+        files.forEach { (fileId, data) in
+            let fileData = data.data
+            let isExternal = data.isExternal
+            context.files[fileId] = FileResource(content: content, id: fileId, data: fileData, isExternalFile: isExternal)
+        }
+    }
+
+    private func loadTags() {
+        guard let tags = storage.loadAllTags() else {
+            context.error("Failed to load file tags")
+            return
+        }
+        if tags.isEmpty { print("No tags loaded") }
+
+        tags.forEach { (tagId, data) in
+            context.tags[tagId] = Tag(context: context, id: tagId, data: data)
+        }
+    }
+
+    private func loadPages() {
+        guard let pages = storage.loadAllPages() else {
+            context.error("Failed to load file pages")
+            return
+        }
+        if pages.isEmpty { print("No pages loaded") }
+
+        pages.forEach { pageId, data in
+            context.pages[pageId] = Page(context: context, id: pageId, data: data)
+        }
+    }
+
+    private func loadPosts() {
+        guard let posts = storage.loadAllPosts() else {
+            context.error("Failed to load file posts")
+            return
+        }
+        if posts.isEmpty { print("No posts loaded") }
+
+        posts.forEach { postId, data in
+            context.posts[postId] = Post(context: context, id: postId, data: data)
+        }
+    }
+
+    private func loadSettings() {
+        guard let settings = storage.loadSettings() else {
+            context.error("Failed to load settings")
+            return
+        }
+
+        context.tagOverview = settings.tagOverview.map { data in
+            TagOverview(context: context, id: "all-tags", data: data)
+        }
+
+        context.settings = Settings(context: context, data: settings)
+    }
+}