WIP - Complete App refactoring

Nextcloud Cookbook iOS Client/Persistence/Interfaces/LocalDataInterface.swift

@@ -0,0 +1,161 @@
+//
+//  LocalDataInterface.swift
+//  Nextcloud Cookbook iOS Client
+//
+//  Created by Vincent Meilinger on 07.05.24.
+//
+
+import Foundation
+import SwiftUI
+
+
+class LocalDataInterface: CookbookInterface {
+    var id: String
+        
+    init(id: String) {
+        self.id = id
+    }
+    
+    enum LocalDataPath {
+        case recipeStubs(category: String),
+             recipe(id: String),
+             image(id: String, size: RecipeImage.RecipeImageSize),
+             categories,
+             keywords
+        
+        var path: String {
+            switch self {
+            case .recipe(let id):
+                "recipe_\(id).data"
+            case .recipeStubs(let category):
+                "recipes_\(category).data"
+            case .image(let id, let size):
+                if size == .FULL {
+                    "image_\(id).data"
+                } else {
+                    "thumb_\(id).data"
+                }
+            case .categories:
+                "categories.data"
+            case .keywords:
+                "keywords.data"
+            }
+        }
+    }
+}
+
+
+
+// MARK: - Local Read Interface
+
+extension LocalDataInterface: ReadInterface {
+    
+    func getImage(id: String, size: RecipeImage.RecipeImageSize) async -> (UIImage?, (any UserAlert)?) {
+        guard let data: String = await load(path: .image(id: id, size: size)) else {
+            return (nil, PersistenceAlert.LOAD_FAILED)
+        }
+        guard let dataDecoded = Data(base64Encoded: data) else { return (nil, PersistenceAlert.DECODING_FAILED) }
+        if let image = UIImage(data: dataDecoded) {
+            return (image, nil)
+        }
+        return (nil, nil)
+    }
+    
+    func getRecipeStubs() async -> ([RecipeStub]?, (any UserAlert)?) {
+        return (nil, PersistenceAlert.LOAD_FAILED)
+    }
+    
+    func getRecipe(id: String) async -> (Recipe?, (any UserAlert)?) {
+        if let recipe: Recipe? = await load(path: LocalDataPath.recipe(id: id)) {
+            return (recipe, nil)
+        }
+        return (nil, nil)
+    }
+    
+    func getCategories() async -> ([Category]?, (any UserAlert)?) {
+        return (await load(path: LocalDataPath.categories), nil)
+    }
+    
+    func getRecipeStubsForCategory(named categoryName: String) async -> ([RecipeStub]?, (any UserAlert)?) {
+        if let stubs: [RecipeStub] = await load(path: .recipeStubs(category: categoryName)) {
+            return (stubs, nil)
+        }
+        return (nil, PersistenceAlert.LOAD_FAILED)
+    }
+    
+    func getTags() async -> ([RecipeKeyword]?, (any UserAlert)?) {
+        if let keywords: [RecipeKeyword] = await load(path: .keywords) {
+            return (keywords, nil)
+        }
+        return (nil, PersistenceAlert.LOAD_FAILED)
+    }
+    
+    func getRecipesTagged(keyword: String) async -> ([RecipeStub]?, (any UserAlert)?) {
+        return (nil, PersistenceAlert.LOAD_FAILED)
+    }
+    
+}
+
+
+
+// MARK: - Local Write Interface
+
+extension LocalDataInterface: WriteInterface {
+    
+    func postImage(id: String, image: UIImage, size: RecipeImage.RecipeImageSize) async -> ((any UserAlert)?) {
+        if let data = image.pngData() {
+            await save(
+                data,
+                path: LocalDataPath.image(id: id, size: size)
+            )
+        }
+    }
+    
+    func postRecipe(recipe: Recipe) async -> ((any UserAlert)?) {
+        await save(recipe, path: LocalDataPath.recipe(id: recipe.id))
+        return nil
+    }
+    
+    func updateRecipe(recipe: Recipe) async -> ((any UserAlert)?) {
+        return await postRecipe(recipe: recipe)
+    }
+    
+    func deleteRecipe(id: String) async -> ((any UserAlert)?) {
+        await delete(path: .recipe(id: id))
+        return nil
+    }
+    
+    func renameCategory(named categoryName: String, newName: String) async -> ((any UserAlert)?) {
+        guard let stubs: [RecipeStub] = await load(path: .recipeStubs(category: categoryName)) else {
+            return PersistenceAlert.LOAD_FAILED
+        }
+        await delete(path: .recipeStubs(category: categoryName))
+        await save(stubs, path: .recipeStubs(category: newName))
+    }
+    
+}
+
+
+
+// MARK: - Local Data Interface Utils
+
+extension LocalDataInterface {
+    
+    func load<T: Codable>(path ldPath: LocalDataPath) async -> T? {
+        do {
+            return try await DataStore.shared.load(fromPath: ldPath.path)
+        } catch (let error) {
+            print(error)
+            return nil
+        }
+    }
+    
+    func save<T: Codable>(_ object: T, path ldPath: LocalDataPath) async {
+        await DataStore.shared.save(data: object, toPath: ldPath.path)
+    }
+    
+    func delete(path ldPath: LocalDataPath) async {
+        DataStore.shared.delete(path: ldPath.path)
+    }
+    
+}