A first calendar use case

src/cli/jupiter/cli/command/calendar_show.py

@@ -0,0 +1,24 @@
+"""Command for loading a calendar."""
+from jupiter.cli.command.command import LoggedInReadonlyCommand
+from jupiter.core.use_cases.application.calendar.load_for_date_and_period import (
+    CalendarLoadForDateAndPeriodResult,
+    CalendarLoadForDateAndPeriodUseCase,
+)
+from jupiter.core.use_cases.infra.use_cases import AppLoggedInReadonlyUseCaseContext
+from rich.console import Console
+
+
+class CalendarShow(
+    LoggedInReadonlyCommand[
+        CalendarLoadForDateAndPeriodUseCase, CalendarLoadForDateAndPeriodResult
+    ]
+):
+    """Command for loading a calendar."""
+
+    def _render_result(
+        self,
+        console: Console,
+        context: AppLoggedInReadonlyUseCaseContext,
+        result: CalendarLoadForDateAndPeriodResult,
+    ) -> None:
+        console.print(result)

src/cli/jupiter/cli/command/email_task_show.py

@@ -1,5 +1,4 @@
 """UseCase for showing the email tasks."""
-
 from jupiter.cli.command.command import LoggedInReadonlyCommand
 from jupiter.cli.command.rendering import (
     actionable_date_to_rich_text,

src/core/jupiter/core/domain/concept/schedule/schedule_event_full_days.py

@@ -32,7 +32,7 @@ class ScheduleEventFullDays(LeafEntity):
 
     time_event_full_day_block = OwnsOne(
         TimeEventFullDaysBlock,
-        namespace=TimeEventNamespace.SCHEDULE_FULL_DAY_BLOCK,
+        namespace=TimeEventNamespace.SCHEDULE_FULL_DAYS_BLOCK,
         source_entity_ref_id=IsRefId(),
     )
     note = OwnsAtMostOne(

src/core/jupiter/core/domain/core/time_events/time_event_full_days_block.py

@@ -27,6 +27,7 @@ class TimeEventFullDaysBlock(LeafSupportEntity):
     source_entity_ref_id: EntityId
     start_date: ADate
     duration_days: int
+    end_date: ADate
 
     @staticmethod
     @create_entity_action
@@ -49,6 +50,7 @@ def new_time_event(
             source_entity_ref_id=source_entity_ref_id,
             start_date=start_date,
             duration_days=duration_days,
+            end_date=start_date.add_days(duration_days),
         )
 
     @update_entity_action
@@ -62,14 +64,12 @@ def update(
         if duration_days < 1:
             raise InputValidationError("Duration must be at least 1 day.")
         return self._new_version(
-            ctx, start_date=start_date, duration_days=duration_days
+            ctx,
+            start_date=start_date,
+            duration_days=duration_days,
+            end_date=start_date.add_days(duration_days),
         )
 
-    @property
-    def end_date(self) -> ADate:
-        """Get the end date."""
-        return self.start_date.add_days(self.duration_days)
-
 
 class TimeEventFullDaysBlockRepository(
     LeafEntityRepository[TimeEventFullDaysBlock], abc.ABC
@@ -83,3 +83,12 @@ async def load_for_namespace(
         source_entity_ref_id: EntityId,
     ) -> TimeEventFullDaysBlock:
         """Load a time event full days block for a namespace and source entity."""
+
+    @abc.abstractmethod
+    async def find_all_between(
+        self,
+        parent_ref_id: EntityId,
+        start_date: ADate,
+        end_date: ADate,
+    ) -> list[TimeEventFullDaysBlock]:
+        """Find all time events in a range."""

src/core/jupiter/core/domain/core/time_events/time_event_in_day_block.py

@@ -91,3 +91,12 @@ async def load_for_namespace(
         allow_archived: bool = False,
     ) -> TimeEventInDayBlock:
         """Load a time event for a namespace."""
+
+    @abc.abstractmethod
+    async def find_all_between(
+        self,
+        parent_ref_id: EntityId,
+        start_date: ADate,
+        end_date: ADate,
+    ) -> list[TimeEventInDayBlock]:
+        """Find all time events between two dates."""

src/core/jupiter/core/domain/core/time_events/time_event_namespace.py

@@ -7,6 +7,6 @@ class TimeEventNamespace(EnumValue):
     """Time event namespaces."""
 
     SCHEDULE_EVENT_IN_DAY = "schedule-event-in-day"
-    SCHEDULE_FULL_DAY_BLOCK = "schedule-full-day-block"
+    SCHEDULE_FULL_DAYS_BLOCK = "schedule-full-days-block"
     INBOX_TASK = "inbox-task"
     PERSON_BIRTHDAY = "person-birthday"

src/core/jupiter/core/repository/sqlite/domain/core/time_events.py

@@ -1,4 +1,5 @@
 """Sqltite implementation of the time events repository."""
+from jupiter.core.domain.core.adate import ADate
 from jupiter.core.domain.core.time_events.time_event_full_days_block import (
     TimeEventFullDaysBlock,
     TimeEventFullDaysBlockRepository,
@@ -14,6 +15,7 @@
 from sqlalchemy import (
     select,
 )
+from sqlalchemy.sql import and_, or_
 
 
 class SqliteTimeEventInDayBlockRepository(
@@ -42,6 +44,20 @@ async def load_for_namespace(
             )
         return self._row_to_entity(result)
 
+    async def find_all_between(
+        self, parent_ref_id: EntityId, start_date: ADate, end_date: ADate
+    ) -> list[TimeEventInDayBlock]:
+        """Find all time events in day blocks between two dates."""
+        query_stmt = (
+            select(self._table)
+            .where(self._table.c.archived.is_(False))
+            .where(self._table.c.time_event_domain_ref_id == parent_ref_id.as_int())
+            .where(self._table.c.start_date >= start_date.the_date)
+            .where(self._table.c.start_date <= end_date.the_date)
+        )
+        result = await self._connection.execute(query_stmt)
+        return [self._row_to_entity(row) for row in result]
+
 
 class SqliteTimeEventFullDaysBlockRepository(
     SqliteLeafEntityRepository[TimeEventFullDaysBlock], TimeEventFullDaysBlockRepository
@@ -68,3 +84,27 @@ async def load_for_namespace(
                 f"Time event in full day block with namespace {namespace} and source {source_entity_ref_id} does not exist"
             )
         return self._row_to_entity(result)
+
+    async def find_all_between(
+        self, parent_ref_id: EntityId, start_date: ADate, end_date: ADate
+    ) -> list[TimeEventFullDaysBlock]:
+        """Find all time events in full day blocks between two dates."""
+        query_stmt = (
+            select(self._table)
+            .where(self._table.c.archived.is_(False))
+            .where(self._table.c.time_event_domain_ref_id == parent_ref_id.as_int())
+            .where(
+                or_(
+                    and_(
+                        self._table.c.start_date >= start_date.the_date,
+                        self._table.c.start_date <= end_date.the_date,
+                    ),
+                    and_(
+                        self._table.c.end_date >= start_date.the_date,
+                        self._table.c.end_date <= end_date.the_date,
+                    ),
+                )
+            )
+        )
+        result = await self._connection.execute(query_stmt)
+        return [self._row_to_entity(row) for row in result]

src/core/jupiter/core/use_cases/application/calendar/__init__.py

@@ -0,0 +1 @@
+"""Use cases for the calendar application."""