当前位置：首页 > 文章列表 > 文章 > 前端 > 底层设计：轮询系统 - 边缘情况

底层设计：轮询系统 - 边缘情况

来源：dev.to 2024-12-02 11:40:24 0浏览收藏

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《底层设计：轮询系统 - 边缘情况》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

底层设计：轮询系统 - 边缘情况

案例 1 - 处理更新的版本控制
情况 2 - pollid 作为 uuid 而不是主键
情况 3 - 选项为空或无效
案例 4 - 重复选项
案例 5 - 问题长度限制
案例 6 - 投票过期

请先参考以下文章：

底层设计：投票系统：基本
底层设计：轮询系统 - 使用 node.js 和 sql

边缘情况处理

案例1

要管理投票问题和选项的更新，同时保留与同一投票 id 关联的先前详细信息，您可以实现版本控制系统。这种方法允许您跟踪每次民意调查的历史数据，确保即使在更新后也保留旧的详细信息。

第 1 步：数据库架构更改

更新投票表
- 将 current_version_id 列添加到 polls 表中以跟踪投票的最新版本。
创建投票版本表
- 创建一个新表来存储民意调查的历史版本。

更新的数据库架构

create database polling_system;

use polling_system;

create table polls (
    poll_id int auto_increment primary key,
    current_version_id int,
    created_at timestamp default current_timestamp,
    foreign key (current_version_id) references poll_versions(version_id) on delete set null
);

create table poll_versions (
    version_id int auto_increment primary key,
    poll_id int,
    question varchar(255) not null,
    created_at timestamp default current_timestamp,
    foreign key (poll_id) references polls(poll_id) on delete cascade
);

create table options (
    option_id int auto_increment primary key,
    poll_id int,
    option_text varchar(255) not null,
    foreign key (poll_id) references polls(poll_id) on delete cascade
);

create table votes (
    vote_id int auto_increment primary key,
    poll_id int,
    user_id varchar(255) not null,
    option_id int,
    created_at timestamp default current_timestamp,
    foreign key (poll_id) references polls(poll_id) on delete cascade,
    foreign key (option_id) references options(option_id) on delete cascade
);

第 2 步：api 实施变更

更新轮询控制器

修改 updatepoll 方法，在创建新版本之前检查问题是否发生变化。

文件：controllers/pollcontroller.js

const pool = require('../db/db');

// create poll
exports.createpoll = async (req, res) => {
    const { question, options } = req.body;

    if (!question || !options || !array.isarray(options) || options.length < 2) {
        return res.status(400).json({ message: "invalid input data. question and at least two options are required." });
    }

    try {
        const connection = await pool.getconnection();
        await connection.begintransaction();

        const [result] = await connection.execute(
            'insert into polls (current_version_id) values (null)'
        );

        const pollid = result.insertid;

        const [versionresult] = await connection.execute(
            'insert into poll_versions (poll_id, question) values (?, ?)',
            [pollid, question]
        );

        const versionid = versionresult.insertid;

        // update the current version in the polls table
        await connection.execute(
            'update polls set current_version_id = ? where poll_id = ?',
            [versionid, pollid]
        );

        const optionqueries = options.map(option => {
            return connection.execute(
                'insert into options (poll_id, option_text) values (?, ?)',
                [pollid, option]
            );
        });

        await promise.all(optionqueries);

        await connection.commit();
        connection.release();

        res.status(201).json({ pollid, message: "poll created successfully." });

    } catch (error) {
        console.error("error creating poll:", error.message);
        res.status(500).json({ message: "error creating poll." });
    }
};

// update poll
exports.updatepoll = async (req, res) => {
    const { pollid } = req.params;
    const { question, options } = req.body;

    if (!pollid || !options || !array.isarray(options) || options.length < 2) {
        return res.status(400).json({ message: "invalid input data. at least two options are required." });
    }

    try {
        const connection = await pool.getconnection();
        await connection.begintransaction();

        // fetch the existing poll
        const [existingpoll] = await connection.execute(
            'select question from poll_versions where poll_id = (select current_version_id from polls where poll_id = ?)',
            [pollid]
        );

        if (existingpoll.length === 0) {
            await connection.rollback();
            connection.release();
            return res.status(404).json({ message: "poll not found." });
        }

        const currentquestion = existingpoll[0].question;

        // check if the question has changed
        if (currentquestion !== question) {
            // create a new version since the question has changed
            const [versionresult] = await connection.execute(
                'insert into poll_versions (poll_id, question) values (?, ?)',
                [pollid, question]
            );

            const versionid = versionresult.insertid;

            // update the current version in the polls table
            await connection.execute(
                'update polls set current_version_id = ? where poll_id = ?',
                [versionid, pollid]
            );
        }

        // remove old options and insert new ones
        await connection.execute('delete from options where poll_id = ?', [pollid]);

        const optionqueries = options.map(option => {
            return connection.execute(
                'insert into options (poll_id, option_text) values (?, ?)',
                [pollid, option]
            );
        });

        await promise.all(optionqueries);

        await connection.commit();
        connection.release();

        res.status(200).json({ message: "poll updated successfully." });

    } catch (error) {
        console.error("error updating poll:", error.message);
        await connection.rollback();
        res.status(500).json({ message: "error updating poll." });
    }
};

// delete poll
exports.deletepoll = async (req, res) => {
    const { pollid } = req.params;

    try {
        const connection = await pool.getconnection();

        const [result] = await connection.execute(
            'delete from polls where poll_id = ?',
            [pollid]
        );

        connection.release();

        if (result.affectedrows === 0) {
            return res.status(404).json({ message: "poll not found." });
        }

        res.status(200).json({ message: "poll deleted successfully." });

    } catch (error) {
        console.error("error deleting poll:", error.message);
        res.status(500).json({ message: "error deleting poll." });
    }
};

// vote in poll
exports.voteinpoll = async (req, res) => {
    const { pollid } = req.params;
    const { userid, option } = req.body;

    if (!userid || !option) {
        return res.status(400).json({ message: "user id and option are required." });
    }

    try {
        const connection = await pool.getconnection();

        const [uservote] = await connection.execute(
            'select * from votes where poll_id = ? and user_id = ?',
            [pollid, userid]
        );

        if (uservote.length > 0) {
            connection.release();
            return res.status(400).json({ message: "user has already voted." });
        }

        const [optionresult] = await connection.execute(
            'select option_id from options where poll_id = ? and option_text = ?',
            [pollid, option]
        );

        if (optionresult.length === 0) {
            connection.release();
            return res.status(404).json({ message: "option not found." });
        }

        const optionid = optionresult[0].option_id;

        await connection.execute(
            'insert into votes (poll_id, user_id, option_id) values (?, ?, ?)',
            [pollid, userid, optionid]
        );

        connection.release();

        res.status(200).json({ message: "vote cast successfully." });

    } catch (error) {
        console.error("error casting vote:", error.message);
        res.status(500).json({ message: "error casting vote." });
    }
};

// view poll results
exports.viewpollresults = async (req, res) => {
    const { pollid } = req.params;

    try {
        const connection = await pool.getconnection();

        const [poll] = await connection.execute(
            'select * from polls where poll_id = ?',
            [pollid]
        );

        if (poll.length === 0) {
            connection.release();
            return res.status(404).json({ message: "poll not found." });
        }

        const [options] = await connection.execute(
            'select option_text, count(votes.option_id) as vote_count from options ' +
            'left join votes on options.option_id = votes.option_id ' +
            'where options.poll_id = ? group by options.option_id',
            [pollid]
        );

        connection.release();

        res.status(200).json({
            pollid: poll[0].poll_id,
            question: poll[0].question,
            results: options.reduce((acc, option) => {
                acc[option.option_text] = option.vote_count;
                return acc;
            }, {})
        });

    } catch (error) {
        console.error("error viewing poll results:", error.message);
        res.status(500).json({ message: "error viewing poll results." });
    }
};

第 3 步：更新投票路线

确保在 pollroutes.js 中正确定义路由。

文件：routes/pollroutes.js

const express = require('express');
const router = express.Router();
const pollController = require('../controllers/pollController');

// Routes
router.post('/polls', pollController.createPoll);
router.put('/polls/:pollId', pollController.updatePoll);
router.delete('/polls/:pollId', pollController.deletePoll);
router.post('/polls/:pollId/vote', pollController.voteInPoll);
router.get('/polls/:pollId/results', pollController.viewPollResults);

module.exports = router;

变更摘要

数据库：
- 更新了投票表以包含 current_version_id。
- 创建了 poll_versions 表来跟踪问题版本。
- 选项和投票表保持不变。
api：
- 创建了一个新的 createpoll 方法来初始化民意调查和版本。
- 更新了 updatepoll 方法以在创建新版本之前检查问题更改。
- 添加了投票和查看投票结果的方法。
路线：
- 确保定义所有必要的路由来处理民意调查创建、更新、投票和结果。

案例2

处理 pollid 需要是 uuid（通用唯一标识符）的场景。

以下是在轮询系统中为 thepollid 实现 uuid 的步骤，无需提供代码：

为投票 id 实施 uuid 的步骤

** 数据库架构更新：**
- 修改 polls、poll_versions、options 和 votes 表，以使用 char(36) 作为 poll_id 而不是整数。
- 创建一个新的 poll_versions 表来存储由 uuid 链接的投票问题和选项的历史版本。
** uuid 生成：**
- 决定生成uuid的方法。您可以使用应用程序环境中的库或内置函数来创建uuid。
** 创建投票逻辑：**
- 创建新投票时，生成一个 uuid 并将其用作 poll_id。
- 将新的投票记录插入投票表中。
- 将初始问题插入 poll_versions 表并将其与生成的 uuid 链接。
** 更新投票逻辑：**
- 更新投票时：
检查问题是否已更改。
- 如果问题已更改，请在poll_versions 表中创建一个新版本条目来存储旧问题和选项。
- 根据需要使用新问题和选项更新投票表。
** 投票逻辑：**
- 更新投票机制，确保使用uuid作为poll_id。
验证投票请求中提供的 uuid 是否存在于 polls 表中。
** api 更新：**
- 修改 api 端点以接受并返回 poll_id 的 uuid。
- 确保所有 api 操作（创建、更新、删除、投票）一致引用 uuid 格式。
** 测试：**
- 彻底测试应用程序，确保在所有场景（创建、更新、投票和检索投票结果）中正确处理 uuid。
** 文档：**
- 更新您的 api 文档以反映 poll_id 格式的更改以及与版本控制和 uuid 使用相关的任何新行为。