Feature/support categories

.gitignore

@@ -1,6 +1,7 @@
 dev.db
 test.db
 config.py
+.vscode/settings.json
 
 # Byte-compiled / optimized / DLL files
 __pycache__/
@@ -88,6 +89,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
@@ -113,6 +117,8 @@ venv/
 ENV/
 env.bak/
 venv.bak/
+Scripts/*
+pyvenv.cfg
 
 # Spyder project settings
 .spyderproject
@@ -131,3 +137,5 @@ dmypy.json
 
 # Pyre type checker
 .pyre/
+
+app/routers/stam

app/config.py.example

@@ -1,8 +1,11 @@
 import os
 
 from fastapi_mail import ConnectionConfig
+
 # flake8: noqa
 
+# general
+DOMAIN = 'Our-Domain'
 
 # DATABASE
 DEVELOPMENT_DATABASE_STRING = "sqlite:///./dev.db"
@@ -12,10 +15,18 @@ MEDIA_DIRECTORY = 'media'
 PICTURE_EXTENSION = '.png'
 AVATAR_SIZE = (120, 120)
 
+# API-KEYS
+WEATHER_API_KEY = os.getenv('WEATHER_API_KEY')
+
+# 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

@@ -2,11 +2,11 @@
 
 from sqlalchemy import create_engine
 from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import Session
 from sqlalchemy.orm import sessionmaker
 
 from app import config
 
-
 SQLALCHEMY_DATABASE_URL = os.getenv(
     "DATABASE_CONNECTION_STRING", config.DEVELOPMENT_DATABASE_STRING)
 
@@ -18,7 +18,7 @@
 Base = declarative_base()
 
 
-def get_db():
+def get_db() -> Session:
     db = SessionLocal()
     try:
         yield db

app/database/models.py

@@ -1,34 +1,110 @@
-from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
+from datetime import datetime
 
-from .database import Base
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, \
+    String, UniqueConstraint
+from sqlalchemy.orm import relationship, Session
+
+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)
+    color = Column(String, nullable=True)
+
+    owner = relationship("User")
+    participants = relationship("UserEvent", back_populates="events")
+
     owner_id = Column(Integer, ForeignKey("users.id"))
+    category_id = Column(Integer, ForeignKey("categories.id"))
+
+    def __repr__(self):
+        return f'<Event {self.id}>'
+
+
+class Category(Base):
+    __tablename__ = "categories"
+
+    __table_args__ = (
+        UniqueConstraint('user_id', 'name', 'color'),
+    )
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=False)
+    color = Column(String, nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+
+    @classmethod
+    def create(cls, db_session: Session, name: str, color: str, user_id: int):
+        try:
+            category = cls(name=name, color=color, user_id=user_id)
+            db_session.add(category)
+            db_session.flush()
+            db_session.commit()
+            db_session.refresh(category)
+            return category
+        except Exception as e:
+            raise e
+
+    def to_dict(self):
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}
+
+    def __repr__(self):
+        return f'<Category {self.id} {self.name} {self.color}>'
+
+
+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/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