Ask members if they don't want more task suggestions, if they persistently ignore them

Author: HalfVoxel

api/src/messages/models.py

@@ -40,6 +40,7 @@ class MessageTemplate(enum.Enum):
     MEMBERBOOTH_BOX_EXPIRED = "memberbooth_box_expired"
     MEMBERBOOTH_BOX_EXPIRING_SOON = "memberbooth_box_expiring_soon"
     QUIZ_COMPLETION = "quiz_completion"
+    TASK_DELEGATION_PREFERENCE = "task_delegation_preference"
 
 
 class Message(Base):

api/src/tasks/delegate.py

@@ -1,3 +1,4 @@
+import json
 import math
 import re
 import time
@@ -11,6 +12,8 @@
 
 import requests
 from membership.models import Group, Member, member_group
+from messages.message import send_message
+from messages.models import Message, MessageTemplate
 from multiaccessy.models import PhysicalAccessEntry
 from PIL import Image
 from quiz.models import QuizAnswer, QuizQuestion
@@ -1164,6 +1167,19 @@ def is_task_delegation_enabled(member_id: int) -> bool:
     return pref.selected_options == "true"
 
 
+def consecutive_ignored_tasks(last_assigned_tasks: list[TaskDelegationLogSimple]) -> list[TaskDelegationLogSimple]:
+    """Return the leading run of ignored tasks (newest first), skipping still-pending and re-rolled tasks."""
+    result = []
+    for task in last_assigned_tasks:
+        if task.status in ("assigned", "not_done_rerolled"):
+            continue
+        if task.status == "ignored":
+            result.append(task)
+        else:
+            break
+    return result
+
+
 def member_recently_received_task(ctx: TaskContext) -> bool:
     # If a member has completed a task recently, don't assign them another one too soon.
     # The wait depends on the size of the task
@@ -1183,10 +1199,11 @@ def member_recently_received_task(ctx: TaskContext) -> bool:
         # It's then no longer assigned or completed, but we still don't want to assign them another task too soon.
         #
         # If the member explicitly wanted a new task, we allow assigning a new task sooner.
-        if (
-            ctx.time - last_assigned_task.created_at < timedelta(hours=14)
-            and last_assigned_task.status != "not_done_rerolled"
-        ):
+        # If the member has been ignoring tasks, increase the delay by 3x.
+        base_delay = timedelta(hours=14)
+        if len(consecutive_ignored_tasks(ctx.member.last_assigned_tasks)) >= 3:
+            base_delay *= 3
+        if ctx.time - last_assigned_task.created_at < base_delay and last_assigned_task.status != "not_done_rerolled":
             return True
 
     return False
@@ -1800,6 +1817,16 @@ def delegate_task_for_member(
         logger.info(f"Member {member_id} received a task recently; skipping delegation")
         return None
 
+    # If 3 tasks have been ignored in a row since the last preference question, ask again.
+    if not force and slack_interaction is None:
+        if should_ask_delegation_preference(member_id, ctx.member.last_assigned_tasks):
+            member = db_session.get(Member, member_id)
+            if member:
+                ask_delegation_preference_question(member)
+                db_session.commit()
+                logger.info(f"Queued delegation preference question for member {member_id}")
+                return None
+
     if picked_card is None:
         picked_card = select_card_for_member(ctx, ignore_reasons)
 
@@ -2010,6 +2037,24 @@ def clear_pending_question(member_id: int) -> None:
     redis_connection.delete(cache_key)
 
 
+def should_ask_delegation_preference(member_id: int, last_assigned_tasks: list[TaskDelegationLogSimple]) -> bool:
+    """Return True if 3 tasks have been ignored in a row since the last delegation preference message was sent."""
+    streak = consecutive_ignored_tasks(last_assigned_tasks)
+    if len(streak) < 3:
+        return False
+    last_message_date = db_session.execute(
+        select(Message.created_at)
+        .where(
+            Message.member_id == member_id,
+            Message.template == MessageTemplate.TASK_DELEGATION_PREFERENCE.value,
+            Message.status != Message.FAILED,
+        )
+        .order_by(Message.created_at.desc())
+        .limit(1)
+    ).scalar_one_or_none()
+    return last_message_date is None or streak[2].created_at > last_message_date
+
+
 def ask_room_preference_question(
     member: Member,
     slack_client: WebClient,
@@ -2179,3 +2224,44 @@ def ask_skill_level_question(
     channel = slack_response.get("channel", "")
     ts = slack_response.get("ts", "")
     return (channel, ts)
+
+
+def ask_delegation_preference_question(member: Member) -> None:
+    """Queue a Slack message asking the member whether they want to continue receiving task suggestions."""
+    text = (
+        f"Hi {member.firstname}! We've noticed you haven't responded to the last few task suggestions. "
+        f"Would you like to continue receiving task suggestions?"
+    )
+
+    blocks: list[Block] = [
+        DividerBlock(),
+        SectionBlock(text=MarkdownTextObject(text=text)),
+        ActionsBlock(
+            block_id="task_delegation_preference",
+            elements=[
+                ButtonElement(
+                    text=PlainTextObject(text="Yes, keep sending tasks", emoji=True),
+                    action_id="task_delegation_preference_yes",
+                    value="yes",
+                    style="primary",
+                ),
+                ButtonElement(
+                    text=PlainTextObject(text="No, stop sending tasks", emoji=True),
+                    action_id="task_delegation_preference_no",
+                    value="no",
+                    style="danger",
+                ),
+            ],
+        ),
+    ]
+
+    send_message(
+        template=MessageTemplate.TASK_DELEGATION_PREFERENCE,
+        member=member,
+        db_session=db_session,
+        recipient=member.email,
+        recipient_type="slack",
+        subject="Continue receiving task suggestions?",
+        body=json.dumps([block.to_dict() for block in blocks]),
+    )
+    logger.info(f"Queued delegation preference question for member #{member.member_number}")

api/src/tasks/views.py

@@ -689,6 +689,8 @@ def slack_interaction() -> dict:
         return slack_handle_new_task_request(payload)
     elif action.action_id in ["slack_email_confirm", "slack_email_cancel"]:
         return slack_handle_email_verification(payload)
+    elif action.action_id.startswith("task_delegation_preference_"):
+        return slack_handle_delegation_preference(payload)
     else:
         return slack_handle_task_feedback(payload)
 
@@ -706,6 +708,52 @@ def slack_handle_new_task_request(payload: SlackInteraction) -> dict:
     return {"message": "New task assigned"}
 
 
+def slack_handle_delegation_preference(payload: SlackInteraction) -> dict:
+    """Handle when a member responds to the 'continue receiving tasks?' question."""
+    action = payload.actions[0]
+    slack_client = get_slack_client()
+    member = member_from_slack_user_id(slack_client, payload.user.id)
+
+    if not member:
+        raise UnprocessableEntity("Member not found")
+
+    if action.action_id == "task_delegation_preference_no":
+        pref = MemberPreference(
+            member_id=member.member_id,
+            question_type=MemberPreferenceQuestionType.TASK_DELEGATION_ENABLED,
+            available_options="true,false",
+            selected_options="false",
+        )
+        db_session.add(pref)
+        db_session.commit()
+
+        slack_client.chat_update(
+            channel=payload.channel.id,
+            ts=payload.message.ts,
+            text="Task suggestions disabled. You can re-enable them at any time in the member portal.",
+            blocks=[
+                SectionBlock(
+                    text=MarkdownTextObject(
+                        text=":no_bell: Got it! We'll stop sending you task suggestions. You can re-enable them at any time in the member portal."
+                    )
+                )
+            ],
+        )
+    else:
+        # "yes" — pref_question_ignore_count is already set to the current count when we asked,
+        # so we just need to confirm to the member.
+        slack_client.chat_update(
+            channel=payload.channel.id,
+            ts=payload.message.ts,
+            text="Great! We'll keep sending you task suggestions.",
+            blocks=[
+                SectionBlock(text=MarkdownTextObject(text=":bell: Great! We'll keep sending you task suggestions."))
+            ],
+        )
+
+    return {"message": "Preference saved"}
+
+
 def slack_handle_email_verification(payload: SlackInteraction) -> dict:
     """Handle Slack email verification confirmation or cancellation."""
     from membership.models import SlackEmailOverride