strapi-plugin-comments 1.0.1 → 2.0.0-beta.1

package/server/services/admin.js

@@ -0,0 +1,180 @@
+'use strict';
+
+const { getPluginService, parseParams } = require('./../utils/functions');
+const { getAssociationModel } = require('./common');
+const { first, isEmpty, isNil, uniq, get } = require('lodash');
+const PluginError = require('./../utils/error');
+const {
+    getModelUid,
+    getRelatedGroups,
+    filterOurResolvedReports,
+    convertContentTypeNameToSlug
+} = require('./utils/functions');
+const { APPROVAL_STATUS, REGEX } = require('./../utils/constants')
+
+/**
+ * Comments Plugin - Moderation services
+ */
+
+ module.exports = ({ strapi }) => ({
+
+    getCommonService() {
+        return getPluginService('common');
+    },
+
+    // Find all comments
+    async findAll({ related, entity, ...query }) {
+        const { _q, orderBy, pageSize = 10, page = 1, filters, ...rest } = parseParams(query);
+
+        let params = {
+            where: !isEmpty(filters) ? {
+                ...filters,
+            } : undefined,
+            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, ['authorUser', 'reports']);
+        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));
+
+            console.log(relatedEntities);
+
+        return {
+            result,
+            pagination: {
+                page: page,
+                pageSize: pageSize,
+                pageCount: Math.floor(total / pageSize) + 1,
+                total,
+            },
+        };
+    },
+
+    // Find single comment
+    async findOneAndThread(id) {
+        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
+            where: {
+                id
+            },
+            populate: ['threadOf', 'threadOf.reports', 'authorUser', 'reports'] 
+        });
+
+        if (!entity){
+            throw new PluginError(404, 'Not found');
+        }
+
+        const [relatedUid, relatedStringId] = getRelatedGroups(entity.related);
+        const relatedId = parseInt(relatedStringId, 10);
+        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: {
+                    threadOf: levelThreadId,
+                    related: entity.related,
+                },
+                startingFromId: levelThreadId,
+                isAdmin: true
+            }, false);
+
+        const selectedEntity = filterOurResolvedReports(this.getCommonService().sanitizeCommentEntity(entity));
+        
+        return {
+            entity: relatedEntity,
+            selected: {
+                ...selectedEntity,
+                threadOf: selectedEntity.threadOf ? filterOurResolvedReports(selectedEntity.threadOf) : null,
+            },
+            level: entitiesOnSameLevel.map(_ => filterOurResolvedReports(_))
+        };
+    },
+
+    // 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 changedEntity = await strapi.db.query(getModelUid('comment')).update({ 
+            where: { id },
+            data: { blockedThread: !isNil(forceStatus) ? forceStatus : !existingEntity.blockedThread }
+        });
+        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

@@ -0,0 +1,227 @@
+'use strict';
+
+const config = require('./../config');
+const { getPluginService } = require('./../utils/functions');
+const { isNil, isEmpty } = require('lodash');
+const PluginError = require('./../utils/error');
+const {
+    isEqualEntity,
+    getModelUid,
+    getRelatedGroups,
+    checkBadWords,
+    isValidUserContext,
+    resolveUserContextError,
+} = require('./utils/functions');
+const { APPROVAL_STATUS, REGEX } = 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, related } = data;
+        const singleRelationFulfilled = related && REGEX.relatedUid.test(related);
+
+        if (relation !== related) {
+            throw new PluginError(400, `Insonsistent relation uid`);
+        }
+
+        if(!singleRelationFulfilled) {
+            throw new PluginError(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
+        }
+
+        const [ uid, relatedStringId ] = getRelatedGroups(related);
+        const relatedId = parseInt(relatedStringId, 10);
+
+        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 linkToThread = !isNil(threadOf) ? !!await this.getCommonService().findOne({
+            id: threadOf,
+            related,
+        }) : true;
+        const validContext = isValidUserContext(user);
+
+        if (!linkToThread) {
+            throw new PluginError(400, 'Thread does not exist');
+        }
+
+        if (!validContext) {
+            throw resolveUserContextError(user);
+        }
+
+        if (checkBadWords(content) && singleRelationFulfilled) {
+            const { author, authorUser, ...rest } = data;
+            let authorData = {};
+            if (validContext && user) {
+                authorData = {
+                    authorUser: user?.id || authorUser,
+                };
+            } else if (authorUser) {
+                authorData = {
+                    authorUser,
+                };
+            } 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) {
+                throw new PluginError(400, 'Object: "author" is invalid. Check your payload');
+            }
+
+            if (relatedEntity.requireCommentsApproval && 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,
+                }
+            });
+            return this.getCommonService().sanitizeCommentEntity(entity);
+        }
+        throw new PluginError(400, 'No content received');
+    },
+
+    // Update a comment
+    async update(id, relation, data, user) {
+        const { content, related } = data;
+
+        const singleRelationFulfilled = related && REGEX.relatedUid.test(related)
+
+        if (relation !== related) {
+            throw new PluginError(400, `Insonsistent relation uid`);
+        }
+
+        if(!singleRelationFulfilled) {
+            throw new PluginError(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
+        }
+
+        const existingEntity = await this.getCommonService().findOne({
+            id,
+            related,
+        });
+        const validContext = isValidUserContext(user);
+
+        if (!validContext) {
+            throw resolveUserContextError(user);
+        }
+
+        if (isEqualEntity(existingEntity, data, user) && content) {
+            if (checkBadWords(content)) {
+                const entity = await strapi.db.query(getModelUid('comment')).update({
+                    where: { id },
+                    data: { content },
+                });
+                return this.getCommonService().sanitizeCommentEntity(entity);
+            }
+        }
+        throw new PluginError(409, 'Action on that entity is not allowed');
+    },
+
+    // Report abuse in comment
+	async reportAbuse(id, relation, payload, user) {
+        if (!isValidUserContext(user)) {
+            throw resolveUserContextError(user);
+        }
+		const existingEntity = await this.getCommonService().findOne({
+            id, 
+            related: relation,
+        });
+		if (existingEntity) {
+            const entity = await strapi.db.query(getModelUid('comment-report')).create({
+                data: {
+                    ...payload,
+                    resolved: false,
+                    related: id,
+                }
+            });
+			if (entity) {
+                try {
+                    await this.sendAbuseReportEmail(entity.reason, entity.content); // Could also add some info about relation
+                } catch (err) {
+                    throw err;
+                }
+            } else {
+                throw new PluginError(500, 'Report cannot be created');
+            }
+            return entity;
+        }
+        throw new PluginError(409, 'Action on that entity is not allowed');
+    },
+
+    async markAsRemoved(relationId, commentId, authorId){
+        const entity = await this.getCommonService().findOne({
+          id: commentId,
+          related: relationId,
+          $or: [{ authorUser: authorId }, { authorId }],
+        });
+        if (!entity){
+            throw strapi.errors.notFound('Entity not exist');
+        }
+        return strapi.db.query(getModelUid('comment'))
+          .update({ id: commentId, relatedSlug: relationId }, { removed: true })
+          .then(({ id }) => this.markAsRemovedNested(id, true))
+          .then(() => ({ id: commentId }));
+    },
+
+	async sendAbuseReportEmail(reason, content) {
+		const rolesToBeNotified = this.getCommonService().getConfig('moderatorRoles') || ['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;
+            }
+		}
+	},
+
+    markAsRemovedNested(id, status){
+        return this.getCommonService().modifiedNestedNestedComments(id, 'removed', status);
+    },
+});

package/server/services/common.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const { isArray, isEmpty, uniq, get, first } = require('lodash');
+// const { sanitizeEntity } = require('strapi-utils');
+const PluginError = require('./../utils/error');
+const {
+    extractMeta,
+    getModelUid,
+    getRelatedGroups,
+    buildNestedStructure,
+    filterOurResolvedReports
+} = require('./utils/functions');
+
+/**
+ * Comments Plugin - common services
+ */
+
+module.exports = ({ strapi }) => ({
+    getAssociationModel(ormModel, related) {
+        const relatedAssociation = ormModel.associations.find(_ => _.alias === 'related');
+        if (relatedAssociation) {
+            return relatedAssociation.related.find(rel => rel.collectionName === related);
+        }
+        return null;
+    },
+
+    getMorphModel() {
+        const ormModel = strapi.query(getModelUid('comment'));
+        return ormModel.model.morph;
+    },
+
+    isMongoDB(){
+        return strapi.query(getModelUid('comment'))?.model?.orm === 'mongoose';
+    },
+
+    getMorphData(query) {
+        return this
+          .getMorphModel()
+          .query(function () {
+              this.where(query);
+          })
+          .fetchAll()
+          .then((entities) => entities.map(entity => entity.toJSON()));
+    },
+
+    checkEntityRelation(uid, entityId) {
+        const result = parsedRelation.some(ref => {
+            const model = strapi.query(ref);
+            return model && model.associations.length &&
+              model.associations.some(_ => _.plugin === 'comments' && _.collection === 'comment');
+        });
+        if (!result) {
+            throw new PluginError(400, 'Comment not have relation to this type content type.');
+        }
+    },
+
+    getConfig(prop) {
+        let queryProp = prop;
+        if (prop && isArray(prop)) {
+            queryProp = prop.join('.');
+        }
+        return strapi.config.get(`plugin.comments${ queryProp ? '.' + queryProp : ''}`);
+    },
+
+    // Find comments in the flat structure
+    async findAllFlat(query, isAdmin = false, relatedEntity = null) {
+        const criteria = { 
+            ...query,
+            $or: [{ removed: { $null: true } }, { removed: false }],
+        }
+
+        if (isAdmin){
+            delete criteria.$or;
+        }
+
+        const populate = { authorUser: true, reports: true };
+
+        const entries = await strapi.db.query(getModelUid('comment'))
+        .findMany({
+            where: {
+                ...criteria,
+            },
+            populate,
+        });
+
+        const entriesWithThreads = await Promise.all(entries.map(async _ => {
+            const [nestedEntries, count] = await strapi.db.query(getModelUid('comment'))
+                .findWithCount({ 
+                    where: {
+                        threadOf: _.id
+                    }
+                 })
+            return { id: _.id, itemsInTread: count, firstThreadItemId: first(nestedEntries)?.id }
+        }));
+
+        const relatedEntities = relatedEntity !== null ? [relatedEntity] : await this.findRelatedEntitiesFor([...entitiesRoot, ...entitiesNested]);
+        const result = entries
+            .map(_ => {
+                const threadedItem = entriesWithThreads.find(item => item.id === _.id);
+                return filterOurResolvedReports(this.sanitizeCommentEntity({
+                    ..._,
+                    threadOf: query.threadOf || _.threadOf || null,
+                    gotThread: (threadedItem?.itemsInTread || 0) > 0,
+                    threadFirstItemId: threadedItem?.firstThreadItemId,
+                }))
+            });
+
+        if (relatedEntities.filter(_ => _).length > 0) {
+            return result.map(_ => this.mergeRelatedEntityTo(_, relatedEntities));
+        }
+        return result;    
+    },
+
+    // Find comments and create relations tree structure
+    async findAllInHierarchy ({
+        query,
+        startingFromId = null,
+        dropBlockedThreads = false,
+        isAdmin = false,
+    }, relatedEntity) {
+        const entities = await this.findAllFlat(query, isAdmin, relatedEntity);
+        return buildNestedStructure(entities, startingFromId, 'threadOf', dropBlockedThreads, false);
+    },
+
+    // Find single comment
+    async findOne(criteria) {
+        const entity = await strapi.db.query(getModelUid('comment'))
+            .findOne({
+                where: criteria
+            }, ['related', 'reports']);
+        if (!entity){
+            throw strapi.errors.notFound();
+        }
+        return filterOurResolvedReports(this.sanitizeCommentEntity(entity));
+    },
+
+    // Find all related entiries
+    async findRelatedEntitiesFor(entities = []) {
+        return Promise.all(uniq(entities.map(_ => _.related)).map(async _ => {
+            const [relatedUid, relatedStringId] = getRelatedGroups(_);
+            const relatedId = parseInt(relatedStringId, 10);
+            const relatedEntity = await strapi.db.query(relatedUid).findOne({ 
+                where: { id: relatedId }
+            });
+            return {
+                ...relatedEntity,
+                uid: relatedUid,
+            };
+        }))
+    },
+
+    // Merge related entity with comment
+    mergeRelatedEntityTo(entity, relatedEntities = []) {
+        return {
+            ...entity,
+            related: relatedEntities.find(relatedEntity => entity.related === `${relatedEntity.uid}:${relatedEntity.id}`)
+        };
+    },
+
+    async modifiedNestedNestedComments(id, fieldName, value) {
+        try {
+            const entitiesToChange = await strapi.bd.query(getModelUid('comment'))
+                .findMany({
+                    where: { threadOf: id }
+                });
+            const changedEntities = await strapi.bd.query(getModelUid('comment'))
+                .updateMany({
+                    where: { id: entitiesToChange.map(_ => _.id) },
+                    data: { [fieldName]: value }
+                });
+            if ((entitiesToChange.length === changedEntities.length) && (changedEntities.length > 0)) {
+                const nestedTransactions = await Promise.all(
+                  changedEntities.map(item => this.modifiedNestedNestedComments(item.id, fieldName, value))
+                );
+                return nestedTransactions.length === changedEntities.length;
+            }
+            return true;
+        } catch (e) {
+            return false;
+        }
+    },
+
+    sanitizeCommentEntity: (entity) => ({
+        ...entity,
+	}),
+
+    // sanitizeCommentEntity: (entity) => ({
+    //     ...entity,
+    //     authorUser: sanitizeEntity(entity.authorUser, { model: strapi.plugins['users-permissions'].models.user }),
+	// }),
+});

package/server/services/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const adminServices = require('./admin');
+const clientServices = require('./client');
+const commonServices = require('./common');
+
+module.exports = {
+  admin: adminServices,
+  client: clientServices,
+  common: commonServices,
+};

package/{services → server/services}/utils/__tests__/functions.test.js

@@ -17,11 +17,9 @@ beforeEach(() => {
         }
       },
       config: {
-        custom: {
-          plugins: {
-            comments: {
-              enableUsers: false,
-            }
+        plugins: {
+          comments: {
+            enableUsers: false,
           }
         }
       }
@@ -31,7 +29,7 @@ beforeEach(() => {
 })
 
 describe('Test Comments service functions utils', () => {
-  
+
   describe('Bad Words filtering', () => {
     const text = 'Lorem ipsum dolor sit fuck amet';
 
@@ -55,7 +53,7 @@ describe('Test Comments service functions utils', () => {
     });
 
     test('Should skip bad words filtering because of configuration change', () => {
-      global.strapi.config.custom.plugins.comments.badWords = false;
+      global.strapi.config.plugins.comments.badWords = false;
 
       expect(checkBadWords(text)).toEqual(text);
     });
@@ -74,13 +72,13 @@ describe('Test Comments service functions utils', () => {
 
   describe('Validating user context', () => {
     test('Context should be skipped based on config', () => {
-      global.strapi.config.custom.plugins.comments.enableUsers = false;
+      global.strapi.config.plugins.comments.enableUsers = false;
       expect(isValidUserContext(undefined)).toEqual(true);
       expect(isValidUserContext({ id: 1 })).toEqual(true);
     });
 
     test('Context should be verified based on input', () => {
-      global.strapi.config.custom.plugins.comments.enableUsers = true;
+      global.strapi.config.plugins.comments.enableUsers = true;
       expect(isValidUserContext(undefined)).toEqual(false);
       expect(isValidUserContext({ id: 1 })).toEqual(true);
     });