enigma-bbs/core/activitypub/util.js

const User = require('../user');
const { Errors, ErrorReasons } = require('../enig_error');
const UserProps = require('../user_property');
const ActivityPubSettings = require('./settings');
const { stripAnsiControlCodes } = require('../string_util');
const { WellKnownRecipientFields } = require('./const');
const Log = require('../logger').log;
const { getWebDomain } = require('../web_util');
const Endpoints = require('./endpoint');

// deps
const _ = require('lodash');
const mimeTypes = require('mime-types');
const waterfall = require('async/waterfall');
const fs = require('graceful-fs');
const paths = require('path');
const moment = require('moment');
const { encode, decode } = require('html-entities');
const { isString, get } = require('lodash');
const { stripHtml } = require('string-strip-html');

exports.getActorId = o => o.actor?.id || o.actor;
exports.parseTimestampOrNow = parseTimestampOrNow;
exports.isValidLink = isValidLink;
exports.userFromActorId = userFromActorId;
exports.getUserProfileTemplatedBody = getUserProfileTemplatedBody;
exports.messageBodyToHtml = messageBodyToHtml;
exports.messageToHtml = messageToHtml;
exports.htmlToMessageBody = htmlToMessageBody;
exports.userNameFromSubject = userNameFromSubject;
exports.userNameToSubject = userNameToSubject;
exports.extractMessageMetadata = extractMessageMetadata;
exports.recipientIdsFromObject = recipientIdsFromObject;
exports.prepareLocalUserAsActor = prepareLocalUserAsActor;

//  :TODO: more info in default
// this profile template is the *default* for both WebFinger
// profiles and 'self' requests without the
// Accept: application/activity+json headers present
exports.DefaultProfileTemplate = `
User information for: %PREFERRED_USERNAME%

Name: %NAME%
Login Count: %LOGIN_COUNT%
Affiliations: %AFFILIATIONS%
Achievement Points: %ACHIEVEMENT_POINTS%
`;

function parseTimestampOrNow(s) {
    try {
        return moment(s);
    } catch (e) {
        Log.warn({ error: e.message }, `Failed parsing timestamp "${s}"`);
        return moment();
    }
}

function isValidLink(l) {
    return /^https?:\/\/.+$/.test(l);
}

function userFromActorId(actorId, cb) {
    User.getUserIdsWithProperty(UserProps.ActivityPubActorId, actorId, (err, userId) => {
        if (err) {
            return cb(err);
        }

        // must only be 0 or 1
        if (!Array.isArray(userId) || userId.length !== 1) {
            return cb(
                Errors.DoesNotExist(
                    `No user with property '${UserProps.ActivityPubActorId}' of ${actorId}`
                )
            );
        }

        userId = userId[0];
        User.getUser(userId, (err, user) => {
            if (err) {
                return cb(err);
            }

            const accountStatus = user.getPropertyAsNumber(UserProps.AccountStatus);
            if (
                User.AccountStatus.disabled == accountStatus ||
                User.AccountStatus.inactive == accountStatus
            ) {
                return cb(Errors.AccessDenied('Account disabled', ErrorReasons.Disabled));
            }

            const activityPubSettings = ActivityPubSettings.fromUser(user);
            if (!activityPubSettings.enabled) {
                return cb(Errors.AccessDenied('ActivityPub is not enabled for user'));
            }

            return cb(null, user);
        });
    });
}

function getUserProfileTemplatedBody(
    templateFile,
    user,
    userAsActor,
    defaultTemplate,
    defaultContentType,
    cb
) {
    const Log = require('../logger').log;
    const Config = require('../config').get;

    waterfall(
        [
            callback => {
                return fs.readFile(templateFile || '', 'utf8', (err, template) => {
                    return callback(null, template);
                });
            },
            (template, callback) => {
                if (!template) {
                    if (templateFile) {
                        Log.warn(`Failed to load profile template "${templateFile}"`);
                    }
                    return callback(null, defaultTemplate, defaultContentType);
                }

                const contentType = mimeTypes.contentType(paths.basename(templateFile));
                return callback(null, template, contentType);
            },
            (template, contentType, callback) => {
                const val = v => {
                    if (isString(v)) {
                        return v ? encode(v) : '';
                    } else {
                        if (isNaN(v)) {
                            return '';
                        }
                        return v ? v : 0;
                    }
                };

                let birthDate = val(user.getProperty(UserProps.Birthdate));
                if (moment.isDate(birthDate)) {
                    birthDate = moment(birthDate);
                }

                const varMap = {
                    ACTOR_OBJ: JSON.stringify(userAsActor),
                    SUBJECT: userNameToSubject(user.username),
                    INBOX: userAsActor.inbox,
                    SHARED_INBOX: userAsActor.endpoints.sharedInbox,
                    OUTBOX: userAsActor.outbox,
                    FOLLOWERS: userAsActor.followers,
                    FOLLOWING: userAsActor.following,
                    USER_ICON: get(userAsActor, 'icon.url', ''),
                    USER_IMAGE: get(userAsActor, 'image.url', ''),
                    PREFERRED_USERNAME: userAsActor.preferredUsername,
                    NAME: userAsActor.name,
                    SEX: user.getProperty(UserProps.Sex),
                    BIRTHDATE: birthDate,
                    AGE: user.getAge(),
                    LOCATION: user.getProperty(UserProps.Location),
                    AFFILIATIONS: user.getProperty(UserProps.Affiliations),
                    EMAIL: user.getProperty(UserProps.EmailAddress),
                    WEB_ADDRESS: user.getProperty(UserProps.WebAddress),
                    ACCOUNT_CREATED: moment(user.getProperty(UserProps.AccountCreated)),
                    LAST_LOGIN: moment(user.getProperty(UserProps.LastLoginTs)),
                    LOGIN_COUNT: user.getPropertyAsNumber(UserProps.LoginCount),
                    ACHIEVEMENT_COUNT: user.getPropertyAsNumber(
                        UserProps.AchievementTotalCount
                    ),
                    ACHIEVEMENT_POINTS: user.getPropertyAsNumber(
                        UserProps.AchievementTotalPoints
                    ),
                    BOARDNAME: Config().general.boardName,
                };

                let body = template;
                _.each(varMap, (v, varName) => {
                    body = body.replace(new RegExp(`%${varName}%`, 'g'), val(v));
                });

                return callback(null, body, contentType);
            },
        ],
        (err, data, contentType) => {
            return cb(err, data, contentType);
        }
    );
}

function messageBodyToHtml(body) {
    body = encode(stripAnsiControlCodes(body), { mode: 'nonAsciiPrintable' }).replace(
        /\r?\n/g,
        '<br>'
    );

    return `<p>${body}</p>`;
}

//
//  Apply very basic HTML to a message following
//  Mastodon's supported tags of 'p', 'br', 'a', and 'span':
//  - https://docs.joinmastodon.org/spec/activitypub/#sanitization
//  - https://blog.joinmastodon.org/2018/06/how-to-implement-a-basic-activitypub-server/
//
//  Microformats:
//  - https://microformats.org/wiki/
//  - https://indieweb.org/note
//  - https://docs.joinmastodon.org/spec/microformats/
//
function messageToHtml(message) {
    const msg = encode(stripAnsiControlCodes(message.message.trim()), {
        mode: 'nonAsciiPrintable',
    }).replace(/\r?\n/g, '<br>');

    //  :TODO: figure out any microformats we should use here...

    return `<p>${msg}</p>`;
}

function htmlToMessageBody(html) {
    const res = stripHtml(decode(html));
    return res.result;
}

function userNameFromSubject(subject) {
    return subject.replace(/^acct:(.+)$/, '$1');
}

function userNameToSubject(userName) {
    return `@${userName}@${getWebDomain()}`;
}

function extractMessageMetadata(body) {
    const metadata = { mentions: new Set(), hashTags: new Set() };

    const re = /(@\w+)|(#[A-Za-z0-9_]+)/g;
    const matches = body.matchAll(re);
    for (const m of matches) {
        if (m[1]) {
            metadata.mentions.add(m[1]);
        } else if (m[2]) {
            metadata.hashTags.add(m[2]);
        }
    }

    return metadata;
}

function recipientIdsFromObject(obj) {
    const ids = [];

    WellKnownRecipientFields.forEach(field => {
        let v = obj[field];
        if (v) {
            if (!Array.isArray(v)) {
                v = [v];
            }
            ids.push(...v);
        }
    });

    return Array.from(new Set(ids));
}

function prepareLocalUserAsActor(user, options = { force: false }, cb) {
    const hasProps =
        user.getProperty(UserProps.ActivityPubActorId) &&
        user.getProperty(UserProps.PrivateActivityPubSigningKey) &&
        user.getProperty(UserProps.PublicActivityPubSigningKey);

    if (hasProps && !options.force) {
        return cb(null);
    }

    const actorId = Endpoints.actorId(user);
    user.setProperty(UserProps.ActivityPubActorId, actorId);

    user.updateActivityPubKeyPairProperties(err => {
        if (err) {
            return cb(err);
        }

        user.generateNewRandomAvatar((err, outPath) => {
            if (err) {
                return err;
            }

            //  :TODO: fetch over +op default overrides here, e.g. 'enabled'
            const apSettings = ActivityPubSettings.fromUser(user);

            const filename = paths.basename(outPath);
            const avatarUrl = Endpoints.avatar(user, filename);

            apSettings.image = avatarUrl;
            apSettings.icon = avatarUrl;

            user.setProperty(UserProps.AvatarImageUrl, avatarUrl);
            user.setProperty(UserProps.ActivityPubSettings, JSON.stringify(apSettings));

            return cb(null);
        });
    });
}