Allow participants to start a vote

Author: sbp

atr/blueprints/api/api.py

@@ -1180,12 +1180,12 @@ async def vote_start(data: models.api.VoteStartArgs) -> DictResponse:
 
     try:
         async with storage.write(asf_uid) as write:
-            wacm = await write.as_project_committee_member(data.project)
-            permitted_recipients = util.permitted_voting_recipients(asf_uid, wacm.committee_name)
+            wacp = await write.as_project_committee_participant(data.project)
+            permitted_recipients = util.permitted_voting_recipients(asf_uid, wacp.committee_name)
             if data.email_to not in permitted_recipients:
                 raise exceptions.Forbidden("Invalid mailing list choice")
             # TODO: Get fullname and use instead of asf_uid
-            task = await wacm.vote.start(
+            task = await wacp.vote.start(
                 data.email_to,
                 data.project,
                 data.version,

atr/routes/voting.py

@@ -258,8 +258,8 @@ async def _selected_revision_data(
         vote_duration_choice: int = util.unwrap(form.vote_duration.data)
         subject_data: str = util.unwrap(form.subject.data)
         body_data: str = util.unwrap(form.body.data)
-        async with storage.write_as_committee_member(committee.name) as wacm:
-            _task = await wacm.vote.start(
+        async with storage.write_as_committee_participant(committee.name) as wacp:
+            _task = await wacp.vote.start(
                 email_to,
                 project_name,
                 version_name,

atr/storage/writers/vote.py

@@ -125,6 +125,75 @@ async def send_user_vote(
 
         return email_recipient, ""
 
+    async def start(
+        self,
+        email_to: str,
+        project_name: str,
+        version_name: str,
+        selected_revision_number: str,
+        vote_duration_choice: int,
+        subject_data: str,
+        body_data: str,
+        asf_uid: str,
+        asf_fullname: str,
+        release: sql.Release | None = None,
+        promote: bool = True,
+        permitted_recipients: list[str] | None = None,
+    ) -> sql.Task:
+        if release is None:
+            release = await self.__data.release(
+                project_name=project_name,
+                version=version_name,
+                _project=True,
+                _committee=True,
+            ).demand(storage.AccessError("Release not found"))
+        if permitted_recipients is None:
+            permitted_recipients = util.permitted_voting_recipients(asf_uid, self.__committee_name)
+        if email_to not in permitted_recipients:
+            # This will be checked again by tasks/vote.py for extra safety
+            log.info(f"Invalid mailing list choice: {email_to} not in {permitted_recipients}")
+            raise storage.AccessError("Invalid mailing list choice")
+
+        if promote is True:
+            # This verifies the state and sets the phase to RELEASE_CANDIDATE
+            error = await interaction.promote_release(
+                self.__data, release.name, selected_revision_number, vote_manual=False
+            )
+            if error:
+                raise storage.AccessError(error)
+
+        # TODO: We also need to store the duration of the vote
+        # We can't allow resolution of the vote until the duration has elapsed
+        # But we allow the user to specify in the form
+        # And yet we also have ReleasePolicy.min_hours
+        # Presumably this sets the default, and the form takes precedence?
+        # ReleasePolicy.min_hours can also be 0, though
+
+        # Create a task for vote initiation
+        task = sql.Task(
+            status=sql.TaskStatus.QUEUED,
+            task_type=sql.TaskType.VOTE_INITIATE,
+            task_args=tasks_vote.Initiate(
+                release_name=release.name,
+                email_to=email_to,
+                vote_duration=vote_duration_choice,
+                initiator_id=asf_uid,
+                initiator_fullname=asf_fullname,
+                subject=subject_data,
+                body=body_data,
+            ).model_dump(),
+            asf_uid=asf_uid,
+            project_name=project_name,
+            version_name=version_name,
+        )
+        self.__data.add(task)
+        await self.__data.commit()
+
+        # TODO: We should log all outgoing email and the session so that users can confirm
+        # And can be warned if there was a failure
+        # (The message should be shown on the vote resolution page)
+        return task
+
 
 class CommitteeMember(CommitteeParticipant):
     def __init__(
@@ -357,75 +426,6 @@ async def send_resolution(
         await self.__data.commit()
         return None
 
-    async def start(
-        self,
-        email_to: str,
-        project_name: str,
-        version_name: str,
-        selected_revision_number: str,
-        vote_duration_choice: int,
-        subject_data: str,
-        body_data: str,
-        asf_uid: str,
-        asf_fullname: str,
-        release: sql.Release | None = None,
-        promote: bool = True,
-        permitted_recipients: list[str] | None = None,
-    ) -> sql.Task:
-        if release is None:
-            release = await self.__data.release(
-                project_name=project_name,
-                version=version_name,
-                _project=True,
-                _committee=True,
-            ).demand(storage.AccessError("Release not found"))
-        if permitted_recipients is None:
-            permitted_recipients = util.permitted_voting_recipients(asf_uid, self.__committee_name)
-        if email_to not in permitted_recipients:
-            # This will be checked again by tasks/vote.py for extra safety
-            log.info(f"Invalid mailing list choice: {email_to} not in {permitted_recipients}")
-            raise storage.AccessError("Invalid mailing list choice")
-
-        if promote is True:
-            # This verifies the state and sets the phase to RELEASE_CANDIDATE
-            error = await interaction.promote_release(
-                self.__data, release.name, selected_revision_number, vote_manual=False
-            )
-            if error:
-                raise storage.AccessError(error)
-
-        # TODO: We also need to store the duration of the vote
-        # We can't allow resolution of the vote until the duration has elapsed
-        # But we allow the user to specify in the form
-        # And yet we also have ReleasePolicy.min_hours
-        # Presumably this sets the default, and the form takes precedence?
-        # ReleasePolicy.min_hours can also be 0, though
-
-        # Create a task for vote initiation
-        task = sql.Task(
-            status=sql.TaskStatus.QUEUED,
-            task_type=sql.TaskType.VOTE_INITIATE,
-            task_args=tasks_vote.Initiate(
-                release_name=release.name,
-                email_to=email_to,
-                vote_duration=vote_duration_choice,
-                initiator_id=asf_uid,
-                initiator_fullname=asf_fullname,
-                subject=subject_data,
-                body=body_data,
-            ).model_dump(),
-            asf_uid=asf_uid,
-            project_name=project_name,
-            version_name=version_name,
-        )
-        self.__data.add(task)
-        await self.__data.commit()
-
-        # TODO: We should log all outgoing email and the session so that users can confirm
-        # And can be warned if there was a failure
-        # (The message should be shown on the vote resolution page)
-        return task
-
     # def __committee_member_or_admin(self, committee: sql.Committee, asf_uid: str) -> None:
     #     if not (user.is_committee_member(committee, asf_uid) or user.is_admin(asf_uid)):
     #         raise storage.AccessError("You do not have permission to perform this action")