@yrpri/api 9.0.101 → 9.0.103

package/dist/models/index.cjs

@@ -0,0 +1,186 @@
+"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

@@ -0,0 +1,48 @@
+"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

@@ -0,0 +1,16 @@
+"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

@@ -0,0 +1,122 @@
+"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

@@ -0,0 +1,273 @@
+"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;
+};