pockybot/built/lib/database/pocky-db.js

Spark bot that handles team recognition

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const db_constants_1 = require("../db-constants");
const logger_1 = require("../logger");
const database_1 = require("../../models/database");
class PockyDB {
    constructor(queryHandler, dbUsers, utilities) {
        this.queryHandler = queryHandler;
        this.dbUsers = dbUsers;
        this.utilities = utilities;
        this.sqlGivePegWithComment = this.queryHandler.readFile('../../../database/queries/give_peg_with_comment.sql');
        this.sqlPegsGiven = this.queryHandler.readFile('../../../database/queries/pegs_given.sql');
        this.sqlPegsReceived = this.queryHandler.readFile('../../../database/queries/pegs_received.sql');
        this.sqlReset = this.queryHandler.readFile('../../../database/queries/reset.sql');
        this.sqlReturnResults = this.queryHandler.readFile('../../../database/queries/return_results.sql');
        this.sqlReturnGives = this.queryHandler.readFile('../../../database/queries/return_gives.sql');
    }
    loadConfig(config) {
        this.config = config;
    }
    /**
     * Returns 0 on success,
     *         1 on 'you have no more pegs left to give' failure
     *         2 on error
     */
    async givePegWithComment(comment, receiver, sender = 'default_user') {
        // Check or create both sender and receiver users
        try {
            await Promise.all([this.dbUsers.existsOrCanBeCreated(sender), this.dbUsers.existsOrCanBeCreated(receiver)]);
        }
        catch (error) {
            return db_constants_1.default.pegError;
        }
        let senderHasPegs;
        try {
            senderHasPegs = await this.senderCanPeg(sender, comment);
        }
        catch (error) {
            return db_constants_1.default.pegError;
        }
        if (!senderHasPegs) {
            logger_1.Logger.information(`[PockyDb.givePegWithComment] Sender ${sender} has no spare pegs`);
            return db_constants_1.default.pegAllSpent;
        }
        let query = {
            name: 'givePegWithCommentQuery',
            text: this.sqlGivePegWithComment,
            values: [sender, receiver, comment]
        };
        try {
            await this.queryHandler.executeNonQuery(query);
            return db_constants_1.default.pegSuccess;
        }
        catch (e) {
            logger_1.Logger.error(`[PockyDb.givePegWithComment] Error executing the givePegWithComment query: ${e.message}`);
            return db_constants_1.default.pegError;
        }
    }
    async countPegsGiven(user, keywords, penaltyKeywords) {
        let query = {
            name: 'pegsGiven',
            text: this.sqlPegsGiven,
            values: [user]
        };
        let givenPegs;
        try {
            givenPegs = await this.queryHandler.executeQuery(query);
        }
        catch (error) {
            logger_1.Logger.error(`[PockyDb.countPegsGiven] Error executing query to count pegs given by user ${user}`);
            throw error;
        }
        const nonPenaltyPegs = this.utilities.getNonPenaltyPegs(givenPegs, keywords, penaltyKeywords);
        return nonPenaltyPegs.length;
    }
    async countPenaltyPegsGiven(user, keywords, penaltyKeywords) {
        let query = {
            name: 'pegsGiven',
            text: this.sqlPegsGiven,
            values: [user]
        };
        let givenPegs;
        try {
            givenPegs = await this.queryHandler.executeQuery(query);
        }
        catch (error) {
            logger_1.Logger.error(`[PockyDb.countPenaltyPegsGiven] Error executing query to count pegs given by user ${user}`);
            throw error;
        }
        const penaltyPegs = this.utilities.getPenaltyPegs(givenPegs, keywords, penaltyKeywords);
        return penaltyPegs.length;
    }
    async countPegsReceived(user) {
        let query = {
            name: 'pegsReceived',
            text: this.sqlPegsReceived,
            values: [user]
        };
        let receivedPegs;
        try {
            receivedPegs = await this.queryHandler.executeQuery(query);
        }
        catch (error) {
            logger_1.Logger.error(`[PockyDb.countPegsReceived] Error executing query to count pegs received by user ${user}`);
            throw error;
        }
        return receivedPegs.length;
    }
    async senderCanPeg(user, comment) {
        const keywords = this.config.getStringConfig('keyword');
        const penaltyKeywords = this.config.getStringConfig('penaltyKeyword');
        let count = this.countPegsGiven(user, keywords, penaltyKeywords);
        logger_1.Logger.debug(`[PockyDb.senderCanPeg] Checking if user ${user} has spare pegs`);
        if (this.utilities.commentIsPenalty(comment, keywords, penaltyKeywords)) {
            return true;
        }
        if (user === 'default_user' || this.config.checkRole(user, database_1.Role.Unmetered)) {
            return true;
        }
        if (await count < this.config.getConfig('limit')) {
            return true;
        }
        return false;
    }
    async reset() {
        let query = {
            name: 'resetQuery',
            text: this.sqlReset
        };
        return await this.queryHandler.executeNonQuery(query);
    }
    async returnResults() {
        let query = {
            name: 'returnResultsQuery',
            text: this.sqlReturnResults,
        };
        let results = await this.queryHandler.executeQuery(query);
        logger_1.Logger.debug('[PockyDb.returnResults] returning results: ' + JSON.stringify(results));
        return results;
    }
    async getPegsGiven(user) {
        let query = {
            name: 'returnGivesQuery',
            text: this.sqlReturnGives,
            values: [user]
        };
        return await this.queryHandler.executeQuery(query);
    }
}
exports.default = PockyDB;