Feature-9065: Track when attendees login and join an event virtually in CSV (#9070)

* fix issue user request check in not admin

* feature-9065: Track when attendees login and join an event virtually in CSV

* feature-9065: Track when attendees login and join an event virtually in CSV

* fix python deepsource scan

---------

Co-authored-by: Mario Behling <[email protected]>

Author: nnhathung

app/api/custom/events.py

@@ -2,17 +2,21 @@
 from flask_jwt_extended import current_user
 from sqlalchemy import asc, distinct, func, or_
 
-from app.api.helpers.errors import ForbiddenError, UnprocessableEntityError
+from app.api.helpers.errors import ForbiddenError, NotFoundError, UnprocessableEntityError
 from app.api.helpers.mail import send_email
 from app.api.helpers.permissions import is_coorganizer, jwt_required, to_event_id
 from app.api.helpers.system_mails import MAILS, MailType
+from app.api.helpers.user import get_user_id_from_token, virtual_event_check_in
 from app.api.helpers.utilities import group_by, strip_tags
 from app.api.schema.exhibitors import ExhibitorReorderSchema
 from app.api.schema.speakers import SpeakerReorderSchema
+from app.api.schema.virtual_check_in import VirtualCheckInSchema
 from app.models import db
 from app.models.discount_code import DiscountCode
 from app.models.event import Event
 from app.models.exhibitor import Exhibitor
+from app.models.microlocation import Microlocation
+from app.models.order import Order
 from app.models.session import Session
 from app.models.speaker import Speaker
 from app.models.ticket_holder import TicketHolder
@@ -216,6 +220,53 @@ def search_attendees(event_id):
     return jsonify({'attendees': attendees})
 
 
+@events_routes.route('/<string:event_identifier>/virtual/check-in', methods=['POST'])
+@jwt_required
+def virtual_check_in(event_identifier):
+    """Search attendees by name or email."""
+    event = db.session.query(Event).filter_by(identifier=event_identifier).first()
+    if event is None:
+        raise NotFoundError({'source': ''}, 'event can not be found')
+    data, errors = VirtualCheckInSchema().load(request.get_json())
+    if errors:
+        raise UnprocessableEntityError(
+            {'pointer': '/data', 'errors': errors}, 'Data in incorrect format'
+        )
+    token = None
+    if "Authorization" in request.headers:
+        token = request.headers["Authorization"].split(" ")[1]
+    if not token:
+        return {
+            "message": "Authentication Token is missing!",
+            "data": None,
+            "error": "Unauthorized",
+        }, 401
+    user_id = get_user_id_from_token(token)
+    if user_id is None:
+        return {"message": "Can't get user id!", "data": None}, 404
+
+    if data.get('microlocation_id') is not None:
+        microlocation = Microlocation.query.filter(
+            Microlocation.id == data.get('microlocation_id')
+        ).first()
+        if microlocation is None:
+            raise NotFoundError({'source': ''}, 'microlocation can not be found')
+
+    orders = Order.query.filter(
+        Order.user_id == user_id, Order.event_id == event.id
+    ).all()
+
+    orders_id = [order.id for order in orders]
+
+    attendees = TicketHolder.query.filter(TicketHolder.order_id.in_(orders_id)).all()
+
+    attendees_ids = [attendee.id for attendee in attendees]
+
+    virtual_event_check_in(data, attendees_ids, event.id)
+
+    return jsonify({'message': 'Attendee check in/out success'})
+
+
 @events_routes.route('/<string:event_identifier>/sessions/languages', methods=['GET'])
 @to_event_id
 def get_languages(event_id):

app/api/helpers/csv_jobs_util.py

@@ -7,6 +7,7 @@
 from app.models.helpers.versioning import strip_tags
 from app.models.order import OrderTicket
 from app.models.ticket import access_codes_tickets
+from app.models.user_check_in import VirtualCheckIn
 
 
 def export_orders_csv(orders):
@@ -148,11 +149,28 @@ def export_attendees_csv(attendees, custom_forms, attendee_form_dict):
                 )
                 converted_header = field.name
                 data[converted_header] = dict_value
+        data['virtual_event_checkin_times'] = get_virtual_checkin_times(attendee.id)
         return_dict_list.append(data)
 
     return return_dict_list
 
 
+def get_virtual_checkin_times(attendee_id: int):
+    """
+    get check in times of attendee
+    @param attendee_id: attendee_id
+    @return: time check in of attendee
+    """
+    virtual_check_in = VirtualCheckIn.query.filter(
+        VirtualCheckIn.ticket_holder_id.any(attendee_id),
+        VirtualCheckIn.check_in_type == 'room',
+    ).all()
+    virtual_check_in_times = [
+        item.check_in_at.strftime("%Y-%m-%dT%H:%M:%S%z") for item in virtual_check_in
+    ]
+    return virtual_check_in_times
+
+
 def export_sessions_csv(sessions):
     headers = [
         'Session Title',

app/api/helpers/user.py

@@ -1,9 +1,14 @@
+import datetime
+
+import jwt
+from flask import current_app
 from sqlalchemy.orm.exc import NoResultFound
 
 from app.api.helpers.db import save_to_db
-from app.api.helpers.errors import ForbiddenError
+from app.api.helpers.errors import ForbiddenError, UnprocessableEntityError
 from app.models import db
 from app.models.user import User
+from app.models.user_check_in import VirtualCheckIn
 
 
 def modify_email_for_user_to_be_deleted(user):
@@ -49,3 +54,50 @@ def modify_email_for_user_to_be_restored(user):
                 "This email is already registered! Manually edit and then try restoring",
             )
     return user
+
+
+def get_user_id_from_token(token: str):
+    """
+    Get user Id from JWT token
+    @param token: JWT token
+    @return: user id
+    """
+    data = jwt.decode(token, current_app.config["SECRET_KEY"], algorithms=["HS256"])
+    if not data.get('identity', False):
+        return {"message": "Can't get user id!", "data": None}, 404
+
+    return data["identity"]
+
+
+def virtual_event_check_in(data, attendee_ids, event_id):
+    """
+    do check in for attendee in virtual event
+    @param data: data
+    @param attendee_ids: attendee_ids
+    @param event_id: event_id
+    """
+    current_time = datetime.datetime.now()
+    if data['is_check_in']:
+        virtual_check_in = VirtualCheckIn(
+            ticket_holder_id=attendee_ids,
+            event_id=event_id,
+            check_in_type=data['check_in_type'],
+            check_in_at=current_time,
+            microlocation_id=data.get('microlocation_id'),
+        )
+    else:
+        virtual_check_in = (
+            VirtualCheckIn.query.filter(
+                VirtualCheckIn.ticket_holder_id == attendee_ids,
+                VirtualCheckIn.event_id == event_id,
+                VirtualCheckIn.microlocation_id == data.get('microlocation_id'),
+            )
+            .order_by(VirtualCheckIn.id.desc())
+            .first()
+        )
+        if virtual_check_in is None:
+            raise UnprocessableEntityError({'errors': 'Attendee not check in yet'})
+        if virtual_check_in.check_out_at is not None:
+            raise UnprocessableEntityError({'errors': 'Attendee Already checked out'})
+        virtual_check_in.check_out_at = current_time
+    save_to_db(virtual_check_in)

app/api/schema/virtual_check_in.py

@@ -0,0 +1,27 @@
+from marshmallow import Schema, ValidationError, fields, validate, validates_schema
+
+CHECK_IN_TYPE = ['event', 'virtual-room', 'room']
+
+
+class VirtualCheckInSchema(Schema):
+    id = fields.Integer(dump_only=True)
+    check_in_type = fields.Str(
+        nullable=False, required=True, validate=validate.OneOf(choices=CHECK_IN_TYPE)
+    )
+    microlocation_id = fields.Integer(nullable=True)
+    is_check_in = fields.Boolean(required=True, nullable=False)
+    check_in_at = fields.DateTime(dump_only=True)
+    check_out_at = fields.DateTime(dump_only=True)
+
+    @validates_schema
+    def validate_microlocation_requires_a(self, data):
+        """
+        validate when check_in_type is room, microlocation id is required
+        @param data: data
+        """
+        if (
+            'check_in_type' in data
+            and data['check_in_type'] == 'room'
+            and 'microlocation_id' not in data
+        ):
+            raise ValidationError('microlocation_id is required for room check in.')

app/models/user_check_in.py

@@ -1,6 +1,9 @@
 import datetime
 
+from sqlalchemy import ARRAY, Integer, func
+
 from app.models import db
+from app.models.base import SoftDeletionModel
 
 
 class UserCheckIn(db.Model):
@@ -35,3 +38,35 @@ class UserCheckIn(db.Model):
 
     def __repr__(self):
         return f'<User Check In {self.id}>'
+
+
+class VirtualCheckIn(SoftDeletionModel):
+    """Virtual check in database model"""
+
+    __tablename__ = 'virtual_check_in'
+
+    id = db.Column(db.Integer, primary_key=True)
+
+    ticket_holder_id = db.Column(ARRAY(Integer), nullable=True)
+
+    event_id = db.Column(db.Integer, db.ForeignKey('events.id', ondelete='SET NULL'))
+    event = db.relationship('Event', backref='virtual_check_ins')
+
+    microlocation_id = db.Column(
+        db.Integer,
+        db.ForeignKey('microlocations.id', ondelete='SET NULL'),
+        nullable=True,
+        default=None,
+    )
+    microlocation = db.relationship('Microlocation', backref='virtual_check_ins')
+
+    check_in_type = db.Column(db.String, nullable=False)
+    check_in_at = db.Column(db.DateTime(timezone=True))
+    check_out_at = db.Column(db.DateTime(timezone=True))
+
+    created_at = db.Column(db.DateTime(timezone=True), default=func.now())
+    updated_at = db.Column(db.DateTime(timezone=True))
+    is_deleted = db.Column(db.Boolean, default=False)
+
+    def __repr__(self):
+        return f'<Virtual Check In {self.id}>'

migrations/versions/rev-2023-08-17-15:38:43-bce7acfe5a4f_.py

@@ -0,0 +1,42 @@
+"""empty message
+
+Revision ID: bce7acfe5a4f
+Revises: 24271525a263
+Create Date: 2023-08-17 15:38:43.387065
+
+"""
+
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'bce7acfe5a4f'
+down_revision = '24271525a263'
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('virtual_check_in',
+    sa.Column('deleted_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('id', sa.Integer(), nullable=False),
+    sa.Column('ticket_holder_id', sa.ARRAY(sa.Integer()), nullable=True),
+    sa.Column('event_id', sa.Integer(), nullable=True),
+    sa.Column('microlocation_id', sa.Integer(), nullable=True),
+    sa.Column('check_in_type', sa.String(), nullable=False),
+    sa.Column('check_in_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('check_out_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('created_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('is_deleted', sa.Boolean(), nullable=True),
+    sa.ForeignKeyConstraint(['event_id'], ['events.id'], ondelete='SET NULL'),
+    sa.ForeignKeyConstraint(['microlocation_id'], ['microlocations.id'], ondelete='SET NULL'),
+    sa.PrimaryKeyConstraint('id')
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_table('virtual_check_in')
+    # ### end Alembic commands ###