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

MemorialHouse/MHCore/MHCore/MHError.swift

@@ -5,6 +5,11 @@ public enum MHError: Error, CustomStringConvertible, Equatable {
     case convertDTOFailure
     case findEntityFailure
     case saveContextFailure
+    case directorySettingError
+    case fileCreationError
+    case fileReadingError
+    case fileDeletionError
+    case fileMovingError
 
     public var description: String {
         switch self {
@@ -16,6 +21,16 @@ public enum MHError: Error, CustomStringConvertible, Equatable {
             "Entity 찾기 실패"
         case .saveContextFailure:
             "Update된 Context 저장 실패"
+        case .directorySettingError:
+            "디렉토리 설정 실패"
+        case .fileCreationError:
+            "파일 생성 실패"
+        case .fileReadingError:
+            "파일 읽기 실패"
+        case .fileDeletionError:
+            "파일 삭제 실패"
+        case .fileMovingError:
+            "파일 이동 실패"
         }
     }
 }

MemorialHouse/MHData/MHData/DTO/BookDTO.swift

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

MemorialHouse/MHData/MHData/DTO/MediaDescriptionDTO.swift

@@ -0,0 +1,16 @@
+import MHFoundation
+import MHDomain
+
+public struct MediaDescriptionDTO {
+    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 {
+    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/CoreDataBookStorage.swift

@@ -0,0 +1,99 @@
+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, MHCore.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(data.index, forKey: "index")
+        book.setValue(data.pages, forKey: "pages")
+
+        await coreDataStorage.saveContext()
+        return .success(())
+    }
+    func fetch(with id: UUID) async -> Result<BookDTO, MHCore.MHError> {
+        let context = coreDataStorage.persistentContainer.viewContext
+        let request = BookEntity.fetchRequest()
+
+        request.predicate = NSPredicate(
+            format: "id LIKE %@", "\(id.uuidString)"
+        )
+
+
+        do {
+            let bookEntity = try context.fetch(request)
+            guard let result = bookEntity.first?.toBookDTO()
+            else { throw MHError.convertDTOFailure }
+
+            return .success(result)
+        } catch {
+            MHLogger.debug("Error fetching book covers: \(error.localizedDescription)")
+            return .failure(.convertDTOFailure)
+        }
+    }
+    func update(with id: UUID, data: BookDTO) async -> Result<Void, MHCore.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(data.index, forKey: "index")
+            newEntity.setValue(data.pages, forKey: "pages")
+
+            await coreDataStorage.saveContext()
+            return .success(())
+        } catch {
+            return .failure(.findEntityFailure)
+        }
+    }
+    func delete(with id: UUID) async -> Result<Void, MHCore.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()
+
+        return try context.fetch(request).first(where: { $0.id == id })
+    }
+}
+
+extension BookEntity {
+    func toBookDTO() -> BookDTO? {
+        guard let id = self.id,
+              let index = self.index,
+              let pages = self.pages else { return nil }
+
+        return BookDTO(
+            id: id,
+            index: index,
+            pages: pages
+        )
+    }
+}

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

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<model type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="23507" systemVersion="24A348" minimumToolsVersion="Automatic" sourceLanguage="Swift" usedWithSwiftData="YES" userDefinedModelVersionIdentifier="">
+<model type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="23231" systemVersion="24A348" minimumToolsVersion="Automatic" sourceLanguage="Swift" usedWithSwiftData="YES" userDefinedModelVersionIdentifier="">
     <entity name="BookCoverEntity" representedClassName="BookCoverEntity" syncable="YES" codeGenerationType="class">
         <attribute name="category" optional="YES" attributeType="String"/>
         <attribute name="color" optional="YES" attributeType="String" customClassName="BookColor"/>
@@ -8,4 +8,9 @@
         <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="index" optional="YES" attributeType="Transformable" customClassName="[Int]"/>
+        <attribute name="pages" optional="YES" attributeType="Transformable" customClassName="[PageDTO]"/>
+    </entity>
 </model>

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

@@ -0,0 +1,83 @@
+import MHFoundation
+import MHCore
+import MHDomain
+
+public struct MHFileManager {
+    private let fileManager = FileManager.default
+    private let directoryType: FileManager.SearchPathDirectory
+}
+
+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(.directorySettingError) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            try fileManager.createDirectory(at: directory, withIntermediateDirectories: false)
+            try data.write(to: dataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileCreationError)
+        }
+    }
+    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(.directorySettingError) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            return .success(try Data(contentsOf: dataPath))
+        } catch {
+            return .failure(.fileReadingError)
+        }
+    }
+    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(.directorySettingError) }
+
+        let dataPath = directory.appendingPathComponent(name)
+
+        do {
+            try fileManager.removeItem(at: dataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileDeletionError)
+        }
+    }
+    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(.directorySettingError) }
+
+        let originDataPath = originDirectory.appendingPathComponent(name)
+
+        guard let newDirectory = fileManager.urls(
+            for: directoryType,
+            in: .userDomainMask
+        ).first?.appending(path: newPath)
+        else { return .failure(.directorySettingError) }
+
+        let newDataPath = newDirectory.appendingPathComponent(name)
+
+        do {
+            try fileManager.moveItem(at: originDataPath, to: newDataPath)
+            return .success(())
+        } catch {
+            return .failure(.fileMovingError)
+        }
+    }
+}

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,62 @@
+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 fetchBook(with 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(id: UUID, book: Book) async {
+        let bookDTO = mappingBookToDTO(book)
+
+        _ = await storage.update(with: id, data: bookDTO)
+    }
+    public func deleteBook(_ 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,
+            index: book.index,
+            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
+        )
+    }
+}