Feature/public event

app/database/models.py

@@ -35,6 +35,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)
 
     owned_events = relationship(
         "Event", cascade="all, delete", back_populates="owner",
@@ -75,6 +76,7 @@ class Event(Base):
     color = Column(String, nullable=True)
     all_day = Column(Boolean, default=False)
     invitees = Column(String)
+    is_public = Column(Boolean, default=False)
     emotion = Column(String, nullable=True)
     availability = Column(Boolean, default=True, nullable=False)
 
@@ -104,8 +106,10 @@ 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'))
+    user_id = Column('user_id', Integer, ForeignKey(
+        'users.id'), nullable=False)
+    event_id = Column('event_id', Integer, ForeignKey(
+        'events.id'), nullable=False)
 
     events = relationship("Event", back_populates="participants")
     participants = relationship("User", back_populates="events")

app/internal/email.py

@@ -9,8 +9,8 @@
 
 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)
 
 
@@ -52,6 +52,49 @@ def send(
     return True
 
 
+def send_email_to_event_participants(
+        session: Session, event_id: int,
+        title: str, content: str,
+        background_tasks: BackgroundTasks = BackgroundTasks
+) -> bool:
+    """This function is being used to send emails in the background.
+    it uses the main elements of the func writen above.
+    It takes an event and a user and it sends the event to the user.
+    Args:
+        session(Session): The session to redirect to the database.
+        title (str): Title of the email that is being sent.
+        event_id (int): Id number of the event that is used.
+        content (str): body of email sent.
+        background_tasks (BackgroundTasks): Function from fastapi that lets
+            you apply tasks in the background.
+    Returns:
+        bool: Returns True if emails were sent, False if none.
+    """
+    event_owner = session.query(Event.owner).filter(id == event_id).first()
+    if event_owner != get_current_user(session):
+        return False
+    # makes sure only event owner can send an email via this func.
+    mailing_list = session.query(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))
+    if not valid_mailing_list:
+        return False
+    # making sure app doesn't crash if emails are invalid
+    event = session.query(Event).get(event_id)
+    subject = f"{event.title}: {title}"
+    recipients = valid_mailing_list
+    body = content
+    for r in recipients:
+        print(r)
+        background_tasks.add_task(send_internal,
+                                  subject=subject,
+                                  recipients=r,
+                                  body=body)
+    return True
+
+
 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

@@ -20,7 +20,7 @@
 )
 from app.internal import comment as cmt
 from app.internal.emotion import get_emotion
-from app.internal.utils import create_model, get_current_user
+from app.internal.utils import create_model, save, get_current_user
 
 
 EVENT_DATA = Tuple[Event, List[Dict[str, str]], str, str]
@@ -280,6 +280,7 @@ def create_event(db: Session, title: str, start, end, owner_id: int,
                  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,
@@ -300,6 +301,7 @@ def create_event(db: Session, title: str, start, end, owner_id: int,
         color=color,
         emotion=get_emotion(title, content),
         invitees=invitees_concatenated,
+        is_public=is_public,
         all_day=all_day,
         category_id=category_id,
         availability=availability,
@@ -398,6 +400,23 @@ 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
+    else:
+        # 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,
                                 db: Session, request: Request) -> templates:
     """Gives shareable template of the event.

app/telegram/handlers.py

@@ -134,10 +134,14 @@ async def process_new_event(self, memo_dict):
             return await self._process_content(memo_dict)
         elif 'location' not in memo_dict:
             return await self._process_location(memo_dict)
+        elif 'is_public' not in memo_dict:
+            return await self._process_is_public(memo_dict)
         elif 'start' not in memo_dict:
             return await self._process_start_date(memo_dict)
         elif 'end' not in memo_dict:
             return await self._process_end_date(memo_dict)
+        elif 'end' not in memo_dict:
+            return await self._process_end_date(memo_dict)
         elif self.chat.message == 'create':
             return await self._submit_new_event(memo_dict)
 
@@ -184,7 +188,37 @@ async def _process_content(self, memo_dict):
     async def _process_location(self, memo_dict):
         memo_dict['location'] = self.chat.message
         answer = f'Location:\n{memo_dict["location"]}\n\n'
-        answer += 'When does it start?'
+        answer += 'is the event public? (yes\\no)'
+        await telegram_bot.send_message(
+            chat_id=self.chat.user_id,
+            text=answer,
+            reply_markup=field_kb)
+        return answer
+
+    async def _process_is_public(self, memo_dict):
+        is_public_response = self.chat.message.lower
+        if is_public_response in ['yes', 'no']:
+            print('yasss')
+            return await self._add_is_public()
+        return await self._process_bad_bool_input()
+
+    async def _process_bad_bool_input(self):
+        answer = '❗️ Please, enter an answer of yes/no.'
+        await telegram_bot.send_message(
+            chat_id=self.chat.user_id,
+            text=answer,
+            reply_markup=field_kb)
+        return answer
+
+    async def _add_is_public(self, memo_dict):
+        if self.chat.message.lower == 'yes':
+            memo_dict['is_public'] = True
+            answer = 'public\\private event:\npublic event\n\n'
+        else:
+            answer = 'private event'
+            memo_dict['is_public'] = False
+        answer = 'public\\private event:\nprivate event\n\n'
+        answer += '\nWhen does it start?'
         await telegram_bot.send_message(
             chat_id=self.chat.user_id,
             text=answer,
@@ -248,6 +282,7 @@ async def _submit_new_event(self, memo_dict):
             content=memo_dict['content'],
             owner_id=self.user.id,
             location=memo_dict['location'],
+            is_public=memo_dict['is_public'],
         )
         # Delete current session
         del telegram_bot.MEMORY[self.chat.user_id]

app/templates/event/eventview.html

@@ -40,5 +40,20 @@
         ADD INCLUDE HERE
       </div> -->
     </div>
+<<<<<<< HEAD
+    <!--    Copy commented section to add another tab-->
+    <!--    <div class="tab-pane fade" id="(CHANGE_ME)" role="tabpanel" aria-labelledby="(CHANGE_ME)-tab">-->
+    <!--        ADD INCLUDE HERE -->
+    <!--    </div>-->
+  </div>
+  <div class="event_info_buttons_row event_info_row_end">
+    <!-- Buttons could and should be replaced with button-like anchors if need so -->
+    <button type="button">Duplicate</button>
+    <button type="button">Edit</button>
+    {% if event.is_public %}
+    <button type="button">Join event</button>
+    {% endif %}
+=======
+>>>>>>> 8cd3a6e3c8c94ff0e9c86c9a6ed15c9856f757f9
   </div>
 {% endblock content %}

tests/test_a_telegram_asyncio.py

@@ -245,6 +245,12 @@ async def test_process_new_event(self):
         chat = Chat(gen_message('Universe'))
         message = MessageHandler(chat, self.TEST_USER)
         answer = 'Location:\nUniverse\n\n'
+        answer += 'is the event public? (yes\\no)'
+        assert await message.process_callback() == answer
+
+        chat = Chat(gen_message('yes'))
+        message = MessageHandler(chat, self.TEST_USER)
+        answer = 'public\\private event:\npublic event\n\n'
         answer += 'When does it start?'
         assert await message.process_callback() == answer
 

tests/test_event.py

@@ -12,7 +12,8 @@
 from app.dependencies import get_db
 from app.internal.utils import delete_instance
 from app.main import app
-
+from app.routers.event import add_new_event, add_user_to_event
+from app.routers.user import create_user
 from app.routers import event as evt
 
 
@@ -138,6 +139,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='new_test.email@gmail.com',
+        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