@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/engine/allOurIdeas/aiHelper.js

@@ -0,0 +1,204 @@
+import { OpenAI } from "openai";
+export class AiHelper {
+    constructor(wsClientSocket = undefined) {
+        this.modelName = "gpt-4o";
+        this.maxTokens = 2048;
+        this.temperature = 0.7;
+        this.cacheExpireTime = 60 * 60;
+        this.moderationSystemPrompt = (instructions) => `The user will provide you with a question and an answer.
+Your job is to moderate the answer if it passes automated moderation or not.
+Moderation instructions:
+${instructions}
+
+Only output: PASSES or FAILS`;
+        this.moderationUserPrompt = (question, answer) => `
+  Question: ${question}
+  Answer: ${answer}
+  `;
+        this.getModerationResponse = async (instructions, question, answerToModerate) => {
+            const messages = [
+                {
+                    role: "system",
+                    content: this.moderationSystemPrompt(instructions),
+                },
+                {
+                    role: "user",
+                    content: this.moderationUserPrompt(question, answerToModerate),
+                },
+            ];
+            console.log(JSON.stringify(messages, null, 2));
+            const response = await this.openaiClient.chat.completions.create({
+                model: this.modelName,
+                messages,
+                max_tokens: 5,
+                temperature: 0,
+            });
+            if (response &&
+                response.choices &&
+                response.choices[0] &&
+                response.choices[0].message &&
+                response.choices[0].message.content) {
+                console.log("Moderation response:", response.choices[0].message.content);
+                return ["PASSES", "PASS"].includes(response.choices[0].message.content.toUpperCase())
+                    ? true
+                    : false;
+            }
+            else {
+                return false;
+            }
+        };
+        this.openaiClient = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+        this.wsClientSocket = wsClientSocket;
+    }
+    async streamChatCompletions(messages) {
+        const stream = await this.openaiClient.chat.completions.create({
+            model: this.modelName,
+            messages,
+            max_tokens: this.maxTokens,
+            temperature: this.temperature,
+            stream: true,
+        });
+        await this.streamWebSocketResponses(stream);
+    }
+    sendToClient(sender, message, type = "stream") {
+        this.wsClientSocket?.send(JSON.stringify({
+            sender,
+            type: type,
+            message,
+        }));
+    }
+    async streamWebSocketResponses(stream) {
+        return new Promise(async (resolve, reject) => {
+            this.sendToClient("bot", "", "start");
+            try {
+                let botMessage = "";
+                for await (const part of stream) {
+                    this.sendToClient("bot", part.choices[0].delta.content);
+                    botMessage += part.choices[0].delta.content;
+                }
+                if (this.redisClient && this.cacheKeyForFullResponse) {
+                    this.redisClient.set(this.cacheKeyForFullResponse, botMessage, "EX", this.cacheExpireTime);
+                }
+            }
+            catch (error) {
+                console.error(error);
+                this.sendToClient("bot", "There has been an error, please retry", "error");
+                reject();
+            }
+            finally {
+                this.sendToClient("bot", "", "end");
+            }
+            resolve();
+        });
+    }
+    async getAnswerIdeas(question, previousIdeas, firstMessage) {
+        try {
+            const moderationResponse = await this.openaiClient.moderations.create({
+                input: question,
+            });
+            console.log("Moderation response:", moderationResponse);
+            const flagged = moderationResponse.results[0].flagged;
+            console.log("Flagged:", flagged);
+            if (flagged) {
+                console.error("Flagged:", question);
+                return null;
+            }
+            else {
+                let firstMessageWithPreviousIdeasTemplate = "";
+                let previewIdeasText = "";
+                if (previousIdeas && previousIdeas.length > 0) {
+                    previewIdeasText = `Previous answer ideas:\n${JSON.stringify(previousIdeas, null, 2)}\n\n`;
+                    if (firstMessage) {
+                        firstMessageWithPreviousIdeasTemplate =
+                            "For your answers please follow the tone of voice, prose, style, and length of the Previous answer ideas\n";
+                    }
+                }
+                const messages = [
+                    {
+                        role: "system",
+                        content: `You are a highly competent AI that is able to generate clear answer ideas for questions.
+                      Genereate up to 10 high quality answer ideas.
+                      Never use numbers at the start of each line.
+                      Always output the ideas in the same language the user is asking the question.
+                      Never use a dash or quote or anything similar at the start of each line, just start with the text.
+                      Never output more than 30 words per idea.
+                      \n${firstMessageWithPreviousIdeasTemplate}`,
+                    },
+                    {
+                        role: "user",
+                        content: `What are some possible answers to the question: ${question}\n\n${previewIdeasText}Answers:\n`,
+                    },
+                ];
+                await this.streamChatCompletions(messages);
+            }
+        }
+        catch (error) {
+            console.error("Error in getAnswerIdeas:", error);
+            this.sendToClient("bot", "There has been an error, please retry", "error");
+            return null;
+        }
+    }
+    async getAiAnalysis(questionId, contextPrompt, answers, cacheKeyForFullResponse, redisClient, locale, topOrBottomIdeasText, typeOfAnalysisText) {
+        this.redisClient = redisClient;
+        this.cacheKeyForFullResponse = cacheKeyForFullResponse;
+        const basePrePrompt = `You are a highly competent text and ideas analysis AI.
+        Instructions:
+        If an answer sounds implausible as an answer to the question, then include a short observation about it in your analysis.
+        Keep your output short, under 300 words.
+        The answers have been rated by the public using a pairwise voting method, so the user is always selecting one to win or one to lose.
+        Generally, do not include the number of wins and losses in your answers.
+        If there are very few wins or losses, under 10 for most of the ideas, then always output a disclaimer to that end, in a separate second paragraph.
+        Don't output Idea 1, Idea 2 in your answer.
+        Be creative and think step by step.
+
+        Output:
+        If the prompt asks for a table always output a markdown table.
+        Always output in a clear markdown format.
+        Always start with the type of analysis and if those are top or bottom ideas.
+
+        Example output:
+
+        ## Points for the most popular answers
+
+        <Your dynamic markdown output>
+
+
+    `;
+        const answersText = answers
+            .map((answer) => `${answer.data.content} (Won: ${answer.wins}, Lost: ${answer.losses})`)
+            .join("\n");
+        try {
+            const moderationResponse = await this.openaiClient.moderations.create({
+                input: answersText,
+            });
+            const flagged = moderationResponse.results[0].flagged;
+            if (flagged) {
+                console.error("Flagged:", answersText);
+                return;
+            }
+            else {
+                const messages = [
+                    {
+                        role: "system",
+                        content: `${basePrePrompt}\n${contextPrompt}`,
+                    },
+                    {
+                        role: "user",
+                        content: `The question: ${questionId}
+              ${topOrBottomIdeasText}
+              Type of analysis: ${typeOfAnalysisText}
+              Language to output: ${locale}
+              Answers to analyse:\n${answersText}`,
+                    },
+                ];
+                this.streamChatCompletions(messages);
+            }
+        }
+        catch (error) {
+            console.error("Error in getAiAnalysis:", error);
+            this.sendToClient("bot", "There has been an error, please retry", "error");
+        }
+    }
+}

package/dist/active-citizen/engine/allOurIdeas/explainAnswersAssistant.js

@@ -0,0 +1,66 @@
+import { OpenAI } from "openai";
+import { YpBaseChatBot } from "../../llms/baseChatBot.js";
+import ioredis from "ioredis";
+import { v4 as uuidv4 } from "uuid";
+const tlsOptions = process.env.REDIS_MEMORY_URL?.startsWith("rediss://")
+    ? { rejectUnauthorized: false }
+    : undefined;
+export class ExplainAnswersAssistant extends YpBaseChatBot {
+    constructor(wsClientId, wsClients, languageName) {
+        const redisConnection = new ioredis.default(process.env.REDIS_MEMORY_URL ||
+            process.env.REDIS_URL ||
+            "redis://localhost:6379", {
+            tls: tlsOptions,
+        });
+        super(wsClientId, wsClients, redisConnection, `${YpBaseChatBot.redisMemoryKeyPrefix}-${uuidv4()}-explain-answers-assistant`);
+        this.modelName = "gpt-4o";
+        this.maxTokens = 4000;
+        this.temperature = 0.8;
+        this.explainConversation = async (chatLog) => {
+            this.setChatLog(chatLog);
+            let messages = chatLog.map((message) => {
+                return {
+                    role: message.sender,
+                    content: message.message,
+                };
+            });
+            const systemMessage = {
+                role: "system",
+                content: this.renderSystemPrompt(),
+            };
+            messages.unshift(systemMessage);
+            const stream = await this.openaiClient.chat.completions.create({
+                model: this.llmModel,
+                messages,
+                max_tokens: this.maxTokens,
+                temperature: this.temperature,
+                stream: true,
+            });
+            this.streamWebSocketResponses(stream);
+        };
+        this.languageName = languageName;
+        this.openaiClient = new OpenAI({
+            apiKey: process.env.OPENAI_API_KEY,
+        });
+    }
+    renderSystemPrompt() {
+        return `The user is doing pairwise voting on two answers at the time, to a question, the user needs help deciding what to vote on.
+
+Instructions:
+Use a relevant emoji for the first and second answers.
+Use thumbs emojis for pros and thumb down emjoi for cons
+Use summary emoji for summary.
+Use simple and upbeat language.
+Ask the user clarifying questions if needed.
+Always answers in the language the user asks for.
+
+Output:
+* Each answer
+-- One short paragraph, max three sentences, explanation in a very simple language
+-- The top pro and con
+-- If this is likely to be a root cause of the problem set out in the question
+* Never offer the user your opinion as we don't want to influence the user, they must make their own decision.
+* Always output in this language: ${this.languageName}
+`;
+    }
+}

package/dist/active-citizen/engine/allOurIdeas/iconGenerator.js

@@ -0,0 +1,38 @@
+import path from "path";
+import fs from "fs";
+import { v4 as uuidv4 } from "uuid";
+import axios from "axios";
+import models from "../../../models/index.cjs";
+import { CollectionImageGenerator } from "../../llms/imageGeneration/collectionImageGenerator.js";
+const dbModels = models;
+const Image = dbModels.Image;
+export class AoiIconGenerator extends CollectionImageGenerator {
+    async createCollectionImage(workPackage) {
+        // 1. Generate the image and record using the base implementation.
+        const { imageId, imageUrl } = await super.createCollectionImage(workPackage);
+        // 2. Now process the image for the icon:
+        // Download the generated image to a temporary location.
+        const tempIconPath = path.join("/tmp", `${uuidv4()}-icon.png`);
+        await this.imageProcessorService.downloadImage(imageUrl, tempIconPath, axios);
+        if (!fs.existsSync(tempIconPath)) {
+            throw new Error("Failed to download the generated image for icon processing.");
+        }
+        // Resize the downloaded image to 400x400 pixels.
+        const resizedIconPath = await this.imageProcessorService.resizeImage(tempIconPath, 400, 400);
+        // Define a new S3 path for the icon image.
+        const iconS3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}-icon.png`;
+        // Upload the resized icon to S3.
+        await this.s3Service.uploadImageToS3(process.env.S3_BUCKET, resizedIconPath, iconS3ImagePath);
+        // Construct a public URL for the icon image.
+        const newIconUrl = process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN
+            ? `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${iconS3ImagePath}`
+            : `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${iconS3ImagePath}`;
+        // Optionally, update the DB record with the new icon URL.
+        const imageRecord = await Image.findOne({ where: { id: imageId } });
+        if (imageRecord) {
+            imageRecord.formats = JSON.stringify([newIconUrl]);
+            await imageRecord.save();
+        }
+        return { imageId, imageUrl: newIconUrl };
+    }
+}

package/dist/active-citizen/engine/analytics/export_anon_community_activities.js

@@ -0,0 +1,334 @@
+const models = require('../../../models/index.cjs');
+const _ = require('lodash');
+const async = require('async');
+const log = require('../../../utils/logger.cjs');
+const crypto = require('crypto');
+const fs = require('fs');
+//const request = require('request');
+const request = {
+    post: (data, done) => {
+        console.log(JSON.stringify(data, null, 4));
+        done();
+    }
+};
+const clean = (text) => {
+    //console.log("Before: "+ text);
+    var newText = text.replace('"', "'").replace('\n', '').replace('\r', '').replace(/(\r\n|\n|\r)/gm, "").replace(/"/gm, "'").replace(/,/, ';').trim();
+    //console.log("After:" + newText);
+    return newText.replace(/´/g, '');
+};
+const getEncryptedId = (id, key, iv) => {
+    let cipher = crypto.createCipheriv('aes-256-cbc', Buffer.from(key), iv);
+    let encrypted = cipher.update(id.toString());
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return encrypted.toString('hex');
+};
+let csvPostsTxt = "Id,Date,Name,NameEn,Description,DescriptionEn,ToxicityScore\n";
+const saveAnonymousPost = (post, accessKey, done) => {
+    let expiryDate = new Date();
+    expiryDate.setDate(expiryDate.getDate() + 7);
+    const properties = {
+        id: post.id,
+        name: post.name,
+        name_en: post.name_en,
+        date: post.created_at.toISOString(),
+        description: post.description,
+        description_en: post.description_en,
+        toxicity_score: post.toxicity_score,
+        access_key: accessKey,
+        access_expires_at: expiryDate.toISOString()
+    };
+    csvPostsTxt += post.id + ',' + properties.date + ',"' + clean(post.name) + '","' + clean(post.name_en) + '",' + '"' + clean(post.description) + '",' + '"' + clean(post.description_en) + '",' + post.toxicity_score + '\n';
+    const options = {
+        url: process.env["AC_ANALYTICS_BASE_URL"] + "anonPosts/" + process.env.AC_ANALYTICS_CLUSTER_ID + "/" + `${accessKey}${post.id}`,
+        headers: {
+            'X-API-KEY': process.env["AC_ANALYTICS_KEY"]
+        },
+        json: properties
+    };
+    request.post(options, (error) => {
+        done(error);
+    });
+};
+let csvPointsTxt = "Id,Date,Content,ContentEn,Value,ToxicityScore\n";
+const saveAnonymousPoint = (point, accessKey, done) => {
+    let expiryDate = new Date();
+    expiryDate.setDate(expiryDate.getDate() + 7);
+    const properties = {
+        id: point.id,
+        date: point.created_at.toISOString(),
+        content: point.content,
+        content_en: point.content_en,
+        value: point.value,
+        access_key: accessKey,
+        toxicity_score: point.toxicity_score,
+        access_expires_at: expiryDate.toISOString()
+    };
+    csvPointsTxt += point.id + ',' + properties.date + ',"' + clean(point.content) + '",' + '"' + clean(point.content_en) + '",' + point.value + ',' + point.toxicity_score + '\n';
+    const options = {
+        url: process.env["AC_ANALYTICS_BASE_URL"] + "anonPoints/" + process.env.AC_ANALYTICS_CLUSTER_ID + "/" + `${accessKey}${point.id}`,
+        headers: {
+            'X-API-KEY': process.env["AC_ANALYTICS_KEY"]
+        },
+        json: properties
+    };
+    request.post(options, (error) => {
+        done(error);
+    });
+};
+let csvActivitiesTxt = "Id,Date,Type,PointId,PostId,UserId\n";
+const saveActivity = (activity, accessKey, done) => {
+    let expiryDate = new Date();
+    expiryDate.setDate(expiryDate.getDate() + 7);
+    const properties = {
+        id: activity.id,
+        date: activity.created_at.toISOString(),
+        type: activity.type,
+        point_id: activity.point_id,
+        post_id: activity.post_id,
+        user_id: activity.user_id,
+        access_key: accessKey,
+        access_expires_at: expiryDate.toISOString()
+    };
+    csvActivitiesTxt += activity.id + ',' + properties.date + ',"' + activity.type + '",' + '"' + activity.point_id + '",' + '"' + activity.post_id + '",' + '"' + activity.user_id + '"\n';
+    const options = {
+        url: process.env["AC_ANALYTICS_BASE_URL"] + "anonActivities/" + process.env.AC_ANALYTICS_CLUSTER_ID + "/" + `${accessKey}${activity.id}`,
+        headers: {
+            'X-API-KEY': process.env["AC_ANALYTICS_KEY"]
+        },
+        json: properties
+    };
+    request.post(options, (error) => {
+        done(error);
+    });
+};
+let csvUsersTxt = "Id\n";
+const saveAnonymousUser = (user, accessKey, done) => {
+    let expiryDate = new Date();
+    expiryDate.setDate(expiryDate.getDate() + 7);
+    const properties = {
+        id: user.id,
+        access_key: accessKey,
+        access_expires_at: expiryDate.toISOString()
+    };
+    csvUsersTxt += user.id + '\n';
+    const options = {
+        url: process.env["AC_ANALYTICS_BASE_URL"] + "anonUsers/" + process.env.AC_ANALYTICS_CLUSTER_ID + "/" + `${accessKey}${user.id}`,
+        headers: {
+            'X-API-KEY': process.env["AC_ANALYTICS_KEY"]
+        },
+        json: properties
+    };
+    request.post(options, (error) => {
+        done(error);
+    });
+};
+const collectAllPostsAndPoints = (activities, collectedPostIds, collectedPointIds) => {
+    activities.forEach((item) => {
+        if (item.Post) {
+            collectedPostIds.push(item.Post.id);
+        }
+        if (item.Point) {
+            collectedPointIds.push(item.Point.id);
+        }
+        if (!item.Point && !item.Post) {
+            log.warn("Can't find post or point id for activity in anonymous export", { item });
+        }
+    });
+};
+const sendAllCollectedPostAndPoints = (accessKey, collectedPostIds, collectedPointIds, encryptionKey, encryptionIv, done) => {
+    collectedPostIds = _.uniq(collectedPostIds);
+    collectedPointIds = _.uniq(collectedPointIds);
+    async.series([
+        (seriesCallback) => {
+            async.forEachSeries(collectedPostIds, (postId, forEachSeriesCallback) => {
+                models.Post.findOne({
+                    where: {
+                        id: postId
+                    },
+                    attributes: ['id', 'name', 'description', 'public_data', 'created_at', 'data']
+                }).then((post) => {
+                    let req = {
+                        query: {
+                            textType: 'postContent',
+                            targetLanguage: 'en'
+                        }
+                    };
+                    models.AcTranslationCache.getTranslation(req, post, function (error, descriptionEn) {
+                        req = {
+                            query: {
+                                textType: 'postName',
+                                targetLanguage: 'en'
+                            }
+                        };
+                        models.AcTranslationCache.getTranslation(req, post, function (error, nameEn) {
+                            saveAnonymousPost({
+                                id: getEncryptedId((post.id), encryptionKey, encryptionIv),
+                                name: post.name,
+                                name_en: nameEn ? nameEn.content : 'no translation',
+                                created_at: post.created_at,
+                                toxicity_score: (post.data && post.data.moderation) ? post.data.moderation.toxicityScore : null,
+                                description: post.description,
+                                description_en: descriptionEn ? descriptionEn.content : 'no translation',
+                            }, accessKey, forEachSeriesCallback);
+                        });
+                    });
+                }).catch((error) => {
+                    forEachSeriesCallback(error);
+                });
+            }, (error) => {
+                seriesCallback(error);
+            });
+        },
+        (seriesCallback) => {
+            async.forEachSeries(collectedPointIds, (pointId, forEachSeriesCallback) => {
+                models.Point.findOne({
+                    where: {
+                        id: pointId
+                    },
+                    order: [
+                        [models.PointRevision, 'created_at', 'asc'],
+                    ],
+                    attributes: ['id', 'created_at', 'content', 'value', 'data'],
+                    include: [
+                        {
+                            model: models.PointRevision,
+                            attributes: ['id', 'content']
+                        }
+                    ]
+                }).then((point) => {
+                    let req = {
+                        query: {
+                            textType: 'pointContent',
+                            targetLanguage: 'en'
+                        }
+                    };
+                    models.AcTranslationCache.getTranslation(req, point, function (error, contentEn) {
+                        saveAnonymousPoint({
+                            id: getEncryptedId((point.id), encryptionKey, encryptionIv),
+                            content: point.content,
+                            value: point.value,
+                            toxicity_score: (point.data && point.data.moderation) ? point.data.moderation.toxicityScore : null,
+                            created_at: point.created_at,
+                            content_en: contentEn ? contentEn.content : 'no translation'
+                        }, accessKey, forEachSeriesCallback);
+                    });
+                }).catch((error) => {
+                    forEachSeriesCallback(error);
+                });
+            }, (error) => {
+                seriesCallback(error);
+            });
+        },
+    ], (error) => {
+        done(error);
+    });
+};
+const sendAllUserActivitiesWithContent = (userId, communityId, collectedPostIds, collectedPointIds, encryptionKey, encryptionIv, accessKey, done) => {
+    models.AcActivity.findAll({
+        where: {
+            user_id: userId,
+            community_id: communityId,
+            type: {
+                $in: [
+                    "activity.post.new", "activity.post.opposition.new", "activity.post.endorsement.new",
+                    "activity.point.new", "activity.point.helpful.new", "activity.point.unhelpful.new"
+                ]
+            }
+        },
+        attributes: ['id', 'type', 'created_at', 'user_id', 'post_id', 'point_id'],
+        include: [
+            {
+                model: models.Post,
+                required: false,
+                attributes: ['id']
+            },
+            {
+                model: models.Point,
+                required: false,
+                attributes: ['id']
+            }
+        ]
+    }).then((activities) => {
+        collectAllPostsAndPoints(activities, collectedPostIds, collectedPointIds);
+        async.forEachSeries(activities, (activity, forEachSeriesCallback) => {
+            if (activity.Post || activity.Point) {
+                saveActivity({
+                    id: getEncryptedId(activity.id, encryptionKey, encryptionIv),
+                    type: activity.type,
+                    created_at: activity.created_at,
+                    post_id: activity.Post ? getEncryptedId(activity.Post.id, encryptionKey, encryptionIv) : null,
+                    point_id: activity.Point ? getEncryptedId(activity.Point.id, encryptionKey, encryptionIv) : null,
+                    user_id: getEncryptedId(activity.user_id, encryptionKey, encryptionIv)
+                }, accessKey, forEachSeriesCallback);
+            }
+            else {
+                log.warn("Can't find post or point for activity");
+                forEachSeriesCallback();
+            }
+        }, (error) => {
+            done(error);
+        });
+    }).catch(function (error) {
+        done(error);
+    });
+};
+const importCommunityUsersAndActivities = (communityId, accessKey, done) => {
+    const encryptionKey = crypto.randomBytes(32);
+    const encryptionIv = crypto.randomBytes(16);
+    let collectedPostIds = [];
+    let collectedPointIds = [];
+    models.Community.findOne({
+        where: {
+            id: communityId
+        },
+        include: [
+            {
+                model: models.User,
+                attributes: ['id'],
+                as: 'CommunityUsers',
+                required: true,
+            }
+        ]
+    }).then(function (community) {
+        if (community && community.CommunityUsers) {
+            async.forEachSeries(community.CommunityUsers, (user, eachSeriesCallback) => {
+                saveAnonymousUser({
+                    id: getEncryptedId(user.id, encryptionKey, encryptionIv)
+                }, accessKey, (error) => {
+                    if (error) {
+                        eachSeriesCallback(error);
+                    }
+                    else {
+                        sendAllUserActivitiesWithContent(user.id, communityId, collectedPostIds, collectedPointIds, encryptionKey, encryptionIv, accessKey, eachSeriesCallback);
+                    }
+                });
+            }, (error) => {
+                if (error) {
+                    done(error);
+                }
+                else {
+                    sendAllCollectedPostAndPoints(accessKey, collectedPostIds, collectedPointIds, encryptionKey, encryptionIv, (error) => {
+                        done(error);
+                    });
+                }
+            });
+        }
+        else {
+            done("Could not find community");
+        }
+    }).catch(function (error) {
+        done(error);
+    });
+};
+importCommunityUsersAndActivities(1017, "12345", () => {
+    fs.writeFileSync("/home/robert/Scratch/MMU/users.csv", csvUsersTxt);
+    fs.writeFileSync("/home/robert/Scratch/MMU/posts.csv", csvPostsTxt);
+    fs.writeFileSync("/home/robert/Scratch/MMU/points.csv", csvPointsTxt);
+    fs.writeFileSync("/home/robert/Scratch/MMU/activities.csv", csvActivitiesTxt);
+    process.exit();
+});
+module.exports = {
+    importCommunityUsersAndActivities
+};
+export {};