cubash-archive/models/team_roles.js

let bcrypt = require('bcryptjs')
let randomColor = require('randomcolor')
var passportLocalSequelize = require('passport-local-sequelize');
let pagination = require('../lib/pagination.js')
const Errors = require('../lib/errors.js')
var crypto = require("crypto");
var cryptoRandomString = require("crypto-random-string");
module.exports = (sequelize, DataTypes) => {
    let TeamRoles = sequelize.define('TeamRoles', {
        name: {
            type: DataTypes.STRING,
            allowNull: false,
            validate: {
                isString(val) {
                    if (typeof val !== 'string') {
                        throw new sequelize.ValidationError('Team name must be a string')
                    }
                },
                len: {
                    args: [3, 30],
                    msg: 'Team name must be between 3 and 30 characters'
                }
            }
        },
        inviteUsers: {
            type: DataTypes.BOOLEAN,
            defaultValue: true
        },
        administrator: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        changeTeamMeta: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        changeTeamRoles: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        forumAdministrator: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        moderateForumThreads: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        changeTeamPrivacy: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        submitTeamItems: {
            type: DataTypes.BOOLEAN,
            defaultValue: false
        },
        priority: {
            type: DataTypes.BIGINT,
            default: 1,
            allowNull: false,
        },
        teamId: {
            type: DataTypes.BIGINT
        }
    }, {
        instanceMethods: {
            async getMeta (limit) {
                let Post = sequelize.models.Post
                let meta = {}

                let nextId = await pagination.getNextIdDesc(Post, { userId: this.id }, this.Posts)

                if(nextId === null) {
                    meta.nextURL = null
                    meta.nextPostsCount = 0
                } else {
                    meta.nextURL =
                        process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + `/` + `user/${this.username}?posts=true&limit=${limit}&from=${nextId - 1}`

                    meta.nextPostsCount = await pagination.getNextCount(
                        Post, this.Posts, limit,
                        { UserId: this.id },
                        true
                    )
                }

                return meta
            },
            async getWallMeta (limit) {
                let Post = sequelize.models.userWall
                let meta = {}

                let nextId = await pagination.getNextIdDesc(Post, { userId: this.id }, this.Posts)

                if(nextId === null) {
                    meta.nextURL = null
                    meta.nextPostsCount = 0
                } else {
                    meta.nextURL =
                        ``

                    meta.nextPostsCount = await pagination.getNextCount(
                        Post, this.Post, limit,
                        { Post: this.id },
                        true
                    )
                }

                return meta
            }
        },
        classMethods: {
            associate (models) {
               // TeamRoles.hasMany(models.User)
               // TeamRoles.hasMany(models.TeamMemberRole, { as: 'team'})
                TeamRoles.hasMany(models.Team)
                //TeamRoles.hasMany(models.Team, {as: 'team'})
            },
            includeOptions (from, limit) {
                let models = sequelize.models
                let options = models.Post.includeOptions()

                return [{
                    model: models.Post,
                    include: options,
                    limit,
                    where: { postNumber: { $gte: from } },
                    order: [['id', 'ASC']]
                }]
            },
            includeWallOptions (from, limit) {
                let models = sequelize.models

                return [{
                    model: models.userWall,
                    limit,
                    where: { postNumber: { $gte: from } },
                    order: [['id', 'ASC']]
                }]
            },
            async canBeUser (passkey) {
                let { User, PassKey } = sequelize.models

                if(User) {
                    if(PassKey) {
                        let passkey = await PassKey.findOne({ where: { passkey } })

                        if(passkey && PassKey.isValid()) {
                            await passkey.destroy()

                            return true
                        } else {
                            throw Errors.invalidPassKey
                        }
                    } else {
                        throw Errors.sequelizeValidation(sequelize, {
                            error: 'Invalid PassKey',
                            path: 'passkey'
                        })
                    }

                } else {
                    return true
                }
            }
        }
    })

    return TeamRoles
}