strapi-plugin-comments 1.0.2 → 2.0.0-beta.3

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) {
+                    return entity;
+                }
+            } 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,197 @@
+'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, populate = {} }, isAdmin = false, relatedEntity = null) {
+        const criteria = { 
+            ...query,
+            $or: [{ removed: { $null: true } }, { removed: false }],
+        }
+
+        if (isAdmin){
+            delete criteria.$or;
+        }
+
+        const defaultPopulate = {
+            authorUser: true,
+        };
+
+        const entries = await strapi.db.query(getModelUid('comment'))
+        .findMany({
+            where: {
+                ...criteria,
+            },
+            populate: {
+                ...defaultPopulate,
+                ...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([...entries]);
+        const result = entries
+            .map(_ => {
+                const threadedItem = entriesWithThreads.find(item => item.id === _.id);
+                return 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,
+        populate = {},
+        startingFromId = null,
+        dropBlockedThreads = false,
+        isAdmin = false,
+    }, relatedEntity) {
+        const entities = await this.findAllFlat({ query, populate }, 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);
     });

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

@@ -1,5 +1,6 @@
 const BadWordsFilter = require('bad-words');
-const PluginError = require('./error');
+const PluginError = require('./../../utils/error');
+const { REGEX } = require('./../../utils/constants')
 const { first, get, isObject, isNil } = require('lodash');
 
 const buildNestedStructure = (
@@ -8,12 +9,11 @@ const buildNestedStructure = (
   field = 'parent',
   dropBlockedThreads = false,
   blockNestedThreads = false,
-  isMongoDB = false
 ) =>
   entities
     .filter(entity => {
         // mongo by default not return `null` for empty data
-        if ((entity[field] === null && id === null) || (isMongoDB && entity[field] === undefined && id === null)) {
+        if (entity[field] === null && id === null) {
             return true;
         }
         let data = entity[field];
@@ -34,12 +34,15 @@ const buildNestedStructure = (
 module.exports = {
     isEqualEntity: (existing, data, user) => {
         const { authorUser, authorId } = existing;
+        console.log('data', data);
+        console.log(existing);
+        const { author } = data;
         if (authorUser) {
-            const existingUserId = get(authorUser, 'id', authorUser);
-            const receivedUserId = get(user, 'id', data.authorUser);
+            const existingUserId = authorUser?.id || authorUser;
+            const receivedUserId = user?.id || author;
             return existingUserId === receivedUserId;
         }
-        return authorId === data.authorId;
+        return authorId === author?.id;
     },
 
     extractMeta: plugins => {
@@ -54,13 +57,21 @@ module.exports = {
         };
     },
 
+    getRelatedGroups: related => related.split(REGEX.relatedUid).filter(s => s && s.length > 0),
+
+    getModelUid: name => {
+        return strapi
+            .plugin('comments')
+            .contentTypes[name]?.uid;
+    },
+
     filterOurResolvedReports: item => (item ? {
         ...item,
         reports: (item.reports || []).filter(report => !report.resolved),
     } : item),
 
     checkBadWords: content => {
-        const config = get(strapi.config, 'custom.plugins.comments.badWords', true);
+        const config = get(strapi.config, 'plugins.comments.badWords', true);
         if (config) {
             const filter = new BadWordsFilter(isObject(config) ? config : undefined);
             if (content && filter.isProfane(content)) {
@@ -82,7 +93,7 @@ module.exports = {
     buildNestedStructure,
 
     isValidUserContext: (user = {}) => {
-        const builtInContextEnabled = get(strapi.config, 'custom.plugins.comments.enableUsers', false);
+		const builtInContextEnabled = get(strapi.config, 'plugins.comments.enableUsers', false);
         return builtInContextEnabled ? !isNil(user.id) : true;
     },
 

package/server/utils/constants.js

@@ -0,0 +1,16 @@
+const APPROVAL_STATUS = {
+  PENDING: "PENDING",
+  APPROVED: "APPROVED",
+  REJECTED: "REJECTED",
+};
+
+const REGEX = {
+  uid: new RegExp(/^(?<type>[a-z]+)\:{2}(?<api>[a-z]+)\.{1}(?<contentType>[a-z]+)$/gmi),
+  relatedUid: new RegExp(/^(?<uid>[a-z]+\:{2}[a-z]+\.[a-z]+)\:{1}(?<id>[0-9]+)$/gmi),
+  email: new RegExp(/\S+@\S+\.\S+/),
+};
+
+module.exports = {
+  APPROVAL_STATUS,
+  REGEX,
+};

package/server/utils/functions.js

@@ -0,0 +1,19 @@
+'use strict'
+
+module.exports = {
+    getPluginService(name) {
+        return strapi
+          .plugin('comments')
+          .service(name);
+      },
+
+    parseParams: params => 
+        Object.keys(params).reduce((prev, curr) => {
+            const value = params[curr];
+            const parsedValue = Number(value);
+            return {
+                ...prev,
+                [curr]: isNaN(parsedValue) ? value : parsedValue
+            };
+        }, {}),
+};

package/strapi-admin.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./admin/src').default;

package/strapi-server.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const server = require('./server');
+const contentTypes = require('./content-types');
+
+module.exports = () => ({
+    ...server,
+    contentTypes,
+  });

package/admin/src/assets/images/icon-cross-blue.svg

@@ -1 +0,0 @@
-<svg width="8" height="8" xmlns="http://www.w3.org/2000/svg"><path d="M7.78 6.72L5.06 4l2.72-2.72a.748.748 0 0 0 0-1.06.748.748 0 0 0-1.06 0L4 2.94 1.28.22a.748.748 0 0 0-1.06 0 .748.748 0 0 0 0 1.06L2.94 4 .22 6.72a.748.748 0 0 0 0 1.06.748.748 0 0 0 1.06 0L4 5.06l2.72 2.72a.748.748 0 0 0 1.06 0 .752.752 0 0 0 0-1.06z" fill="#007EFF" fill-rule="evenodd"/></svg>

package/admin/src/assets/images/icon_remove.svg

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg width="20px" height="20px" viewBox="0 0 20 20" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <!-- Generator: Sketch 49.3 (51167) - http://www.bohemiancoding.com/sketch -->
-    <title>Icon remove</title>
-    <desc>Created with Sketch.</desc>
-    <defs></defs>
-    <g id="Pages" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Content-Manager---List-view" transform="translate(-279.000000, -165.000000)">
-            <g id="Container" transform="translate(234.000000, 0.000000)">
-                <g id="Add-filters" transform="translate(0.000000, 60.000000)">
-                    <g id="Icon-remove" transform="translate(45.000000, 105.000000)">
-                        <rect id="Rectangle-12" stroke="#E3E9F3" x="0.5" y="0.5" width="19" height="19" rx="9.5"></rect>
-                        <path d="M6,10 L14,10" id="Line-4" stroke="#007EFF" stroke-width="2" stroke-linecap="round"></path>
-                    </g>
-                </g>
-            </g>
-        </g>
-    </g>
-</svg>

package/admin/src/assets/images/logo.svg

@@ -1,5 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 576 512"><path d="M532 386.2c27.5-27.1 44-61.1 44-98.2 0-80-76.5-146.1-176.2-157.9C368.3 72.5 294.3 32 208 32 93.1 32 0 103.6 0 192c0 37 16.5 71 44 98.2-15.3 30.7-37.3 54.5-37.7 54.9-6.3 6.7-8.1 16.5-4.4 25 3.6 8.5 12 14 21.2 14 53.5 0 96.7-20.2 125.2-38.8 9.2 2.1 18.7 3.7 28.4 4.9C208.1 407.6 281.8 448 368 448c20.8 0 40.8-2.4 59.8-6.8C456.3 459.7 499.4 480 553 480c9.2 0 17.5-5.5 21.2-14 3.6-8.5 1.9-18.3-4.4-25-.4-.3-22.5-24.1-37.8-54.8zm-392.8-92.3L122.1 305c-14.1 9.1-28.5 16.3-43.1 21.4 2.7-4.7 5.4-9.7 8-14.8l15.5-31.1L77.7 256C64.2 242.6 48 220.7 48 192c0-60.7 73.3-112 160-112s160 51.3 160 112-73.3 112-160 112c-16.5 0-33-1.9-49-5.6l-19.8-4.5zM498.3 352l-24.7 24.4 15.5 31.1c2.6 5.1 5.3 10.1 8 14.8-14.6-5.1-29-12.3-43.1-21.4l-17.1-11.1-19.9 4.6c-16 3.7-32.5 5.6-49 5.6-54 0-102.2-20.1-131.3-49.7C338 339.5 416 272.9 416 192c0-3.4-.4-6.7-.7-10C479.7 196.5 528 238.8 528 288c0 28.7-16.2 50.6-29.7 64z"/></svg>
-<!--
-Font Awesome Free 5.2.0 by @fontawesome - https://fontawesome.com
-License - https://fontawesome.com/license (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License)
--->

package/admin/src/components/AbuseReportsPopUp/ItemPreviewContainer.js

@@ -1,8 +0,0 @@
-import Container from '../List/Container';
-import styled from 'styled-components';
-
-const ItemPreviewContainer = styled(Container)`
-    padding: 0;
-`;
-
-export default ItemPreviewContainer;

package/admin/src/components/AbuseReportsPopUp/ModalFooter.js

@@ -1,31 +0,0 @@
-import { ModalFooter as StrapiModalFooter, colors } from 'strapi-helper-plugin';
-
-import styled from 'styled-components';
-
-const ModalFooter = styled(StrapiModalFooter)`
-      section {
-        justify-content: flex-end;
-        &:last-of-type {
-            justify-content: flex-end;
-        }
-
-        label {
-            display: flex;
-            flex-direction: row;
-            align-items: center;
-            justify-content: center;
-            padding: 0;
-            margin: 0;
-
-            color: ${colors.leftMenu.darkGrey};
-            font-weight: 600;
-            font-style: italic;
-        }
-
-        button {
-            margin-left: 1rem;
-        }
-    }
-`;
-
-export default ModalFooter;