strapi-plugin-comments 2.0.11 → 2.1.1

package/server/services/admin.js

@@ -1,296 +0,0 @@
-'use strict';
-
-const { getPluginService, parseParams } = require('./../utils/functions');
-const { isEmpty, isNil, isNumber, parseInt } = require('lodash');
-const PluginError = require('./../utils/error');
-const {
-    getModelUid,
-    getRelatedGroups,
-    filterOurResolvedReports,
-} = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
-
-/**
- * Comments Plugin - Moderation services
- */
-
- module.exports = ({ strapi }) => ({
-
-    getCommonService() {
-        return getPluginService('common');
-    },
-
-    // Config
-    async config(viaSettingsPage = false) {
-        const pluginStore = await this.getCommonService().getPluginStore();
-        const config = await pluginStore.get({ key: 'config' });
-        const additionalConfiguration = {
-            regex: Object.keys(REGEX).reduce((prev, curr) => ({
-                ...prev,
-                [curr]: REGEX[curr].toString(),
-            }), {}),
-        };
-
-        const isGQLPluginEnabled = !isNil(strapi.plugin('graphql'));
-
-        if (config) {
-            return {
-                ...config,
-                ...additionalConfiguration,
-                isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
-            };
-        }
-
-        const entryLabel = this.getCommonService().getLocalConfig('entryLabel');
-        const approvalFlow = this.getCommonService().getLocalConfig('approvalFlow');
-        const reportReasons = this.getCommonService().getLocalConfig('reportReasons');
-        const result = {
-            entryLabel,
-            approvalFlow,
-            reportReasons,
-            ...additionalConfiguration,
-        };
-
-        if (viaSettingsPage) {
-            const enabledCollections = this.getCommonService().getLocalConfig('enabledCollections');
-            const moderatorRoles = this.getCommonService().getLocalConfig('moderatorRoles');
-            return {
-                ...result,
-                enabledCollections,
-                moderatorRoles,
-                isGQLPluginEnabled,
-            };
-        }
-
-        return result;
-    },
-
-    async updateConfig(body) {
-        const pluginStore = await this.getCommonService().getPluginStore();
-    
-        await pluginStore.set({ key: 'config', value: body });
-    
-        return this.config();
-      },
-    
-      async restoreConfig() {
-        const pluginStore = await this.getCommonService().getPluginStore();
-
-        await pluginStore.delete({key: 'config'})
-    
-        return this.config();
-      },
-
-    async restart() {
-        setImmediate(() => strapi.reload());
-    },
-
-    // Find all comments
-    async findAll({ related, entity, ...query }) {
-        const { _q, orderBy, pageSize = 10, page = 1, filters, ...rest } = parseParams(query);
-
-        const defaultWhere = {
-            $or: [
-                { removed: false },
-                { removed: null },
-            ],
-        };
-
-        let params = {
-            where: !isEmpty(filters) ? {
-                ...defaultWhere,
-                ...filters,
-            } : { ...defaultWhere },
-            offset: (page - 1)*pageSize, 
-            limit: pageSize,
-            orderBy: orderBy || [{ createdAt: 'desc' }],
-        };
-        if (_q) {
-            params = {
-                ...params,
-                where: {
-                    ...params.where,
-                    content: {
-                        $contains: _q
-                    },
-                }
-            };
-        }
-    
-        const entities = await strapi.db.query(getModelUid('comment'))
-            .findMany({
-                ...params, 
-                populate: {
-                    authorUser: true,
-                    threadOf: true,
-                    reports: {
-                        where: { 
-                            resolved: false
-                        },
-                    },
-                },
-            });
-        const total = await strapi.db.query(getModelUid('comment'))
-            .count({
-                where: params.where,
-            });
-        const relatedEntities = await this.getCommonService().findRelatedEntitiesFor(entities);
-        const result = entities
-            .map(_ => filterOurResolvedReports(this.getCommonService().sanitizeCommentEntity(_)))
-            .map(_ => this.getCommonService().mergeRelatedEntityTo(_, relatedEntities));
-
-        const pageCount = Math.floor(total / pageSize);
-        return {
-            result,
-            pagination: {
-                page: page,
-                pageSize: pageSize,
-                pageCount: total % pageSize === 0 ? pageCount : pageCount + 1,
-                total,
-            },
-        };
-    },
-
-    // Find single comment
-    async findOneAndThread(id, { removed, ...query }) {
-        const defaultWhere = !removed ? {
-            $or: [
-                { removed: false },
-                { removed: null },
-            ],
-        } : {};
-        
-        const reportsPopulation = {
-            reports: {
-                where: { 
-                    resolved: false,
-                },
-            }
-        };
-
-        const defaultPopulate = {
-            populate: {
-                authorUser: true,
-                threadOf: {
-                    populate: { 
-                        authorUser: true,
-                        ...reportsPopulation
-                    },
-                },
-                ...reportsPopulation,
-            },
-        }
-
-        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
-            where: {
-                id,
-            },
-            ...defaultPopulate,
-        });
-
-        if (!entity){
-            throw new PluginError(404, 'Not found');
-        }
-
-        const [relatedUid, relatedStringId] = getRelatedGroups(entity.related);
-        const parsedRelatedId = parseInt(relatedStringId);
-        const relatedId = isNumber(parsedRelatedId) ? parsedRelatedId : relatedStringId;
-        const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
-            where: { id: relatedId }
-        }).then(_ => ({
-            ..._,
-            uid: relatedUid,
-        }));
-
-        if (!relatedEntity) {
-            throw new PluginError(404, 'Relation not found');
-        }
-
-        const levelThreadId = entity?.threadOf?.id || null;
-        const entitiesOnSameLevel = await this.getCommonService()
-            .findAllInHierarchy({
-                query: {
-                    ...defaultWhere,
-                    ...query,
-                    threadOf: levelThreadId,
-                    related: entity.related,
-                },
-                ...defaultPopulate,
-                startingFromId: levelThreadId,
-                isAdmin: true
-            }, false);
-        const selectedEntity = this.getCommonService().sanitizeCommentEntity({
-            ...entity,
-            threadOf: entity.threadOf || null,
-        });
-        
-        return {
-            entity: relatedEntity,
-            selected: selectedEntity,
-            level: entitiesOnSameLevel,
-        };
-    },
-
-    // Block / Unblock a comment
-    async blockComment(id, forceStatus) {
-        const existingEntity = await this.getCommonService().findOne({ id });
-        const changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
-            where: { id },
-            data: { blocked: !isNil(forceStatus) ? forceStatus : !existingEntity.blocked }
-        });
-        return this.getCommonService().sanitizeCommentEntity(changedEntity);
-    },
-
-    // Block / Unblock a comment thread
-    async blockCommentThread(id, forceStatus) {
-        const existingEntity = await this.getCommonService().findOne({ id });
-        const status = !isNil(forceStatus) ? forceStatus : !existingEntity.blockedThread;
-        const changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
-            where: { id },
-            data: { 
-                blocked: status,
-                blockedThread: status,
-            },
-        });
-        await this.blockNestedThreads(id, changedEntity.blockedThread);
-
-        return this.getCommonService().sanitizeCommentEntity(changedEntity);
-    },
-
-    // Approve comment
-    async approveComment(id) {
-        const changedEntity = await strapi.db.query(getModelUid('comment'))
-          .update({
-              where: { id },
-              data: { approvalStatus: APPROVAL_STATUS.APPROVED }
-          });
-    
-        return this.getCommonService().sanitizeCommentEntity(changedEntity);
-    },
-    
-    async rejectComment(id) {
-        const changedEntity = await strapi.db.query(getModelUid('comment'))
-            .update({ 
-                where: { id }, 
-                data: { approvalStatus: APPROVAL_STATUS.REJECTED }
-            });
-
-        return this.getCommonService().sanitizeCommentEntity(changedEntity);
-    },
-
-    async blockNestedThreads(id, blockStatus) {
-        return await this.getCommonService()
-            .modifiedNestedNestedComments(id, 'blockedThread', blockStatus)
-    },
-
-    // Resolve reported abuse for comment
-    async resolveAbuseReport(id, commentId) {
-        return strapi.db.query(getModelUid('comment-report')).update({
-            where: {
-                id,
-                related: commentId,
-            },
-            data: { resolved: true }
-        });
-    }, 
-});

package/server/services/client.js

@@ -1,263 +0,0 @@
-'use strict';
-
-const config = require('../config');
-const { getPluginService } = require('./../utils/functions');
-const { isNil, isEmpty, isNumber, parseInt } = require('lodash');
-const PluginError = require('./../utils/error');
-const {
-    isEqualEntity,
-    getModelUid,
-    getRelatedGroups,
-    resolveUserContextError,
-} = require('./utils/functions');
-const { APPROVAL_STATUS, REGEX, CONFIG_PARAMS } = require('./../utils/constants')
-
-/**
- * Comments Plugin - Client services
- */
-
-module.exports = ({ strapi }) => ({
-
-    getCommonService() {
-        return getPluginService('common');
-    },
-
-    // Create a comment
-    async create(relation, data, user = undefined) {
-        const { content, threadOf } = data;
-        const singleRelationFulfilled = relation && REGEX.relatedUid.test(relation);
-        
-        if(!singleRelationFulfilled) {
-            throw new PluginError(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
-        }
-
-        const [ uid, relatedId ] = await this.getCommonService().parseRelationString(relation);
-
-        const relatedEntity = await strapi.db.query(uid).findOne(relatedId);
-        if (!relatedEntity) {
-            throw new PluginError(400, `Relation for field "related" does not exist. Check your payload please.`);
-        }
-
-        const approvalFlow = await this.getCommonService().getConfig(CONFIG_PARAMS.APPROVAL_FLOW, []);
-        const isApprovalFlowEnabled = approvalFlow.includes(uid) ||
-            relatedEntity.requireCommentsApproval;
-
-        const linkToThread = !isNil(threadOf) ? await this.getCommonService().findOne({
-            id: threadOf,
-            related: relation,
-        }) : true;
-        const validContext = this.getCommonService().isValidUserContext(user);
-
-        if (!linkToThread) {
-            throw new PluginError(400, 'Thread does not exist');
-        }
-
-        if (!validContext) {
-            throw resolveUserContextError(user);
-        }
-
-        if (await this.getCommonService().checkBadWords(content) && singleRelationFulfilled) {
-            const { author = {}, ...rest } = data;
-            let authorData = {};
-            if (validContext && user) {
-                authorData = {
-                    authorUser: user?.id,
-                };
-            } else {
-                if (author.email && !REGEX.email.test(author.email)) {
-                    throw new PluginError(400, 'Field: "author.email". Author e-mail is not valid value. Check your payload');
-                }
-
-                authorData = {
-                    authorId: author.id,
-                    authorName: author.name,
-                    authorEmail: author.email,
-                    authorAvatar: author.avatar,
-                };
-            }
-            
-            if (!isEmpty(authorData) && !(authorData.authorId || authorData.authorUser)) {
-                throw new PluginError(400, `Not able to recognise author of a comment. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
-            }
-
-            if (isApprovalFlowEnabled && 
-                (!isNil(data.approvalStatus) && (data.approvalStatus !== APPROVAL_STATUS.PENDING))) {
-                throw new PluginError(400, 'Invalid approval status');
-            }
-
-            const entity = await strapi.db.query(getModelUid('comment')).create({
-                data: {
-                    ...rest,
-                    ...authorData,
-                    related: relation,
-                    approvalStatus: isApprovalFlowEnabled ? APPROVAL_STATUS.PENDING : null,
-                },
-                populate: {
-                    authorUser: true,
-                },
-            });
-            return this.getCommonService().sanitizeCommentEntity({
-                ...entity,
-                threadOf: !isNil(threadOf) ? linkToThread : null,
-            });
-        }
-        throw new PluginError(400, 'No content received');
-    },
-
-    // Update a comment
-    async update(id, relation, data, user = undefined) {
-        const { content } = data;
-
-        const singleRelationFulfilled = relation && REGEX.relatedUid.test(relation)
-
-        if(!singleRelationFulfilled) {
-            throw new PluginError(400, `Request property "relation" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
-        }
-
-        await this.getCommonService().parseRelationString(relation);
-
-        const existingEntity = await this.getCommonService().findOne({
-            id,
-            related: relation,
-        });
-
-        const validContext = this.getCommonService().isValidUserContext(user);
-
-        if (!validContext) {
-            throw resolveUserContextError(user);
-        }
-
-        if (isEqualEntity(existingEntity, data, user) && content) {
-            if (await this.getCommonService().checkBadWords(content)) {
-                const entity = await strapi.db.query(getModelUid('comment')).update({
-                    where: { id },
-                    data: { content },
-                    populate: { threadOf: true, authorUser: true },
-                });
-                return this.getCommonService().sanitizeCommentEntity(entity);
-            }
-        }
-        throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
-    },
-
-    // Report abuse in comment
-	async reportAbuse(id, relation, payload, user = undefined) {
-        if (!this.getCommonService().isValidUserContext(user)) {
-            throw resolveUserContextError(user);
-        }
-
-        await this.getCommonService().parseRelationString(relation);
-
-		const reportAgainstEntity = await this.getCommonService().findOne({
-            id, 
-            related: relation,
-        });
-		if (reportAgainstEntity) {
-            const entity = await strapi.db.query(getModelUid('comment-report')).create({
-                data: {
-                    ...payload,
-                    resolved: false,
-                    related: id,
-                }
-            });
-			if (entity) {
-                const response = {
-                    ...entity,
-                    related: reportAgainstEntity,
-                };
-                try {
-                    await this.sendAbuseReportEmail(entity.reason, entity.content); // Could also add some info about relation
-                    return response
-                } catch (err) {
-                    return response;
-                }
-            } else {
-                throw new PluginError(500, 'Report cannot be created');
-            }
-        }
-        throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure that comment exist or you've authenticated your request properly.`);
-    },
-
-    async markAsRemoved(id, relation, authorId, user = undefined){
-        if (!this.getCommonService().isValidUserContext(user)) {
-            throw resolveUserContextError(user);
-        }
-
-        const author = user?.id || authorId;
-
-        if (!author) {
-            throw new PluginError(403, `You're not allowed to take an action on that entity. Make sure that you've provided proper "authorId" or authenticated your request properly.`);
-        }
-
-        await this.getCommonService().parseRelationString(relation);
-
-        let entity;
-        try {
-            const byAuthor = user?.id ? {
-                authorUser: author
-            } : {
-                authorId: author
-            }
-            entity = await this.getCommonService().findOne({
-                id,
-                related: relation,
-                ...byAuthor,
-            });
-        } catch(e) {
-            throw new PluginError(404, `Entity does not exist or you're not allowed to take an action on it`);
-        }
-
-        const removedEntity = await strapi.db.query(getModelUid('comment'))
-          .update({
-              where: { 
-                  id, 
-                  related: relation
-                },
-                data: { removed: true },
-                populate: { threadOf: true, authorUser: true },
-          })
-        await this.markAsRemovedNested(id, true);
-
-        return this.getCommonService().sanitizeCommentEntity(removedEntity);
-    },
-
-	async sendAbuseReportEmail(reason, content) {
-		const rolesToBeNotified = await this.getCommonService().getConfig(CONFIG_PARAMS.MODERATOR_ROLES) || ['strapi-super-admin'];
-
-        const adminUserModel = strapi.db.query('admin::user');
-		const emails = await adminUserModel.findMany({
-            where: { 
-                roles: { code: rolesToBeNotified },
-            },
-        }).then(items => items.map(_ => _.email));
-
-		const superAdmin = await strapi.db.query('admin::user')
-            .findOne({
-                where: {
-                    roles: { code: 'strapi-super-admin' },
-                },
-            });
-		
-		if (emails.length > 0) {
-            try {
-                await strapi.plugin('email').service('email').send({
-                    to: emails,
-                    from: superAdmin.email,
-                    subject: 'New abuse report on comment',
-                    text: `
-                        There was a new abuse report on your app. 
-                        Reason: ${reason}
-                        Message: ${content}
-                    `,
-                });
-            } catch(err) {
-                strapi.log.error(err);
-                throw err;
-            }
-		}
-	},
-
-    async markAsRemovedNested(id, status){
-        return this.getCommonService().modifiedNestedNestedComments(id, 'removed', status);
-    },
-});