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

@@ -9,14 +9,15 @@
 
 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.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
+        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.
@@ -48,10 +49,45 @@ def send(
     background_tasks.add_task(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) -> 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,

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

tests/test_email.py

@@ -1,11 +1,15 @@
 from fastapi import BackgroundTasks, status
 import pytest
 from sqlalchemy.orm import Session
+# from starlette.status import HTTP_302_FOUND
 
-from app.database.models import User
+from app.database.models import User, UserEvent
+# from app.internal.security.dependancies import current_user
 from app.internal.email import (mail, send, send_email_file,
-                                send_email_invitation, verify_email_pattern)
-from app.internal.utils import create_model, delete_instance
+                                send_email_invitation,
+                                send_email_to_event_participants,
+                                verify_email_pattern)
+from app.internal.utils import create_model, delete_instance, save
 
 
 def test_email_send(client, user, event, smtpd):
@@ -240,3 +244,46 @@ def test_send(session, bad_user, event):
                                    "test@mail-com"])
 def test_verify_email_pattern(email):
     assert not verify_email_pattern(email)
+
+
+def test_sending_mailing_list_with_no_user(session, no_event_user,
+                                           event_owning_user,
+                                           user1,
+                                           event_example):
+    """this test assures a wrong user won't be able to use the mailing list"""
+    association = UserEvent(
+        user_id=no_event_user.id,
+        event_id=event_example.id
+    )
+    save(session, association)
+
+    association2 = UserEvent(
+        user_id=user1.id,
+        event_id=event_example.id
+    )
+    save(session, association2)
+
+    num_emails_send = send_email_to_event_participants(
+        session, event_example.id, 'this mail example', 'booboo')
+    assert num_emails_send == 0
+
+
+def test_sending_mailing_list_from_event_owner(session, no_event_user,
+                                               event_owning_user,
+                                               user1,
+                                               event_example, client,
+                                               security_test_client):
+    """this test assures mailing list is sent successfuly from
+    the event owner. assiciations were created already at the test above."""
+    # logged_user_data = {'username': event_owning_user.username,
+    #                     'password': event_owning_user.password}
+    pass
+    # res = security_test_client.post(
+    #     security_test_client.app.url_path_for('login'),
+    #     data=logged_user_data)
+    # TODO: log in event_owning_user to assure successful mailing list send
+
+    # if res.status_code == HTTP_302_FOUND:
+    #     num_emails_send = send_email_to_event_participants(
+    #         session, event_example.id, 'this mail example', 'booboo')
+    #     assert num_emails_send == 2

tests/test_event.py

@@ -15,7 +15,8 @@
 from app.internal.utils import delete_instance
 from app.main import app
 from app.routers import event as evt
-from app.routers.event import event_to_show
+from app.routers.event import add_new_event, add_user_to_event, event_to_show
+from app.routers.user import create_user
 
 CORRECT_EVENT_FORM_DATA = {
     "title": "test title",
@@ -140,6 +141,36 @@
 ]
 
 
+@pytest.fixture
+def new_event(session, new_user):
+    event = add_new_event(TestApp.event_test_data, session)
+    return event
+
+
+@pytest.fixture
+def new_user(session):
+    user = create_user(
+        session=session,
+        username='new_test_username',
+        password='new_test_password',
+        email='[email protected]',
+        language_id='english'
+    )
+
+    return user
+
+
+def test_joining_public_event(session, new_event, new_user):
+    """test in order to make sure user is added the first time
+    he asks to join event, yet won't join the same user twice"""
+    first_join = add_user_to_event(
+        session, event_id=new_event.id, user_id=new_user.id)
+    assert first_join
+    second_join = add_user_to_event(
+        session, event_id=new_event.id, user_id=new_user.id)
+    assert not second_join
+
+
 def test_get_events(event_test_client, session, event):
     response = event_test_client.get("/event/")
     assert response.ok