Book, Page 등 Entity, Storage, Repository, FileManager 생성

MemorialHouse/MHCore/MHCore/MHError.swift

@@ -3,19 +3,37 @@ import Foundation
 public enum MHError: Error, CustomStringConvertible, Equatable {
     case DIContainerResolveFailure(key: String)
     case convertDTOFailure
+    case fetchFaliure
     case findEntityFailure
     case saveContextFailure
+    case directorySettingFailure
+    case fileCreationFailure
+    case fileReadingFailure
+    case fileDeletionFailure
+    case fileMovingFailure
 
     public var description: String {
         switch self {
         case .DIContainerResolveFailure(let key):
             "\(key)에 대한 dependency resolve 실패"
         case .convertDTOFailure:
             "Entity에 대한 DTO 변환 실패"
+        case .fetchFaliure:
+            "Entity Fetch 실패"
         case .findEntityFailure:
             "Entity 찾기 실패"
         case .saveContextFailure:
             "Update된 Context 저장 실패"
+        case .directorySettingFailure:
+            "디렉토리 설정 실패"
+        case .fileCreationFailure:
+            "파일 생성 실패"
+        case .fileReadingFailure:
+            "파일 읽기 실패"
+        case .fileDeletionFailure:
+            "파일 삭제 실패"
+        case .fileMovingFailure:
+            "파일 이동 실패"
         }
     }
 }

MemorialHouse/MHData/MHData/DTO/BookDTO.swift

@@ -0,0 +1,14 @@
+import MHFoundation
+import MHDomain
+
+public struct BookDTO {
+    let id: UUID
+    let pages: [PageDTO]
+
+    func toBook() -> Book {
+        return Book(
+            id: self.id,
+            pages: self.pages.map { $0.toPage() }
+        )
+    }
+}

MemorialHouse/MHData/MHData/DTO/MediaDescriptionDTO.swift

@@ -0,0 +1,16 @@
+import MHFoundation
+import MHDomain
+
+public struct MediaDescriptionDTO: Codable {
+    let id: UUID
+    let type: String
+
+    func toMediaDescription() -> MediaDescription? {
+        guard let type = MediaType(rawValue: self.type) else { return nil }
+
+        return MediaDescription(
+            id: self.id,
+            type: type
+        )
+    }
+}

MemorialHouse/MHData/MHData/DTO/PageDTO.swift

@@ -0,0 +1,19 @@
+import MHFoundation
+import MHDomain
+
+public struct PageDTO: Codable {
+    let id: UUID
+    let metadata: [Int: MediaDescriptionDTO]
+    let text: String
+
+    func toPage() -> Page {
+        let metadata = self.metadata
+            .compactMapValues { $0.toMediaDescription() }
+
+        return Page(
+            id: self.id,
+            metadata: metadata,
+            text: self.text
+        )
+    }
+}

MemorialHouse/MHData/MHData/LocalStorage/BookStorage.swift

@@ -0,0 +1,9 @@
+import MHFoundation
+import MHCore
+
+public protocol BookStorage {
+    func create(data: BookDTO) async -> Result<Void, MHError>
+    func fetch(with id: UUID) async -> Result<BookDTO, MHError>
+    func update(with id: UUID, data: BookDTO) async -> Result<Void, MHError>
+    func delete(with id: UUID) async -> Result<Void, MHError>
+}

MemorialHouse/MHData/MHData/LocalStorage/CoreData/CoreDataBookCoverStorage.swift

@@ -39,7 +39,7 @@ extension CoreDataBookCoverStorage: BookCoverStorage {
             return .success(result)
         } catch {
             MHLogger.debug("Error fetching book covers: \(error.localizedDescription)")
-            return .failure(.convertDTOFailure)
+            return .failure(.fetchFaliure)
         }
     }
 

MemorialHouse/MHData/MHData/LocalStorage/CoreData/CoreDataBookStorage.swift

@@ -0,0 +1,104 @@
+import MHFoundation
+import MHCore
+import CoreData
+
+final class CoreDataBookStorage {
+    private let coreDataStorage: CoreDataStorage
+
+    init(coreDataStorage: CoreDataStorage) {
+        self.coreDataStorage = coreDataStorage
+    }
+}
+
+extension CoreDataBookStorage: BookStorage {
+    func create(data: BookDTO) async -> Result<Void, MHError> {
+        let context = coreDataStorage.persistentContainer.viewContext
+        guard let entity = NSEntityDescription.entity(forEntityName: "BookEntity", in: context) else {
+            return .failure(.DIContainerResolveFailure(key: "BookEntity"))
+        }
+
+        let book = NSManagedObject(entity: entity, insertInto: context)
+        book.setValue(data.id, forKey: "id")
+        book.setValue(DTOPagesToCore(data.pages), forKey: "pages")
+
+        await coreDataStorage.saveContext()
+        return .success(())
+    }
+    func fetch(with id: UUID) async -> Result<BookDTO, MHError> {
+        let context = coreDataStorage.persistentContainer.viewContext
+
+        do {
+            guard let bookEntity = try getEntityByIdentifier(in: context, with: id)
+            else { return .failure(.findEntityFailure) }
+
+            guard let result = coreBookToDTO(bookEntity)
+            else { return .failure(.convertDTOFailure) }
+
+            return .success(result)
+        } catch {
+            MHLogger.debug("Error fetching book: \(error.localizedDescription)")
+            return .failure(.findEntityFailure)
+        }
+    }
+    func update(with id: UUID, data: BookDTO) async -> Result<Void, MHError> {
+        do {
+            let context = coreDataStorage.persistentContainer.viewContext
+            guard let newEntity = try getEntityByIdentifier(in: context, with: id) else {
+                return .failure(.findEntityFailure)
+            }
+            newEntity.setValue(data.id, forKey: "id")
+            newEntity.setValue(DTOPagesToCore(data.pages), forKey: "pages")
+
+            await coreDataStorage.saveContext()
+            return .success(())
+        } catch {
+            return .failure(.findEntityFailure)
+        }
+    }
+    func delete(with id: UUID) async -> Result<Void, MHError> {
+        do {
+            let context = coreDataStorage.persistentContainer.viewContext
+            guard let entity = try getEntityByIdentifier(in: context, with: id) else {
+                return .failure(.findEntityFailure)
+            }
+
+            context.delete(entity)
+
+            await coreDataStorage.saveContext()
+            return .success(())
+        } catch {
+            return .failure(.findEntityFailure)
+        }
+    }
+
+    private func getEntityByIdentifier(in context: NSManagedObjectContext, with id: UUID) throws -> BookEntity? {
+        let request = BookEntity.fetchRequest()
+
+        request.predicate = NSPredicate(
+            format: "id == %@", id as CVarArg
+        )
+
+        return try context.fetch(request).first
+    }
+}
+
+// MARK: - Mapper
+extension CoreDataBookStorage {
+    // MARK: - Core to DTO
+    private func coreBookToDTO(_ book: BookEntity) -> BookDTO? {
+        guard let id = book.id,
+              let pages = try? JSONDecoder().decode([PageDTO].self, from: book.pages ?? Data())
+        else { return nil }
+
+        return BookDTO(
+            id: id,
+            pages: pages
+        )
+    }
+
+    // MARK: - DTO to Core
+    private func DTOPagesToCore(_ pages: [PageDTO]) -> Data? {
+        guard let data = try? JSONEncoder().encode(pages) else { return nil }
+        return data
+    }
+}

MemorialHouse/MHData/MHData/LocalStorage/CoreData/MemorialHouseModel.xcdatamodeld/MemorialHouseModel.xcdatamodel/contents

@@ -8,4 +8,8 @@
         <attribute name="imageURL" optional="YES" attributeType="String"/>
         <attribute name="title" optional="YES" attributeType="String"/>
     </entity>
+    <entity name="BookEntity" representedClassName="BookEntity" syncable="YES" codeGenerationType="class">
+        <attribute name="id" attributeType="UUID" usesScalarValueType="NO"/>
+        <attribute name="pages" optional="YES" attributeType="Binary" customClassName="[PageEntity]"/>
+    </entity>
 </model>

MemorialHouse/MHData/MHData/LocalStorage/FileManager/MHFileManager.swift

@@ -0,0 +1,88 @@
+import MHFoundation
+import MHCore
+import MHDomain
+
+public struct MHFileManager {
+    private let fileManager = FileManager.default
+    private let directoryType: FileManager.SearchPathDirectory
+
+    public init(directoryType: FileManager.SearchPathDirectory) {
+        self.directoryType = directoryType
+    }
+}
+
+extension MHFileManager: FileStorage {
+    func create(at path: String, fileName name: String, data: Data) async -> Result<Void, MHError> {
+        guard let directory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: path)
+        else { return .failure(.directorySettingFailure) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            try fileManager.createDirectory(at: directory, withIntermediateDirectories: true)
+            try data.write(to: dataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileCreationFailure)
+        }
+    }
+    func read(at path: String, fileName name: String) async -> Result<Data, MHError> {
+        guard let directory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: path)
+        else { return .failure(.directorySettingFailure) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            return .success(try Data(contentsOf: dataPath))
+        } catch {
+            return .failure(.fileReadingFailure)
+        }
+    }
+    func delete(at path: String, fileName name: String) async -> Result<Void, MHError> {
+        guard let directory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: path)
+        else { return .failure(.directorySettingFailure) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            try fileManager.removeItem(at: dataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileDeletionFailure)
+        }
+    }
+    func move(at path: String, fileName name: String, to newPath: String) async -> Result<Void, MHError> {
+        guard let originDirectory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: path)
+        else { return .failure(.directorySettingFailure) }
+
+        let originDataPath = originDirectory.appendingPathComponent(name)
+
+        guard let newDirectory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: newPath)
+        else { return .failure(.directorySettingFailure) }
+
+        let newDataPath = newDirectory.appendingPathComponent(name)
+
+        do {
+            try fileManager.createDirectory(at: newDirectory, withIntermediateDirectories: true)
+            try fileManager.moveItem(at: originDataPath, to: newDataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileMovingFailure)
+        }
+    }
+}

MemorialHouse/MHData/MHData/LocalStorage/FileStorage.swift

@@ -0,0 +1,9 @@
+import MHFoundation
+import MHCore
+
+protocol FileStorage {
+    func create(at path: String, fileName name: String, data: Data) async -> Result<Void, MHError>
+    func read(at path: String, fileName name: String) async -> Result<Data, MHError>
+    func delete(at path: String, fileName name: String) async -> Result<Void, MHError>
+    func move(at path: String, fileName name: String, to newPath: String) async -> Result<Void, MHError>
+}

MemorialHouse/MHData/MHData/Repository/LocalBookRepository.swift

@@ -0,0 +1,61 @@
+import MHFoundation
+import MHDomain
+import MHCore
+
+public struct LocalBookRepository: BookRepository {
+    private let storage: BookStorage
+
+    public init(storage: BookStorage) {
+        self.storage = storage
+    }
+
+    public func create(book: Book) async {
+        let bookDTO = mappingBookToDTO(book)
+
+        _ = await storage.create(data: bookDTO)
+    }
+    public func fetch(bookID id: UUID) async -> Book? {
+        let result = await storage.fetch(with: id)
+
+        switch result {
+        case .success(let bookDTO):
+            return bookDTO.toBook()
+        case .failure(let failure):
+            MHLogger.debug("\(failure.description)")
+        }
+
+        return nil
+    }
+    public func update(bookID id: UUID, to book: Book) async {
+        let bookDTO = mappingBookToDTO(book)
+
+        _ = await storage.update(with: id, data: bookDTO)
+    }
+    public func delete(bookID id: UUID) async {
+        _ = await storage.delete(with: id)
+    }
+
+    private func mappingBookToDTO(_ book: Book) -> BookDTO {
+        let pages = book.pages.map { mappingPageToDTO($0) }
+        return BookDTO(
+            id: book.id,
+            pages: pages
+        )
+    }
+    private func mappingPageToDTO(_ page: Page) -> PageDTO {
+        let meatadata = page.metadata
+            .compactMapValues { mappingMediaDescriptionToDTO($0) }
+
+        return PageDTO(
+            id: page.id,
+            metadata: meatadata,
+            text: page.text
+        )
+    }
+    private func mappingMediaDescriptionToDTO(_ description: MediaDescription) -> MediaDescriptionDTO {
+        return MediaDescriptionDTO(
+            id: description.id,
+            type: description.type.rawValue
+        )
+    }
+}