implement

Author: laheri72

blueprints/admin/routes.py

@@ -175,6 +175,49 @@ def admin():
             flash('Role assigned successfully', 'success')
             return redirect(url_for('admin_panel.admin'))
 
+        if action == 'bulk_reassign':
+            try:
+                from_user_id = int(request.form.get('from_user_id') or '')
+                to_user_id = int(request.form.get('to_user_id') or '')
+                reassign_types = request.form.getlist('reassign_types')
+                
+                if from_user_id == to_user_id:
+                    flash('Source and target user cannot be the same.', 'error')
+                    return redirect(url_for('admin_panel.admin'))
+                
+                from_user = tenant_filter(User.query).filter_by(id=from_user_id).first()
+                to_user = tenant_filter(User.query).filter_by(id=to_user_id).first()
+                
+                if not from_user or not to_user:
+                    flash('One or both users not found.', 'error')
+                    return redirect(url_for('admin_panel.admin'))
+                
+                updates = 0
+                if 'menu' in reassign_types:
+                    count = tenant_filter(Menu.query).filter_by(assigned_to_id=from_user_id).update(
+                        {Menu.assigned_to_id: to_user_id}, synchronize_session=False
+                    )
+                    updates += count
+                
+                if 'tea' in reassign_types:
+                    count = tenant_filter(TeaTask.query).filter_by(assigned_to_id=from_user_id).update(
+                        {TeaTask.assigned_to_id: to_user_id}, synchronize_session=False
+                    )
+                    updates += count
+                
+                if 'procurement' in reassign_types:
+                    count = tenant_filter(ProcurementItem.query).filter_by(assigned_to_id=from_user_id).update(
+                        {ProcurementItem.assigned_to_id: to_user_id}, synchronize_session=False
+                    )
+                    updates += count
+                
+                db.session.commit()
+                flash(f'Successfully reassigned {updates} items from {from_user.full_name or from_user.email} to {to_user.full_name or to_user.email}.', 'success')
+            except Exception as e:
+                db.session.rollback()
+                flash(f'Error during reassignment: {str(e)}', 'error')
+            return redirect(url_for('admin_panel.admin'))
+
         if action == 'delete_user':
             try:
                 target_user_id = int(request.form.get('user_id') or '')
@@ -286,16 +329,22 @@ def admin_floor_members():
     if floor < FLOOR_MIN or floor > FLOOR_MAX:
         return jsonify({"error": "invalid_floor"}), 400
 
-    members = (
-        tenant_filter(User.query).filter_by(floor=floor, role='member')
-        .order_by(User.tr_number.asc(), User.full_name.asc(), User.email.asc())
+    role_type = (request.args.get('role') or 'member').strip()
+
+    query = tenant_filter(User.query).filter_by(floor=floor)
+    if role_type != 'all':
+        query = query.filter_by(role=role_type)
+    
+    users = (
+        query.order_by(User.tr_number.asc(), User.full_name.asc(), User.email.asc())
         .all()
     )
 
     def _label(u):
         name = (u.full_name or u.username or u.email or '').strip()
         tr = (u.tr_number or '-').strip()
-        return f"{tr} - {name}".strip(' -')
+        role_label = f" ({u.role})" if role_type == 'all' else ""
+        return f"{tr} - {name}{role_label}".strip(' -')
 
     return jsonify(
         {
@@ -307,7 +356,7 @@ def _label(u):
                     "name": (u.full_name or u.username or u.email),
                     "label": _label(u),
                 }
-                for u in members
+                for u in users
             ],
         }
     )

blueprints/ops/routes.py

@@ -26,7 +26,7 @@ def tea():
     floor = _get_active_floor(user)
     floor_users = tenant_filter(User.query).filter_by(floor=floor).all()
 
-    if request.method == 'POST' and user.role in ['admin', 'teaManager']:
+    if request.method == 'POST' and user.role in ['admin', 'teaManager', 'pantryHead']:
         try:
             task_date = datetime.strptime(request.form.get('date'), '%Y-%m-%d').date()
         except Exception:
@@ -66,6 +66,14 @@ def tea():
         flash('tea task added successfully', 'success')
         return redirect(url_for('ops.tea'))
 
+    # Auto-complete past pending tasks for this floor
+    tenant_filter(TeaTask.query).filter(
+        TeaTask.floor == floor,
+        TeaTask.date < date.today(),
+        TeaTask.status == 'pending'
+    ).update({TeaTask.status: 'completed'}, synchronize_session=False)
+    db.session.commit()
+
     month_param = (request.args.get('month') or '').strip()
     today = date.today()
     if month_param:
@@ -117,6 +125,7 @@ def tea():
         selected_month=month_param,
         month_start=month_start,
         current_user=user,
+        today=today
     )
 
 @ops_bp.route('/tea/complete/<int:task_id>', methods=['POST'])
@@ -125,7 +134,7 @@ def complete_tea_task(task_id):
     if not user:
         return ('', 401)
 
-    if user.role not in ['admin', 'teaManager']:
+    if user.role not in ['admin', 'teaManager', 'pantryHead']:
         return ('', 403)
 
     task = tenant_filter(TeaTask.query).filter_by(id=task_id).first()
@@ -138,6 +147,163 @@ def complete_tea_task(task_id):
     db.session.commit()
     return ('', 204)
 
+@ops_bp.route('/tea/bulk-assign', methods=['POST'])
+def bulk_assign_tea():
+    user = _require_user()
+    if not user or user.role not in ['admin', 'teaManager', 'pantryHead']:
+        abort(403)
+
+    floor = _get_active_floor(user)
+    try:
+        start_date = datetime.strptime(request.form.get('start_date'), '%Y-%m-%d').date()
+        end_date = datetime.strptime(request.form.get('end_date'), '%Y-%m-%d').date()
+        user_ids = request.form.getlist('user_ids')
+    except Exception:
+        flash('Invalid rotation parameters', 'error')
+        return redirect(url_for('ops.tea'))
+
+    if not user_ids:
+        flash('Please select at least one user for rotation.', 'error')
+        return redirect(url_for('ops.tea'))
+
+    if start_date > end_date:
+        flash('Start date cannot be after end_date.', 'error')
+        return redirect(url_for('ops.tea'))
+
+    current_date = start_date
+    user_index = 0
+    tasks_created = 0
+    from datetime import timedelta
+
+    while current_date <= end_date:
+        # Check if task already exists for this floor and date
+        existing = tenant_filter(TeaTask.query).filter_by(floor=floor, date=current_date).first()
+        if not existing:
+            # Try to find the next available user in the rotation
+            found_user = False
+            for _ in range(len(user_ids)):
+                target_user_id = int(user_ids[user_index % len(user_ids)])
+                
+                # Check for approved absence request
+                absence = tenant_filter(Request.query).filter(
+                    Request.user_id == target_user_id,
+                    Request.status == 'approved',
+                    Request.request_type == 'absence',
+                    Request.start_date <= current_date,
+                    Request.end_date >= current_date
+                ).first()
+
+                if not absence:
+                    # Found an available user
+                    new_task = TeaTask(
+                        date=current_date,
+                        assigned_to_id=target_user_id,
+                        floor=floor,
+                        created_by_id=user.id,
+                        tenant_id=getattr(g, 'tenant_id', None)
+                    )
+                    db.session.add(new_task)
+                    tasks_created += 1
+                    user_index += 1 # Move to next user for next date
+                    found_user = True
+                    break
+                else:
+                    # User is on leave, try the next one for THIS same date
+                    user_index += 1
+            
+            # if no user was found available for this date, the date is skipped
+        
+        current_date += timedelta(days=1)
+
+    db.session.commit()
+    flash(f'Successfully generated {tasks_created} tea tasks.', 'success')
+    return redirect(url_for('ops.tea'))
+
+@ops_bp.route('/tea/bulk-assign-preview', methods=['POST'])
+def bulk_assign_preview():
+    user = _require_user()
+    if not user or user.role not in ['admin', 'teaManager', 'pantryHead']:
+        return jsonify({"error": "unauthorized"}), 403
+
+    floor = _get_active_floor(user)
+    try:
+        data = request.get_json()
+        start_date = datetime.strptime(data.get('start_date'), '%Y-%m-%d').date()
+        end_date = datetime.strptime(data.get('end_date'), '%Y-%m-%d').date()
+        user_ids = [int(uid) for uid in data.get('user_ids', [])]
+    except Exception:
+        return jsonify({"error": "invalid_parameters"}), 400
+
+    if not user_ids:
+        return jsonify({"error": "no_users_selected"}), 400
+
+    current_date = start_date
+    user_index = 0
+    preview_tasks = []
+    from datetime import timedelta
+
+    # Get floor user names for labeling
+    users_map = {u.id: (u.full_name or u.username or u.email) for u in tenant_filter(User.query).filter_by(floor=floor).all()}
+
+    while current_date <= end_date:
+        existing = tenant_filter(TeaTask.query).filter_by(floor=floor, date=current_date).first()
+        if not existing:
+            found_user = False
+            for _ in range(len(user_ids)):
+                target_user_id = user_ids[user_index % len(user_ids)]
+                absence = tenant_filter(Request.query).filter(
+                    Request.user_id == target_user_id,
+                    Request.status == 'approved',
+                    Request.request_type == 'absence',
+                    Request.start_date <= current_date,
+                    Request.end_date >= current_date
+                ).first()
+
+                if not absence:
+                    preview_tasks.append({
+                        "date": current_date.strftime('%Y-%m-%d'),
+                        "day": current_date.strftime('%A'),
+                        "user_id": target_user_id,
+                        "user_name": users_map.get(target_user_id, "Unknown")
+                    })
+                    user_index += 1
+                    found_user = True
+                    break
+                else:
+                    user_index += 1
+        
+        current_date += timedelta(days=1)
+
+    return jsonify({"tasks": preview_tasks})
+
+@ops_bp.route('/tea/fail/<int:task_id>', methods=['POST'])
+def fail_tea_task(task_id):
+    user = _require_user()
+    if not user or user.role not in ['admin', 'teaManager', 'pantryHead']:
+        return ('', 403)
+
+    task = tenant_filter(TeaTask.query).filter_by(id=task_id).first()
+    if not task: return ('', 404)
+    if user.role != 'admin' and task.floor != user.floor: return ('', 403)
+
+    task.status = 'failed'
+    db.session.commit()
+    return ('', 204)
+
+@ops_bp.route('/tea/pending/<int:task_id>', methods=['POST'])
+def reset_tea_task(task_id):
+    user = _require_user()
+    if not user or user.role not in ['admin', 'teaManager', 'pantryHead']:
+        return ('', 403)
+
+    task = tenant_filter(TeaTask.query).filter_by(id=task_id).first()
+    if not task: return ('', 404)
+    if user.role != 'admin' and task.floor != user.floor: return ('', 403)
+
+    task.status = 'pending'
+    db.session.commit()
+    return ('', 204)
+
 @ops_bp.route('/requests', methods=['GET', 'POST'])
 def requests():
     user = _require_user()

blueprints/pantry/routes.py

@@ -387,9 +387,49 @@ def calendar():
         return redirect(url_for('auth.login'))
 
     floor = _get_active_floor(user)
-    floor_menus = tenant_filter(Menu.query).options(joinedload(Menu.assigned_to), joinedload(Menu.assigned_team)).filter_by(floor=floor).all()
-    floor_tea_tasks = tenant_filter(TeaTask.query).options(joinedload(TeaTask.assigned_to)).filter_by(floor=floor).all()
-    floor_special_events = tenant_filter(SpecialEvent.query).options(joinedload(SpecialEvent.created_by)).filter_by(floor=floor).all()
+    
+    # Get year and month from query params or default to current date
+    now = datetime.now()
+    try:
+        current_year = int(request.args.get('year', now.year))
+        current_month = int(request.args.get('month', now.month))
+    except (ValueError, TypeError):
+        current_year = now.year
+        current_month = now.month
+
+    # Handle month rollover safely (e.g. month=0 or month=13)
+    if current_month < 1:
+        current_month = 12
+        current_year -= 1
+    elif current_month > 12:
+        current_month = 1
+        current_year += 1
+
+    # Calculate range for calendar grid (roughly 6 weeks)
+    start_bound = date(current_year, current_month, 1) - timedelta(days=7)
+    if current_month == 12:
+        next_month_start = date(current_year + 1, 1, 1)
+    else:
+        next_month_start = date(current_year, current_month + 1, 1)
+    end_bound = next_month_start + timedelta(days=14)
+
+    floor_menus = tenant_filter(Menu.query).options(joinedload(Menu.assigned_to), joinedload(Menu.assigned_team)).filter(
+        Menu.floor == floor,
+        Menu.date >= start_bound,
+        Menu.date <= end_bound
+    ).all()
+    
+    floor_tea_tasks = tenant_filter(TeaTask.query).options(joinedload(TeaTask.assigned_to)).filter(
+        TeaTask.floor == floor,
+        TeaTask.date >= start_bound,
+        TeaTask.date <= end_bound
+    ).all()
+    
+    floor_special_events = tenant_filter(SpecialEvent.query).options(joinedload(SpecialEvent.created_by)).filter(
+        SpecialEvent.floor == floor,
+        SpecialEvent.date >= start_bound,
+        SpecialEvent.date <= end_bound
+    ).all()
 
     menus = [
         {
@@ -440,7 +480,14 @@ def calendar():
         for s in floor_special_events
     ]
 
-    return render_template('calendar.html', menus=menus, tea_tasks=tea_tasks, special_events=special_events, current_user=user, active_floor=floor)
+    return render_template('calendar.html', 
+                           menus=menus, 
+                           tea_tasks=tea_tasks, 
+                           special_events=special_events, 
+                           current_user=user, 
+                           active_floor=floor,
+                           current_year=current_year,
+                           current_month=current_month)
 
 @pantry_bp.route('/special-events', methods=['POST'])
 def create_special_event():