Feature 179 add notes to calendar (#267)

* Apply automatic translateable string changes

Author: ron-huberfeld

Diff for: app/database/models.py

@@ -39,8 +39,8 @@ class UserFeature(Base):
     __tablename__ = "user_feature"
 
     id = Column(Integer, primary_key=True, index=True)
-    feature_id = Column('feature_id', Integer, ForeignKey('features.id'))
-    user_id = Column('user_id', Integer, ForeignKey('users.id'))
+    feature_id = Column("feature_id", Integer, ForeignKey("features.id"))
+    user_id = Column("user_id", Integer, ForeignKey("users.id"))
 
     is_enable = Column(Boolean, default=False)
 
@@ -90,6 +90,8 @@ class User(Base):
         uselist=False,
     )
 
+    notes = relationship("Note", back_populates="creator")
+
     def __repr__(self):
         return f"<User {self.id}>"
 
@@ -614,3 +616,18 @@ def insert_data(target, session: Session, **kw):
 
 
 event.listen(Language.__table__, "after_create", insert_data)
+
+
+class Note(Base):
+    __tablename__ = "notes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(String, nullable=False)
+    description = Column(String)
+    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"))
+
+    creator = relationship("User", back_populates="notes")
+
+    def __repr__(self) -> str:
+        return f"<Note {self.id} {self.title}>"

Diff for: app/database/schemas.py

@@ -1,19 +1,28 @@
+from datetime import datetime
 from typing import Optional, Union
 
-from pydantic import BaseModel, EmailError, EmailStr, validator
+from pydantic import BaseModel, EmailError, EmailStr, Field, validator
 
 EMPTY_FIELD_STRING = "field is required"
 MIN_FIELD_LENGTH = 3
 MAX_FIELD_LENGTH = 20
 
 
-def fields_not_empty(field: Optional[str]) -> Union[ValueError, str]:
+def fields_not_empty(field: Optional[str]) -> str:
     """Global function to validate fields are not empty."""
     if not field:
         raise ValueError(EMPTY_FIELD_STRING)
     return field
 
 
+class UserModel(BaseModel):
+    username: str
+    password: str
+    email: str = Field(regex="^\\S+@\\S+\\.\\S+$")
+    language: str
+    language_id: int
+
+
 class UserBase(BaseModel):
     """
     Validating fields types
@@ -60,18 +69,14 @@ class UserCreate(UserBase):
     )
 
     @validator("confirm_password")
-    def passwords_match(
-        cls,
-        confirm_password: str,
-        values: UserBase,
-    ) -> Union[ValueError, str]:
+    def passwords_match(cls, confirm_password: str, values: UserBase) -> str:
         """Validating passwords fields identical."""
         if "password" in values and confirm_password != values["password"]:
             raise ValueError("doesn't match to password")
         return confirm_password
 
     @validator("username")
-    def username_length(cls, username: str) -> Union[ValueError, str]:
+    def username_length(cls, username: str) -> str:
         """Validating username length is legal"""
         if not (MIN_FIELD_LENGTH < len(username) < MAX_FIELD_LENGTH):
             raise ValueError("must contain between 3 to 20 charactars")
@@ -80,14 +85,14 @@ def username_length(cls, username: str) -> Union[ValueError, str]:
         return username
 
     @validator("password")
-    def password_length(cls, password: str) -> Union[ValueError, str]:
+    def password_length(cls, password: str) -> str:
         """Validating username length is legal"""
         if not (MIN_FIELD_LENGTH < len(password) < MAX_FIELD_LENGTH):
             raise ValueError("must contain between 3 to 20 charactars")
         return password
 
     @validator("email")
-    def confirm_mail(cls, email: str) -> Union[ValueError, str]:
+    def confirm_mail(cls, email: str) -> str:
         """Validating email is valid mail address."""
         try:
             EmailStr.validate(email)
@@ -104,3 +109,23 @@ class User(UserBase):
 
     id: int
     is_active: bool
+
+
+class NoteSchema(BaseModel):
+    title: str
+    description: Optional[str] = None
+    timestamp: Optional[datetime]
+    creator: Optional[User]
+
+    class Config:
+        orm_mode = True
+        schema_extra = {
+            "example": {
+                "title": "Foo",
+                "description": "Bar",
+            },
+        }
+
+
+class NoteDB(NoteSchema):
+    id: int

Diff for: app/internal/agenda_events.py

@@ -6,30 +6,26 @@
 from sqlalchemy.orm import Session
 
 from app.database.models import Event
+from app.internal.user import user
 from app.routers.event import sort_by_date
-from app.routers.user import get_all_user_events
 
 
 def get_events_per_dates(
-        session: Session,
-        user_id: int,
-        start: Optional[date],
-        end: Optional[date]
+    session: Session,
+    user_id: int,
+    start: Optional[date],
+    end: Optional[date],
 ) -> Union[Iterator[Event], list]:
     """Read from the db. Return a list of all
     the user events between the relevant dates."""
 
     if start > end:
         return []
 
-    return (
-        filter_dates(
-            sort_by_date(
-                get_all_user_events(session, user_id)
-            ),
-            start,
-            end,
-        )
+    return filter_dates(
+        sort_by_date(user.get_all_user_events(session, user_id)),
+        start,
+        end,
     )
 
 
@@ -54,15 +50,17 @@ def get_time_delta_string(start: date, end: date) -> str:
     diff = end - start
     granularity = build_arrow_delta_granularity(diff)
     duration_string = arrow_end.humanize(
-        arrow_start, only_distance=True, granularity=granularity
+        arrow_start,
+        only_distance=True,
+        granularity=granularity,
     )
     return duration_string
 
 
 def filter_dates(
-        events: List[Event],
-        start: Union[None, date] = None,
-        end: Union[None, date] = None,
+    events: List[Event],
+    start: Union[None, date] = None,
+    end: Union[None, date] = None,
 ) -> Iterator[Event]:
     """Returns all events in a time frame.
 
@@ -82,24 +80,25 @@ def filter_dates(
 
 
 def get_events_in_time_frame(
-        start_date: Union[date, None],
-        end_date: Union[date, None],
-        user_id: int, db: Session
+    start_date: Union[date, None],
+    end_date: Union[date, None],
+    user_id: int,
+    db: Session,
 ) -> Iterator[Event]:
     """Yields all user's events in a time frame."""
-    events = get_all_user_events(db, user_id)
+    events = user.get_all_user_events(db, user_id)
     yield from filter_dates(events, start_date, end_date)
 
 
-def get_events_for_the_week(db: Session, user_id: int
-                            ) -> Tuple[Union[Iterator[Event], list], Dict]:
+def get_events_for_the_week(
+    db: Session,
+    user_id: int,
+) -> Tuple[Union[Iterator[Event], list], Dict]:
     WEEK_DAYS = 7
     start_date = date.today()
     end_date = start_date + timedelta(days=WEEK_DAYS - 1)
 
-    events_this_week = get_events_per_dates(
-        db, user_id, start_date, end_date
-    )
+    events_this_week = get_events_per_dates(db, user_id, start_date, end_date)
     events_for_graph = {
         str(start_date + timedelta(i)): 0 for i in range(WEEK_DAYS)
     }

Diff for: app/internal/friend_view.py

@@ -3,22 +3,22 @@
 from sqlalchemy.orm import Session
 
 from app.database.models import Event
+from app.internal.user import user
 from app.routers.event import sort_by_date
-from app.routers.user import get_all_user_events
 
 
 def get_events_per_friend(
-        session: Session,
-        user_id: int,
-        my_friend: str,
+    session: Session,
+    user_id: int,
+    my_friend: str,
 ) -> List[Event]:
-    """ My_friend is the name of a person that appears in the invite list of
+    """My_friend is the name of a person that appears in the invite list of
     events. He is not necessarily a registered userץ The variable is used to
     show all events where we are both in the invitees list"""
 
     events_together = []
-    sorted_events = sort_by_date(get_all_user_events(session, user_id))
+    sorted_events = sort_by_date(user.get_all_user_events(session, user_id))
     for event in sorted_events:
-        if my_friend in event.invitees.split(','):
+        if my_friend in event.invitees.split(","):
             events_together.append(event)
     return events_together

Diff for: app/internal/notes/__init__.py

@@ -0,0 +1,69 @@
+from datetime import datetime
+from typing import Any, Dict, List
+
+from fastapi import HTTPException, status
+from sqlalchemy.orm import Session
+
+from app.database.models import Note
+from app.database.schemas import NoteSchema
+
+
+async def create(session: Session, payload: NoteSchema) -> int:
+    note = Note(
+        title=payload.title,
+        description=payload.description,
+        creator=payload.creator,
+    )
+    session.add(note)
+    session.commit()
+    session.refresh(note)
+    return note.id
+
+
+async def view(session: Session, note_id: int) -> Note:
+    note = session.query(Note).filter_by(id=note_id).first()
+    if not note:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Note with id {note_id} not found",
+        )
+    return note
+
+
+async def get_all(
+    session: Session,
+    skip: int = 0,
+    limit: int = 100,
+) -> List[Note]:
+    return session.query(Note).offset(skip).limit(limit).all()
+
+
+async def update(request: NoteSchema, session: Session, note_id: int) -> str:
+    note = session.query(Note).filter_by(id=note_id)
+    if not note.first():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Note with id {note_id} not found",
+        )
+    if request.timestamp is None:
+        request.timestamp = datetime.utcnow()
+    note.update(request.dict(exclude_unset=True), synchronize_session=False)
+    session.commit()
+    return "updated"
+
+
+async def delete(session: Session, note_id: int) -> str:
+    note = session.query(Note).filter_by(id=note_id)
+    if not note.first():
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Note with id {note_id} not found",
+        )
+    note.delete(synchronize_session=False)
+    session.commit()
+    return "deleted"
+
+
+async def create_note(note: NoteSchema, session: Session) -> Dict[str, Any]:
+    note_id = await create(session, note)
+    return {"id": note_id, **dict(note)}