strapi-plugin-comments 1.0.2-beta.1 → 2.0.0-beta.2

package/content-types/comment.js

@@ -0,0 +1,97 @@
+/**
+ * Comments Collection Type
+ */
+
+module.exports = {
+  info: {
+    tableName: 'plugin-comments-comments',
+    singularName: 'comment',
+    pluralName: 'comments',
+    displayName: 'Comment',
+    description: 'Comment content type',
+    kind: 'collectionType',
+  },
+  options: {
+    draftAndPublish: false,
+  },
+  pluginOptions: {
+    'content-manager': {
+      visible: false
+    },
+    'content-type-builder': {
+      visible: false
+    }
+  },
+  attributes: {
+    content: {
+      type: 'text',
+      configurable: false,
+      required: true
+    },
+    blocked: {
+      type: 'boolean',
+      default: false,
+      configurable: false
+    },
+    blockedThread: {
+      type: 'boolean',
+      default: false,
+      configurable: false
+    },
+    blockReason: {
+      type: 'string',
+      configurable: false
+    },
+    authorUser: {
+      type: 'relation',
+      relation: 'oneToOne',
+      target: 'plugin::users-permissions.user',
+      configurable: false,
+    },
+    authorType: {
+      type: 'string',
+      configurable: false
+    },
+    authorId: {
+      type: 'string',
+      configurable: false
+    },
+    authorName: {
+      type: 'string',
+      configurable: false
+    },
+    authorEmail: {
+      type: 'email',
+      configurable: false
+    },
+    authorAvatar: {
+      type: 'string',
+      configurable: false
+    },
+    removed: {
+      type: 'boolean',
+      configurable: false
+    },
+    approvalStatus: {
+      type: 'string',
+      configurable: false
+    },
+    related: {
+      type: 'string',
+      configurable: false
+    },
+    reports: {
+      type: 'relation',
+      relation: 'oneToMany',
+      target: 'plugin::comments.comment-report',
+      mappedBy: 'related',
+      configurable: false,
+    },
+    threadOf: {
+      type: 'relation',
+      relation: 'oneToOne',
+      target: 'plugin::comments.comment',
+      configurable: false,
+    },
+  },
+};

package/content-types/index.js

@@ -0,0 +1,11 @@
+const CommentCT = require('./comment');
+const ReportCT = require('./report');
+
+module.exports = {
+  'comment': {
+    schema: CommentCT,
+  },
+  'comment-report': {
+    schema: ReportCT,
+  }, 
+};

package/content-types/report.js

@@ -0,0 +1,54 @@
+/**
+ * Comments Collection Type
+ */
+
+ module.exports = {
+  info: {
+    tableName: 'plugin-comments-reports',
+    singularName: 'comment-report',
+    pluralName: 'comment-reports',
+    displayName: 'Reports',
+    description: 'Reports content type',
+    kind: 'collectionType',
+  },
+  options: {
+    draftAndPublish: false,
+  },
+  pluginOptions: {
+    'content-manager': {
+      visible: false
+    },
+    'content-type-builder': {
+      visible: false
+    }
+  },
+  attributes: {
+    content: {
+      type: 'text',
+      configurable: false
+    },
+    reason: {
+      type: 'enumeration',
+      enum: [
+        'BAD_LANGUAGE',
+        'DISCRIMINATION',
+        'OTHER'
+      ],
+      default: 'OTHER',
+      configurable: false,
+      required: true
+    },
+    resolved: {
+      type: 'boolean',
+      default: false,
+      configurable: false
+    },
+    related: {
+      type: 'relation',
+      relation: 'manyToOne',
+      target: 'plugin::comments.comment',
+      inversedBy: 'reports',
+      configurable: false,
+    },
+  },
+};

package/package.json

@@ -1,41 +1,27 @@
 {
   "name": "strapi-plugin-comments",
-  "version": "1.0.2-beta.1",
+  "version": "2.0.0-beta.2",
   "description": "Strapi - Comments plugin",
   "strapi": {
-    "name": "Comments",
-    "icon": "comments",
-    "description": "Comments & audience engagement"
+    "name": "comments",
+    "description": "Comments & audience engagement",
+    "kind": "plugin"
+  },
+  "scripts": {
+    "test:unit": "jest --verbose --coverage"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/VirtusLab-Open-Source/strapi-plugin-comments"
   },
-  "scripts": {
-    "test:unit": "jest --verbose --coverage"
-  },
   "dependencies": {
-    "bad-words": "^3.0.3",
-    "lodash": "^4.17.11",
-    "react": "^16.9.0",
-    "react-dom": "^16.9.0",
-    "react-intl": "4.5.0",
-    "react-redux": "^7.0.2",
-    "react-router": "^5.0.0",
-    "react-router-dom": "^5.0.0",
-    "reactstrap": "8.4.1",
-    "redux-saga": "^0.16.0",
-    "request": "^2.83.0",
-    "strapi-helper-plugin": "3.6.5",
-    "strapi-utils": "3.6.5",
-    "uuid": "^3.1.0"
+    "bad-words": "^3.0.4"
   },
   "devDependencies": {
-    "koa": "^2.8.0",
+    "codecov": "^3.7.2",
     "jest": "^26.0.1",
     "jest-cli": "^26.0.1",
-    "jest-styled-components": "^7.0.2",
-    "codecov": "^3.7.2"
+    "jest-styled-components": "^7.0.2"
   },
   "author": {
     "name": "VirtusLab // Mateusz Ziarko",
@@ -55,7 +41,7 @@
     }
   ],
   "engines": {
-    "node": ">=10.16.0",
+    "node": ">=12.x. <=16.x.x",
     "npm": ">=6.0.0"
   },
   "keywords": ["strapi", "plugin", "comments"],

package/server/bootstrap.js

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

package/server/config/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports = {
+  default: {
+    entryLabel: {
+      '*': ['Title', 'title', 'Name', 'name', 'Subject', 'subject']
+    }
+  },
+  validator() {},
+};

package/server/controllers/admin.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const { getPluginService } = require('./../utils/functions');
+const { parseParams, throwError } = require('./utils/functions');
+const _ = require('lodash');
+
+module.exports = {
+
+  getService(name = 'admin') {
+    return getPluginService(name);
+  },
+
+  async findAll(ctx) {
+    return this.getService()
+      .findAll(ctx.query);
+  },
+
+  async findOne(ctx) {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService()
+        .findOneAndThread(id);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async blockComment(ctx) {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService()
+        .blockComment(id, true);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async unblockComment(ctx) {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService()
+        .blockComment(id, false);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async blockCommentThread(ctx) {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService()
+        .blockCommentThread(id, true);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async unblockCommentThread(ctx) {
+    const { params = {} } = ctx;
+    const { id } = parseParams(params);
+    try {
+      return await this.getService()
+        .blockCommentThread(id, false);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async resolveAbuseReport(ctx) {
+    const { params = {} } = ctx;
+    const { id: commentId, reportId } = parseParams(params);
+    try {
+      return await this.getService()
+        .resolveAbuseReport(reportId, commentId);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async approveComment(ctx) {
+    const { id } = parseParams(ctx.params || {});
+    try {
+      return await this.getService()
+        .approveComment(id);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async rejectComment(ctx) {
+    const { id } = parseParams(ctx.params || {});
+    try {
+      return await this.getService()
+        .rejectComment(id);
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  async config() {
+    try {
+      return await this.getService().config();
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+
+  getContentsTypes() {
+    return Object.entries(strapi.contentTypes)
+      .filter(([, contentType]) => (
+        contentType.associations || []).some(_ => _.plugin === 'comments' && _.collection === 'comment'),
+      )
+      .reduce((acc, [, contentType]) => [
+          ...acc,
+          { key: contentType.globalName, value: contentType.collectionName }],
+        [],
+      );
+  },
+
+  async contentTypeName(ctx) {
+    const { params: { contentTypeName } } = ctx;
+    try {
+      const result = await this.getService()
+        .contentTypeName(contentTypeName);
+      return { list: result };
+    } catch (e) {
+      throwError(ctx, e);
+    }
+  },
+};

package/server/controllers/client.js

@@ -0,0 +1,109 @@
+'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,
+          related: relation,
+        });
+    } 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,
+          },
+          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,
+  },
+};