Fixing shift based approvals

Author: bitbyt3r

backend/tuber/api/hotels.py

@@ -11,6 +11,7 @@
 from tuber.api.util import *
 from .room_matcher import rematch_hotel_block, clear_hotel_block
 from .uber import export_requests
+from .util import paginate
 import time
 
 @app.route("/api/event/<int:event>/hotel/<int:hotel_block>/room/<int:room_id>/remove_roommates", methods=["POST"])
@@ -128,22 +129,19 @@ def room_details(event):
         HotelRoomRequest, HotelRoomRequest.badge == RoomNightAssignment.badge
     ).filter(HotelRoom.id.in_(rooms)).distinct().options(
         selectinload(HotelRoomRequest.roommate_requests).load_only(
-            Badge.id, Badge.public_name)
-    ).options(
+            Badge.id, Badge.public_name),
         selectinload(
-            HotelRoomRequest.roommate_anti_requests).load_only(Badge.id, Badge.public_name)
-    ).options(
+            HotelRoomRequest.roommate_anti_requests).load_only(Badge.id, Badge.public_name),
         selectinload(HotelRoomRequest.room_night_requests).load_only(
-            RoomNightRequest.room_night, RoomNightRequest.requested)
-    ).options(
-        selectinload(HotelRoomRequest.room_night_approvals).load_only(
-            RoomNightApproval.room_night, RoomNightApproval.approved
-        )
-    ).options(
+            RoomNightRequest.room_night, RoomNightRequest.requested),
+        selectinload(HotelRoom.roommates).load_only(
+            Badge.id, Badge.public_name
+        ).selectinload(Badge.manually_approved_nights),
         selectinload(HotelRoom.roommates).load_only(
-            Badge.id, Badge.public_name)
+            Badge.id, Badge.public_name
+        ).selectinload(Badge.shift_overlap_nights),
     ).all()
-
+    
     for hotel_room, request in hotel_rooms:
         if not hotel_room.id in gender_prefs:
             gender_prefs[hotel_room.id] = set()
@@ -165,11 +163,10 @@ def room_details(event):
         nights = set()
         for night_request in request.room_night_requests:
             if night_request.requested:
-                #if room_nights[night_request.room_night].restricted:
-                #    for approval in request.room_night_approvals:
-                #        if approval.room_night == night_request.room_night and approval.approved:
-                #            nights.add(night_request.room_night)
-                #else:
+                approved_nights = set()
+                for roommate in hotel_room.roommates:
+                    approved_nights.update([x.id for x in roommate.approved_hotel_nights])
+                if night_request.room_night in approved_nights:
                     nights.add(night_request.room_night)
         assigned_nights = [x.room_night for x in rnas_by_badge[request.badge]]
         missing_nights = nights.difference(set(assigned_nights))
@@ -219,21 +216,18 @@ def matching_roommates(event):
 
     badges = db.query(Badge).join(HotelRoomRequest, HotelRoomRequest.badge == Badge.id).filter(
         or_(HotelRoomRequest.declined == False, HotelRoomRequest.declined == None)
-    ).filter(Badge.event == event, Badge.search_name.contains(g.data.get('search', "").lower())).order_by(Badge.public_name).limit(20).all()
+    ).filter(Badge.event == event, Badge.search_name.contains(g.data.get('search', "").lower())
+    ).options(selectinload(Badge.shift_overlap_nights), selectinload(Badge.manually_approved_nights)
+    ).order_by(Badge.public_name).limit(20).all()
 
     results = []
     for badge in badges:
         missing = []
+        approved_nights = badge.approved_hotel_nights
         for night in badge.room_night_requests:
             assign = False
-            if night.requested:
-                #if room_nights[night.room_night].restricted:
-                #    for approval in badge.room_night_approvals:
-                #        if approval.room_night == night.room_night and approval.approved:
-                #            assign = True
-                #            break
-                #else:
-                    assign = True
+            if night.requested and night.room_night in [x.id for x in approved_nights]:
+                assign = True
             for assignment in badge.room_night_assignments:
                 if assignment.room_night == night.room_night:
                     assign = False
@@ -265,11 +259,46 @@ def room_search(event):
     return jsonify(hotel_rooms=HotelRoom.serialize(rooms, serialize_relationships=True), count=count), 200
 
 
+@app.route("/api/event/<int:event>/hotel/list_requests", methods=["GET"])
+def list_requests(event):
+    if not check_permission("hotel_block.*.read"):
+        return "", 403
+    
+    query = db.query(HotelRoomRequest)
+    if "hotel_block" in g.data:
+        query = query.filter(HotelRoomRequest.hotel_block == int(g.data['hotel_block']))
+    query = query.options(
+        selectinload(HotelRoomRequest.badge_obj, Badge.manually_approved_nights),
+        selectinload(HotelRoomRequest.badge_obj, Badge.shift_overlap_nights)
+    )
+    
+    query = paginate(query, HotelRoomRequest, event)
+    
+    if request.args.get("count", False, type=lambda x: x.lower() == "true"):
+        return json.dumps(query.count()), 200
+    requests = query.all()
+    
+    room_nights = db.query(HotelRoomNight).filter(HotelRoomNight.event == event).all()
+    
+    return [
+        {
+            "first_name": x.badge_obj.first_name,
+            "last_name": x.badge_obj.last_name,
+            "notes": x.notes,
+            "id": x.id,
+            "approved_nights": {y.id: y in x.badge_obj.approved_hotel_nights for y in room_nights},
+            "requested_nights": {z.id: z.id in [y.room_night for y in x.room_night_requests if y.requested] for z in room_nights}
+        } for x in requests
+    ]
+
+
 @app.route("/api/event/<int:event>/hotel/<int:hotel_block>/request_search", methods=["GET"])
 def request_search(event, hotel_block):
     if not check_permission("hotel_block.*.read"):
         return "", 403
 
+    room_nights = db.query(HotelRoomNight).filter(HotelRoomNight.event == event).all()
+    
     assigned_nights = db.query(RoomNightRequest.id).filter(RoomNightRequest.requested).join(
         RoomNightAssignment, and_(RoomNightAssignment.badge == RoomNightRequest.badge,
                                   RoomNightAssignment.room_night == RoomNightRequest.room_night)
@@ -280,7 +309,10 @@ def request_search(event, hotel_block):
         HotelRoomRequest.hotel_block == hotel_block,
         or_(HotelRoomRequest.declined == False, HotelRoomRequest.declined == None),
         HotelRoomRequest.room_night_requests.any(and_(RoomNightRequest.requested, not_(RoomNightRequest.id.in_(assigned_nights))))
-    ).join(Badge, Badge.id == HotelRoomRequest.badge)
+    ).join(Badge, Badge.id == HotelRoomRequest.badge).options(
+        selectinload(HotelRoomRequest.badge_obj, Badge.shift_overlap_nights),
+        selectinload(HotelRoomRequest.badge_obj, Badge.manually_approved_nights)
+    )
     if g.data['search_term']:
         reqs = reqs.filter(
             or_(Badge.search_name.contains(g.data['search_term'].lower()), func.lower(
@@ -295,7 +327,18 @@ def request_search(event, hotel_block):
     if g.data['order'] == "desc":
         sort = sort.desc()
     reqs = reqs.order_by(sort).offset(int(g.data['offset'])).limit(int(g.data['limit'])).all()
-    return jsonify(requests=HotelRoomRequest.serialize(reqs, serialize_relationships=True, deep=True), count=count), 200
+    
+    results = [{
+        "id": req.id,
+        "approved_nights": {x.id: x in req.badge_obj.approved_hotel_nights for x in room_nights},
+        "requested_nights": {x.id: x.id in [y.room_night for y in req.room_night_requests if y.requested] for x in room_nights},
+        "notes": req.notes,
+        "first_name": req.first_name,
+        "last_name": req.last_name,
+        "public_name": req.badge_obj.public_name,
+        "badge": req.badge,
+    } for req in reqs]
+    return jsonify(requests=results, count=count), 200
 
 
 @app.route("/api/event/<int:event>/hotel/submitted_requests", methods=["GET"])
@@ -382,7 +425,7 @@ def block_assignments(event):
 @app.route("/api/event/<int:event>/hotel/requests/<int:department>", methods=["GET"])
 def hotel_requests(event, department):
     requests = db.query(Badge, HotelRoomRequest).join(BadgeToDepartment, BadgeToDepartment.badge == Badge.id).filter(
-        BadgeToDepartment.department == department).join(HotelRoomRequest, HotelRoomRequest.badge == BadgeToDepartment.badge).all()
+        BadgeToDepartment.department == department).join(HotelRoomRequest, HotelRoomRequest.badge == BadgeToDepartment.badge).options(selectinload(Badge.manually_approved_nights), selectinload(Badge.shift_overlap_nights)).all()
     res = []
     for req in requests:
         badge, roomrequest = req
@@ -399,6 +442,8 @@ def hotel_requests(event, department):
                     "id": btr.id,
                     "requested": btr.requested,
                     "room_night": btr.room_night,
+                    "approved_by_anyone": btr.room_night in [x.id for x in badge.manually_approved_nights],
+                    "approved_by_shifts": btr.room_night in [x.id for x in badge.shift_overlap_nights],
                     "approved": rna.approved if rna else None
                 } for btr, rna in room_nights}
         })
@@ -410,20 +455,20 @@ def hotel_requests(event, department):
 def hotel_approve(event, department):
     if check_permission("hotel_request.*.approve", event=event, department=department):
         room_night_request = db.query(RoomNightRequest).filter(
-            RoomNightRequest.room_night == request.json['room_night'], RoomNightRequest.badge == request.json['badge']).one_or_none()
+            RoomNightRequest.room_night == int(request.json['room_night']), RoomNightRequest.badge == int(request.json['badge'])).one_or_none()
         if not room_night_request:
             return "Could not find corresponding request.", 404
         approval = db.query(RoomNightApproval).filter(RoomNightApproval.badge ==
-                                                      request.json['badge'], RoomNightApproval.room_night == request.json['room_night'], RoomNightApproval.department == department).one_or_none()
+                                                      int(request.json['badge']), RoomNightApproval.room_night == int(request.json['room_night']), RoomNightApproval.department == department).one_or_none()
         if request.json['approved'] is None:
             if approval:
                 db.delete(approval)
         else:
             if not approval:
                 approval = RoomNightApproval(
-                    event=event, badge=request.json['badge'], department=department)
+                    event=event, badge=int(request.json['badge']), department=department)
             approval.approved = request.json['approved']
-            approval.room_night = request.json['room_night']
+            approval.room_night = int(request.json['room_night'])
             db.add(approval)
         hotel_room_request = db.query(HotelRoomRequest).filter(
             HotelRoomRequest.badge == room_night_request.badge).one()

backend/tuber/api/uber.py

@@ -26,7 +26,42 @@ def import_shifts(event):
                 "department_id": dept.uber_id
             }
         }
-        shifts = requests.post(event_obj.uber_url, headers=headers, json=req).json()['result']
+        jobs = requests.post(event_obj.uber_url, headers=headers, json=req).json()['result']
+        db.query(Job).filter(Job.department == dept.id, Job.event == event).delete()
+        for job in jobs:
+            job_obj = Job(
+                name=job["name"],
+                description=job["description"],
+                department=dept.id,
+                event=event
+            )
+            db.add(job_obj)
+            db.flush()
+            start_time = datetime.datetime.strptime(job["start_time"], "%Y-%m-%d %H:%M:%S.%f")
+            end_time = datetime.datetime.strptime(job["end_time"], "%Y-%m-%d %H:%M:%S.%f")
+            shift_obj = Shift(
+                event=event,
+                job=job_obj.id,
+                starttime=start_time,
+                duration=(end_time-start_time).seconds,
+                slots=job["slots"],
+                filledslots=job["slots_taken"],
+                weighting=1.0
+            )
+            db.add(shift_obj)
+            db.flush()
+            for shift in job["shifts"]:
+                try:
+                    badge = db.query(Badge).filter(Badge.event==event, Badge.uber_id==shift["attendee"]["id"]).one()
+                    assignment = ShiftAssignment(
+                        event=event,
+                        badge=badge.id,
+                        shift=shift_obj.id
+                    )
+                    db.add(assignment)
+                except sqlalchemy.exc.NoResultFound:
+                    print(f"Failed to find attendee for {shift['attendee']['id']} (Not hotel elligible?)")
+    db.commit()
     return "null", 200
 
 def get_nights(url, headers):

backend/tuber/migrations/versions/28e0b36a0af8_added_timezone_to_event.py

@@ -0,0 +1,32 @@
+"""Added timezone to event
+
+Revision ID: 28e0b36a0af8
+Revises: afc23d43704e
+Create Date: 2025-06-25 21:54:34.030171
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '28e0b36a0af8'
+down_revision = 'afc23d43704e'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('event', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('timezone', sa.String(), nullable=False, server_default="America/New_York"))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('event', schema=None) as batch_op:
+        batch_op.drop_column('timezone')
+
+    # ### end Alembic commands ###

backend/tuber/migrations/versions/afc23d43704e_added_shift_start_and_end_times_to_.py

@@ -0,0 +1,34 @@
+"""Added shift start and end times to hotelroomnight
+
+Revision ID: afc23d43704e
+Revises: 44ea59b15fb5
+Create Date: 2025-06-25 21:22:11.475460
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'afc23d43704e'
+down_revision = '44ea59b15fb5'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('hotel_room_night', schema=None) as batch_op:
+        batch_op.add_column(sa.Column('shift_starttime', sa.DateTime(), nullable=True))
+        batch_op.add_column(sa.Column('shift_endtime', sa.DateTime(), nullable=True))
+
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('hotel_room_night', schema=None) as batch_op:
+        batch_op.drop_column('shift_endtime')
+        batch_op.drop_column('shift_starttime')
+
+    # ### end Alembic commands ###

backend/tuber/models/__init__.py

@@ -1,4 +1,4 @@
-
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 from sqlalchemy.ext.declarative import declarative_base
 import sqlalchemy.inspection
 from sqlalchemy.types import JSON
@@ -11,6 +11,37 @@
 import json
 
 
+class TimeZone(sqlalchemy.types.TypeDecorator):
+    """
+    Stores and retrieves timezone-aware datetimes as string objects.
+
+    In the database, the timezone is stored as a string (e.g., 'America/New_York').
+    In the Python application, it's represented as a `zoneinfo.ZoneInfo` object.
+    """
+    impl = sqlalchemy.types.String(100)
+    cache_ok = True # The type is immutable, so it's safe to cache
+
+    def process_bind_param(self, value: ZoneInfo | None, dialect) -> str | None:
+        """
+        Takes a ZoneInfo object from the app and converts it to a string for the DB.
+        """
+        if value is None:
+            return None
+        if not isinstance(value, ZoneInfo):
+            raise TypeError("TimeZone column requires a zoneinfo.ZoneInfo object")
+        return value.key
+
+    def process_result_value(self, value: str | None, dialect) -> ZoneInfo | None:
+        """
+        Takes a string from the DB and converts it to a ZoneInfo object for the app.
+        """
+        if value is None:
+            return None
+        try:
+            return ZoneInfo(value)
+        except ZoneInfoNotFoundError:
+            raise ValueError(f"Invalid timezone '{value}' found in database")
+
 def model_permissions(name):
     """
     Retrieves the permissions of the current user on the given model class.
@@ -69,8 +100,12 @@ def transform(inst, column): return getattr(inst, column.name)
             def transform(inst, column): return json.loads(
                 getattr(inst, column.name) or "{}")
         elif type(column.type) is Date:
-            def transform(inst, calumn): return getattr(
+            def transform(inst, column): return getattr(
                 inst, column.name).strftime("%Y-%m-%d")
+        elif type(column.type) is TimeZone:
+            def transform(inst, column): return str(getattr(
+                inst, column.name
+            ))
         for i in range(len(instances)):
             data[i][column.name] = transform(instances[i], column)
 
@@ -173,10 +208,16 @@ def filter_columns(cls, instance, perms, existing=None):
                 key = column.name
                 val = instance[key]
                 if type(column.type) is DateTime:
-                    instance[key] = datetime.datetime.strptime(
-                        val, '%Y-%m-%dT%H:%M:%S.%f')
+                    if val.endswith("Z"):
+                        instance[key] = datetime.datetime.strptime(
+                            val, '%Y-%m-%dT%H:%M:%S.%fZ', ).replace(tzinfo=datetime.timezone.utc)
+                    else:
+                        instance[key] = datetime.datetime.strptime(
+                            val, '%Y-%m-%dT%H:%M:%S.%f')
                 elif type(column.type) is JSON:
                     instance[key] = json.dumps(val)
+                elif type(column.type) is TimeZone:
+                    instance[key] = ZoneInfo(val)
         for relation in relations:
             #     new = []
             if relation.key in instance: