feat: implement poll status management with start and end functionality (#906)

* feat: implement poll status management with start and end functionality

* fix: refine error handling for poll start and end authorization

* fix: correct ordinal suffix for ranking display

Author: Bekiboo

platforms/evoting/api/scripts/seed.ts

@@ -486,7 +486,33 @@ async function seed() {
 
         console.log(`\n📊 Polls created: ${pollsCreated}, Votes created: ${votesCreated}\n`);
 
-        // Optionally add a custom user to all groups
+        // Auto-add all non-seed users (created via dev-sandbox auth/webhooks) to all groups
+        const seedEnames = new Set(seedUsers.map(u => u.ename));
+        const allUsers = await userRepo.find();
+        const nonSeedUsers = allUsers.filter(u => !seedEnames.has(u.ename));
+
+        if (nonSeedUsers.length > 0) {
+            console.log(`👤 Adding ${nonSeedUsers.length} existing user(s) to all groups...`);
+
+            const groupsToUpdate = await groupRepo.find({
+                relations: ["members", "participants"],
+            });
+
+            for (const user of nonSeedUsers) {
+                for (const group of groupsToUpdate) {
+                    const isAlreadyMember = group.members.some((m) => m.id === user.id);
+
+                    if (!isAlreadyMember) {
+                        group.members.push(user);
+                        group.participants.push(user);
+                        await groupRepo.save(group);
+                        console.log(`  ✅ Added "${user.name || user.ename}" to "${group.name}"`);
+                    }
+                }
+            }
+        }
+
+        // Also support explicit ename argument
         const customEname = process.argv[2];
         if (customEname) {
             console.log(`\n👤 Adding custom user to all groups...`);
@@ -532,7 +558,8 @@ async function seed() {
 
         console.log("\n🎉 Seed completed successfully!\n");
         console.log("Summary:");
-        console.log(`  - ${seedUsers.length} users`);
+        console.log(`  - ${seedUsers.length} seed users`);
+        console.log(`  - ${nonSeedUsers.length} existing user(s) added to all groups`);
         console.log(`  - ${seedGroups.length} groups (with charters)`);
         console.log(`  - ${seedPolls.length} polls (various modes: normal, point, rank)`);
         console.log(`  - Includes public and private polls with sample votes`);

platforms/evoting/api/src/controllers/PollController.ts

@@ -156,4 +156,50 @@ export class PollController {
             res.status(500).json({ error: "Failed to fetch user polls" });
         }
     };
+
+    startPoll = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const userId = (req as any).user.id;
+            const poll = await this.pollService.startPoll(id, userId);
+            res.json(poll);
+        } catch (error) {
+            console.error("Error starting poll:", error);
+            if (error instanceof Error) {
+                if (error.message === "Poll not found") {
+                    return res.status(404).json({ error: error.message });
+                }
+                if (error.message === "Not authorized to start this poll") {
+                    return res.status(403).json({ error: error.message });
+                }
+                if (error.message === "Only draft polls can be started") {
+                    return res.status(400).json({ error: error.message });
+                }
+            }
+            res.status(500).json({ error: "Failed to start poll" });
+        }
+    };
+
+    endPoll = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const userId = (req as any).user.id;
+            const poll = await this.pollService.endPoll(id, userId);
+            res.json(poll);
+        } catch (error) {
+            console.error("Error ending poll:", error);
+            if (error instanceof Error) {
+                if (error.message === "Poll not found") {
+                    return res.status(404).json({ error: error.message });
+                }
+                if (error.message === "Not authorized to end this poll") {
+                    return res.status(403).json({ error: error.message });
+                }
+                if (error.message === "Only active polls can be ended") {
+                    return res.status(400).json({ error: error.message });
+                }
+            }
+            res.status(500).json({ error: "Failed to end poll" });
+        }
+    };
 } 

platforms/evoting/api/src/database/entities/Poll.ts

@@ -40,6 +40,12 @@ export class Poll {
     @Column("simple-array")
     options!: string[]; // stored as comma-separated values
 
+    @Column("enum", {
+        enum: ["draft", "active", "ended"],
+        default: "active",
+    })
+    status!: "draft" | "active" | "ended";
+
     @Column({ type: "timestamp", nullable: true })
     deadline!: Date | null;
 

platforms/evoting/api/src/database/migrations/1772851200000-migration.ts

@@ -0,0 +1,15 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class Migration1772851200000 implements MigrationInterface {
+    name = 'Migration1772851200000'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TYPE "public"."polls_status_enum" AS ENUM('draft', 'active', 'ended')`);
+        await queryRunner.query(`ALTER TABLE "polls" ADD "status" "public"."polls_status_enum" NOT NULL DEFAULT 'active'`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "polls" DROP COLUMN "status"`);
+        await queryRunner.query(`DROP TYPE "public"."polls_status_enum"`);
+    }
+}

platforms/evoting/api/src/index.ts

@@ -209,6 +209,8 @@ app.get("/api/polls/my", authGuard, pollController.getPollsByCreator);
 app.post("/api/polls", authGuard, pollController.createPoll);
 app.put("/api/polls/:id", authGuard, pollController.updatePoll);
 app.delete("/api/polls/:id", authGuard, pollController.deletePoll);
+app.post("/api/polls/:id/start", authGuard, pollController.startPoll);
+app.post("/api/polls/:id/end", authGuard, pollController.endPoll);
 
 // Vote routes
 app.post("/api/votes", voteController.createVote.bind(voteController)); // Create normal/point/rank vote (old format)

platforms/evoting/api/src/services/DeadlineCheckService.ts

@@ -80,8 +80,8 @@ export class DeadlineCheckService {
                 voteId: poll.id
             });
 
-            // Mark that we've sent the deadline message
-            await this.pollRepository.update(poll.id, { deadlineMessageSent: true });
+            // Mark that we've sent the deadline message and set status to ended
+            await this.pollRepository.update(poll.id, { deadlineMessageSent: true, status: "ended" });
 
             console.log(`Successfully sent deadline message for poll: ${poll.title} (${poll.id})`);
 

platforms/evoting/api/src/services/PollService.ts

@@ -86,8 +86,8 @@ export class PollService {
         // Custom sorting based on sortField and sortDirection
         const sortedPolls = filteredPolls.sort((a, b) => {
             const now = new Date();
-            const aIsActive = !a.deadline || new Date(a.deadline) > now;
-            const bIsActive = !b.deadline || new Date(b.deadline) > now;
+            const aIsActive = a.status === "active" || (a.status !== "ended" && a.status !== "draft" && (!a.deadline || new Date(a.deadline) > now));
+            const bIsActive = b.status === "active" || (b.status !== "ended" && b.status !== "draft" && (!b.deadline || new Date(b.deadline) > now));
 
             // Apply the user's chosen sorting
             let comparison = 0;
@@ -218,13 +218,15 @@ export class PollService {
             throw new Error("Blind voting (private visibility) cannot be combined with eReputation weighted voting.");
         }
 
+        const hasDeadline = !!pollData.deadline;
         const pollDataForEntity = {
             title: pollData.title,
             mode: pollData.mode as "normal" | "point" | "rank",
             visibility: pollData.visibility as "public" | "private",
             votingWeight: votingWeight,
             options: pollData.options,
-            deadline: pollData.deadline ? new Date(pollData.deadline) : null,
+            status: hasDeadline ? "active" as const : "draft" as const,
+            deadline: hasDeadline ? new Date(pollData.deadline!) : null,
             creator,
             creatorId: pollData.creatorId,
             groupId: pollData.groupId || null
@@ -237,8 +239,8 @@ export class PollService {
         const savedPoll = await this.pollRepository.save(poll);
         console.log('🔍 Poll saved to database:', savedPoll);
 
-        // Create a system message about the new vote
-        if (pollData.groupId) {
+        // Create a system message about the new vote (only for active polls, not drafts)
+        if (pollData.groupId && hasDeadline) {
             await this.messageService.createVoteCreatedMessage(pollData.groupId, pollData.title, savedPoll.id, creator.name, savedPoll.deadline);
         }
 
@@ -301,6 +303,67 @@ export class PollService {
 
 
 
+    /**
+     * Manually start a poll (draft → active). Only creator can do this.
+     */
+    async startPoll(id: string, userId: string): Promise<Poll> {
+        const poll = await this.getPollById(id);
+        if (!poll) {
+            throw new Error("Poll not found");
+        }
+        if (poll.creatorId !== userId) {
+            throw new Error("Not authorized to start this poll");
+        }
+        if (poll.status !== "draft") {
+            throw new Error("Only draft polls can be started");
+        }
+
+        await this.pollRepository.update(id, { status: "active" });
+
+        // Send system message that voting is now open
+        if (poll.groupId) {
+            await this.messageService.createVoteCreatedMessage(
+                poll.groupId,
+                poll.title,
+                poll.id,
+                poll.creator.name,
+                poll.deadline
+            );
+        }
+
+        return (await this.getPollById(id))!;
+    }
+
+    /**
+     * Manually end a poll (active → ended). Only creator can do this.
+     */
+    async endPoll(id: string, userId: string): Promise<Poll> {
+        const poll = await this.getPollById(id);
+        if (!poll) {
+            throw new Error("Poll not found");
+        }
+        if (poll.creatorId !== userId) {
+            throw new Error("Not authorized to end this poll");
+        }
+        if (poll.status !== "active") {
+            throw new Error("Only active polls can be ended");
+        }
+
+        await this.pollRepository.update(id, { status: "ended", deadlineMessageSent: true });
+
+        // Send system message that voting has ended
+        if (poll.groupId) {
+            const voteUrl = `${process.env.PUBLIC_EVOTING_URL || 'http://localhost:3000'}/${poll.id}`;
+            await this.messageService.createSystemMessage({
+                text: `eVoting Platform: Vote has been manually closed!\n\n"${poll.title}"\n\nVote ID: ${poll.id}\n\nClosed by: ${poll.creator.name}\n\n<a href="${voteUrl}" target="_blank">View results here</a>`,
+                groupId: poll.groupId,
+                voteId: poll.id
+            });
+        }
+
+        return (await this.getPollById(id))!;
+    }
+
     /**
      * Get polls by group ID
      */

platforms/evoting/api/src/services/VoteService.ts

@@ -115,6 +115,14 @@ export class VoteService {
       throw new Error('Poll not found');
     }
 
+    // Prevent voting on polls that are not active
+    if (poll.status === "draft") {
+      throw new Error('Voting has not started yet');
+    }
+    if (poll.status === "ended") {
+      throw new Error('Voting has ended');
+    }
+
     // Check if user has already voted
     const existingVote = await this.voteRepository.findOne({
       where: { pollId, userId }
@@ -178,6 +186,14 @@ export class VoteService {
       throw new Error('Poll not found');
     }
 
+    // Prevent voting on polls that are not active
+    if (poll.status === "draft") {
+      throw new Error('Voting has not started yet');
+    }
+    if (poll.status === "ended") {
+      throw new Error('Voting has ended');
+    }
+
     const delegation = await this.delegationRepository.findOne({
       where: {
         pollId,
@@ -660,6 +676,14 @@ export class VoteService {
         throw new Error('Poll not found');
       }
 
+      // Prevent voting on polls that are not active
+      if (poll.status === "draft") {
+        throw new Error('Voting has not started yet');
+      }
+      if (poll.status === "ended") {
+        throw new Error('Voting has ended');
+      }
+
       // Create election if it doesn't exist
       try {
         const options = poll.options.map((opt: string, index: number) => `option_${index}`);