Style/weekview

.gitignore

@@ -123,8 +123,10 @@ venv.bak/
 .vscode/
 Scripts/*
 pyvenv.cfg
+.history
 calender-venv/
 
+
 # Spyder project settings
 .spyderproject
 .spyproject

app/main.py

@@ -28,12 +28,16 @@ def create_tables(engine, psql_environment):
 app.mount("/media", StaticFiles(directory=MEDIA_PATH), name="media")
 app.logger = logger
 
+
+json_data_loader.load_to_db(next(get_db()))
 # This MUST come before the app.routers imports.
 set_ui_language()
 
+
 from app.routers import (  # noqa: E402
-    agenda, calendar, categories, celebrity, currency, dayview, email,
-    event, four_o_four, invitation, profile, search, telegram, whatsapp
+    agenda, calendar, categories, celebrity, currency, dayview, 
+    email, event, four_o_four, invitation, profile, search,
+    weekview, telegram, whatsapp,
 )
 
 json_data_loader.load_to_db(next(get_db()))
@@ -45,6 +49,7 @@ def create_tables(engine, psql_environment):
     celebrity.router,
     currency.router,
     dayview.router,
+    weekview.router,
     email.router,
     event.router,
     four_o_four.router,

app/routers/dayview.py

@@ -1,12 +1,13 @@
+from bisect import bisect_left
 from datetime import datetime, timedelta
-from typing import Tuple, Union
+from typing import Tuple, Union, Optional
 
-from fastapi import APIRouter, Depends, Request
+from fastapi import APIRouter, Depends, HTTPException, Request
 from fastapi.templating import Jinja2Templates
-from sqlalchemy import and_, or_
 
 from app.database.models import Event, User
 from app.dependencies import get_db, TEMPLATES_PATH
+from app.routers.user import get_all_user_events
 from app.internal import zodiac
 
 templates = Jinja2Templates(directory=TEMPLATES_PATH)
@@ -25,6 +26,8 @@ class DivAttributes:
     DEFAULT_COLOR = 'grey'
     DEFAULT_FORMAT = "%H:%M"
     MULTIDAY_FORMAT = "%d/%m %H:%M"
+    CLASS_SIZES = ('title_size_tiny', 'title_size_Xsmall', 'title_size_small')
+    LENGTH_SIZE_STEP = (30, 45, 90)
 
     def __init__(self, event: Event,
                  day: Union[bool, datetime] = False) -> None:
@@ -34,6 +37,8 @@ def __init__(self, event: Event,
         self.start_multiday, self.end_multiday = self._check_multiday_event()
         self.color = self._check_color(event.color)
         self.total_time = self._set_total_time()
+        self.total_time_visible = self._set_total_time_visiblity()
+        self.title_size_class = self._set_title_size()
         self.grid_position = self._set_grid_position()
 
     def _check_color(self, color: str) -> str:
@@ -72,14 +77,22 @@ def _get_time_format(self) -> str:
         for multiday in [self.start_multiday, self.end_multiday]:
             yield self.MULTIDAY_FORMAT if multiday else self.DEFAULT_FORMAT
 
-    def _set_total_time(self) -> None:
+    def _set_total_time(self) -> str:
         length = self.end_time - self.start_time
         self.length = length.seconds / 60
         format_gen = self._get_time_format()
         start_time_str = self.start_time.strftime(next(format_gen))
         end_time_str = self.end_time.strftime(next(format_gen))
         return ' '.join([start_time_str, '-', end_time_str])
 
+    def _set_total_time_visiblity(self) -> bool:
+        return self.length > 60
+
+    def _set_title_size(self) -> Optional[str]:
+        i = bisect_left(self.LENGTH_SIZE_STEP, self.length)
+        if i < len(self.CLASS_SIZES):
+            return self.CLASS_SIZES[i]
+
     def _check_multiday_event(self) -> Tuple[bool]:
         start_multiday, end_multiday = False, False
         if self.day:
@@ -91,23 +104,44 @@ def _check_multiday_event(self) -> Tuple[bool]:
         return (start_multiday, end_multiday)
 
 
+def event_in_day(event: Event, day: datetime, day_end: datetime) -> bool:
+    return (
+        (event.start >= day and event.start < day_end) or
+        (event.end >= day and event.end < day_end) or
+        (event.start < day_end < event.end)
+        )
+
+
+def get_events_and_attributes(
+    day: datetime, session, user_id: int,
+) -> Tuple[Event, DivAttributes]:
+    events = get_all_user_events(session, user_id)
+    day_end = day + timedelta(hours=24)
+    for event in events:
+        if event_in_day(event=event, day=day, day_end=day_end):
+            yield (event, DivAttributes(event, day))
+
+
 @router.get('/day/{date}')
-async def dayview(request: Request, date: str, db_session=Depends(get_db)):
+async def dayview(
+          request: Request, date: str, session=Depends(get_db), view='day',
+      ):
     # TODO: add a login session
-    user = db_session.query(User).filter_by(username='test1').first()
-    day = datetime.strptime(date, '%Y-%m-%d')
-    day_end = day + timedelta(hours=24)
-    events = db_session.query(Event).filter(
-        Event.owner_id == user.id).filter(
-        or_(and_(Event.start >= day, Event.start < day_end),
-            and_(Event.end >= day, Event.end < day_end),
-            and_(Event.start < day_end, day_end < Event.end)))
-    events_n_attrs = [(event, DivAttributes(event, day)) for event in events]
-    zodiac_obj = zodiac.get_zodiac_of_day(db_session, day)
+    user = session.query(User).filter_by(username='test_username').first()
+    try:
+        day = datetime.strptime(date, '%Y-%m-%d')
+    except ValueError as err:
+        raise HTTPException(status_code=404, detail=f"{err}")
+    zodiac_obj = zodiac.get_zodiac_of_day(session, day)
+    events_n_attrs = get_events_and_attributes(
+        day=day, session=session, user_id=user.id,
+    )
+    month = day.strftime("%B").upper()
     return templates.TemplateResponse("dayview.html", {
         "request": request,
         "events": events_n_attrs,
-        "month": day.strftime("%B").upper(),
+        "month": month,
         "day": day.day,
-        "zodiac": zodiac_obj
+        "zodiac": zodiac_obj,
+        "view": view
     })

app/routers/event.py

@@ -203,11 +203,13 @@ def update_event(event_id: int, event: Dict, db: Session
 
 
 def create_event(db: Session, title: str, start, end, owner_id: int,
-                 content: str = None,
-                 location: str = None,
+                 content: Optional[str] = None,
+                 location: Optional[str] = None,
+                 color: Optional[str] = None,
                  invitees: List[str] = None,
-                 category_id: int = None,
-                 availability: bool = True):
+                 category_id: Optional[int] = None,
+                 availability: bool = True,
+                 ):
     """Creates an event and an association."""
 
     invitees_concatenated = ','.join(invitees or [])
@@ -220,6 +222,7 @@ def create_event(db: Session, title: str, start, end, owner_id: int,
         content=content,
         owner_id=owner_id,
         location=location,
+        color=color,
         emotion=get_emotion(title, content),
         invitees=invitees_concatenated,
         category_id=category_id,

app/routers/weekview.py

@@ -0,0 +1,61 @@
+from datetime import datetime, timedelta
+from itertools import accumulate
+from typing import Iterator, NamedTuple, Tuple
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.templating import Jinja2Templates
+from sqlalchemy.orm.session import Session
+
+from app.database.models import Event, User
+from app.dependencies import get_db, TEMPLATES_PATH
+from app.routers.dayview import (
+    DivAttributes, dayview, get_events_and_attributes
+)
+
+
+templates = Jinja2Templates(directory=TEMPLATES_PATH)
+
+
+router = APIRouter()
+
+
+class DayEventsAndAttrs(NamedTuple):
+    day: datetime
+    template: Jinja2Templates.TemplateResponse
+    events_and_attrs: Tuple[Event, DivAttributes]
+
+
+def get_week_dates(firstday: datetime) -> Iterator[datetime]:
+    rest_of_days = [timedelta(days=1) for _ in range(6)]
+    rest_of_days.insert(0, firstday)
+    return accumulate(rest_of_days)
+
+
+async def get_day_events_and_attributes(
+        request: Request, day: datetime, session: Session, user: User,
+      ) -> DayEventsAndAttrs:
+    template = await dayview(
+        request=request,
+        date=day.strftime('%Y-%m-%d'),
+        view='week',
+        session=session
+    )
+    events_and_attrs = get_events_and_attributes(
+            day=day, session=session, user_id=user.id)
+    return DayEventsAndAttrs(day, template, events_and_attrs)
+
+
+@router.get('/week/{firstday}')
+async def weekview(
+          request: Request, firstday: str, session=Depends(get_db)
+      ):
+    user = session.query(User).filter_by(username='test_username').first()
+    firstday = datetime.strptime(firstday, '%Y-%m-%d')
+    week_days = get_week_dates(firstday)
+    week = [await get_day_events_and_attributes(
+                request, day, session, user
+            ) for day in week_days]
+    return templates.TemplateResponse("weekview.html", {
+        "request": request,
+        "week": week,
+        })

app/static/dayview.css

@@ -47,25 +47,26 @@ html {
 }
 
 .event {
-  font-size: 1rem;
+    font-size: 1.2rem;
+    padding: 0;
 }
 
 .total-time {
-  font-size: 0.4rem;
-  line-height: 1rem;
+    font-size: 0.8rem;
 }
 
 .title_size_small {
-  font-size: 0.6em;
+    font-size: 0.8em;
 }
 
 .title_size_Xsmall {
   font-size: 0.4em;
 }
 
 .title_size_tiny {
-  font-size: 0.1em;
-  line-height: 4em;
+
+    font-size: 0.2em;
+    line-height: 1em;
 }
 
 .actiongrid {
@@ -90,6 +91,10 @@ html {
   visibility: visible;
 }
 
+.week-view-title {
+    font-size: 2em;
+}
+
 .zodiac-sign {
   position: fixed;
   right: 1.2em;

app/static/weekview.css

@@ -0,0 +1,41 @@
+:root {
+    --primary:#30465D;
+    --primary-variant:#FFDE4D;
+    --secondary:#EF5454;
+    --borders:#E7E7E7;
+    --borders-variant:#F7F7F7;
+}
+
+.day {
+    border-left: 1px solid var(--borders);
+    width: 100%;
+}
+
+#week-view {
+    display: grid;
+    grid-template-rows: 1fr;
+    grid-template-columns: 2.3em 1fr;
+}
+
+
+#week-schedule {
+    grid-row: 1;
+    grid-column: 2;
+    z-index: 10;
+}
+
+#hoursgrid {
+    grid-row: 1;
+    grid-column: 1;
+    margin-top: 2.1em;
+    margin-left: -0.1em;
+    z-index: 30;
+}
+
+.hour-top {
+    color: white;
+    width: 2.4em;
+    margin-left: -2;
+    overflow: hidden;
+}
+