아이폰 캘린더 연동 & 토덕 서버의 일정과 통합하여 함께 표시

Projects/TDCore/Sources/Error/TDDataError.swift

@@ -14,6 +14,7 @@ public enum TDDataError: Error, Equatable {
     case parsingError
     case createRequestFailure
     case fetchRequestFailure
+    case permissionDenied
 
     /// 로그인
     case invalidIDOrPassword
@@ -56,6 +57,8 @@ extension TDDataError: CustomStringConvertible {
             "요청 생성 실패"
         case .fetchRequestFailure:
             "요청 실패"
+        case .permissionDenied:
+            "권한이 거부되었습니다."
 
         /// 로그인 관련
         case .invalidIDOrPassword:

Projects/TDData/Sources/DTO/ScheduleListResponseDTO.swift

@@ -55,7 +55,8 @@ public extension ScheduleHeadDTO {
             place: location,
             memo: memo,
             isFinished: false,
-            scheduleRecords: records
+            scheduleRecords: records,
+            source: .server
         )
     }
 }

Projects/TDData/Sources/DataAssembly.swift

@@ -70,7 +70,10 @@ public struct DataAssembly: Assembly {
             guard let service = container.resolve(ScheduleService.self) else {
                 fatalError("ScheduleService is not registered")
             }
-            return ScheduleRepositoryImpl(service: service)
+            guard let storage = container.resolve(ScheduleStorage.self) else {
+                fatalError("ScheduleStorage is not registered")
+            }
+            return ScheduleRepositoryImpl(service: service, storage: storage)
         }.inObjectScope(.container)
 
         container.register(UserRepository.self) { _ in

Projects/TDData/Sources/Repository/ScheduleRepositoryImpl.swift

@@ -1,48 +1,75 @@
 import TDCore
+import EventKit
 import TDDomain
 import Foundation
 
 public final class ScheduleRepositoryImpl: ScheduleRepository {
     private let service: ScheduleService
+    private let storage: ScheduleStorage
 
-    public init(service: ScheduleService) {
+    public init(
+        service: ScheduleService,
+        storage: ScheduleStorage
+    ) {
         self.service = service
+        self.storage = storage
     }
 
     public func createSchedule(schedule: Schedule) async throws {
         let scheduleRequestDTO = ScheduleRequestDTO(schedule: schedule)
         try await service.createSchedule(schedule: scheduleRequestDTO)
     }
 
-    public func fetchScheduleList(startDate: String, endDate: String) async throws -> [Schedule] {
+    public func fetchServerScheduleList(startDate: String, endDate: String) async throws -> [Schedule] {
         let responseDTO = try await service.fetchScheduleList(startDate: startDate, endDate: endDate)
         return responseDTO.scheduleHeadDtos.map { $0.convertToSchedule() }
     }
 
-    public func fetchSchedule() async throws -> Schedule {
-        return
-            Schedule(
-                id: 0,
-                title: "title",
-                category: TDCategory(colorHex: "", imageName: ""),
-                startDate: "",
-                endDate: "",
-                isAllDay: false,
-                time: nil,
+    public func fetchLocalCalendarScheduleList(startDate: String, endDate: String) async throws -> [Schedule] {
+        let format = DateFormatType.yearMonthDay
+        let calendar = Calendar.current
+
+        guard let startDay = Date.convertFromString(startDate, format: format),
+              let endDay = Date.convertFromString(endDate, format: format) else {
+            throw TDDataError.convertDTOFailure
+        }
+
+        let rangeStartDate = calendar.startOfDay(for: startDay)
+
+        guard let rangeEndDate = calendar.date(byAdding: .day, value: 1, to: calendar.startOfDay(for: endDay)) else {
+            throw TDDataError.convertDTOFailure
+        }
+
+        let events = try await storage.fetchEvents(from: rangeStartDate, to: rangeEndDate)
+
+        return mapToSchedules(from: events)
+    }
+
+    private func mapToSchedules(from events: [EKEvent]) -> [Schedule] {
+        return events.map { event in
+            return Schedule(
+                id: event.eventIdentifier.hashValue,
+                title: event.title ?? "",
+                category: TDCategory(colorHex: "#FFFFFF", imageName: "none"),
+                startDate: event.startDate.convertToString(formatType: .yearMonthDay),
+                endDate: event.endDate.convertToString(formatType: .yearMonthDay),
+                isAllDay: event.isAllDay,
+                time: event.isAllDay ? nil : event.startDate.convertToString(formatType: .time24Hour),
                 repeatDays: nil,
                 alarmTime: nil,
-                place: nil,
-                memo: nil,
+                place: event.location,
+                memo: event.notes,
                 isFinished: false,
-                scheduleRecords: nil
+                scheduleRecords: nil,
+                source: .localCalendar
             )
+        }
     }
 
     public func finishSchedule(scheduleId: Int, isComplete: Bool, queryDate: String) async throws {
         try await service.finishSchedule(scheduleId: scheduleId, isComplete: isComplete, queryDate: queryDate)
     }
 
-
     public func updateSchedule(scheduleId: Int, isOneDayDeleted: Bool, queryDate: String, scheduleData: Schedule) async throws {
         let scheduleData = ScheduleDataDTO(schedule: scheduleData)
         let scheduleUpdateRequestDTO = ScheduleUpdateRequestDTO(
@@ -61,8 +88,4 @@ public final class ScheduleRepositoryImpl: ScheduleRepository {
             queryDate: queryDate
         )
     }
-
-    public func moveTomorrowSchedule(scheduleId: Int) async throws {
-
-    }
 }

Projects/TDData/Sources/StorageProtocol/ScheduleStorage.swift

@@ -0,0 +1,15 @@
+import Foundation
+import EventKit
+
+/// 캘린더 데이터 소스(Storage)가 수행해야 하는 기능을 정의하는 프로토콜입니다.
+/// EventKit 프레임워크에 직접 접근하여 원시 데이터인 `EKEvent`를 가져오는 역할을 합니다.
+public protocol ScheduleStorage {
+
+    /// 지정된 기간에 해당하는 모든 캘린더 이벤트를 가져옵니다.
+    /// - Parameters:
+    ///   - startDate: 조회를 시작할 날짜
+    ///   - endDate: 조회를 종료할 날짜
+    /// - Returns: EventKit의 원시 데이터 모델인 `EKEvent`의 배열
+    /// - Throws: 권한이 없거나 데이터를 가져오는 중 오류가 발생하면 에러를 던집니다.
+    func fetchEvents(from startDate: Date, to endDate: Date) async throws -> [EKEvent]
+}

Projects/TDDomain/Sources/DomainAssembly.swift

@@ -313,18 +313,18 @@ public struct DomainAssembly: Assembly {
             return FetchRoutineUseCaseImpl(repository: repository)
         }
 
-        container.register(FetchScheduleListUseCase.self) { resolver in
+        container.register(FetchServerScheduleListUseCase.self) { resolver in
             guard let repository = resolver.resolve(ScheduleRepository.self) else {
                 fatalError("컨테이너에 ScheduleRepository가 등록되어 있지 않습니다.")
             }
-            return FetchScheduleListUseCaseImpl(repository: repository)
+            return FetchServerScheduleListUseCaseImpl(repository: repository)
         }
 
-        container.register(FetchScheduleUseCase.self) { resolver in
+        container.register(FetchLocalCalendarScheduleListUseCase.self) { resolver in
             guard let repository = resolver.resolve(ScheduleRepository.self) else {
                 fatalError("컨테이너에 ScheduleRepository가 등록되어 있지 않습니다.")
             }
-            return FetchScheduleUseCaseImpl(repository: repository)
+            return FetchLocalCalendarScheduleListUseCaseImpl(repository: repository)
         }
 
         container.register(FetchUserPostUseCase.self) { resolver in
@@ -390,13 +390,6 @@ public struct DomainAssembly: Assembly {
             return FinishRoutineUseCaseImpl(repository: repository)
         }
 
-        container.register(MoveTomorrowScheduleUseCase.self) { resolver in
-            guard let repository = resolver.resolve(ScheduleRepository.self) else {
-                fatalError("컨테이너에 ScheduleRepository가 등록되어 있지 않습니다.")
-            }
-            return MoveTomorrowScheduleUseCaseImpl(repository: repository)
-        }
-
         container.register(ReportCommentUseCase.self) { resolver in
             guard let repository = resolver.resolve(SocialRepository.self) else {
                 fatalError("컨테이너에 SocialRepository가 등록되어 있지 않습니다.")

Projects/TDDomain/Sources/Entity/Schedule.swift

@@ -1,6 +1,11 @@
 import Foundation
 
 public struct Schedule: TodoItem {
+    public enum Source {
+        case server
+        case localCalendar
+    }
+
     public let id: Int? // 서버의 일정 PK
     public let title: String
     public let category: TDCategory
@@ -15,6 +20,7 @@ public struct Schedule: TodoItem {
     public let isFinished: Bool
     public let scheduleRecords: [ScheduleRecord]?
     public let eventMode: TDTodoMode = .schedule
+    public let source: Source
 
     public var isRepeating: Bool {
         repeatDays != nil || startDate != endDate
@@ -33,7 +39,8 @@ public struct Schedule: TodoItem {
         place: String?,
         memo: String?,
         isFinished: Bool,
-        scheduleRecords: [ScheduleRecord]?
+        scheduleRecords: [ScheduleRecord]?,
+        source: Source
     ) {
         self.id = id
         self.title = title
@@ -48,6 +55,7 @@ public struct Schedule: TodoItem {
         self.memo = memo
         self.isFinished = isFinished
         self.scheduleRecords = scheduleRecords
+        self.source = source
     }
 }
 

Projects/TDDomain/Sources/RepositoryProtocol/ScheduleRepository.swift

@@ -4,9 +4,8 @@ import TDCore
 public protocol ScheduleRepository {
     func createSchedule(schedule: Schedule) async throws
     func finishSchedule(scheduleId: Int, isComplete: Bool, queryDate: String) async throws
-    func fetchSchedule() async throws -> Schedule
-    func fetchScheduleList(startDate: String, endDate: String) async throws -> [Schedule]
+    func fetchServerScheduleList(startDate: String, endDate: String) async throws -> [Schedule]
+    func fetchLocalCalendarScheduleList(startDate: String, endDate: String) async throws -> [Schedule]
     func updateSchedule(scheduleId: Int, isOneDayDeleted: Bool, queryDate: String, scheduleData: Schedule) async throws
     func deleteSchedule(scheduleId: Int, isOneDayDeleted: Bool, queryDate: String) async throws
-    func moveTomorrowSchedule(scheduleId: Int) async throws
 }

Projects/TDDomain/Sources/UseCase/Schedule/FetchAllSchedulesUseCase.swift

@@ -0,0 +1,33 @@
+import Foundation
+import TDCore
+
+public protocol FetchAllSchedulesUseCase {
+    func execute(startDate: String, endDate: String) async throws -> [Date: [Schedule]]
+}
+
+public final class FetchAllSchedulesUseCaseImpl: FetchAllSchedulesUseCase {
+    private let serverUseCase: FetchServerScheduleListUseCase
+    private let localUseCase: FetchLocalCalendarScheduleListUseCase
+
+    public init(
+        serverUseCase: FetchServerScheduleListUseCase,
+        localUseCase: FetchLocalCalendarScheduleListUseCase
+    ) {
+        self.serverUseCase = serverUseCase
+        self.localUseCase = localUseCase
+    }
+
+    public func execute(startDate: String, endDate: String) async throws -> [Date: [Schedule]] {
+        async let serverSchedulesTask = serverUseCase.execute(startDate: startDate, endDate: endDate)
+        async let localSchedulesTask = localUseCase.execute(startDate: startDate, endDate: endDate)
+
+        let (serverSchedules, localSchedules) = try await (serverSchedulesTask, localSchedulesTask)
+
+        var combinedSchedules = serverSchedules
+        for (date, schedules) in localSchedules {
+            combinedSchedules[date, default: []].append(contentsOf: schedules)
+        }
+
+        return combinedSchedules
+    }
+}

Projects/TDDomain/Sources/UseCase/Schedule/FetchLocalCalendarScheduleListUseCase.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+public protocol FetchLocalCalendarScheduleListUseCase {
+    func execute(startDate: String, endDate: String) async throws -> [Date: [Schedule]]
+}
+
+public final class FetchLocalCalendarScheduleListUseCaseImpl: FetchLocalCalendarScheduleListUseCase {
+    private let repository: ScheduleRepository
+
+    public init(repository: ScheduleRepository) {
+        self.repository = repository
+    }
+
+    public func execute(
+        startDate: String,
+        endDate: String
+    ) async throws -> [Date: [Schedule]] {
+        let schedules = try await repository.fetchLocalCalendarScheduleList(
+            startDate: startDate,
+            endDate: endDate
+        )
+
+        return groupSchedulesByDay(schedules: schedules)
+    }
+
+    private func groupSchedulesByDay(schedules: [Schedule]) -> [Date: [Schedule]] {
+        var groupedDictionary = [Date: [Schedule]]()
+        let calendar = Calendar.current
+
+        for schedule in schedules {
+            guard
+                let startDate = Date.convertFromString(schedule.startDate, format: .yearMonthDay),
+                let endDate = Date.convertFromString(schedule.endDate, format: .yearMonthDay)
+            else { continue }
+
+            var currentDate = startDate
+            while calendar.startOfDay(for: currentDate) <= calendar.startOfDay(for: endDate) {
+                let dayKey = calendar.startOfDay(for: currentDate)
+                groupedDictionary[dayKey, default: []].append(schedule)
+
+                if let nextDay = calendar.date(byAdding: .day, value: 1, to: currentDate) {
+                    currentDate = nextDay
+                } else {
+                    break
+                }
+            }
+        }
+
+        return groupedDictionary
+    }
+}

Projects/TDDomain/Sources/UseCase/Schedule/FetchScheduleListUseCase.swift → Projects/TDDomain/Sources/UseCase/Schedule/FetchServerScheduleListUseCase.swift

@@ -1,11 +1,11 @@
 import TDCore
 import Foundation
 
-public protocol FetchScheduleListUseCase {
+public protocol FetchServerScheduleListUseCase {
     func execute(startDate: String, endDate: String) async throws -> [Date: [Schedule]]
 }
 
-public final class FetchScheduleListUseCaseImpl: FetchScheduleListUseCase {
+public final class FetchServerScheduleListUseCaseImpl: FetchServerScheduleListUseCase {
     private let repository: ScheduleRepository
 
     public init(repository: ScheduleRepository) {
@@ -16,7 +16,7 @@ public final class FetchScheduleListUseCaseImpl: FetchScheduleListUseCase {
         startDate: String,
         endDate: String
     ) async throws -> [Date: [Schedule]] {
-        let fetchedScheduleList = try await repository.fetchScheduleList(startDate: startDate, endDate: endDate)
+        let fetchedScheduleList = try await repository.fetchServerScheduleList(startDate: startDate, endDate: endDate)
         let filteredScheduleList = filterScheduleList(with: fetchedScheduleList, startDate: startDate, endDate: endDate)
         let buildScheduleDictionary = buildScheduleDictionary(with: filteredScheduleList, queryStartDate: startDate, queryEndDate: endDate)
 
@@ -175,23 +175,8 @@ public final class FetchScheduleListUseCaseImpl: FetchScheduleListUseCase {
             place: schedule.place,
             memo: schedule.memo,
             isFinished: isFinished,
-            scheduleRecords: schedule.scheduleRecords
+            scheduleRecords: schedule.scheduleRecords,
+            source: .server
         )
     }
 }
-
-extension Date {
-    func weekdayEnum() -> TDWeekDay {
-        let weekday = Calendar.current.component(.weekday, from: self)
-        switch weekday {
-        case 1: return .sunday
-        case 2: return .monday
-        case 3: return .tuesday
-        case 4: return .wednesday
-        case 5: return .thursday
-        case 6: return .friday
-        case 7: return .saturday
-        default: return .monday
-        }
-    }
-}