@yrpri/api 9.0.103 → 9.0.104

package/dist/models/audio.cjs

@@ -1,430 +0,0 @@
-"use strict";
-const log = require('../utils/logger.cjs');
-const aws = require('aws-sdk');
-const _ = require('lodash');
-const queue = require('../active-citizen/workers/queue.cjs');
-let bullAudioQueue;
-if (process.env.USE_YOUR_PRIORITIES_ENCODER) {
-    const Queue = require('bull');
-    const redisUrl = process.env.REDIS_URL ? process.env.REDIS_URL : undefined;
-    bullAudioQueue = new Queue('AudioEncoding', redisUrl);
-}
-module.exports = (sequelize, DataTypes) => {
-    const Audio = sequelize.define("Audio", {
-        name: DataTypes.STRING,
-        description: DataTypes.TEXT,
-        meta: DataTypes.JSONB,
-        public_meta: DataTypes.JSONB,
-        formats: DataTypes.JSONB,
-        listens: { type: DataTypes.BIGINT, defaultValue: 0 },
-        long_listens: { type: DataTypes.BIGINT, defaultValue: 0 },
-        user_id: DataTypes.INTEGER,
-        listenable: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        ip_address: { type: DataTypes.STRING, allowNull: false },
-        user_agent: { type: DataTypes.TEXT, allowNull: false },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
-    }, {
-        underscored: true,
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        tableName: 'audios',
-        defaultScope: {
-            where: {
-                deleted: false
-            },
-            order: [
-                ['created_at', 'asc']
-            ]
-        },
-        indexes: [
-            {
-                fields: ['meta'],
-                using: 'gin',
-                operator: 'jsonb_path_ops'
-            },
-            {
-                fields: ['public_meta'],
-                using: 'gin',
-                operator: 'jsonb_path_ops'
-            },
-            {
-                fields: ['formats'],
-                using: 'gin',
-                operator: 'jsonb_path_ops'
-            },
-            {
-                fields: ['user_id', 'listenable', 'deleted']
-            },
-            {
-                fields: ['id', 'deleted']
-            },
-            {
-                fields: ['updated_at', 'deleted']
-            },
-            {
-                fields: ['created_at', 'deleted']
-            },
-            { name: 'audios_idx_deleted',
-                fields: ['deleted']
-            }
-        ]
-    });
-    Audio.associate = (models) => {
-        Audio.belongsTo(models.User, { foreignKey: 'user_id' });
-        Audio.belongsToMany(models.Post, { as: 'PostAudios', through: 'PostAudio' });
-        Audio.belongsToMany(models.Point, { as: 'PointAudios', through: 'PointAudio' });
-    };
-    Audio.defaultAttributesPublic = ["id", "updated_at", "formats"];
-    Audio.getRandomFileKey = (id) => {
-        const random = Math.random().toString(36).substring(2, 9);
-        return random + '_audio' + id + '.mp4';
-    };
-    Audio.getFullUrl = (meta) => {
-        if (process.env.MINIO_ROOT_USER && process.env.NODE_ENV === 'development') {
-            return meta.endPoint
-                + "/" + meta.publicBucket + '/' + meta.fileKey;
-        }
-        else if (process.env.MINIO_ROOT_USER) {
-            return "https://"
-                + meta.endPoint
-                + "/" + meta.publicBucket + '/' + meta.fileKey;
-        }
-        else {
-            return 'https://' + meta.publicBucket + '.' + meta.endPoint + '/' + meta.fileKey;
-        }
-    };
-    Audio.createAndGetSignedUploadUrl = (req, res) => {
-        const userId = req.user.id;
-        sequelize.models.Audio.build({
-            user_id: userId,
-            user_agent: req.useragent.source,
-            ip_address: req.clientIp,
-        }).save().then((audio) => {
-            audio.getPreSignedUploadUrl({}, (error, presignedUrl) => {
-                if (error) {
-                    log.error("Could not get preSigned URL for audio", { error });
-                    res.sendStatus(500);
-                }
-                else {
-                    log.info("Got presigned url", { presignedUrl });
-                    res.send({ presignedUrl, audioId: audio.id });
-                }
-            });
-        }).catch((error) => {
-            log.error("Could not create audio", { error });
-            res.sendStatus(500);
-        });
-    };
-    Audio.addToPost = (audio, options, callback) => {
-        sequelize.models.Post.findOne({
-            where: {
-                id: options.postId
-            }
-        }).then((post) => {
-            post.addPostAudio(audio).then(() => {
-                log.info("Have added audio to post", { id: options.postId });
-                if (process.env.GOOGLE_TRANSCODING_FLAC_BUCKET && process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON) {
-                    if (!post.public_data) {
-                        post.set('public_data', {});
-                    }
-                    post.set('public_data.transcript', {});
-                    post.set('public_data.transcript', { audioId: audio.id });
-                    post.set('public_data.transcript.inProgress', true);
-                    post.set('public_data.transcript.inProgressDate', new Date());
-                    const workPackage = {
-                        browserLanguage: options.browserLanguage,
-                        appLanguage: options.appLanguage,
-                        audioId: audio.id,
-                        type: 'create-audio-transcript'
-                    };
-                    queue.add('process-voice-to-text', workPackage, 'high');
-                    post.save().then(() => {
-                        callback();
-                    }).catch(error => {
-                        callback(error);
-                    });
-                }
-                else {
-                    callback();
-                }
-            });
-        }).catch((error) => callback(error));
-    };
-    Audio.addToCollection = (audio, options, callback) => {
-        if (options.postId) {
-            sequelize.models.Audio.addToPost(audio, options, callback);
-        }
-        else {
-            callback("No collection to add to");
-        }
-    };
-    Audio.getTranscodingJobStatus = (audio, req, res) => {
-        if (process.env.USE_YOUR_PRIORITIES_ENCODER) {
-            Audio.getYrpriEncoderTranscodingJobStatus(audio, req, res);
-        }
-        else {
-            const params = {
-                Id: req.body.jobId
-            };
-            const eltr = new aws.ElasticTranscoder({
-                apiVersion: '2012–09–25',
-                region: process.env.S3_REGION ? process.env.S3_REGION : 'eu-west-1'
-            });
-            eltr.readJob(params, (error, data) => {
-                if (error) {
-                    log.error("Could not get status of transcoding job", { error });
-                    res.sendStatus(500);
-                }
-                else {
-                    const jobStatus = { status: data.Job.Status, statusDetail: data.Job.StatusDetail };
-                    if (jobStatus.status === "Complete") {
-                        res.send(jobStatus);
-                    }
-                    else if (jobStatus.status === "Error") {
-                        log.error("Could not transcode audio image and audio", { jobStatus: jobStatus, data: data });
-                        res.sendStatus(500);
-                    }
-                    else {
-                        res.send(jobStatus);
-                    }
-                }
-            });
-        }
-    };
-    Audio.startTranscoding = (audio, options, req, res) => {
-        if (options.audioPostUploadLimitSec && options.audioPostUploadLimitSec !== "") {
-            const postLimitSeconds = parseInt(options.audioPostUploadLimitSec);
-            audio.set('meta.maxDuration', Math.min(postLimitSeconds, 600));
-        }
-        else if (options.audioPointUploadLimitSec && options.audioPointUploadLimitSec !== "") {
-            const pointLimitSeconds = parseInt(options.audioPointUploadLimitSec);
-            audio.set('meta.maxDuration', Math.min(pointLimitSeconds, 600));
-        }
-        else {
-            audio.set('meta.maxDuration', "600");
-        }
-        audio.save().then((audio) => {
-            sequelize.models.Audio.startTranscodingJob(audio, (error, data) => {
-                if (error) {
-                    log.error("Could not start transcoding job", { error });
-                    res.sendStatus(500);
-                }
-                else {
-                    res.send({ transcodingJobId: data.Job.Id });
-                }
-            });
-        }).catch((error) => {
-            log.error("Could not start transcoding job", { error });
-            res.sendStatus(500);
-        });
-    };
-    Audio.completeUploadAndAddToPoint = (req, res, options, callback) => {
-        sequelize.models.Audio.findOne({
-            where: {
-                id: options.audioId
-            },
-            attributes: sequelize.models.Audio.defaultAttributesPublic.concat(['user_id', 'meta'])
-        }).then((audio) => {
-            if (audio.user_id === req.user.id) {
-                audio.listenable = true;
-                audio.createFormats(audio);
-                audio.save().then(() => {
-                    sequelize.models.Point.findOne({
-                        where: {
-                            id: options.pointId
-                        }
-                    }).then((point) => {
-                        point.addPointAudio(audio).then(() => {
-                            log.info("Have added audio to point", { id: options.pointId });
-                            callback();
-                        });
-                    }).catch((error) => callback(error));
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback("Could not get audio for wrong user");
-            }
-        }).catch((error) => {
-            callback(error);
-        });
-    };
-    Audio.completeUploadAndAddToCollection = (req, res, options) => {
-        sequelize.models.Audio.findOne({
-            where: {
-                id: options.audioId
-            },
-            attributes: sequelize.models.Audio.defaultAttributesPublic.concat(['user_id', 'meta'])
-        }).then((audio) => {
-            if (audio.user_id === req.user.id) {
-                audio.listenable = true;
-                audio.createFormats(audio);
-                audio.save().then(() => {
-                    sequelize.models.Audio.addToCollection(audio, options, (error) => {
-                        if (error) {
-                            log.error("Could not add audio to collection", { error, options });
-                            res.sendStatus(500);
-                        }
-                        else {
-                            res.sendStatus(200);
-                        }
-                    });
-                }).catch((error) => {
-                    log.error("Could not save audio", { error });
-                    res.sendStatus(500);
-                });
-            }
-            else {
-                log.error("Could not get audio for wrong user");
-                res.sendStatus(401);
-            }
-        }).catch((error) => {
-            log.error("Could not get audio", { error });
-            res.sendStatus(500);
-        });
-    };
-    Audio.startTranscodingJob = (audio, callback) => {
-        if (process.env.USE_YOUR_PRIORITIES_ENCODER) {
-            Audio.startYrpriEncoderTranscodingJob(audio, callback);
-        }
-        else {
-            const eltr = new aws.ElasticTranscoder({
-                apiVersion: '2012–09–25',
-                region: process.env.S3_REGION ? process.env.S3_REGION : 'eu-west-1'
-            });
-            const fileKey = audio.meta.fileKey;
-            const pipelineId = process.env.AWS_TRANSCODER_AUDIO_PIPELINE_ID;
-            const params = {
-                PipelineId: pipelineId,
-                Input: {
-                    Key: fileKey,
-                    Container: 'auto',
-                    TimeSpan: {
-                        Duration: audio.meta.maxDuration + '.000'
-                    }
-                },
-                Outputs: [
-                    {
-                        Key: fileKey,
-                        PresetId: process.env.AWS_TRANSCODER_AUDIO_PRESET_ID,
-                    },
-                    {
-                        Key: fileKey.slice(0, fileKey.length - 4) + '.flac',
-                        PresetId: process.env.AWS_TRANSCODER_FLAC_PRESET_ID
-                    }
-                ]
-            };
-            log.info('Starting AWS transcoding Audio Job');
-            eltr.createJob(params, (error, data) => {
-                if (error) {
-                    log.error("Error creating AWS Audio transcoding job", { error });
-                    callback(error);
-                }
-                else {
-                    callback(null, data);
-                }
-            });
-        }
-    };
-    Audio.prototype.createFormats = function (audio) {
-        this.formats = [];
-        this.formats.push(sequelize.models.Audio.getFullUrl(audio.meta));
-    };
-    Audio.prototype.getPreSignedUploadUrl = function (options, callback) {
-        const endPoint = process.env.S3_ENDPOINT || "s3.amazonaws.com";
-        const accelEndPoint = process.env.S3_ACCELERATED_ENDPOINT || process.env.S3_ENDPOINT || "s3.amazonaws.com";
-        const s3 = new aws.S3({
-            secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-            endpoint: accelEndPoint,
-            useAccelerateEndpoint: process.env.S3_ACCELERATED_ENDPOINT != null,
-            region: process.env.S3_REGION || ((process.env.S3_ENDPOINT || process.env.S3_ACCELERATED_ENDPOINT) ? null : 'us-east-1'),
-            s3ForcePathStyle: process.env.S3_FORCE_PATH_STYLE ? true : false
-        });
-        const signedUrlExpireSeconds = 60 * 60;
-        const bucketName = process.env.S3_AUDIO_UPLOAD_BUCKET;
-        const publicBucket = process.env.S3_AUDIO_PUBLIC_BUCKET;
-        const contentType = 'audio/mp4';
-        const a = this.id;
-        const fileKey = sequelize.models.Audio.getRandomFileKey(this.id);
-        const s3Params = {
-            Bucket: bucketName,
-            Key: fileKey,
-            Expires: signedUrlExpireSeconds,
-            ACL: process.env.S3_FORCE_PATH_STYLE ? undefined : 'bucket-owner-full-control',
-            ContentType: contentType
-        };
-        s3.getSignedUrl('putObject', s3Params, (error, url) => {
-            if (error) {
-                log.error('Error getting presigned url from AWS S3', { error });
-                callback(error);
-            }
-            else {
-                let meta = { bucketName, publicBucket, endPoint, accelEndPoint,
-                    maxDuration: options.maxDuration, fileKey, contentType, uploadUrl: url };
-                if (this.meta)
-                    meta = _.merge(this.meta, meta);
-                this.set('meta', meta);
-                log.info('Presigned URL:', { url, meta });
-                log.info('Saving audio metadata');
-                this.save().then(() => {
-                    callback(null, url);
-                }).catch((error) => { callback(error); });
-            }
-        });
-    };
-    // Using Your Priorities Encoder
-    Audio.startYrpriEncoderTranscodingJob = (audio, callback) => {
-        const fileKey = audio.meta.fileKey;
-        let jobPackage = {
-            fileKey,
-            duration: audio.meta.maxDuration + '.000',
-            flacFilename: fileKey.slice(0, fileKey.length - 4) + '.flac'
-        };
-        sequelize.models.AcBackgroundJob.createJob(jobPackage, {}, async (error, jobId) => {
-            log.info('Starting YRPRI transcoding Job');
-            if (error) {
-                log.error("Error creating YRPRI transcoding job", { error });
-                callback(error);
-            }
-            else {
-                jobPackage = _.merge(jobPackage, {
-                    acBackgroundJobId: jobId,
-                });
-                await bullAudioQueue.add(jobPackage);
-                callback(null, { Job: { Id: jobId } });
-            }
-        });
-    };
-    Audio.getYrpriEncoderTranscodingJobStatus = (audio, req, res) => {
-        sequelize.models.AcBackgroundJob.findOne({
-            where: {
-                id: req.body.jobId
-            }
-        }).then(job => {
-            if (job) {
-                const jobStatus = { status: job.data.status, statusDetail: "" };
-                if (job.data.status === "Complete") {
-                    res.send(jobStatus);
-                }
-                else if (job.data.status === "Error") {
-                    log.error("Could not transcode audio image and audio", { jobStatus: jobStatus, data: job.data });
-                    res.sendStatus(500);
-                }
-                else {
-                    res.send(jobStatus);
-                }
-            }
-            else {
-                log.error("Could not find transcoding job");
-                res.sendStatus(404);
-            }
-        }).catch(error => {
-            log.error("Could not transcode image and audio", { error });
-            res.sendStatus(500);
-        });
-    };
-    return Audio;
-};

package/dist/models/bulk_status_update.cjs

@@ -1,58 +0,0 @@
-"use strict";
-const async = require('async');
-module.exports = (sequelize, DataTypes) => {
-    const BulkStatusUpdate = sequelize.define("BulkStatusUpdate", {
-        config: { type: DataTypes.JSONB, allowNull: true },
-        templates: { type: DataTypes.JSONB, allowNull: true },
-        name: { type: DataTypes.STRING, allowNull: false },
-        sent_at: { type: DataTypes.DATE },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
-    }, {
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        timestamps: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        underscored: true,
-        tableName: 'bulk_status_updates'
-    });
-    BulkStatusUpdate.associate = (models) => {
-        BulkStatusUpdate.belongsTo(models.Group, { foreignKey: 'group_id' });
-        BulkStatusUpdate.belongsTo(models.Community, { foreignKey: 'community_id' });
-        BulkStatusUpdate.belongsTo(models.User, { foreignKey: 'user_id' });
-    };
-    BulkStatusUpdate.prototype.initializeConfig = function (emailHeader, emailFooter, done) {
-        const config = { groups: [], emailHeader: emailHeader, emailFooter: emailFooter };
-        const self = this;
-        sequelize.models.Group.findAll({
-            where: {
-                community_id: this.community_id
-            }
-        }).then((groups) => {
-            async.eachSeries(groups, (group, seriesCallback) => {
-                const configPosts = [];
-                sequelize.models.Post.findAll({
-                    where: {
-                        group_id: group.id
-                    }
-                }).then((posts) => {
-                    async.eachSeries(posts, (post, innerSeriesCallback) => {
-                        configPosts.push({ id: post.id, name: post.name, location: post.location,
-                            currentOfficialStatus: post.official_status, newOfficialStatus: null,
-                            selectedTemplateTitle: null, uniqueStatusMessage: null, moveToGroupId: null });
-                        innerSeriesCallback();
-                    }, (error) => {
-                        config.groups.push({ id: group.id, name: group.name, posts: configPosts });
-                        seriesCallback();
-                    });
-                });
-            }, (error) => {
-                done(error, config);
-            });
-        });
-    };
-    return BulkStatusUpdate;
-};

package/dist/models/campaign.cjs

@@ -1,78 +0,0 @@
-"use strict";
-const queue = require("../active-citizen/workers/queue.cjs");
-module.exports = (sequelize, DataTypes) => {
-    const Campaign = sequelize.define("Campaign", {
-        configuration: DataTypes.JSONB,
-        user_id: { type: DataTypes.INTEGER, allowNull: false },
-        post_id: { type: DataTypes.INTEGER, allowNull: true },
-        group_id: { type: DataTypes.INTEGER, allowNull: true },
-        community_id: { type: DataTypes.INTEGER, allowNull: true },
-        domain_id: { type: DataTypes.INTEGER, allowNull: true },
-        deleted: {
-            type: DataTypes.BOOLEAN,
-            allowNull: false,
-            defaultValue: false,
-        },
-        active: {
-            type: DataTypes.BOOLEAN,
-            allowNull: false,
-            defaultValue: true,
-        },
-    }, {
-        underscored: true,
-        timestamps: true,
-        createdAt: "created_at",
-        updatedAt: "updated_at",
-        tableName: "campaigns",
-        defaultScope: {
-            where: {
-                deleted: false,
-            },
-        },
-        indexes: [
-            {
-                fields: ["configuration"],
-                using: "gin",
-                operator: "jsonb_path_ops",
-            },
-            {
-                fields: ["id", "group_id", "deleted"],
-            },
-            {
-                fields: ["id", "community_id", "deleted"],
-            },
-            {
-                fields: ["id", "domain_id", "deleted"],
-            },
-            {
-                fields: ["id", "post_id", "deleted"],
-            },
-            {
-                fields: ["id", "user_id", "deleted"],
-            },
-            {
-                fields: ["id", "group_id", "deleted", "active"],
-            },
-            {
-                fields: ["id", "community_id", "deleted", "active"],
-            },
-            {
-                fields: ["id", "domain_id", "deleted", "active"],
-            },
-            {
-                fields: ["id", "post_id", "deleted", "active"],
-            },
-            {
-                fields: ["id", "user_id", "deleted", "active"],
-            },
-        ],
-    });
-    Campaign.associate = (models) => {
-        Campaign.belongsTo(models.User, { foreignKey: "user_id" });
-        Campaign.belongsTo(models.Post, { foreignKey: "post_id" });
-        Campaign.belongsTo(models.Group, { foreignKey: "group_id" });
-        Campaign.belongsTo(models.Community, { foreignKey: "community_id" });
-        Campaign.belongsTo(models.Domain, { foreignKey: "domain_id" });
-    };
-    return Campaign;
-};

package/dist/models/category.cjs

@@ -1,94 +0,0 @@
-"use strict";
-const async = require("async");
-module.exports = (sequelize, DataTypes) => {
-    const Category = sequelize.define("Category", {
-        name: { type: DataTypes.STRING, allowNull: false },
-        description: { type: DataTypes.TEXT, allowNull: false },
-        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
-        icon_file_name: DataTypes.STRING,
-        language: { type: DataTypes.STRING, allowNull: true }
-    }, {
-        underscored: true,
-        createdAt: 'created_at',
-        updatedAt: 'updated_at',
-        tableName: 'categories',
-        defaultScope: {
-            where: {
-                deleted: false
-            }
-        },
-        indexes: [
-            {
-                fields: ['id', 'deleted']
-            },
-            {
-                fields: ['name', 'deleted']
-            },
-            {
-                name: 'categories_idx_deleted_group_id',
-                fields: ['deleted', 'group_id']
-            },
-            {
-                name: 'categories_idx_deleted',
-                fields: ['deleted']
-            }
-        ],
-        timestamps: true,
-    });
-    Category.associate = (models) => {
-        Category.hasMany(models.Post);
-        Category.belongsTo(models.Group, { foreignKey: 'group_id' });
-        Category.belongsToMany(models.Image, {
-            as: 'CategoryIconImages',
-            through: 'CategoryIconImage'
-        });
-        Category.belongsToMany(models.Image, { as: 'CategoryHeaderImages', through: 'CategoryHeaderImage' });
-    };
-    Category.prototype.setupIconImage = function (body, done) {
-        if (body.uploadedIconImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedIconImageId }
-            }).then((image) => {
-                if (image)
-                    this.addCategoryIconImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Category.prototype.setupHeaderImage = function (body, done) {
-        if (body.uploadedHeaderImageId) {
-            sequelize.models.Image.findOne({
-                where: { id: body.uploadedHeaderImageId }
-            }).then((image) => {
-                if (image)
-                    this.addCategoryHeaderImage(image);
-                done();
-            });
-        }
-        else
-            done();
-    };
-    Category.prototype.setupImages = function (body, done) {
-        async.parallel([
-            (callback) => {
-                this.setupIconImage(body, (err) => {
-                    if (err)
-                        return callback(err);
-                    callback();
-                });
-            },
-            (callback) => {
-                this.setupHeaderImage(body, (err) => {
-                    if (err)
-                        return callback(err);
-                    callback();
-                });
-            }
-        ], (err) => {
-            done(err);
-        });
-    };
-    return Category;
-};