Feature/public event

app/database/models.py

@@ -48,6 +48,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(
@@ -97,6 +98,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)
     availability = Column(Boolean, default=True, nullable=False)

app/internal/email.py

@@ -7,16 +7,26 @@
 from pydantic.errors import EmailError
 from sqlalchemy.orm.session import Session
 
-from app.config import (CALENDAR_HOME_PAGE, CALENDAR_REGISTRATION_PAGE,
-                        CALENDAR_SITE_NAME, email_conf, templates)
-from app.database.models import Event, User
+from app.config import (
+    CALENDAR_HOME_PAGE,
+    CALENDAR_REGISTRATION_PAGE,
+    CALENDAR_SITE_NAME,
+    email_conf,
+    templates,
+)
+from app.database.models import Event, User, UserEvent
+from app.internal.utils import get_current_user
 
 mail = FastMail(email_conf)
 
 
 def send(
-        session: Session, event_used: int, user_to_send: int,
-        title: str, background_tasks: BackgroundTasks = BackgroundTasks
+    session: Session,
+    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.
     It takes an event and a user and it sends the event to the user.
@@ -32,10 +42,8 @@ def send(
     Returns:
         bool: Returns True if the email was sent, else returns False.
     """
-    event_used = session.query(Event).filter(
-        Event.id == event_used).first()
-    user_to_send = session.query(User).filter(
-        User.id == user_to_send).first()
+    event_used = session.query(Event).filter(Event.id == event_used).first()
+    user_to_send = session.query(User).filter(User.id == user_to_send).first()
     if not user_to_send or not event_used:
         return False
     if not verify_email_pattern(user_to_send.email):
@@ -45,18 +53,61 @@ def send(
     recipients = {"email": [user_to_send.email]}.get("email")
     body = f"begins at:{event_used.start} : {event_used.content}"
 
-    background_tasks.add_task(send_internal,
-                              subject=subject,
-                              recipients=recipients,
-                              body=body)
+    background_tasks.add_task(
+        send_internal,
+        subject=subject,
+        recipients=recipients,
+        body=body + content,
+    )
     return True
 
 
-def send_email_invitation(sender_name: str,
-                          recipient_name: str,
-                          recipient_mail: str,
-                          background_tasks: BackgroundTasks = BackgroundTasks
-                          ) -> bool:
+def send_email_to_event_participants(
+    session: Session,
+    event_id: int,
+    title: str,
+    content: str,
+) -> 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 != get_current_user(session):
+        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,
+    recipient_mail: str,
+    background_tasks: BackgroundTasks = BackgroundTasks,
+) -> bool:
     """
     This function takes as parameters the sender's name,
     the recipient's name and his email address, configuration, and
@@ -81,28 +132,35 @@ def send_email_invitation(sender_name: str,
         return False
 
     template = templates.get_template("invite_mail.html")
-    html = template.render(recipient=recipient_name, sender=sender_name,
-                           site_name=CALENDAR_SITE_NAME,
-                           registration_link=CALENDAR_REGISTRATION_PAGE,
-                           home_link=CALENDAR_HOME_PAGE,
-                           addr_to=recipient_mail)
+    html = template.render(
+        recipient=recipient_name,
+        sender=sender_name,
+        site_name=CALENDAR_SITE_NAME,
+        registration_link=CALENDAR_REGISTRATION_PAGE,
+        home_link=CALENDAR_HOME_PAGE,
+        addr_to=recipient_mail,
+    )
 
     subject = "Invitation"
     recipients = [recipient_mail]
     body = html
     subtype = "html"
 
-    background_tasks.add_task(send_internal,
-                              subject=subject,
-                              recipients=recipients,
-                              body=body,
-                              subtype=subtype)
+    background_tasks.add_task(
+        send_internal,
+        subject=subject,
+        recipients=recipients,
+        body=body,
+        subtype=subtype,
+    )
     return True
 
 
-def send_email_file(file_path: str,
-                    recipient_mail: str,
-                    background_tasks: BackgroundTasks = BackgroundTasks):
+def send_email_file(
+    file_path: str,
+    recipient_mail: str,
+    background_tasks: BackgroundTasks = BackgroundTasks,
+):
     """
     his function takes as parameters the file's path,
     the recipient's email address, configuration, and
@@ -126,19 +184,23 @@ def send_email_file(file_path: str,
     body = "file"
     file_attachments = [file_path]
 
-    background_tasks.add_task(send_internal,
-                              subject=subject,
-                              recipients=recipients,
-                              body=body,
-                              file_attachments=file_attachments)
+    background_tasks.add_task(
+        send_internal,
+        subject=subject,
+        recipients=recipients,
+        body=body,
+        file_attachments=file_attachments,
+    )
     return True
 
 
-async def send_internal(subject: str,
-                        recipients: List[str],
-                        body: str,
-                        subtype: Optional[str] = None,
-                        file_attachments: Optional[List[str]] = None):
+async def send_internal(
+    subject: str,
+    recipients: List[str],
+    body: str,
+    subtype: Optional[str] = None,
+    file_attachments: Optional[List[str]] = None,
+):
     if file_attachments is None:
         file_attachments = []
 
@@ -147,8 +209,10 @@ async def send_internal(subject: str,
         recipients=[EmailStr(recipient) for recipient in recipients],
         body=body,
         subtype=subtype,
-        attachments=[UploadFile(file_attachment)
-                     for file_attachment in file_attachments])
+        attachments=[
+            UploadFile(file_attachment) for file_attachment in file_attachments
+        ],
+    )
 
     return await send_internal_internal(message)
 

app/routers/email.py

@@ -8,6 +8,7 @@
 from app.internal.email import send as internal_send
 from app.internal.email import send_email_invitation
 
+
 router = APIRouter(
     prefix="/email",
     tags=["email"],

app/routers/event.py

@@ -24,7 +24,7 @@
 from app.internal import comment as cmt
 from app.internal.emotion import get_emotion
 from app.internal.privacy import PrivacyKinds
-from app.internal.utils import create_model, get_current_user
+from app.internal.utils import create_model, save, get_current_user
 from app.routers.categories import get_user_categories
 
 EVENT_DATA = Tuple[Event, List[Dict[str, str]], str]
@@ -393,6 +393,7 @@ def create_event(
     vc_link: 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,
@@ -416,6 +417,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,
         availability=availability,
@@ -516,6 +518,22 @@ 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 not user_already_connected:
+        """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
+    # if the user has a connection to the event,
+    # the function will recognize the duplicate and return false.
+    return False
+
+
 def get_template_to_share_event(
     event_id: int,
     user_name: str,

tests/conftest.py

@@ -1,11 +1,14 @@
 import calendar
+from datetime import datetime
 
 import pytest
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 
 from app.config import PSQL_ENVIRONMENT
 from app.database.models import Base
+from app.routers.event import create_event
+from app.routers.user import create_user
 
 pytest_plugins = [
     'tests.user_fixture',
@@ -80,3 +83,70 @@ def sqlite_engine():
 @pytest.fixture
 def Calendar():
     return calendar.Calendar(0)
+
+
+@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='[email protected]',
+        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='[email protected]',
+        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='[email protected]',
+        language_id='english'
+    )
+    return user
+
+
+@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