Feature/public event

app/database/models.py

@@ -38,8 +38,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)
 
@@ -60,6 +60,7 @@ class User(Base):
     privacy = Column(String, default="Private", nullable=False)
     is_manager = Column(Boolean, default=False)
     language_id = Column(Integer, ForeignKey("languages.id"))
+    availability = Column(Boolean, default=True, nullable=False)
     target_weight = Column(Float, nullable=True)
 
     owned_events = relationship(
@@ -124,6 +125,7 @@ class Event(Base):
     color = Column(String, nullable=True)
     all_day = Column(Boolean, default=False)
     invitees = Column(String)
+    is_public = Column(Boolean, default=False)
     privacy = Column(String, default=PrivacyKinds.Public.name, nullable=False)
     emotion = Column(String, nullable=True)
     image = Column(String, nullable=True)

app/internal/email.py

@@ -1,7 +1,7 @@
 import os
 from typing import List, Optional
 
-from fastapi import BackgroundTasks, UploadFile
+from fastapi import BackgroundTasks, Depends, UploadFile
 from fastapi_mail import FastMail, MessageSchema
 from pydantic import EmailStr
 from pydantic.errors import EmailError
@@ -14,8 +14,9 @@
     DOMAIN,
     email_conf,
 )
-from app.database.models import Event, User
+from app.database.models import Event, User, UserEvent
 from app.dependencies import templates
+from app.internal.security.dependencies import current_user
 from app.internal.security.schema import ForgotPassword
 
 mail = FastMail(email_conf)
@@ -26,6 +27,7 @@ def send(
     event_used: int,
     user_to_send: int,
     title: str,
+    content: str = "",
     background_tasks: BackgroundTasks = BackgroundTasks,
 ) -> bool:
     """This function is being used to send emails in the background.
@@ -57,11 +59,52 @@ def send(
         send_internal,
         subject=subject,
         recipients=recipients,
-        body=body,
+        body=body + content,
     )
     return True
 
 
+def send_email_to_event_participants(
+    session: Session,
+    event_id: int,
+    title: str,
+    content: str,
+    user_logged: User = Depends(current_user),
+) -> int:
+    """This function sends emails to a mailing list of all event participants.
+    it uses the function send above to do this and avoid double codes..
+    Args:
+        session(Session): The session to redirect to the database.
+        event_id (int): Id number of the event that is used.
+        title (str): Title of the email that is being sent.
+        content (str): body of email sent.
+    Returns:
+        int: Returns the number of emails sent
+        (number of valid emails in event's participants)
+    """
+    event_owner = session.query(Event.owner).filter(id == event_id).first()
+    if event_owner != user_logged:
+        return 0
+    # makes sure only event owner can send an email via this func.
+    mailing_list = (
+        session.query(User.id, User.email)
+        .join(UserEvent, User.id == UserEvent.user_id)
+        .filter(event_id == event_id)
+        .all()
+    )
+    valid_mailing_list = list(filter(verify_email_pattern, mailing_list.email))
+    if not valid_mailing_list:
+        return 0
+    # making sure app doesn't crash if emails are invalid
+
+    event = session.query(Event).get(event_id)
+    subject = f"{event.title}: {title}"
+    for r in valid_mailing_list:
+        send(session, event, r.id, subject, content)
+    # sends the send email function parameters to send on the mailing list
+    return len(valid_mailing_list)
+
+
 def send_email_invitation(
     sender_name: str,
     recipient_name: str,

app/routers/email.py

@@ -17,17 +17,20 @@
 
 @router.post("/send")
 async def send(
-        db: Session = Depends(get_db),
-        send_to: str = "/",
-        title: str = Form(...),
-        event_used: str = Form(...),
-        user_to_send: str = Form(...),
-        background_tasks: BackgroundTasks = BackgroundTasks
+    db: Session = Depends(get_db),
+    send_to: str = "/",
+    title: str = Form(...),
+    event_used: str = Form(...),
+    user_to_send: str = Form(...),
+    background_tasks: BackgroundTasks = BackgroundTasks,
 ) -> RedirectResponse:
     if not internal_send(
-            title=title, event_used=event_used,
-            user_to_send=user_to_send,
-            background_tasks=background_tasks, session=db):
+        title=title,
+        event_used=event_used,
+        user_to_send=user_to_send,
+        background_tasks=background_tasks,
+        session=db,
+    ):
         raise HTTPException(status_code=404, detail="Couldn't send the email!")
     return RedirectResponse(send_to, status_code=303)
 
@@ -44,8 +47,10 @@ class InvitationParams(BaseModel):
 
 
 @router.post("/invitation/")
-def send_invitation(invitation: InvitationParams,
-                    background_task: BackgroundTasks):
+def send_invitation(
+    invitation: InvitationParams,
+    background_task: BackgroundTasks,
+):
     """
     This function sends the recipient an invitation
     to his email address in the format HTML.
@@ -60,12 +65,14 @@ def send_invitation(invitation: InvitationParams,
     except EmailError:
         raise HTTPException(
             status_code=422,
-            detail=INVALID_EMAIL_ADDRESS_ERROR_MESSAGE)
+            detail=INVALID_EMAIL_ADDRESS_ERROR_MESSAGE,
+        )
 
     if not send_email_invitation(
-            sender_name=invitation.sender_name,
-            recipient_name=invitation.recipient_name,
-            recipient_mail=invitation.recipient_mail,
-            background_tasks=background_task):
+        sender_name=invitation.sender_name,
+        recipient_name=invitation.recipient_name,
+        recipient_mail=invitation.recipient_mail,
+        background_tasks=background_task,
+    ):
         raise HTTPException(status_code=422, detail="Couldn't send the email!")
     return RedirectResponse(invitation.send_to, status_code=303)

app/routers/event.py

@@ -41,7 +41,7 @@
 )
 from app.internal.privacy import PrivacyKinds
 from app.internal.security.dependencies import current_user
-from app.internal.utils import create_model, get_current_user
+from app.internal.utils import create_model, get_current_user, save
 from app.routers.categories import get_user_categories
 
 IMAGE_HEIGHT = 200
@@ -488,6 +488,7 @@ def create_event(
     longitude: Optional[str] = None,
     color: Optional[str] = None,
     invitees: List[str] = None,
+    is_public: bool = False,
     category_id: Optional[int] = None,
     availability: bool = True,
     is_google_event: bool = False,
@@ -515,6 +516,7 @@ def create_event(
         color=color,
         emotion=get_emotion(title, content),
         invitees=invitees_concatenated,
+        is_public=is_public,
         all_day=all_day,
         category_id=category_id,
         shared_list=shared_list,
@@ -617,6 +619,24 @@ def add_new_event(values: dict, db: Session) -> Optional[Event]:
         return None
 
 
+def add_user_to_event(session: Session, user_id: int, event_id: int):
+    user_already_connected = (
+        session.query(UserEvent)
+        .filter_by(event_id=event_id, user_id=user_id)
+        .all()
+    )
+
+    # if the user has a connection to the event,
+    # the function will recognize the duplicate and return false.
+
+    if user_already_connected:
+        return False
+    # if user is not registered to the event, the system will add him
+    association = UserEvent(user_id=user_id, event_id=event_id)
+    save(session, association)
+    return True
+
+
 def extract_shared_list_from_data(
     event_info: ImmutableMultiDict,
     db: Session,

tests/conftest.py

@@ -1,4 +1,5 @@
 import calendar
+from datetime import datetime
 
 import nest_asyncio
 import pytest
@@ -7,6 +8,7 @@
 
 from app.config import PSQL_ENVIRONMENT
 from app.database.models import Base
+from app.routers.event import create_event
 
 pytest_plugins = [
     "tests.fixtures.user_fixture",
@@ -92,4 +94,26 @@ def Calendar():
     return calendar.Calendar(0)
 
 
+# the following fixtures are meant to replace user1, user2,user3
+# fixtures inside test_user. they do the same but those have more indicative
+# name, so after the feature freeze ill make sure to replace them completely.
+# did not delete user1, user2 and user3 since some people
+# use them in testing now.
+
+
+@pytest.fixture
+def event_example(session, event_owning_user):
+    data = {
+        "title": "test event title",
+        "start": datetime.strptime("2021-05-05 14:59", "%Y-%m-%d %H:%M"),
+        "end": datetime.strptime("2021-05-05 15:01", "%Y-%m-%d %H:%M"),
+        "location": "https://us02web.zoom.us/j/87538459r6",
+        "content": "content",
+        "owner_id": event_owning_user.id,
+    }
+
+    event = create_event(session, **data)
+    return event
+
+
 nest_asyncio.apply()

tests/fixtures/user_fixture.py

@@ -1,3 +1,4 @@
+from datetime import datetime
 from typing import Generator
 
 import pytest
@@ -6,7 +7,8 @@
 from app.database.models import User
 from app.database.schemas import UserCreate
 from app.internal.utils import create_model, delete_instance
-from app.routers.register import create_user
+from app.routers.event import create_event
+from app.routers.register import _create_user, create_user
 
 
 @pytest.fixture
@@ -38,3 +40,55 @@ def sender(session: Session) -> Generator[User, None, None]:
     )
     yield mock_user
     delete_instance(session, mock_user)
+
+
+@pytest.fixture
+def no_event_user(session):
+    """a user made for testing who doesn't own any event."""
+    user = _create_user(
+        session=session,
+        username="new_test_username",
+        password="new_test_password",
+        email="new2_test.email@gmail.com",
+        language_id="english",
+    )
+
+    return user
+
+
+@pytest.fixture
+def event_owning_user(session):
+    """a user made for testing who already owns an event."""
+    user = _create_user(
+        session=session,
+        username="new_test_username2",
+        password="new_test_password2",
+        email="new_test_love231.email@gmail.com",
+        language_id="english",
+    )
+
+    data = {
+        "title": "event_owning_user event",
+        "start": datetime.strptime("2021-05-05 14:59", "%Y-%m-%d %H:%M"),
+        "end": datetime.strptime("2021-05-05 15:01", "%Y-%m-%d %H:%M"),
+        "location": "https://us02web.zoom.us/j/875384596",
+        "content": "content",
+        "owner_id": user.id,
+    }
+
+    create_event(session, **data)
+
+    return user
+
+
+@pytest.fixture
+def user1(session):
+    """another user made for testing"""
+    user = _create_user(
+        session=session,
+        username="user2user2",
+        password="verynicepass",
+        email="trulyyours1.email@gmail.com",
+        language_id="english",
+    )
+    return user