@yrpri/api 9.0.101 → 9.0.103

package/dist/models/user.cjs

@@ -0,0 +1,604 @@
+"use strict";
+const async = require("async");
+const log = require('../utils/logger.cjs');
+const toJson = require('../utils/to_json.cjs');
+const _ = require('lodash');
+const bcrypt = require('bcrypt');
+module.exports = (sequelize, DataTypes) => {
+    const User = sequelize.define("User", {
+        name: { type: DataTypes.STRING, allowNull: false },
+        email: { type: DataTypes.STRING, allowNull: true },
+        status: { type: DataTypes.STRING, allowNull: false },
+        ssn: DataTypes.STRING,
+        age_group: DataTypes.STRING,
+        post_code: DataTypes.STRING,
+        my_gender: DataTypes.STRING,
+        description: DataTypes.TEXT,
+        profile_data: DataTypes.JSONB,
+        private_profile_data: DataTypes.JSONB,
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+        facebook_id: DataTypes.BIGINT,
+        facebook_profile: DataTypes.JSONB,
+        twitter_id: DataTypes.BIGINT,
+        twitter_profile: DataTypes.JSONB,
+        google_id: DataTypes.BIGINT,
+        google_profile: DataTypes.JSONB,
+        github_id: DataTypes.BIGINT,
+        github_profile: DataTypes.JSONB,
+        buddy_icon_file_name: DataTypes.STRING,
+        twitter_profile_image_url: DataTypes.STRING,
+        encrypted_password: DataTypes.STRING,
+        default_locale: DataTypes.STRING,
+        reset_password_token: DataTypes.STRING,
+        reset_password_expires: DataTypes.DATE,
+        notifications_settings: { type: DataTypes.JSONB },
+        interaction_profile: DataTypes.JSONB,
+        counter_login: { type: DataTypes.INTEGER, defaultValue: 0 },
+        last_login_at: DataTypes.DATE,
+        social_points: DataTypes.INTEGER,
+        legacy_user_id: DataTypes.INTEGER,
+        legacy_new_domain_id: DataTypes.INTEGER,
+        theme_id: { type: DataTypes.INTEGER, defaultValue: null },
+        legacy_passwords_disabled: { type: DataTypes.BOOLEAN, defaultValue: false },
+        privacy_settings: DataTypes.JSONB,
+        ignore_list: DataTypes.JSONB
+    }, {
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'users',
+        defaultScope: {
+            where: {
+                deleted: false,
+                status: 'active'
+            }
+        },
+        indexes: [
+            {
+                unique: true,
+                fields: ['email']
+            },
+            {
+                name: 'users_idx_deleted_status',
+                fields: ['deleted', 'status']
+            },
+            {
+                fields: ['interaction_profile'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                fields: ['ssn']
+            },
+            {
+                fields: ['facebook_id']
+            },
+            {
+                fields: ['notifications_settings'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                fields: ['id', 'deleted']
+            },
+            {
+                fields: ['id', 'deleted', 'status']
+            }
+        ],
+    });
+    User.associate = (models) => {
+        User.hasMany(models.Post);
+        User.hasMany(models.Point);
+        User.hasMany(models.Endorsement);
+        User.hasMany(models.PointQuality);
+        User.hasMany(models.UserLegacyPassword);
+        User.belongsToMany(models.Group, { as: 'GroupUsers', through: 'GroupUser' });
+        User.belongsToMany(models.Community, { as: 'CommunityUsers', through: 'CommunityUser' });
+        User.belongsToMany(models.Domain, { as: 'DomainUsers', through: 'DomainUser' });
+        User.belongsToMany(models.Image, { as: 'UserProfileImages', through: 'UserProfileImage' });
+        User.belongsToMany(models.Image, { as: 'UserHeaderImages', through: 'UserHeaderImage' });
+        User.belongsToMany(models.Domain, { as: 'DomainAdmins', through: 'DomainAdmin' });
+        User.belongsToMany(models.Community, { as: 'CommunityAdmins', through: 'CommunityAdmin' });
+        User.belongsToMany(models.Community, { as: 'CommunityPromoters', through: 'CommunityPromoter' });
+        User.belongsToMany(models.Group, { as: 'GroupAdmins', through: 'GroupAdmin' });
+        User.belongsToMany(models.Group, { as: 'GroupPromoters', through: 'GroupPromoter' });
+        User.belongsToMany(models.Organization, { as: 'OrganizationAdmins', through: 'OrganizationAdmin' });
+        User.belongsToMany(models.Organization, { as: 'OrganizationUsers', through: 'OrganizationUser' });
+        User.belongsToMany(models.Video, { as: 'UserProfileVideos', through: 'UserProfileVideo' });
+        User.hasMany(models.Campaign);
+    };
+    User.defaultAttributesWithSocialMedia = ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'github_id', 'twitter_id', 'default_locale', 'legacy_passwords_disabled'];
+    User.defaultAttributesWithSocialMediaPublic = ['id', 'description', 'name', 'facebook_id', 'google_id', 'github_id', 'twitter_id', 'legacy_passwords_disabled'];
+    User.defaultAttributesWithSocialMediaPublicAndEmail = ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'github_id', 'twitter_id', 'legacy_passwords_disabled'];
+    User.serializeSamlUser = (profile, req, callback) => {
+        log.info("Serialize SAML user", { context: 'serializeSamlUser', profile: profile });
+        if (profile.UserSSN) {
+            sequelize.models.User.serializeIslandIsSamlUser(profile, callback);
+        }
+        else if (profile["urn:mynj:userCode"] || profile.issuer === 'https://my.state.nj.us/idp/shibboleth') {
+            sequelize.models.User.serializeMyNJSamlUser(profile, req, callback);
+        }
+        else {
+            callback("Can't find SAML serialize handler");
+        }
+    };
+    User.serializeMyNJSamlUser = (profile, req, callback) => {
+        log.info("User Serialized In Serialize MyNJ SAML User", { context: 'serializeSamlUser', profile: profile });
+        let email = null;
+        let user;
+        async.series([
+            (seriesCallback) => {
+                if (!profile["urn:mynj:userCode"] ||
+                    (req.ypDomain.configuration &&
+                        req.ypDomain.configuration.forceSecureSamlEmployeeLogin &&
+                        !profile["urn:mynj:pubEmpAgency"])) {
+                    log.info("User not allowed access through MyNJ", { context: 'serializeSamlUser', profile: profile });
+                    seriesCallback("customError");
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+            (seriesCallback) => {
+                sequelize.models.User.findOne({
+                    where: {
+                        ssn: profile["urn:mynj:userCode"]
+                    },
+                    attributes: ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'profile_data', 'github_id', 'twitter_id', 'ssn', 'legacy_passwords_disabled']
+                }).then((userIn) => {
+                    if (userIn) {
+                        user = userIn;
+                        log.info("User Serialized Found MyNJ SAML User", { context: 'serializeSamlUser', userSsn: user.ssn });
+                        seriesCallback();
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (!user) {
+                    email = profile["urn:mynj:pubEmpEmail"];
+                    if (email) {
+                        email = email.toLowerCase();
+                        sequelize.models.User.findOne({
+                            where: {
+                                email: email
+                            },
+                            attributes: ['id', 'email']
+                        }).then((userByEmail) => {
+                            if (userByEmail) {
+                                email = 'my-nj-' + Math.floor(Math.random() * 999) + '.' + email;
+                            }
+                            seriesCallback();
+                        }).catch((error) => {
+                            seriesCallback(error);
+                        });
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+            (seriesCallback) => {
+                if (!user) {
+                    sequelize.models.User.create({
+                        ssn: profile["urn:mynj:userCode"],
+                        name: profile.FirstName + ' ' + profile.LastName,
+                        email: email,
+                        profile_data: {
+                            saml_show_confirm_email_completed: email ? false : true,
+                        },
+                        private_profile_data: {
+                            saml_agency: profile["urn:mynj:pubEmpAgency"],
+                            saml_provider: 'MyNJ'
+                        },
+                        notifications_settings: sequelize.models.AcNotification.defaultNotificationSettings,
+                        status: 'active'
+                    }).then((userIn) => {
+                        if (userIn) {
+                            user = userIn;
+                            log.info("User Serialized Created MyNJ SAML User", { context: 'serializeSamlUser', userSsn: user.ssn });
+                            seriesCallback();
+                        }
+                        else {
+                            seriesCallback("Could not create user from SAML");
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        ], (error) => {
+            if (error) {
+                callback(error);
+            }
+            else {
+                callback(null, user);
+            }
+        });
+    };
+    User.serializeIslandIsSamlUser = (profile, callback) => {
+        log.info("User Serialized In Serialize IslandIs SAML User", { context: 'serializeSamlUser', profile: profile });
+        let user;
+        async.series([
+            (seriesCallback) => {
+                sequelize.models.User.findOne({
+                    where: {
+                        ssn: profile.UserSSN
+                    },
+                    attributes: ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'profile_data', 'github_id', 'twitter_id', 'ssn', 'legacy_passwords_disabled']
+                }).then((userIn) => {
+                    if (userIn) {
+                        user = userIn;
+                        log.info("User Serialized Found IslandIs SAML User", { context: 'serializeSamlUser', userSsn: user.ssn });
+                        seriesCallback();
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (!user) {
+                    sequelize.models.User.create({
+                        ssn: profile.UserSSN,
+                        name: profile.Name,
+                        private_profile_data: { saml_provider: 'island.is' },
+                        notifications_settings: sequelize.models.AcNotification.defaultNotificationSettings,
+                        status: 'active'
+                    }).then((userIn) => {
+                        if (userIn) {
+                            user = userIn;
+                            log.info("User Serialized Created IslandIs SAML User", { context: 'serializeSamlUser', userSsn: user.ssn });
+                            seriesCallback();
+                        }
+                        else {
+                            seriesCallback("Could not create user from SAML");
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        ], (error) => {
+            if (error) {
+                callback(error);
+            }
+            else {
+                callback(null, user);
+            }
+        });
+    };
+    User.serializeOidcUser = (profile, req, callback) => {
+        log.info("User Serialized In Serialize OIDC User", { context: 'serializeOidcUser', profile: profile });
+        let user;
+        async.series([
+            (seriesCallback) => {
+                sequelize.models.User.findOne({
+                    where: {
+                        ssn: profile.nationalRegisterId
+                    },
+                    attributes: ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'profile_data', 'github_id', 'twitter_id', 'ssn', 'legacy_passwords_disabled']
+                }).then((userIn) => {
+                    if (userIn) {
+                        user = userIn;
+                        log.info("User Serialized Found OIDC User", { context: 'serializeOidcUser', userSsn: user.ssn });
+                        seriesCallback();
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (!user) {
+                    sequelize.models.User.create({
+                        ssn: profile.nationalRegisterId,
+                        name: profile.name,
+                        private_profile_data: { oidc_provider: "oidc" },
+                        notifications_settings: sequelize.models.AcNotification.defaultNotificationSettings,
+                        status: 'active'
+                    }).then((userIn) => {
+                        if (userIn) {
+                            user = userIn;
+                            log.info("User Serialized Created OIDC User", { context: 'serializeOidcUser', userSsn: user.ssn });
+                            seriesCallback();
+                        }
+                        else {
+                            seriesCallback("Could not create user from OIDC");
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        ], (error) => {
+            if (error) {
+                callback(error);
+            }
+            else {
+                callback(null, user);
+            }
+        });
+    };
+    User.serializeFacebookUser = (profile, domain, callback) => {
+        let user;
+        async.series([
+            (seriesCallback) => {
+                sequelize.models.User.findOne({
+                    where: {
+                        facebook_id: profile.identifier
+                    },
+                    attributes: ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'github_id', 'twitter_id', 'legacy_passwords_disabled']
+                }).then((userIn) => {
+                    if (userIn) {
+                        user = userIn;
+                        seriesCallback();
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (!user && profile.email) {
+                    sequelize.models.User.findOne({
+                        where: {
+                            email: profile.email
+                        },
+                        attributes: ['id', 'email', 'description', 'name', 'facebook_id', 'google_id', 'github_id', 'twitter_id', 'legacy_passwords_disabled']
+                    }).then((userIn) => {
+                        if (userIn) {
+                            userIn.facebook_id = profile.identifier;
+                            userIn.save().then((results) => {
+                                user = userIn;
+                                seriesCallback();
+                            });
+                        }
+                        else {
+                            seriesCallback();
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+            (seriesCallback) => {
+                if (!user) {
+                    sequelize.models.User.create({
+                        email: profile.email,
+                        facebook_id: profile.identifier,
+                        name: profile.nameDisplay,
+                        notifications_settings: sequelize.models.AcNotification.defaultNotificationSettings,
+                        status: 'active'
+                    }).then((userIn) => {
+                        if (userIn) {
+                            user = userIn;
+                            seriesCallback();
+                        }
+                        else {
+                            seriesCallback("Could not create user");
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        ], (error) => {
+            if (error) {
+                callback(error);
+            }
+            else {
+                callback(null, user);
+            }
+        });
+    };
+    User.localCallback = (req, email, password, done) => {
+        sequelize.models.User.findOne({
+            where: { email: email },
+            attributes: ['id', 'encrypted_password', 'legacy_passwords_disabled']
+        }).then((user) => {
+            if (user) {
+                user.validatePassword(password, done);
+            }
+            else {
+                log.warn("User LocalStrategy Incorrect username", { context: 'localStrategy', user: toJson(user), err: 'Incorrect username', errorStatus: 401 });
+                return done(null, false, { message: 'Incorrect username.' });
+            }
+            return null;
+        }).catch((error) => {
+            log.error("User LocalStrategy Error", { context: 'localStrategy', err: error, errorStatus: 500 });
+            done(error);
+        });
+    };
+    User.getUserWithAll = (userId, callback) => {
+        let user, endorsements, pointQualities;
+        async.parallel([
+            (seriesCallback) => {
+                sequelize.models.User.findOne({
+                    where: { id: userId },
+                    attributes: _.concat(sequelize.models.User.defaultAttributesWithSocialMediaPublic, ['notifications_settings', 'profile_data', 'email', 'default_locale']),
+                    order: [
+                        [{ model: sequelize.models.Image, as: 'UserProfileImages' }, 'created_at', 'asc'],
+                        [{ model: sequelize.models.Image, as: 'UserHeaderImages' }, 'created_at', 'asc']
+                    ],
+                    include: [
+                        {
+                            model: sequelize.models.Image, as: 'UserProfileImages',
+                            attributes: ['id', 'created_at', 'formats'],
+                            required: false
+                        },
+                        {
+                            model: sequelize.models.Image, as: 'UserHeaderImages',
+                            attributes: ['id', 'created_at', 'formats'],
+                            required: false
+                        }
+                    ]
+                }).then((userIn) => {
+                    user = userIn;
+                    seriesCallback();
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                sequelize.models.Endorsement.findAll({
+                    where: { user_id: userId },
+                    attributes: ['id', 'value', 'post_id']
+                }).then((endorsementsIn) => {
+                    endorsements = endorsementsIn;
+                    seriesCallback();
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                sequelize.models.PointQuality.findAll({
+                    where: { user_id: userId },
+                    attributes: ['id', 'value', 'point_id']
+                }).then((pointQualitiesIn) => {
+                    pointQualities = pointQualitiesIn;
+                    seriesCallback();
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            }
+        ], (error) => {
+            if (user) {
+                user.dataValues.Endorsements = endorsements;
+                user.dataValues.PointQualities = pointQualities;
+            }
+            callback(error, user);
+        });
+    };
+    User.prototype.simple = function () {
+        return { id: this.id, name: this.name, email: this.email };
+    };
+    User.prototype.setLocale = function (i18n, domain, community, done) {
+        if (this.default_locale && this.default_locale !== "") {
+            i18n.changeLanguage(this.default_locale, (err, t) => {
+                done();
+            });
+        }
+        else if (community && community.default_locale && community.default_locale !== "") {
+            i18n.changeLanguage(community.default_locale, (err, t) => {
+                done();
+            });
+        }
+        else {
+            i18n.changeLanguage(domain.default_locale, (err, t) => {
+                done();
+            });
+        }
+    };
+    User.prototype.setupProfileImage = function (body, done) {
+        if (body.uploadedProfileImageId) {
+            sequelize.models.Image.findOne({
+                where: { id: body.uploadedProfileImageId }
+            }).then((image) => {
+                if (image)
+                    this.addUserProfileImage(image);
+                done();
+            });
+        }
+        else
+            done();
+    };
+    User.prototype.setupHeaderImage = function (body, done) {
+        if (body.uploadedHeaderImageId) {
+            sequelize.models.Image.findOne({
+                where: { id: body.uploadedHeaderImageId }
+            }).then((image) => {
+                if (image)
+                    this.addUserHeaderImage(image);
+                done();
+            });
+        }
+        else
+            done();
+    };
+    User.prototype.setupImages = function (body, done) {
+        async.parallel([
+            (callback) => {
+                this.setupProfileImage(body, (err) => {
+                    if (err)
+                        return callback(err);
+                    callback();
+                });
+            },
+            (callback) => {
+                this.setupHeaderImage(body, (err) => {
+                    if (err)
+                        return callback(err);
+                    callback();
+                });
+            }
+        ], (err) => {
+            done(err);
+        });
+    };
+    User.prototype.createPasswordHash = function (password) {
+        const salt = bcrypt.genSaltSync(10);
+        this.encrypted_password = bcrypt.hashSync(password, salt);
+    };
+    User.prototype.validatePassword = function (password, done) {
+        let verified = this.encrypted_password ? bcrypt.compareSync(password, this.encrypted_password) : null;
+        if (verified) {
+            console.log(`User ${this.id} has verified password`);
+            done(null, this);
+        }
+        else {
+            if (this.legacy_passwords_disabled) {
+                done(null, false, { message: 'Incorrect password.' });
+            }
+            else {
+                log.warn("Looking for legacy passwords");
+                sequelize.models.User.findOne({
+                    where: { id: this.id },
+                    include: [sequelize.models.UserLegacyPassword]
+                }).then((user) => {
+                    user.UserLegacyPasswords.map((legacyPassword) => {
+                        if (bcrypt.compareSync(password, legacyPassword.encrypted_password)) {
+                            verified = true;
+                        }
+                    });
+                    if (verified) {
+                        done(null, this);
+                    }
+                    else {
+                        done(null, false, { message: 'Incorrect password.' });
+                    }
+                });
+            }
+        }
+    };
+    return User;
+};

package/dist/models/user_legacy_password.cjs

@@ -0,0 +1,13 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const UserLegacyPassword = sequelize.define("UserLegacyPassword", {
+        encrypted_password: { type: DataTypes.STRING, allowNull: false }
+    }, {
+        underscored: true,
+        tableName: 'user_legacy_passwords'
+    });
+    UserLegacyPassword.associate = (models) => {
+        UserLegacyPassword.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    return UserLegacyPassword;
+};