@yrpri/api 9.0.103 → 9.0.105

package/dist/models/index.cjs

@@ -1,186 +0,0 @@
-"use strict";
-const fs = require("fs");
-const path = require("path");
-const env = process.env.NODE_ENV || "development";
-const _ = require("lodash");
-const { Sequelize, DataTypes } = require("sequelize");
-let sequelize;
-const Op = Sequelize.Op;
-const operatorsAliases = {
-    $gt: Op.gt,
-    $gte: Op.gte,
-    $lt: Op.lt,
-    $lte: Op.lte,
-    $in: Op.in,
-    $and: Op.and,
-    $or: Op.or,
-    $eq: Op.eq,
-    $ne: Op.ne,
-    $is: Op.is,
-    $not: Op.not,
-    $between: Op.between,
-    $notBetween: Op.notBetween,
-    $like: Op.like,
-    $contains: Op.contains,
-    $any: Op.any,
-};
-if (process.env.NODE_ENV === "production") {
-    if (process.env.DISABLE_PG_SSL) {
-        sequelize = new Sequelize(process.env.DATABASE_URL, {
-            dialect: "postgres",
-            minifyAliases: true,
-            logging: false,
-            operatorsAliases: operatorsAliases,
-        });
-    }
-    else {
-        sequelize = new Sequelize(process.env.DATABASE_URL, {
-            dialect: "postgres",
-            dialectOptions: {
-                ssl: {
-                    rejectUnauthorized: false,
-                },
-            },
-            minifyAliases: true,
-            logging: false,
-            operatorsAliases: operatorsAliases,
-        });
-    }
-}
-else {
-    let config;
-    try {
-        sequelize = new Sequelize(process.env.YP_DEV_DATABASE_NAME, process.env.YP_DEV_DATABASE_USERNAME, process.env.YP_DEV_DATABASE_PASSWORD, {
-            dialect: "postgres",
-            protocol: "postgres",
-            host: process.env.YP_DEV_DATABASE_HOST,
-            port: process.env.YP_DEV_DATABASE_PORT,
-            minifyAliases: true,
-            dialectOptions: {
-                ssl: false,
-                rejectUnauthorized: false,
-            },
-            logging: false,
-            operatorsAliases: operatorsAliases,
-        });
-    }
-    catch (error) {
-        console.error("Error reading or parsing config file:", error);
-        process.exit(1);
-    }
-}
-const db = {};
-async function createCompoundIndexes(indexCommands) {
-    for (const command of indexCommands) {
-        try {
-            await sequelize.query(command);
-            console.log(`Successfully created index with command: ${command}`);
-        }
-        catch (error) {
-            if (error.message.indexOf("already exists") > -1) {
-                //console.log("already exists")
-            }
-            else {
-                console.error(`Error creating index with command: ${command}`);
-                console.error(error.message);
-            }
-        }
-    }
-}
-const compoundIndexCommands = [
-    `CREATE INDEX domainheaderimage_idx2_domain_id ON "DomainHeaderImage" (domain_id)`,
-    `CREATE INDEX domainlogoimage_idx2_domain_id ON "DomainLogoImage" (domain_id)`,
-    `CREATE INDEX domainlogovideo_idx2_domain_id ON "DomainLogoVideo" (domain_id)`,
-    `CREATE INDEX domainheaderimage_idx2_domain_id_u ON "DomainHeaderImage" (domain_id, updated_at)`,
-    `CREATE INDEX domainlogoimage_idx2_domain_id_u ON "DomainLogoImage" (domain_id, updated_at)`,
-    `CREATE INDEX domainlogovideo_idx2_domain_id_u ON "DomainLogoVideo" (domain_id, updated_at)`,
-    `CREATE INDEX domainheaderimage_idx2_domain_id_c ON "DomainHeaderImage" (domain_id, created_at)`,
-    `CREATE INDEX domainlogoimage_idx2_domain_id_c ON "DomainLogoImage" (domain_id, created_at)`,
-    `CREATE INDEX domainlogovideo_idx2_domain_id_c ON "DomainLogoVideo" (domain_id, created_at)`,
-    `CREATE INDEX communityheaderimage_idx2_community_id ON "CommunityHeaderImage" (community_id)`,
-    `CREATE INDEX communitylogoimage_idx2_community_id ON "CommunityLogoImage" (community_id)`,
-    `CREATE INDEX communitylogovideo_idx2_community_id ON "CommunityLogoVideo" (community_id)`,
-    `CREATE INDEX communityheaderimage_idx2_community_id_u ON "CommunityHeaderImage" (community_id, updated_at)`,
-    `CREATE INDEX communitylogoimage_idx2_community_id_u ON "CommunityLogoImage" (community_id, updated_at)`,
-    `CREATE INDEX communitylogovideo_idx2_community_id_u ON "CommunityLogoVideo" (community_id, updated_at)`,
-    `CREATE INDEX communityheaderimage_idx2_community_id_c ON "CommunityHeaderImage" (community_id, created_at)`,
-    `CREATE INDEX communitylogoimage_idx2_community_id_c ON "CommunityLogoImage" (community_id, created_at)`,
-    `CREATE INDEX communitylogovideo_idx2_community_id_c ON "CommunityLogoVideo" (community_id, created_at)`,
-    `CREATE INDEX groupheaderimage_idx2_group_id_u ON "GroupHeaderImage" (group_id, updated_at)`,
-    `CREATE INDEX grouplogoimage_idx2_group_id_u ON "GroupLogoImage" (group_id, updated_at)`,
-    `CREATE INDEX grouplogovideo_idx2_group_id_u ON "GroupLogoVideo" (group_id, updated_at)`,
-    `CREATE INDEX groupheaderimage_idx2_group_id_c ON "GroupHeaderImage" (group_id, created_at)`,
-    `CREATE INDEX grouplogoimage_idx2_group_id_c ON "GroupLogoImage" (group_id, created_at)`,
-    `CREATE INDEX grouplogovideo_idx2_group_id_c ON "GroupLogoVideo" (group_id, created_at)`,
-    `CREATE INDEX idx2_group_categories_name ON Categories (group_id, name)`,
-    `CREATE INDEX organizationlogoimag_idx_organization_id ON "OrganizationLogoImage" (organization_id)`,
-    `CREATE INDEX organizationlogoimag_idx_organization_id_u ON "OrganizationLogoImage" (organization_id, updated_at)`,
-    `CREATE INDEX organizationlogoimag_idx_organization_id_c ON "OrganizationLogoImage" (organization_id, created_at)`,
-    `CREATE INDEX organizationuser_idx2_user_id ON "OrganizationUser" (user_id)`,
-    `CREATE INDEX pointaudio_idx2_point_id ON "PointAudio" (point_id)`,
-    `CREATE INDEX pointvideo_idx2_point_id ON "PointVideo" (point_id)`,
-    `CREATE INDEX pointaudio_idx2_point_id_u ON "PointAudio" (point_id, updated_at)`,
-    `CREATE INDEX pointvideo_idx2_point_id_u ON "PointVideo" (point_id, updated_at)`,
-    `CREATE INDEX pointaudio_idx2_point_id_c ON "PointAudio" (point_id, created_at)`,
-    `CREATE INDEX pointvideo_idx2_point_id_c ON "PointVideo" (point_id, created_at)`,
-    `CREATE INDEX points_idx2_counter_sum_post_id_status_value_deleted ON points ((counter_quality_up-counter_quality_down), post_id, status, value, deleted)`,
-    `CREATE INDEX userprofileimage_idx2_user_id ON "UserProfileImage" (user_id)`,
-    `CREATE INDEX userprofileimage_idx2_user_id_u ON "UserProfileImage" (user_id, updated_at)`,
-    `CREATE INDEX userprofileimage_idx2_user_id_c ON "UserProfileImage" (user_id, created_at)`,
-    `CREATE INDEX categoryiconimage_idx2_category_id ON "CategoryIconImage" (category_id)`,
-    `CREATE INDEX idx2_category_icon_images ON "CategoryIconImage" (category_id, updated_at)`,
-    `CREATE INDEX idx2_category_icon_images_c ON "CategoryIconImage" (category_id, created_at)`,
-    `CREATE INDEX videoimage_idx2_video_id ON "VideoImage" (video_id)`,
-    `CREATE INDEX videoimage_idx2_video_id_u ON "VideoImage" (video_id, updated_at)`,
-    `CREATE INDEX videoimage_idx2_video_id_c ON "VideoImage" (video_id, created_at)`,
-    `CREATE INDEX postaudio_idx2_post_id ON "PostAudio" (post_id)`,
-    `CREATE INDEX postvideo_idx2_post_id ON "PostVideo" (post_id)`,
-    `CREATE INDEX postheaderimage_idx2_post_id ON "PostHeaderImage" (post_id)`,
-    `CREATE INDEX posimage_idx2_post_id ON "PostImage" (post_id)`,
-    `CREATE INDEX idx2_post_header_images_u ON "PostHeaderImage" (post_id, updated_at)`,
-    `CREATE INDEX idx2_post_images_u ON "PostImage" (post_id, updated_at)`,
-    `CREATE INDEX idx2_post_audios_u ON "PostAudio" (post_id, updated_at)`,
-    `CREATE INDEX idx2_post_videos_u ON "PostVideo" (post_id, updated_at)`,
-    `CREATE INDEX idx2_post_header_images_c ON "PostHeaderImage" (post_id, created_at)`,
-    `CREATE INDEX idx2_post_images_c ON "PostImage" (post_id, created_at)`,
-    `CREATE INDEX idx2_post_audios_c ON "PostAudio" (post_id, created_at)`,
-    `CREATE INDEX idx2_post_videos_c ON "PostVideo" (post_id, created_at)`,
-    `CREATE INDEX posts_idx2_counter_sum_group_id_deleted ON posts ((counter_endorsements_up-counter_endorsements_down),group_id,deleted)`,
-    `CREATE INDEX posts_idx2_counter_sum_group_id_category_id_deleted ON posts ((counter_endorsements_up-counter_endorsements_down),group_id,category_id,deleted)`,
-];
-// Read models from local folder
-fs.readdirSync(__dirname)
-    .filter((file) => {
-    return file.indexOf(".") !== 0 && file !== "index.cjs";
-})
-    .forEach((file) => {
-    const model = require(path.join(__dirname, file))(sequelize, DataTypes);
-    db[model.name] = model;
-});
-// Read from active citizen,
-const acDirname = __dirname + "/../active-citizen/models";
-fs.readdirSync(acDirname)
-    .filter((file) => {
-    return file.indexOf(".") !== 0;
-})
-    .forEach((file) => {
-    const model = require(path.join(acDirname, file))(sequelize, DataTypes);
-    db[model.name] = model;
-});
-Object.keys(db).forEach((modelName) => {
-    if ("associate" in db[modelName]) {
-        db[modelName].associate(db);
-    }
-});
-if (process.env.FORCE_DB_SYNC || process.env.NODE_ENV === "development") {
-    sequelize.sync().then(async () => {
-        await createCompoundIndexes(compoundIndexCommands);
-        db.Post.addFullTextIndex();
-    });
-}
-else if (process.env.FORCE_DB_INDEX_SYNC) {
-    createCompoundIndexes(compoundIndexCommands);
-}
-db.sequelize = sequelize;
-db.Sequelize = Sequelize;
-module.exports = db;

package/dist/models/invite.cjs

@@ -1,48 +0,0 @@
-"use strict";
-module.exports = function (sequelize, DataTypes) {
-    const Invite = sequelize.define("Invite", {
-        type: { type: DataTypes.INTEGER, allowNull: false },
-        expires_at: DataTypes.DATE,
-        token: DataTypes.STRING,
-        joined_at: DataTypes.DATE,
-        metadata: DataTypes.JSONB,
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
-    }, {
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        indexes: [
-            {
-                fields: ['token'],
-                where: {
-                    deleted: false
-                }
-            }
-        ],
-        underscored: true,
-        tableName: 'invites'
-    });
-    Invite.associate = (models) => {
-        Invite.belongsTo(models.Community, { foreignKey: 'community_id' });
-        Invite.belongsTo(models.Group, { foreignKey: 'group_id' });
-        Invite.belongsTo(models.Post, { foreignKey: 'post_id' });
-        Invite.belongsTo(models.User, { as: 'FromUser', foreignKey: "from_user_id" });
-        Invite.belongsTo(models.User, { as: 'ToUser', foreignKey: "to_user_id" });
-    };
-    Invite.INVITE_TO_GROUP = 0;
-    Invite.INVITE_TO_COMMUNITY = 1;
-    Invite.INVITE_TO_IDEA = 2;
-    Invite.INVITE_TO_FRIEND = 3;
-    Invite.INVITE_TO_COMMUNITY_AND_GROUP_AS_ANON = 4;
-    Invite.checkIfColumnExists = function (columnName) {
-        const a = this.rawAttributes;
-        const b = this.rawAttributes[columnName];
-        return this.rawAttributes[columnName] != null;
-    };
-    return Invite;
-};

package/dist/models/iso_country.cjs

@@ -1,16 +0,0 @@
-"use strict";
-module.exports = function (sequelize, DataTypes) {
-    const IsoCountry = sequelize.define("IsoCountry", {
-        code: DataTypes.STRING,
-        country_english_name: DataTypes.STRING
-    }, {
-        underscored: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        tableName: 'tr8n_iso_countries'
-    });
-    IsoCountry.associate = (models) => {
-        IsoCountry.hasMany(models.Group, { foreignKey: "iso_country_id" });
-    };
-    return IsoCountry;
-};

package/dist/models/organization.cjs

@@ -1,122 +0,0 @@
-"use strict";
-const async = require("async");
-module.exports = (sequelize, DataTypes) => {
-    const Organization = sequelize.define("Organization", {
-        name: { type: DataTypes.STRING, allowNull: false },
-        description: DataTypes.TEXT,
-        address: DataTypes.TEXT,
-        phone_number: DataTypes.STRING,
-        access: { type: DataTypes.INTEGER, allowNull: false }, // 0: public, 1: closed, 2: secret
-        status: { type: DataTypes.STRING, allowNull: false, defaultValue: 'active' },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        website: DataTypes.TEXT,
-        ip_address: { type: DataTypes.STRING, allowNull: false },
-        user_agent: { type: DataTypes.TEXT, allowNull: false },
-        weight: { type: DataTypes.INTEGER, defaultValue: 0 },
-        counter_users: { type: DataTypes.INTEGER, defaultValue: 0 },
-        theme_id: { type: DataTypes.INTEGER, defaultValue: 0 }
-    }, {
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        underscored: true,
-        indexes: [
-            {
-                name: 'organizations_idx_id_deleted',
-                fields: ['id', 'deleted']
-            },
-            {
-                name: 'organizations_idx_deleted',
-                fields: ['deleted']
-            }
-        ],
-        tableName: 'organizations',
-    });
-    Organization.associate = (models) => {
-        Organization.belongsTo(models.Domain, { foreignKey: 'domain_id' });
-        Organization.belongsTo(models.Community, { foreignKey: 'community_id' });
-        Organization.belongsTo(models.User, { foreignKey: 'user_id' });
-        Organization.belongsToMany(models.Image, { as: 'OrgLogoImgs', through: 'OrganizationLogoImage' });
-        Organization.belongsToMany(models.Image, { as: 'OrganizationHeaderImages', through: 'OrganizationHeaderImage' });
-        Organization.belongsToMany(models.User, { as: 'OrganizationUsers', through: 'OrganizationUser' });
-        Organization.belongsToMany(models.User, { as: 'OrganizationAdmins', through: 'OrganizationAdmin' });
-    };
-    Organization.ACCESS_PUBLIC = 0;
-    Organization.ACCESS_CLOSED = 1;
-    Organization.ACCESS_SECRET = 2;
-    Organization.convertAccessFromRadioButtons = (body) => {
-        let access = 0;
-        if (body.public) {
-            access = 0;
-        }
-        else if (body.closed) {
-            access = 1;
-        }
-        else if (body.secret) {
-            access = 2;
-        }
-        return access;
-    };
-    Organization.prototype.simple = function () {
-        return { id: this.id, name: this.name, hostname: this.hostname };
-    };
-    Organization.prototype.updateAllExternalCounters = function (req, direction, column, done) {
-        if (direction === 'up')
-            req.ypDomain.increment(column);
-        else if (direction === 'down')
-            req.ypDomain.decrement(column);
-        done();
-    };
-    Organization.prototype.setupLogoImage = function (body, done) {
-        if (body.uploadedLogoImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedLogoImageId }
-            }).then((image) => {
-                if (image)
-                    this.addOrganizationLogoImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Organization.prototype.setupHeaderImage = function (body, done) {
-        if (body.uploadedHeaderImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedHeaderImageId }
-            }).then((image) => {
-                if (image)
-                    this.addOrganizationHeaderImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Organization.prototype.setupImages = function (body, done) {
-        async.parallel([
-            (callback) => {
-                this.setupLogoImage(body, (err) => {
-                    if (err)
-                        return callback(err);
-                    callback();
-                });
-            },
-            (callback) => {
-                this.setupHeaderImage(body, (err) => {
-                    if (err)
-                        return callback(err);
-                    callback();
-                });
-            }
-        ], (err) => {
-            done(err);
-        });
-    };
-    return Organization;
-};

package/dist/models/page.cjs

@@ -1,273 +0,0 @@
-"use strict";
-const async = require('async');
-const _ = require('lodash');
-module.exports = (sequelize, DataTypes) => {
-    const Page = sequelize.define("Page", {
-        title: { type: DataTypes.JSONB, allowNull: false },
-        content: { type: DataTypes.JSONB, allowNull: false },
-        weight: { type: DataTypes.INTEGER, defaultValue: 0 },
-        published: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        legacy_page_id: DataTypes.INTEGER,
-        legacy_new_domain_id: DataTypes.INTEGER
-    }, {
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        indexes: [
-            {
-                fields: ['community_id'],
-                where: {
-                    deleted: false,
-                    published: true
-                }
-            },
-            {
-                fields: ['group_id'],
-                where: {
-                    deleted: false,
-                    published: true
-                }
-            },
-            {
-                fields: ['domain_id'],
-                where: {
-                    deleted: false,
-                    published: true
-                }
-            },
-            {
-                name: "community_id_only_deleted",
-                fields: ['community_id'],
-                where: {
-                    deleted: false
-                }
-            },
-            {
-                name: "group_id_only_deleted",
-                fields: ['group_id'],
-                where: {
-                    deleted: false
-                }
-            },
-            {
-                name: "domain_id_only_deleted",
-                fields: ['domain_id'],
-                where: {
-                    deleted: false
-                }
-            },
-            {
-                name: 'pages_idx_domain_id_published_deleted',
-                fields: ['domain_id', 'published', 'deleted']
-            },
-            {
-                name: 'pages_idx_community_id_published_deleted',
-                fields: ['community_id', 'published', 'deleted']
-            },
-            {
-                name: 'pages_idx_group_id_published_deleted',
-                fields: ['group_id', 'published', 'deleted']
-            }
-        ],
-        underscored: true,
-        tableName: 'pages'
-    });
-    Page.associate = (models) => {
-        Page.belongsTo(models.Domain, { foreignKey: 'domain_id' });
-        Page.belongsTo(models.Community, { foreignKey: 'community_id' });
-        Page.belongsTo(models.Group, { foreignKey: 'group_id' });
-        Page.belongsTo(models.User, { foreignKey: 'user_id' });
-    };
-    Page.getPagesForAdmin = (req, options, callback) => {
-        sequelize.models.Page.findAll({
-            where: options,
-            order: [["created_at", "asc"]]
-        }).then((pages) => {
-            callback(null, pages);
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.newPage = (req, options, callback) => {
-        sequelize.models.Page.create(options).then((results) => {
-            callback();
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.updatePageWeight = (req, options, callback) => {
-        sequelize.models.Page.findOne({ where: options }).then((page) => {
-            if (page) {
-                page.weight = req.body.weight;
-                page.save().then((results) => {
-                    callback();
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback("Not found");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.updatePageLocale = (req, options, callback) => {
-        sequelize.models.Page.findOne({ where: options }).then((page) => {
-            if (page) {
-                const content = {};
-                if (!page.content) {
-                    page.content = {};
-                }
-                if (!page.title) {
-                    page.title = {};
-                }
-                page.set('content.' + req.body.locale, req.body.content);
-                page.set('title.' + req.body.locale, req.body.title);
-                page.save({ fields: ['title', 'content'] }).then((results) => {
-                    callback();
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback("Not found");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.publishPage = (req, options, callback) => {
-        sequelize.models.Page.findOne({ where: options }).then((page) => {
-            if (page) {
-                page.published = true;
-                page.save().then((results) => {
-                    callback();
-                });
-            }
-            else {
-                callback("Not found");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.unPublishPage = (req, options, callback) => {
-        sequelize.models.Page.findOne({ where: options }).then((page) => {
-            if (page) {
-                page.published = false;
-                page.save().then((results) => {
-                    callback();
-                });
-            }
-            else {
-                callback("Not found");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.deletePage = (req, options, callback) => {
-        sequelize.models.Page.findOne({ where: options }).then((page) => {
-            if (page) {
-                page.deleted = true;
-                page.save().then((results) => {
-                    callback();
-                });
-            }
-            else {
-                callback("Not found");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Page.getPages = (req, options, callback) => {
-        let groupPages = [];
-        let communityPages = [];
-        let domainPages = [];
-        async.parallel([
-            (seriesCallback) => {
-                if (options.group_id) {
-                    sequelize.models.Page.findAll({
-                        where: {
-                            group_id: options.group_id,
-                            published: true
-                        },
-                        order: [
-                            ['weight', 'asc'],
-                            ['created_at', 'asc']
-                        ]
-                    }).then((pages) => {
-                        if (pages) {
-                            groupPages = groupPages.concat(pages);
-                        }
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            },
-            (seriesCallback) => {
-                if (options.community_id) {
-                    sequelize.models.Page.findAll({
-                        where: {
-                            community_id: options.community_id,
-                            published: true
-                        },
-                        order: [
-                            ['weight', 'asc'],
-                            ['created_at', 'asc']
-                        ]
-                    }).then((pages) => {
-                        if (pages) {
-                            communityPages = communityPages.concat(pages);
-                        }
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            },
-            (seriesCallback) => {
-                if (options.domain_id) {
-                    sequelize.models.Page.findAll({
-                        where: {
-                            domain_id: options.domain_id,
-                            published: true
-                        },
-                        order: [
-                            ['weight', 'asc'],
-                            ['created_at', 'asc']
-                        ]
-                    }).then((pages) => {
-                        if (pages) {
-                            domainPages = domainPages.concat(pages);
-                        }
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            }
-        ], (error) => {
-            callback(error, groupPages.concat(communityPages, domainPages));
-        });
-    };
-    return Page;
-};