strapi-plugin-comments 1.0.4 → 2.0.0-beta.4

package/server/controllers/client.js

@@ -0,0 +1,117 @@
+'use strict';
+
+const { getPluginService } = require('./../utils/functions');
+const { parseParams, throwError } = require('./utils/functions');
+const _ = require('lodash');
+
+module.exports = {
+
+  getService(name = 'client') {
+    return getPluginService(name);
+  },
+
+  async findAllFlat(ctx) {
+    const { params = {}, query } = ctx;
+    const { relation } = parseParams(params);
+    try {
+      return this.getService('common')
+        .findAllFlat({
+          query: {
+            ...query,
+            related: relation,
+          },
+          populate: {
+            threadOf: true,
+          },
+        });
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async findAllInHierarchy(ctx) {
+    const { params = {}, query } = ctx;
+    const { relation } = parseParams(params);
+    try {
+      return await this.getService('common')
+        .findAllInHierarchy({
+          query: {
+            ...query,
+            related: relation,
+          },
+          populate: {
+            threadOf: true,
+          },
+          dropBlockedThreads: true,
+        });
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async post(ctx) {
+    const { request, params = {}, state = {} } = ctx;
+    const { relation } = parseParams(params);
+    const { user } = state;
+    const { body = {} } = request;
+    try {
+      const entity = await this.getService()
+        .create(relation, body, user);
+
+      if (entity) {
+        return entity;
+      }
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async put(ctx) {
+    const { request, state, params = {} } = ctx;
+    const { body = {} } = request;
+    const { user } = state;
+    const { commentId, relation } = parseParams(params);
+    try {
+      return await this.getService()
+        .update(commentId, relation, body, user);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async reportAbuse(ctx) {
+    const { request, state, params = {} } = ctx;
+    const { body = {} } = request;
+    if (!body.content) {
+      return ctx.badRequest(null, 'Content field is required');
+    }
+    const { user } = state;
+    const { relation, commentId } = parseParams(params);
+    try {
+      return await this.getService()
+        .reportAbuse(commentId, relation, body, user);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async removeComment(ctx) {
+    const { params: { relationId, commentId }, query: { authorId } } = ctx;
+    if (authorId) {
+      try {
+        return await this.getService()
+          .markAsRemoved(
+            relationId,
+            commentId,
+            authorId,
+          );
+      } catch (e) {
+        if (!e.isBoom) {
+          throwError(ctx, e);
+        }
+        throw e;
+      }
+    }
+    return ctx.badRequest('Not provided authorId');
+  },
+};

package/server/controllers/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const adminController = require('./admin');
+const clientController = require('./client');
+
+module.exports = {
+  admin: adminController,
+  client: clientController,
+};

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

@@ -1,4 +1,4 @@
-const PluginError = require('../../services/utils/error');
+const PluginError = require('./../../utils/error');
 
 module.exports = {
     parseParams: params => Object.keys(params).reduce((prev, curr) => {

package/server/destroy.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // destroy phase
+};

package/server/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const register = require('./register');
+const bootstrap = require('./bootstrap');
+const destroy = require('./destroy');
+const config = require('./config');
+const controllers = require('./controllers');
+const routes = require('./routes');
+const services = require('./services');
+
+module.exports = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes: {},
+  policies: {},
+  middlewares: {},
+};

package/server/register.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = ({ strapi }) => {
+  // registeration phase
+};

package/server/routes/admin.js

@@ -0,0 +1,92 @@
+'use strict';
+
+module.exports = [
+  {
+    method: 'GET',
+    path: '/moderate/config',
+    handler: 'admin.config',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/moderate/config/content-types/:contentTypeName',
+    handler: 'admin.contentTypeName',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/moderate/all',
+    handler: 'admin.findAll',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/moderate/single/:id',
+    handler: 'admin.findOne',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/single/:id/approve',
+    handler: 'admin.approveComment',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/single/:id/reject',
+    handler: 'admin.rejectComment',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/single/:id/block',
+    handler: 'admin.blockComment',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/single/:id/unblock',
+    handler: 'admin.unblockComment',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/single/:id/report/:reportId/resolve',
+    handler: 'admin.resolveAbuseReport',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/thread/:id/block',
+    handler: 'admin.blockCommentThread',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PATCH',
+    path: '/moderate/thread/:id/unblock',
+    handler: 'admin.unblockCommentThread',
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/client.js

@@ -0,0 +1,52 @@
+'use strict';
+
+module.exports = [
+  {
+    method: 'GET',
+    path: '/:relation',
+    handler: 'client.findAllInHierarchy',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'POST',
+    path: '/:relation',
+    handler: 'client.post',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/:relation/flat',
+    handler: 'client.findAllFlat',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/:relation/comment/:commentId',
+    handler: 'client.put',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'POST',
+    path: '/:relation/comment/:commentId/report-abuse',
+    handler: 'client.reportAbuse',
+    config: {
+      policies: [],
+    },
+  },
+  {
+    method: 'DELETE',
+    path: '/:relationId/comment/:commentId',
+    handler: 'client.removeComment',
+    config: {
+      policies: [],
+    },
+  },
+];

package/server/routes/index.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const clientRoutes = require('./client');
+const adminRoutes = require('./admin');
+
+module.exports = {
+  'content-api': {
+    type: 'content-api',
+    routes: clientRoutes,
+  },
+  admin: {
+    type: 'admin',
+    routes: adminRoutes,
+  },
+};

package/server/services/admin.js

@@ -0,0 +1,215 @@
+'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');
+    },
+
+    // Config
+    async config() {
+        const entryLabel = this.getCommonService().getConfig('entryLabel');
+        return {
+            entryLabel,
+        };
+    },
+
+    // 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, 
+                populate: {
+                    authorUser: 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));
+
+        return {
+            result,
+            pagination: {
+                page: page,
+                pageSize: pageSize,
+                pageCount: Math.floor(total / pageSize) + 1,
+                total,
+            },
+        };
+    },
+
+    // Find single comment
+    async findOneAndThread(id) {
+        const reportsPopulation = {
+            reports: {
+                where: { 
+                    resolved: false,
+                },
+            }
+        };
+
+        const entity = await strapi.db.query(getModelUid('comment')).findOne({ 
+            where: {
+                id
+            },
+            populate: {
+                authorUser: true,
+                threadOf: {
+                    populate: { 
+                        ...reportsPopulation
+                    },
+                },
+                ...reportsPopulation,
+            },
+        });
+
+        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,
+                },
+                populate: {
+                    ...reportsPopulation,
+                },
+                startingFromId: levelThreadId,
+                isAdmin: true
+            }, false);
+
+        const selectedEntity = this.getCommonService().sanitizeCommentEntity(entity);
+        
+        return {
+            entity: relatedEntity,
+            selected: {
+                ...selectedEntity,
+                threadOf: selectedEntity.threadOf ? selectedEntity.threadOf : null,
+            },
+            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 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 }
+        });
+    }, 
+});