Conception de bas niveau : système d'interrogation

Table des matières

1. Énoncé du problème
2. Hypothèses
3. Exigences
   • Créer des sondages
   • Gérer les sondages
   • Votez dans les sondages
   • Afficher les résultats du sondage
   • Données du sondage
4. Détails de mise en œuvre
   • Fonctions/Méthodes
     • Créer un sondage
     • Mettre à jour le sondage
     • Supprimer le sondage
     • Votez dans le sondage
     • Afficher les résultats du sondage
5. Modèles de données
   • Sondage
   • Votez
6. Détails de mise en œuvre
7. CODE

Énoncé du problème

Vous devez concevoir et mettre en œuvre un système de sondage en ligne. Le système doit permettre aux utilisateurs de créer, gérer et participer à des sondages. Chaque sondage se compose d'une question et de plusieurs options de réponses. Les utilisateurs peuvent voter sur les sondages et consulter les résultats.

Hypothèses :

• Nous utilisons une implémentation basée sur les classes
• Nous n'utilisons pas de base de données supplémentaire pour stocker ces informations
• Comme ni la base de données ni le serveur ne sont impliqués, aucune API REST
• Approche simple de bas niveau sur le système de sondage

Exigences

Créer des sondages :

• Les utilisateurs devraient pouvoir créer un nouveau sondage avec une question et plusieurs options de réponse.
• Chaque sondage doit avoir un identifiant unique, une question, une liste d'options et un horodatage de création.

Gérer les sondages :

• Les utilisateurs devraient pouvoir mettre à jour la question ou les options d'un sondage existant.
• Les utilisateurs devraient pouvoir supprimer un sondage.

Votez dans les sondages :

• Les utilisateurs devraient pouvoir voter pour l'une des options d'un sondage.
• Chaque utilisateur ne peut voter qu'une seule fois par sondage.

Voir les résultats du sondage :

• Les utilisateurs devraient pouvoir consulter les résultats actuels d'un sondage, y compris le nombre de votes pour chaque option.

Données du sondage :

• Stockez les sondages, les options et les votes de manière à permettre une récupération et des mises à jour efficaces.
• Garantir l'intégrité et la cohérence des données, en particulier lorsque plusieurs utilisateurs votent simultanément.

Détails de mise en œuvre

Fonctions/Méthodes :

Créer un sondage

créer un sondage :

• Saisie : question (chaîne), options (tableau de chaînes)
• Sortie : pollId (string), message (string)
• Exemple : createPoll("Quelle est votre couleur préférée ?", ["Rouge", "Bleu", "Vert", "Jaune"]) renvoie {"pollId": "123", "message" : "Le sondage a été créé avec succès."}

Mettre à jour le sondage

mise à jour du sondage :

• Entrée : pollId (chaîne), question (chaîne), options (tableau de chaînes)
• Sortie : message (chaîne)
• Exemple : updatePoll("123", "Question mise à jour ?", ["Option1", "Option2"]) renvoie {"message": "Le sondage a été mis à jour avec succès."}

Supprimer le sondage

supprimer le sondage :

• Entrée : pollId (chaîne)
• Sortie : message (chaîne)
• Exemple : deletePoll("123") renvoie {"message": "Le sondage a été supprimé avec succès."}

Voter dans le sondage

voteInPoll :

• Entrée : pollId (chaîne), userId (chaîne), option (chaîne)
• Sortie : message (chaîne)
• Exemple : voteInPoll("123", "user1", "Option1") renvoie {"message": "Vote exprimé avec succès."}

Afficher les résultats du sondage

afficher les résultats du sondage :

• Entrée : pollId (chaîne)
• Sortie : pollId (chaîne), question (chaîne), résultats (objet avec clés d'option et valeurs du décompte des votes)
• Exemple : viewPollResults("123") renvoie {"pollId": "123", "question": "Quelle est votre couleur préférée ?", "results": {"Rouge": 10, "Bleu " : 5, "Vert" : 3, "Jaune" : 2}}

Modèles de données

• Sondage :

{
  "pollId": "123",
  "question": "What is your favorite color?",
  "options": ["Red", "Blue", "Green", "Yellow"],
  "createdAt": "2024-07-11T00:00:00Z"
}

• Votez :

{
  "pollId": "123",
  "userId": "user1",
  "option": "Red",
  "timestamp": "2024-07-11T01:00:00Z"
}

Détails de mise en œuvre

Ce code définit un système de sondage de base utilisant des classes JavaScript. Il permet la création, la gestion et le vote dans des sondages. Décomposons chaque partie du code :

1. Class Definitions

Poll Class

• Purpose: Represents an individual poll.
• Constructor Parameters:
  • id: A unique identifier for the poll.
  • question: The question being asked in the poll.
  • options: An array of possible options that users can vote on.
• Properties:
  • pollId: Stores the unique ID of the poll.
  • question: Stores the poll question.
  • options: Stores the array of options.
  • createdAt: Stores the creation date and time of the poll.

Vote Class

• Purpose: Represents an individual vote cast by a user.
• Constructor Parameters:
  • pollId: The ID of the poll the vote is associated with.
  • userId: The ID of the user who cast the vote.
  • option: The option that the user voted for.
• Properties:
  • pollId: Stores the poll ID for which the vote was cast.
  • userId: Stores the user ID of the voter.
  • option: Stores the option that the user voted for.
  • timestamp: Stores the date and time when the vote was cast.

2. PollManager Class

Purpose: Manages the entire polling system, including creating polls, managing votes, and viewing results.

Constructor:

• Properties:
  • polls: A Map that stores all polls, where the key is the poll ID and the value is the Poll object.
  • pollResults: A Map that stores the results of each poll, where the key is the poll ID and the value is another Map that tracks votes for each option.
  • userVotes: A Map that stores the votes by each user, where the key is the poll ID and the value is another Map that tracks whether a user has voted in that poll.

Methods:

• createPoll(question, options)

  • Generates a new poll with a unique ID.
  • Initializes the poll results, setting the vote count for each option to 0.
  • Stores the poll and returns the generated poll ID.

• updatePoll(pollId, question, options)

  • Updates the question and options for an existing poll.
  • Resets the poll results to 0 for the updated options.
  • Returns a success message if the poll is found, otherwise returns "Poll not found."

• deletePoll(pollId)

  • Deletes a poll by its ID.
  • Also removes associated poll results and user votes.
  • Returns a success message if the poll is found, otherwise returns "Poll not found."

• voteInPoll(pollId, userId, option)

  • Allows a user to cast a vote in a specific poll.
  • Ensures a user can only vote once per poll.
  • Updates the vote count for the selected option if valid.
  • Returns appropriate messages depending on whether the vote was successful, the user had already voted, or the poll or option was invalid.

• viewPollResults(pollId)

  • Returns the results of a specific poll in an array format, where each entry is a tuple of the option and its vote count.
  • Returns "Poll not found" if the poll doesn't exist.

3. Example Usage

• Poll Creation: A poll is created asking, "What is your favorite color?" with options ["Red", "Blue", "Green", "Yellow"]. The poll ID is generated as "1".
• Voting: Multiple users vote in the poll, and the system ensures users can only vote once.
• Viewing Results: The poll results are displayed, showing the vote counts for each option.
• Updating the Poll: The poll's question and options are updated, resetting the results.
• Voting in Updated Poll: A user votes in the updated poll, and the results are displayed.
• Poll Deletion: The poll is deleted, and an attempt to view the results afterward confirms the poll no longer exists.

This implementation provides a basic but functional polling system, handling common scenarios such as poll creation, updating, voting, and deletion.

CODE

class Poll {
    constructor(id, question, options) {
        this.pollId = id;
        this.question = question;
        this.options = options;
        this.createdAt = new Date();
    }
}

class Vote {
    constructor(pollId, userId, option) {
        this.pollId = pollId;
        this.userId = userId;
        this.option = option;
        this.timestamp = new Date();
    }
}

class PollManager {
    constructor() {
        this.polls = new Map();
        this.pollResults = new Map();
        this.userVotes = new Map();
    }

    createPoll(question, options) {
        const pollId = (this.polls.size + 1).toString();
        const poll = new Poll(pollId, question, options);
        this.polls.set(pollId, poll);

        const result = new Map();
        options.forEach(option => result.set(option, 0));
        this.pollResults.set(pollId, result);

        return pollId;
    }

    updatePoll(pollId, question, options) {
        const poll = this.polls.get(pollId);
        if (poll) {
            poll.question = question;
            poll.options = options;

            // Update results for the new options
            const result = new Map();
            options.forEach(option => result.set(option, 0));
            this.pollResults.set(pollId, result);

            return "Poll updated successfully.";
        }
        return "Poll not found.";
    }

    deletePoll(pollId) {
        if (this.polls.delete(pollId)) {
            this.pollResults.delete(pollId);
            this.userVotes.delete(pollId);
            return "Poll deleted successfully.";
        }
        return "Poll not found.";
    }

    voteInPoll(pollId, userId, option) {
        const poll = this.polls.get(pollId);
        if (poll) {
            if (!this.userVotes.has(pollId)) {
                this.userVotes.set(pollId, new Map());
            }

            const userVote = this.userVotes.get(pollId);
            if (userVote.get(userId)) {
                return "User has already voted.";
            }

            const result = this.pollResults.get(pollId);
            if (result.has(option)) {
                result.set(option, result.get(option) + 1);
                userVote.set(userId, true);
                return "Vote cast successfully.";
            } else {
                return "Invalid option.";
            }
        }
        return "Poll not found.";
    }

    viewPollResults(pollId) {
        const results = this.pollResults.get(pollId);
        if (results) {
            return Array.from(results.entries());
        }
        return "Poll not found.";
    }
}

// Example usage
const pollManager = new PollManager();

// Creating a poll
const pollId = pollManager.createPoll("What is your favorite color?", ["Red", "Blue", "Green", "Yellow"]);
console.log("Poll created with ID:", pollId);

// Voting in the poll
let voteMessage = pollManager.voteInPoll(pollId, "user1", "Red");
console.log(voteMessage);

voteMessage = pollManager.voteInPoll(pollId, "user2", "Blue");
console.log(voteMessage);

voteMessage = pollManager.voteInPoll(pollId, "user1", "Green");
console.log(voteMessage); // Should inform the user has already voted

// Viewing poll results
let results = pollManager.viewPollResults(pollId);
console.log("Poll results for poll ID", pollId, ":", results);

// Updating the poll
let updateMessage = pollManager.updatePoll(pollId, "What is your favorite primary color?", ["Red", "Blue", "Yellow"]);
console.log(updateMessage);

// Voting in the updated poll
voteMessage = pollManager.voteInPoll(pollId, "user3", "Yellow");
console.log(voteMessage);

// Viewing updated poll results
results = pollManager.viewPollResults(pollId);
console.log("Updated poll results for poll ID", pollId, ":", results);

// Deleting the poll
let deleteMessage = pollManager.deletePoll(pollId);
console.log(deleteMessage);

// Attempting to view results of a deleted poll
results = pollManager.viewPollResults(pollId);
if (typeof results === "string") {
    console.log(results);
}


// Response
// Poll created with ID: 1
// Vote cast successfully.
// Vote cast successfully.
// User has already voted.
// Poll results for poll ID 1 : [['Red', 1], ['Blue', 1], ['Green', 0], ['Yellow', 0]]
// Poll updated successfully.
// Vote cast successfully.
// Updated poll results for poll ID 1 : [['Red', 0], ['Blue', 0], ['Yellow', 1]]
// Poll deleted successfully.
// Poll not found.

Note: Please follow for more detail & Enchanced version of this article with DB, API & other system Design Concept.

More Details:

Get all articles related to system design
Hastag: SystemDesignWithZeeshanAli

conception du système aveczeeshanali

Git : https://github.com/ZeeshanAli-0704/SystemDesignWithZeeshanAli

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!