@yrpri/api 9.0.103 → 9.0.104

package/dist/models/domain.cjs

@@ -1,486 +0,0 @@
-"use strict";
-const async = require("async");
-const log = require("../utils/logger.cjs");
-const toJson = require("../utils/to_json.cjs");
-const parseDomain = require("../utils/parse_domain.cjs");
-var queue = require("../active-citizen/workers/queue.cjs");
-const Community = require("./community.cjs");
-const checkValidKeys = (keys) => {
-    return (keys.client_id &&
-        keys.client_id != "" &&
-        keys.client_id.length > 6 &&
-        keys.client_secret &&
-        keys.client_secret != "");
-};
-module.exports = (sequelize, DataTypes) => {
-    const Domain = sequelize.define("Domain", {
-        name: { type: DataTypes.STRING, allowNull: false },
-        domain_name: { type: DataTypes.STRING, allowNull: false },
-        access: { type: DataTypes.INTEGER, allowNull: false },
-        deleted: {
-            type: DataTypes.BOOLEAN,
-            allowNull: false,
-            defaultValue: false,
-        },
-        default_locale: {
-            type: DataTypes.STRING,
-            allowNull: false,
-            default: "en",
-        },
-        description: DataTypes.TEXT,
-        message_to_users: DataTypes.STRING,
-        message_for_new_idea: DataTypes.STRING,
-        ip_address: { type: DataTypes.STRING, allowNull: false },
-        user_agent: { type: DataTypes.TEXT, allowNull: false },
-        google_analytics_code: { type: DataTypes.STRING, allowNull: true },
-        counter_communities: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_users: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_groups: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_points: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_posts: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_organizations: { type: DataTypes.INTEGER, defaultValue: 0 },
-        only_admins_can_create_communities: {
-            type: DataTypes.BOOLEAN,
-            defaultValue: false,
-        },
-        theme_id: { type: DataTypes.INTEGER, defaultValue: null },
-        other_social_media_info: DataTypes.JSONB,
-        secret_api_keys: DataTypes.JSONB,
-        public_api_keys: DataTypes.JSONB,
-        info_texts: DataTypes.JSONB,
-        configuration: DataTypes.JSONB,
-        language: { type: DataTypes.STRING, allowNull: true },
-        data: DataTypes.JSONB,
-    }, {
-        underscored: true,
-        tableName: "domains",
-        timestamps: true,
-        createdAt: "created_at",
-        updatedAt: "updated_at",
-        indexes: [
-            {
-                fields: ["id", "deleted"],
-            },
-            {
-                name: "domains_idx_deleted_domain_name",
-                fields: ["deleted", "domain_name"],
-            },
-        ],
-        instanceMethods: {},
-    });
-    Domain.associate = (models) => {
-        Domain.hasMany(models.Community, { foreignKey: "domain_id" });
-        Domain.belongsToMany(models.Video, {
-            as: "DomainLogoVideos",
-            through: "DomainLogoVideo",
-        });
-        Domain.belongsToMany(models.Image, {
-            as: "DomainLogoImages",
-            through: "DomainLogoImage",
-        });
-        Domain.belongsToMany(models.Image, {
-            as: "DomainHeaderImages",
-            through: "DomainHeaderImage",
-        });
-        Domain.belongsToMany(models.User, { through: "DomainUser" });
-        Domain.belongsToMany(models.User, {
-            as: "DomainUsers",
-            through: "DomainUser",
-        });
-        Domain.belongsToMany(models.User, {
-            as: "DomainAdmins",
-            through: "DomainAdmin",
-        });
-    };
-    Domain.ACCESS_PUBLIC = 0;
-    Domain.ACCESS_CLOSED = 1;
-    Domain.ACCESS_SECRET = 2;
-    Domain.defaultAttributesPublic = [
-        "id",
-        "name",
-        "domain_name",
-        "access",
-        "deleted",
-        "description",
-        "default_locale",
-        "message_to_users",
-        "message_for_new_idea",
-        "google_analytics_code",
-        "counter_communities",
-        "counter_users",
-        "counter_groups",
-        "counter_points",
-        "counter_posts",
-        "counter_organizations",
-        "only_admins_can_create_communities",
-        "theme_id",
-        "other_social_media_info",
-        "public_api_keys",
-        "info_texts",
-        "configuration",
-    ];
-    Domain.getLoginProviders = (req, domainIn, callback) => {
-        const providers = [];
-        console.log(`-------------------> getLoginProviders Checking local keys for domain ${domainIn.id}`);
-        providers.push({
-            name: "local-strategy",
-            provider: "local",
-            protocol: "local",
-            strategyObject: "Strategy",
-            strategyPackage: "passport-local",
-            clientID: "false",
-            clientSecret: "false",
-            scope: [],
-            fields: null,
-            urlCallback: "http://localhost/callback/users/auth/local-strategy-1/callback",
-        });
-        async.eachSeries([domainIn], (domain, seriesCallback) => {
-            console.log(`================> Processing domain ${domain.id} ${process.env.STAGING_SETUP ? "staging" : "production"}`);
-            let callbackDomainName;
-            if (process.env.STAGING_SETUP) {
-                if (domain.domain_name === "betrireykjavik.is") {
-                    callbackDomainName = "betri." + domain.domain_name;
-                }
-                else if (domain.domain_name === "betraisland.is") {
-                    callbackDomainName = "betra." + domain.domain_name;
-                }
-                else if (domain.domain_name === "yrpri.org") {
-                    callbackDomainName = "beta." + domain.domain_name;
-                }
-                else {
-                    callbackDomainName = domain.domain_name;
-                }
-            }
-            else {
-                if (domain.domain_name === "forbrukerradet.no") {
-                    callbackDomainName = "mineideer." + domain.domain_name;
-                }
-                else if (domain.domain_name === "parliament.scot") {
-                    callbackDomainName = "engage." + domain.domain_name;
-                }
-                else if (domain.domain_name === "engage-southampton.ac.uk") {
-                    callbackDomainName = "scca-online." + domain.domain_name;
-                }
-                else if (domain.domain_name === "boliden.com") {
-                    callbackDomainName = "sidtjarn." + domain.domain_name;
-                }
-                else if (domain.domain_name === "multicitychallenge.org" &&
-                    process.env.US_CLUSTER != null) {
-                    callbackDomainName = "ideas." + domain.domain_name;
-                }
-                else if (domain.domain_name === "multicitychallenge.org") {
-                    callbackDomainName = "yp." + domain.domain_name;
-                }
-                else if (domain.domain_name === "mycitychallenge.org") {
-                    callbackDomainName = "ideas." + domain.domain_name;
-                }
-                else if (domain.domain_name === "engagebritain.org") {
-                    callbackDomainName = "socialcare." + domain.domain_name;
-                }
-                else if (process.env.LOGIN_CALLBACK_CUSTOM_HOSTNAME) {
-                    console.log("Using custom login back name", {
-                        custom: process.env.LOGIN_CALLBACK_CUSTOM_HOSTNAME,
-                    });
-                    callbackDomainName =
-                        process.env.LOGIN_CALLBACK_CUSTOM_HOSTNAME +
-                            "." +
-                            domain.domain_name;
-                }
-                else {
-                    if (domain.domain_name === "betrireykjavik.is") {
-                        callbackDomainName = domain.domain_name;
-                    }
-                    else if (domain.domain_name === "betraisland.is") {
-                        callbackDomainName = domain.domain_name;
-                    }
-                    else {
-                        callbackDomainName = "login." + domain.domain_name;
-                    }
-                }
-            }
-            console.log(`Checking facebook keys for domain ${domain.id}`);
-            if (domain.secret_api_keys &&
-                domain.secret_api_keys.facebook &&
-                checkValidKeys(domain.secret_api_keys.facebook)) {
-                providers.push({
-                    name: "facebook-strategy-" + domain.id,
-                    provider: "facebook",
-                    protocol: "oauth2",
-                    strategyObject: "Strategy",
-                    strategyPackage: "passport-facebook",
-                    clientID: domain.secret_api_keys.facebook.client_id,
-                    clientSecret: domain.secret_api_keys.facebook.client_secret,
-                    scope: ["email"],
-                    fields: ["id", "displayName", "email"],
-                    // urlCallback     : 'http://fbtest.betrireykjavik.is:4242/api/users/auth/facebook/callback'
-                    urlCallback: "https://" +
-                        callbackDomainName +
-                        "/api/users/auth/facebook/callback",
-                });
-            }
-            console.log(`Checking oidc keys for domain ${domain.id}`);
-            //console.log(JSON.stringify(domain.secret_api_keys, null, 2));
-            //callbackDomainName = "betrireykjavik.is";
-            if (domain.secret_api_keys &&
-                domain.secret_api_keys.oidc &&
-                checkValidKeys(domain.secret_api_keys.oidc)) {
-                console.log(`---------------------> OIDC keys found for domain ${domain.id}`);
-                providers.push({
-                    name: "oidc-strategy-" + domain.id,
-                    provider: "oidc",
-                    protocol: "oidc",
-                    strategyObject: "Strategy",
-                    strategyPackage: "passport-openidconnect",
-                    clientID: domain.secret_api_keys.oidc.client_id,
-                    clientSecret: domain.secret_api_keys.oidc.client_secret,
-                    issuer: domain.secret_api_keys.oidc.issuer,
-                    authorizationURL: domain.secret_api_keys.oidc.authorizationURL,
-                    tokenURL: domain.secret_api_keys.oidc.tokenURL,
-                    userInfoURL: domain.secret_api_keys.oidc.userInfoURL,
-                    callbackUrl: "https://" +
-                        callbackDomainName +
-                        "/api/users/auth/audkenni/callback",
-                    scope: ["openid"],
-                    urlCallback: "https://" +
-                        callbackDomainName +
-                        "/api/users/auth/audkenni/callback",
-                });
-            }
-            if (domain.secret_api_keys &&
-                domain.secret_api_keys.saml &&
-                domain.secret_api_keys.saml.entryPoint &&
-                domain.secret_api_keys.saml.entryPoint !== "" &&
-                domain.secret_api_keys.saml.entryPoint.length > 6) {
-                providers.push({
-                    name: "saml-strategy-" + domain.id,
-                    provider: "saml",
-                    protocol: "saml",
-                    strategyObject: "Strategy",
-                    strategyPackage: "passport-saml",
-                    certInPemFormat: true,
-                    audience: req.hostname,
-                    issuer: domain.secret_api_keys.saml.issuer
-                        ? domain.secret_api_keys.saml.issuer
-                        : null,
-                    entryPoint: domain.secret_api_keys.saml.entryPoint,
-                    identifierFormat: domain.secret_api_keys.saml.identifierFormat
-                        ? domain.secret_api_keys.saml.identifierFormat
-                        : undefined,
-                    cert: domain.secret_api_keys.saml.cert
-                        ? domain.secret_api_keys.saml.cert
-                        : null,
-                    callbackUrl: domain.secret_api_keys.saml.callbackUrl &&
-                        domain.secret_api_keys.saml.callbackUrl !== ""
-                        ? domain.secret_api_keys.saml.callbackUrl
-                        : null,
-                });
-            }
-            seriesCallback();
-        }, (error) => {
-            callback(error, providers);
-        });
-    };
-    Domain.getLoginHosts = (domainIn, callback) => {
-        const hosts = [];
-        hosts.push("127.0.0.1");
-        hosts.push("localhost");
-        async.eachSeries([domainIn], (domain, seriesCallback) => {
-            hosts.push(domain.domain_name);
-            seriesCallback();
-        }, (error) => {
-            callback(error, hosts);
-        });
-    };
-    Domain.setYpDomain = (req, res, next) => {
-        let domainName;
-        const parsedDomain = parseDomain(req.headers.host);
-        if (parsedDomain && parsedDomain.domain) {
-            if (parsedDomain.subdomain.indexOf(".") > -1) {
-                let subdomain = parsedDomain.subdomain.split(".")[parsedDomain.subdomain.split(".").length - 1];
-                domainName =
-                    subdomain + "." + parsedDomain.domain + "." + parsedDomain.tld;
-            }
-            else {
-                domainName = parsedDomain.domain + "." + parsedDomain.tld;
-            }
-        }
-        else if (parsedDomain) {
-            domainName = parsedDomain.tld;
-        }
-        else {
-            domainName = "localhost";
-        }
-        if (process.env.CREATE_NEW_DOMAINS_ON_DEMAND) {
-            sequelize.models.Domain.findOrCreate({
-                where: { domain_name: domainName },
-                defaults: {
-                    access: sequelize.models.Domain.ACCESS_PUBLIC,
-                    default_locale: "en",
-                    name: "New Domain",
-                    configuration: {},
-                    user_agent: req.useragent.source,
-                    ip_address: req.clientIp,
-                },
-            })
-                .then((results) => {
-                const [domain, created] = results;
-                if (created) {
-                    log.info("Domain Created", {
-                        domain: toJson(domain.simple()),
-                        context: "create",
-                    });
-                    queue.add("process-similarities", { type: "update-collection", domainId: domain.id }, "low");
-                }
-                else {
-                    //log.info('Domain Loaded', { domain: toJson(domain.simple()), context: 'create' });
-                }
-                req.ypDomain = domain;
-                if (req.url.indexOf("/auth") > -1 ||
-                    req.url.indexOf("/login") > -1 ||
-                    req.url.indexOf("saml_assertion") > -1) {
-                    sequelize.models.Domain.getLoginProviders(req, domain, (error, providers) => {
-                        req.ypDomain.loginProviders = providers;
-                        sequelize.models.Domain.getLoginHosts(domain, (error, hosts) => {
-                            req.ypDomain.loginHosts = hosts;
-                            next();
-                        });
-                    });
-                }
-                else {
-                    next();
-                }
-            })
-                .catch((error) => {
-                next(error);
-            });
-        }
-        else {
-            sequelize.models.Domain.findOne({
-                where: { domain_name: domainName },
-            })
-                .then((domain) => {
-                if (domain) {
-                    req.ypDomain = domain;
-                    if (req.url.indexOf("/auth") > -1 ||
-                        req.url.indexOf("/login") > -1 ||
-                        req.url.indexOf("saml_assertion") > -1) {
-                        sequelize.models.Domain.getLoginProviders(req, domain, (error, providers) => {
-                            req.ypDomain.loginProviders = providers;
-                            sequelize.models.Domain.getLoginHosts(domain, (error, hosts) => {
-                                req.ypDomain.loginHosts = hosts;
-                                next();
-                            });
-                        });
-                    }
-                    else {
-                        next();
-                    }
-                }
-                else {
-                    next(`Domain ${domainName} not found`);
-                }
-            })
-                .catch((error) => {
-                next(error);
-            });
-        }
-    };
-    Domain.extractDomain = (url) => {
-        let domain, host, dot;
-        domain = url.split(":")[0];
-        if (!Domain.isIpAddress(domain)) {
-            if ((domain.match(/./g) || []).length > 1) {
-                dot = domain.indexOf(".");
-                domain = domain.substring(dot + 1, domain.length);
-            }
-        }
-        return domain;
-    };
-    Domain.extractHost = (url) => {
-        let domain, host, dot;
-        domain = url.split(":")[0];
-        if (!Domain.isIpAddress(domain)) {
-            if ((domain.match(/./g) || []).length > 1) {
-                domain = url.split(":")[0];
-                dot = domain.indexOf(".");
-                host = domain.substring(0, dot);
-                return host;
-            }
-        }
-        return null;
-    };
-    Domain.isIpAddress = (domain) => {
-        if (/^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(domain)) {
-            return true;
-        }
-        else {
-            return false;
-        }
-    };
-    Domain.prototype.simple = function () {
-        return { id: this.id, name: this.name, domain_name: this.domain_name };
-    };
-    Domain.prototype.ensureApiKeySetup = function () {
-        if (!this.secret_api_keys) {
-            this.secret_api_keys = {
-                facebook: {},
-                google: {},
-                github: {},
-                twitter: {},
-            };
-        }
-    };
-    Domain.prototype.setupLogoImage = function (body, done) {
-        if (body.uploadedLogoImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedLogoImageId },
-            }).then((image) => {
-                if (image)
-                    this.addDomainLogoImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Domain.prototype.setupHeaderImage = function (body, done) {
-        if (body.uploadedHeaderImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedHeaderImageId },
-            }).then((image) => {
-                if (image)
-                    this.addDomainHeaderImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Domain.prototype.getImageFormatUrl = function (formatId) {
-        if (this.DomainLogoImages && this.DomainLogoImages.length > 0) {
-            const formats = JSON.parse(this.DomainLogoImages[this.DomainLogoImages.length - 1].formats);
-            if (formats && formats.length > 0)
-                return formats[formatId];
-        }
-        else {
-            return "";
-        }
-    };
-    Domain.prototype.setupImages = function (body, done) {
-        async.parallel([
-            (callback) => {
-                this.setupLogoImage(body, (err) => {
-                    callback(err);
-                });
-            },
-            (callback) => {
-                this.setupHeaderImage(body, (err) => {
-                    callback(err);
-                });
-            },
-        ], (err) => {
-            done(err);
-        });
-    };
-    return Domain;
-};

package/dist/models/endorsement.cjs

@@ -1,39 +0,0 @@
-"use strict";
-module.exports = function (sequelize, DataTypes) {
-    const Endorsement = sequelize.define("Endorsement", {
-        value: { type: DataTypes.INTEGER, allowNull: false },
-        status: { type: DataTypes.STRING, allowNull: false },
-        ip_address: { type: DataTypes.STRING, allowNull: false },
-        user_agent: { type: DataTypes.TEXT, allowNull: false },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        data: { type: DataTypes.JSONB, allowNull: true }
-    }, {
-        underscored: true,
-        tableName: 'endorsements',
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        indexes: [
-            {
-                fields: ['user_id', 'post_id'],
-                where: {
-                    deleted: false
-                }
-            },
-            {
-                fields: ['user_id', 'deleted']
-            }
-        ],
-        classMethods: {}
-    });
-    Endorsement.associate = (models) => {
-        Endorsement.belongsTo(models.Post, { foreignKey: 'post_id' });
-        Endorsement.belongsTo(models.User, { foreignKey: 'user_id' });
-    };
-    return Endorsement;
-};

package/dist/models/general_data_store.cjs

@@ -1,20 +0,0 @@
-"use strict";
-module.exports = function (sequelize, DataTypes) {
-    const GeneralDataStore = sequelize.define("GeneralDataStore", {
-        data: DataTypes.JSONB
-    }, {
-        indexes: [
-            {
-                fields: ['data'],
-                using: 'gin',
-                operator: 'jsonb_path_ops'
-            }
-        ],
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        underscored: true,
-        tableName: 'general_data_store'
-    });
-    return GeneralDataStore;
-};