Merge branch 'develop' of https://github.com/PythonFreeCourse/calendar into feature/corona-time-meetings

Author: Ap1234567

.gitignore

@@ -88,6 +88,9 @@ ipython_config.py
 # pyenv
 .python-version
 
+# pycharm
+.idea/
+
 # pipenv
 #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 #   However, in case of collaboration, if having platform-specific dependencies or dependencies

app/config.py.example

@@ -3,6 +3,8 @@ import os
 from fastapi_mail import ConnectionConfig
 # flake8: noqa
 
+# general
+DOMAIN = 'Our-Domain'
 
 # DATABASE
 DEVELOPMENT_DATABASE_STRING = "sqlite:///./dev.db"
@@ -12,10 +14,15 @@ MEDIA_DIRECTORY = 'media'
 PICTURE_EXTENSION = '.png'
 AVATAR_SIZE = (120, 120)
 
+# export
+ICAL_VERSION = '2.0'
+PRODUCT_ID = '-//Our product id//'
+
+# email
 email_conf = ConnectionConfig(
     MAIL_USERNAME=os.getenv("MAIL_USERNAME") or "user",
     MAIL_PASSWORD=os.getenv("MAIL_PASSWORD") or "password",
-    MAIL_FROM=os.getenv("MAIL_FROM") or "a@a.com",   
+    MAIL_FROM=os.getenv("MAIL_FROM") or "a@a.com",
     MAIL_PORT=587,
     MAIL_SERVER="smtp.gmail.com",
     MAIL_TLS=True,

app/database/database.py

@@ -6,7 +6,6 @@
 
 from app import config
 
-
 SQLALCHEMY_DATABASE_URL = os.getenv(
     "DATABASE_CONNECTION_STRING", config.DEVELOPMENT_DATABASE_STRING)
 

app/database/models.py

@@ -1,34 +1,76 @@
+from datetime import datetime
+
 from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String
 from sqlalchemy.orm import relationship
 
-from .database import Base
+from app.database.database import Base
+
+
+class UserEvent(Base):
+    __tablename__ = "user_event"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column('user_id', Integer, ForeignKey('users.id'))
+    event_id = Column('event_id', Integer, ForeignKey('events.id'))
+
+    events = relationship("Event", back_populates="participants")
+    participants = relationship("User", back_populates="events")
+
+    def __repr__(self):
+        return f'<UserEvent ({self.participants}, {self.events})>'
 
 
 class User(Base):
     __tablename__ = "users"
 
     id = Column(Integer, primary_key=True, index=True)
-    username = Column(String, unique=True)
-    email = Column(String, unique=True)
-    password = Column(String)
+    username = Column(String, unique=True, nullable=False)
+    email = Column(String, unique=True, nullable=False)
+    password = Column(String, nullable=False)
     full_name = Column(String)
     description = Column(String, default="Happy new user!")
     avatar = Column(String, default="profile.png")
+    is_active = Column(Boolean, default=False)
 
-    is_active = Column(Boolean, default=True)
+    events = relationship("UserEvent", back_populates="participants")
 
-    events = relationship(
-        "Event", cascade="all, delete", back_populates="owner")
+    def __repr__(self):
+        return f'<User {self.id}>'
 
 
 class Event(Base):
     __tablename__ = "events"
 
     id = Column(Integer, primary_key=True, index=True)
-    title = Column(String)
-    content = Column(String)
+    title = Column(String, nullable=False)
     start = Column(DateTime, nullable=False)
     end = Column(DateTime, nullable=False)
+    content = Column(String)
+    location = Column(String)
+
+    owner = relationship("User")
     owner_id = Column(Integer, ForeignKey("users.id"))
+    participants = relationship("UserEvent", back_populates="events")
+
+    def __repr__(self):
+        return f'<Event {self.id}>'
+
+
+class Invitation(Base):
+    __tablename__ = "invitations"
+
+    id = Column(Integer, primary_key=True, index=True)
+    status = Column(String, nullable=False, default="unread")
+    recipient_id = Column(Integer, ForeignKey("users.id"))
+    event_id = Column(Integer, ForeignKey("events.id"))
+    creation = Column(DateTime, default=datetime.now)
+
+    recipient = relationship("User")
+    event = relationship("Event")
 
-    owner = relationship("User", back_populates="events")
+    def __repr__(self):
+        return (
+            f'<Invitation '
+            f'({self.event.owner}'
+            f'to {self.recipient})>'
+        )

app/internal/agenda_events.py

@@ -1,32 +1,35 @@
 from datetime import date, timedelta
-from typing import List, Optional
+from typing import List, Optional, Union, Iterator
 
-from app.database.models import Event
-from app.database.database import SessionLocal
 import arrow
-from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from app.database.models import Event
+from app.routers.event import sort_by_date
+from app.routers.user import get_all_user_events
 
 
 def get_events_per_dates(
-        session: SessionLocal,
+        session: Session,
         user_id: int,
         start: Optional[date],
         end: Optional[date]
-        ) -> List[Event]:
-    """Read from the db. Return a list of all the user events between
-    the relevant dates."""
+) -> Union[Iterator[Event], list]:
+    """Read from the db. Return a list of all
+    the user events between the relevant dates."""
+
     if start > end:
         return []
-    try:
-        events = (
-            session.query(Event).filter(Event.owner_id == user_id)
-            .filter(Event.start.between(start, end + timedelta(days=1)))
-            .order_by(Event.start).all()
-            )
-    except SQLAlchemyError:
-        return []
-    else:
-        return events
+
+    return (
+        filter_dates(
+            sort_by_date(
+                get_all_user_events(session, user_id)
+            ),
+            start,
+            end,
+        )
+    )
 
 
 def build_arrow_delta_granularity(diff: timedelta) -> List[str]:
@@ -51,5 +54,16 @@ def get_time_delta_string(start: date, end: date) -> str:
     granularity = build_arrow_delta_granularity(diff)
     duration_string = arrow_end.humanize(
         arrow_start, only_distance=True, granularity=granularity
-        )
+    )
     return duration_string
+
+
+def filter_dates(
+        events: List[Event], start: Optional[date],
+        end: Optional[date]) -> Iterator[Event]:
+    """filter events by a time frame."""
+
+    yield from (
+        event for event in events
+        if start <= event.start.date() <= end
+    )

app/internal/event.py

@@ -0,0 +1,11 @@
+import re
+
+from fastapi import HTTPException
+
+ZOOM_REGEX = re.compile(r'https://.*?\.zoom.us/[a-z]/.[^.,\b\t\n]+')
+
+
+def validate_zoom_link(location):
+    if not ZOOM_REGEX.findall(location):
+        raise HTTPException(status_code=400,
+                            detail="VC type with no valid zoom link")

app/internal/utils.py

@@ -0,0 +1,22 @@
+from sqlalchemy.orm import Session
+
+from app.database.models import Base
+
+
+def save(item, session: Session) -> bool:
+    """Commits an instance to the db.
+    source: app.database.database.Base"""
+
+    if issubclass(item.__class__, Base):
+        session.add(item)
+        session.commit()
+        return True
+    return False
+
+
+def create_model(session: Session, model_class, **kw):
+    """Creates and saves a db model."""
+
+    instance = model_class(**kw)
+    save(instance, session)
+    return instance

app/main.py

@@ -5,8 +5,7 @@
 from app.database.database import engine
 from app.dependencies import (
     MEDIA_PATH, STATIC_PATH, templates)
-from app.routers import agenda, event, profile, email
-
+from app.routers import agenda, event, profile, email, invitation
 
 models.Base.metadata.create_all(bind=engine)
 
@@ -18,12 +17,12 @@
 app.include_router(event.router)
 app.include_router(agenda.router)
 app.include_router(email.router)
+app.include_router(invitation.router)
 
 
 @app.get("/")
 async def home(request: Request):
     return templates.TemplateResponse("home.html", {
         "request": request,
-        "message": "Hello, World!"
-
+        "message": "Hello, World!",
     })

app/routers/agenda.py

@@ -3,23 +3,22 @@
 from typing import Optional, Tuple
 
 from fastapi import APIRouter, Depends, Request
-from fastapi.templating import Jinja2Templates
 from sqlalchemy.orm import Session
+from starlette.templating import _TemplateResponse
 
 from app.database.database import get_db
 from app.dependencies import templates
 from app.internal import agenda_events
 
-
 router = APIRouter()
 
 
 def calc_dates_range_for_agenda(
         start: Optional[date],
         end: Optional[date],
-        days: Optional[int]
+        days: Optional[int],
         ) -> Tuple[date, date]:
-    """Create start and end dates eccording to the parameters in the page."""
+    """Create start and end dates according to the parameters in the page."""
     if days is not None:
         start = date.today()
         end = start + timedelta(days=days)
@@ -35,8 +34,8 @@ def agenda(
         db: Session = Depends(get_db),
         start_date: Optional[date] = None,
         end_date: Optional[date] = None,
-        days: Optional[int] = None
-        ) -> Jinja2Templates:
+        days: Optional[int] = None,
+        ) -> _TemplateResponse:
     """Route for the agenda page, using dates range or exact amount of days."""
 
     user_id = 1   # there is no user session yet, so I use user id- 1.
@@ -58,5 +57,5 @@ def agenda(
         "request": request,
         "events": events,
         "start_date": start_date,
-        "end_date": end_date
+        "end_date": end_date,
     })

app/routers/event.py

@@ -1,14 +1,20 @@
-import re
 from datetime import datetime as dt
-from fastapi import APIRouter, Request, Depends, HTTPException
+from operator import attrgetter
+from typing import List
+
+from fastapi import APIRouter, Request
+from fastapi import Depends
 from fastapi.responses import RedirectResponse
 from starlette.status import HTTP_303_SEE_OTHER
 
 from app.database.database import get_db
-from app.database.models import Event, User
+from app.database.models import Event
+from app.database.models import User
+from app.database.models import UserEvent
 from app.dependencies import templates
-
-ZOOM_REGEX = re.compile(r'https://.*?\.zoom.us/[a-z]/.[^.,\b\t\n]+')
+from app.internal.event import validate_zoom_link
+from app.internal.utils import create_model
+from app.routers.user import create_user
 
 router = APIRouter(
     prefix="/event",
@@ -24,7 +30,7 @@ async def eventedit(request: Request):
 
 
 @router.post("/edit")
-async def create_event(request: Request, session=Depends(get_db)):
+async def create_new_event(request: Request, session=Depends(get_db)):
     data = await request.form()
     title = data['title']
     content = data['description']
@@ -33,18 +39,17 @@ async def create_event(request: Request, session=Depends(get_db)):
     end = dt.strptime(data['end_date'] + ' ' + data['end_time'],
                       '%Y-%m-%d %H:%M')
     user = session.query(User).filter_by(id=1).first()
+    if not user:
+        user = create_user("username", "password", "email@email.com", session)
     owner_id = user.id
     location_type = data['location_type']
     is_zoom = location_type == 'vc_url'
     location = data['location']
 
-    if is_zoom and not ZOOM_REGEX.findall(location):
-        raise HTTPException(status_code=400,
-                            detail="VC type with no valid zoom link")
-    event = Event(title=title, content=content, start=start, end=end,
-                  owner_id=owner_id)
-    session.add(event)
-    session.commit()
+    if is_zoom:
+        validate_zoom_link(location)
+
+    event = create_event(session, title, start, end, owner_id, content, location)
     return RedirectResponse(f'/event/view/{event.id}',
                             status_code=HTTP_303_SEE_OTHER)
 
@@ -53,3 +58,30 @@ async def create_event(request: Request, session=Depends(get_db)):
 async def eventview(request: Request, id: int):
     return templates.TemplateResponse("event/eventview.html",
                                       {"request": request, "event_id": id})
+
+
+def create_event(db, title, start, end, owner_id, content=None, location=None):
+    """Creates an event and an association."""
+
+    event = create_model(
+        db, Event,
+        title=title,
+        start=start,
+        end=end,
+        content=content,
+        owner_id=owner_id,
+        location=location,
+    )
+    create_model(
+        db, UserEvent,
+        user_id=owner_id,
+        event_id=event.id
+    )
+    return event
+
+
+def sort_by_date(events: List[Event]) -> List[Event]:
+    """Sorts the events by the start of the event."""
+
+    temp = events.copy()
+    return sorted(temp, key=attrgetter('start'))