@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/engine/reports/xlsAllOurIdeasExport.js

@@ -0,0 +1,232 @@
+import ExcelJS from "exceljs";
+import fetch from "node-fetch";
+import { Headers } from "node-fetch";
+import { v4 as uuidv4 } from "uuid";
+import models from "../../../models/index.cjs";
+import { setJobError, updateUploadJobStatus, uploadToS3, } from "./commonUtils.js";
+const dbModels = models;
+const Image = dbModels.Image;
+const PAIRWISE_API_HOST = process.env.PAIRWISE_API_HOST; // Your API host
+const defaultAuthHeader = new Headers({
+    "Content-Type": "application/json",
+    Authorization: `Basic ${Buffer.from(`${process.env.PAIRWISE_USERNAME}:${process.env.PAIRWISE_PASSWORD}`).toString("base64")}`,
+});
+async function fetchChoices(questionId, utmSource) {
+    try {
+        const url = `${PAIRWISE_API_HOST}/questions/${questionId}/choices.json?include_inactive=true&show_all=true${utmSource ? `?utm_source=${utmSource}` : ""}`;
+        const response = await fetch(url, {
+            method: "GET",
+            headers: defaultAuthHeader,
+        });
+        console.log(url);
+        if (!response.ok) {
+            console.error(response.statusText);
+            throw new Error("Fetching choices failed.");
+        }
+        const choices = (await response.json());
+        return choices;
+    }
+    catch (error) {
+        console.error("Error fetching choices:", error);
+        throw error;
+    }
+}
+async function fetchVotes(questionId, choiceId, utmSource) {
+    try {
+        let url = `${PAIRWISE_API_HOST}/questions/${questionId}/choices/${choiceId}/show_votes.json`;
+        if (utmSource) {
+            url += `&utm_source=${utmSource}`;
+        }
+        const response = await fetch(url, {
+            method: "GET",
+            headers: defaultAuthHeader,
+        });
+        if (!response.ok) {
+            console.error(response.statusText);
+            throw new Error("Fetching votes failed.");
+        }
+        const votes = (await response.json());
+        return votes;
+    }
+    catch (error) {
+        console.error("Error fetching votes:", error);
+        throw error;
+    }
+}
+function calculateElo(rating1, rating2, score1, score2) {
+    const kFactor = 32;
+    const expected1 = 1.0 / (1 + Math.pow(10, (rating2 - rating1) / 400.0));
+    const expected2 = 1.0 / (1 + Math.pow(10, (rating1 - rating2) / 400.0));
+    const newRating1 = rating1 + kFactor * (score1 - expected1);
+    const newRating2 = rating2 + kFactor * (score2 - expected2);
+    return [newRating1, newRating2];
+}
+export async function exportChoiceVotes(workPackage, done) {
+    try {
+        await updateUploadJobStatus(workPackage.jobId, 5);
+        console.log(`Exporting choice votes for question ${workPackage.questionId} with utm_source ${workPackage.utmSource}`);
+        const choices = (await fetchChoices(workPackage.questionId, workPackage.utmSource));
+        console.log(`Found ${choices.length} choices`);
+        const workbook = new ExcelJS.Workbook();
+        const choicesSheet = workbook.addWorksheet("Choices");
+        const winningVotesSheet = workbook.addWorksheet("Winning Votes");
+        const losingVotesSheet = workbook.addWorksheet("Losing Votes");
+        // Setting the headers
+        const choicesHeaders = [
+            "Id",
+            "Question Id",
+            "Wins",
+            "Losses",
+            "Votes",
+            "Score",
+            "Data",
+            "Elo Rating",
+            "Seed",
+        ];
+        choicesSheet.addRow(choicesHeaders);
+        const votesHeaders = [
+            "Id",
+            "Voter Id",
+            "Question Id",
+            "Prompt Id",
+            "Choice Id",
+            "Loser Choice Id",
+            "Created At",
+            "Updated At",
+            "Time Viewed",
+            "UTM Source",
+            "UTM Campaign",
+            "UTM Medium",
+            "UTM Content",
+        ];
+        winningVotesSheet.addRow(votesHeaders);
+        losingVotesSheet.addRow(votesHeaders);
+        const choiceVoteMap = new Map();
+        for (let i = 0; i < choices.length; i++) {
+            const choice = choices[i];
+            const votes = (await fetchVotes(workPackage.questionId, choice.id, workPackage.utmSource));
+            choiceVoteMap.set(choice.id, votes);
+            const voteCount = choice.wins + choice.losses;
+            let data = choice.data;
+            try {
+                const jsonData = JSON.parse(choice.data);
+                debugger;
+                if (jsonData && jsonData.content) {
+                    data = jsonData.content;
+                }
+            }
+            catch (error) {
+            }
+            choicesSheet.addRow([
+                choice.id,
+                workPackage.questionId,
+                choice.wins,
+                choice.losses,
+                voteCount,
+                Math.round(choice.score),
+                data,
+                "N/A",
+                choice.user_created ? "User" : "Seed",
+            ]);
+            votes.winning_votes.forEach((vote) => {
+                console.log(`${vote.tracking ? JSON.stringify(vote.tracking) : ""}`);
+                winningVotesSheet.addRow([
+                    vote.id,
+                    vote.voter_id,
+                    vote.question_id,
+                    vote.prompt_id,
+                    vote.choice_id,
+                    vote.loser_choice_id,
+                    vote.created_at,
+                    vote.updated_at,
+                    vote.time_viewed,
+                    vote.tracking?.utm_source,
+                    vote.tracking?.utm_campaign,
+                    vote.tracking?.utm_medium,
+                    vote.tracking?.utm_content,
+                ]);
+            });
+            votes.losing_votes.forEach((vote) => {
+                losingVotesSheet.addRow([
+                    vote.id,
+                    vote.voter_id,
+                    vote.question_id,
+                    vote.prompt_id,
+                    vote.choice_id,
+                    vote.loser_choice_id,
+                    vote.created_at,
+                    vote.updated_at,
+                    vote.time_viewed,
+                    vote.tracking?.utm_source,
+                    vote.tracking?.utm_campaign,
+                    vote.tracking?.utm_medium,
+                    vote.tracking?.utm_content,
+                ]);
+            });
+            const progress = Math.round((i / choices.length) * 95); // Scale to 95% maximum to leave room for final steps
+            await updateUploadJobStatus(workPackage.jobId, Math.max(progress, 99));
+        }
+        const eloRatings = new Map();
+        choices.forEach(choice => {
+            eloRatings.set(choice.id, 1000); // Default ELO rating
+        });
+        // NowvotesMap, iterate over choices to compute ELO ratings without fetching votes again
+        choices.forEach(choice1 => {
+            choices.forEach(choice2 => {
+                if (choice1.id === choice2.id)
+                    return; // Skip comparison with itself
+                // Assuming votesMap is a Map where each entry's key is a choice ID
+                // and its value is an object with winning_votes and losing_votes arrays
+                const votes1 = choiceVoteMap.get(choice1.id);
+                const votes2 = choiceVoteMap.get(choice2.id);
+                const directVotes1 = votes1?.winning_votes.filter(vote => vote.loser_choice_id === choice2.id) || [];
+                const directVotes2 = votes2?.winning_votes.filter(vote => vote.loser_choice_id === choice1.id) || [];
+                if (directVotes1.length === 0 && directVotes2.length === 0)
+                    return;
+                const score1 = directVotes1.length / (directVotes1.length + directVotes2.length);
+                const score2 = directVotes2.length / (directVotes2.length + directVotes1.length);
+                const currentRating1 = eloRatings.get(choice1.id) || 1500;
+                const currentRating2 = eloRatings.get(choice2.id) || 1500;
+                const [newRating1, newRating2] = calculateElo(currentRating1, currentRating2, score1, score2);
+                eloRatings.set(choice1.id, newRating1);
+                eloRatings.set(choice2.id, newRating2);
+            });
+        });
+        // After the ELO ratings are computed
+        choices.forEach((choice, i) => {
+            const eloRating = eloRatings.get(choice.id);
+            // Update the Excel sheet with the new ELO rating
+            // Note: Adjust the cell reference as needed
+            if (eloRating) {
+                choicesSheet.getCell(`H${i + 2}`).value = Math.round(eloRating);
+                console.log(`Choice ${choice.id} has elo rating ${Math.round(eloRating)}`);
+            }
+            else {
+                console.error(`Choice ${choice.id} has no elo rating`);
+            }
+        });
+        // Generate and upload the workbook to S3
+        const buffer = await workbook.xlsx.writeBuffer();
+        const filename = `choice_votes_${uuidv4()}.xlsx`;
+        console.log(`Uploading choice votes to S3: ${filename}`);
+        uploadToS3(workPackage.jobId, `${workPackage.userId}`, filename, workPackage.exportType, buffer, async (error, url) => {
+            if (error) {
+                console.error("Error uploading choice votes to S3:", error);
+                done(error, url);
+            }
+            else {
+                console.log(`Uploaded choice votes to S3: ${url}`);
+                await updateUploadJobStatus(workPackage.jobId, 100, {
+                    reportUrl: url,
+                });
+                done(undefined, url);
+            }
+        });
+        console.log(`Successfully exported and uploaded choice votes for question ${workPackage.questionId}`);
+    }
+    catch (error) {
+        console.error("Error exporting choice votes:", error);
+        await setJobError(workPackage.jobId, "Error exporting choice votes");
+        done(error);
+    }
+}

package/dist/active-citizen/engine/reports/xls_community_users_report.cjs

@@ -0,0 +1,277 @@
+"use strict";
+const models = require("../../../models/index.cjs");
+const async = require("async");
+const moment = require("moment");
+const log = require("../../utils/logger.cjs");
+const _ = require("lodash");
+const Excel = require("exceljs");
+const getGroupPosts = require("./common_utils.cjs").getGroupPosts;
+const getContactData = require("./common_utils.cjs").getContactData;
+const getAttachmentData = require("./common_utils.cjs").getAttachmentData;
+const getMediaTranscripts = require("./common_utils.cjs").getMediaTranscripts;
+const getPostRatings = require("./common_utils.cjs").getPostRatings;
+const getPostUrl = require("./common_utils.cjs").getPostUrl;
+const getLocation = require("./common_utils.cjs").getLocation;
+const getCategory = require("./common_utils.cjs").getCategory;
+const getUserEmail = require("./common_utils.cjs").getUserEmail;
+const getMediaFormatUrl = require("./common_utils.cjs").getMediaFormatUrl;
+const getMediaURLs = require("./common_utils.cjs").getMediaURLs;
+const getPointsUpOrDown = require("./common_utils.cjs").getPointsUpOrDown;
+const getPointsUp = require("./common_utils.cjs").getPointsUp;
+const getPointsDown = require("./common_utils.cjs").getPointsDown;
+const getTranslatedPoints = require("./common_utils.cjs").getTranslatedPoints;
+const getTranslation = require("./common_utils.cjs").getTranslation;
+const getOrderedPosts = require("./common_utils.cjs").getOrderedPosts;
+const updateJobStatusIfNeeded = require("./common_utils.cjs")
+    .updateJobStatusIfNeeded;
+const setJobError = require("./common_utils.cjs").setJobError;
+const uploadToS3 = require("./common_utils.cjs").uploadToS3;
+const sanitizeFilename = require("sanitize-filename");
+const cleanText = (text) => {
+    let outText = text;
+    outText = outText.replace(/\*/g, '');
+    outText = outText.replace(/\?/g, '');
+    outText = outText.replace(/:/g, '');
+    outText = outText.replace(/\//g, '');
+    outText = outText.replace(/\\/g, '');
+    outText = outText.replace(/\[/g, '');
+    outText = outText.replace(/\]/g, '');
+    return outText;
+};
+const formatWorksheet = (worksheet) => {
+    worksheet.getRow(1).font = { bold: true };
+    //  worksheet.properties.defaultRowHeight = 20;
+};
+const getAnswerFor = (text, answers) => {
+    for (let i = 0; i < answers.length; i++) {
+        if (Object.keys(answers[i])[0] === text)
+            return Object.values(answers[i])[0];
+    }
+    return '';
+};
+async function addUsers(worksheet, model, modelId, asUsersCode, registrationQuestions) {
+    let foundAll = false;
+    let offset = 0;
+    while (!foundAll) {
+        const modelResults = await model.findOne({
+            attributes: ['id'],
+            where: {
+                id: modelId,
+            },
+            include: [
+                {
+                    model: models.User,
+                    as: asUsersCode,
+                    attributes: ['id', 'email', 'ssn', 'name', 'private_profile_data', 'created_at'],
+                }
+            ],
+        });
+        foundAll = true;
+        if (modelResults) {
+            const users = modelResults[asUsersCode];
+            if (users.length === 0) {
+                foundAll = true;
+            }
+            else {
+                for (let i = 0; i < users.length; i++) {
+                    let row = {
+                        email: users[i].email,
+                        name: users[i].name,
+                        ssn: users[i].ssn,
+                        id: users[i].id,
+                        createdAt: users[i].created_at
+                    };
+                    if (registrationQuestions && users[i].private_profile_data && users[i].private_profile_data.registration_answers) {
+                        const answers = users[i].private_profile_data.registration_answers;
+                        for (let i = 0; i < registrationQuestions.length; i++) {
+                            if (registrationQuestions[i].type !== "segment" && registrationQuestions[i].type !== "textDescription") {
+                                const key = registrationQuestions[i].text;
+                                const value = getAnswerFor(registrationQuestions[i].text, answers);
+                                row = _.merge(row, { [key]: value });
+                            }
+                        }
+                    }
+                    worksheet.addRow(row);
+                    offset += users.length;
+                }
+            }
+        }
+    }
+}
+async function addCommunity(workbook, community) {
+    let name = community.translatedName ? community.translatedName : community.name;
+    name = cleanText(name);
+    const worksheet = workbook.addWorksheet(`Community Users ${community.id} ${name}`);
+    const columns = [
+        { header: "User Id", key: "id", width: 10 },
+        { header: "Created at", key: "createdAt", width: 15 },
+        { header: "Name", key: "name", width: 30 },
+        { header: "National Id", key: "ssn", width: 15 },
+        { header: "Email", key: "email", width: 40 },
+    ];
+    const registrationQuestions = community.configuration.registrationQuestionsJson;
+    if (registrationQuestions) {
+        for (let i = 0; i < registrationQuestions.length; i++) {
+            if (registrationQuestions[i].type !== "segment" && registrationQuestions[i].type !== "textDescription") {
+                try {
+                    columns.push({
+                        header: registrationQuestions[i].text,
+                        key: registrationQuestions[i].text,
+                        style: { numFmt: '@' },
+                        alignment: { wrapText: true },
+                        width: 30
+                    });
+                }
+                catch (ex) {
+                    log.error(ex);
+                }
+            }
+        }
+    }
+    worksheet.columns = columns;
+    await addUsers(worksheet, models.Community, community.id, "CommunityUsers", registrationQuestions);
+    formatWorksheet(worksheet);
+}
+async function addGroup(workbook, group) {
+    let name = group.translatedName ? group.translatedName : group.name;
+    name = cleanText(name);
+    const worksheet = workbook.addWorksheet(`Group Users ${group.id} ${name}`);
+    let columns = [
+        { header: "User Id", key: "id", width: 10 },
+        { header: "Created at", key: "createdAt", width: 15 },
+        { header: "Name", key: "name", width: 35 },
+        { header: "National Id", key: "ssn", width: 15 },
+        { header: "Email", key: "email", width: 40 },
+    ];
+    const registrationQuestions = group.configuration.registrationQuestionsJson;
+    if (registrationQuestions) {
+        for (let i = 0; i < registrationQuestions.length; i++) {
+            if (registrationQuestions[i].type !== "segment" && registrationQuestions[i].type !== "textDescription") {
+                try {
+                    columns.push({
+                        header: registrationQuestions[i].text,
+                        key: registrationQuestions[i].text,
+                        width: 30
+                    });
+                }
+                catch (ex) {
+                    log.error(ex);
+                }
+            }
+        }
+    }
+    worksheet.columns = columns;
+    await addUsers(worksheet, models.Group, group.id, "GroupUsers", registrationQuestions);
+    formatWorksheet(worksheet);
+}
+async function exportToXls(options, callback) {
+    const community = options.community;
+    const groupsLength = community.Groups.length;
+    const workbook = new Excel.Workbook();
+    workbook.creator = "Your Priorities Report - Automated";
+    workbook.created = new Date();
+    try {
+        await addCommunity(workbook, community);
+        for (let i = 0; i < groupsLength; i++) {
+            await addGroup(workbook, community.Groups[i]);
+            const jobProgress = Math.min(15 + (Math.round(85 / (groupsLength))) * i, 95);
+            await models.AcBackgroundJob.update({
+                progress: jobProgress,
+            }, {
+                where: { id: options.jobId },
+            });
+        }
+        const buffer = await workbook.xlsx.writeBuffer();
+        callback(null, buffer);
+    }
+    catch (error) {
+        callback(error);
+    }
+}
+const createXlsCommunityUsersReport = (workPackage, callback) => {
+    let exportedData, filename;
+    async.series([
+        (seriesCallback) => {
+            models.Community.findOne({
+                where: {
+                    id: workPackage.communityId,
+                },
+                include: [
+                    {
+                        model: models.Group,
+                        attributes: ['id', 'name', 'configuration']
+                    }
+                ],
+                attributes: [
+                    "id",
+                    "name",
+                    "description",
+                    "configuration"
+                ]
+            })
+                .then(community => {
+                workPackage.community = community;
+                const dateString = moment(new Date()).format("DD_MM_YY_HH_mm");
+                const communityName = sanitizeFilename(community.name).replace(/ /g, "");
+                workPackage.filename =
+                    "Community_Users_Export_" +
+                        community.id +
+                        "_" +
+                        communityName +
+                        "_" +
+                        dateString +
+                        "." +
+                        workPackage.fileEnding;
+                seriesCallback();
+            })
+                .catch((error) => {
+                seriesCallback(error);
+            });
+        },
+        (seriesCallback) => {
+            models.AcBackgroundJob.updateProgress(workPackage.jobId, 5, seriesCallback);
+        },
+        (seriesCallback) => {
+            exportToXls({ jobId: workPackage.jobId, community: workPackage.community }, (error, data) => {
+                exportedData = data;
+                seriesCallback(error);
+            });
+        },
+        (seriesCallback) => {
+            uploadToS3(workPackage.jobId, workPackage.userId, workPackage.filename, workPackage.fileEnding, exportedData, (error, reportUrl) => {
+                if (error) {
+                    seriesCallback(error);
+                }
+                else {
+                    console.log(`Updating job 100 with DATA`);
+                    models.AcBackgroundJob.update({
+                        progress: 100,
+                        data: { reportUrl },
+                    }, {
+                        where: { id: workPackage.jobId },
+                    })
+                        .then(() => {
+                        seriesCallback();
+                    })
+                        .catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+            });
+        },
+    ], (error) => {
+        if (error) {
+            setJobError(workPackage.jobId, "errorXlsCommunityUsersReportGeneration", error, (dbError) => {
+                callback(dbError || error);
+            });
+        }
+        else {
+            log.info("Done generating report");
+            callback();
+        }
+    });
+};
+module.exports = {
+    createXlsCommunityUsersReport,
+    getAnswerFor
+};