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

package/config/functions/bootstrap.js

@@ -1,48 +0,0 @@
-module.exports = async () => {
-  // Check if the plugin users-permissions is installed because the comments needs it
-  if (Object.keys(strapi.plugins).indexOf('users-permissions') === -1) {
-    throw new Error(
-      'In order to make the comments plugin work the users-permissions plugin is required'
-    );
-  }
-
-  // Add permissions
-  const actions = [
-    {
-      section: 'plugins',
-      displayName: 'Access the Comments',
-      uid: 'read',
-      pluginName: 'comments',
-    },
-    {
-      section: 'plugins',
-      displayName: 'Modefation',
-      uid: 'moderate',
-      pluginName: 'comments',
-    },
-    {
-      section: 'plugins',
-      displayName: 'Single comments',
-      uid: 'moderate.block.comment',
-      subCategory: 'moderate',
-      pluginName: 'comments',
-    },
-    {
-      section: 'plugins',
-      displayName: 'Comments threads',
-      uid: 'moderate.block.thread',
-      subCategory: 'moderate',
-      pluginName: 'comments',
-    },
-    {
-      section: 'plugins',
-      displayName: 'Review & resolve reports',
-      uid: 'moderate.reports',
-      subCategory: 'moderate',
-      pluginName: 'comments',
-    },
-  ];
-
-  const { actionProvider } = strapi.admin.services.permission;
-  await actionProvider.registerMany(actions);
-};

package/config/routes.json

@@ -1,116 +0,0 @@
-{
-  "routes": [
-    {
-      "method": "GET",
-      "path": "/:relation",
-      "handler": "comments.findAllInHierarchy",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "POST",
-      "path": "/:relation",
-      "handler": "comments.post",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "GET",
-      "path": "/:relation/flat",
-      "handler": "comments.findAllFlat",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "PUT",
-      "path": "/:relation/comment/:commentId",
-      "handler": "comments.put",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "POST",
-      "path": "/:relation/comment/:commentId/report-abuse",
-      "handler": "comments.reportAbuse",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "PATCH",
-      "path": "/:relation/comment/:commentId/like",
-      "handler": "comments.pointsUp",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "DELETE",
-      "path": "/:relationId/:commentId",
-      "handler": "comments.removeComment",
-      "config": {
-        "policies": []
-      }
-    },
-    {
-      "method": "GET",
-      "path": "/moderation/all",
-      "handler": "comments.findAll",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.read"]]]
-      }
-    },
-    {
-      "method": "GET",
-      "path": "/moderation/single/:id",
-      "handler": "comments.findOne",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.read"]]]
-      }
-    },
-    {
-      "method": "GET",
-      "path": "/moderation/config",
-      "handler": "comments.config",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.read"]]]
-      }
-    },
-    {
-      "method": "GET",
-      "path": "/moderation/contents-types/:contentTypeName",
-      "handler": "comments.contentTypeName",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.read"]]]
-      }
-    },
-    {
-      "method": "PUT",
-      "path": "/moderation/block/:id",
-      "handler": "comments.blockComment",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.moderate.block.comment"]]]
-      }
-    },
-    {
-      "method": "PUT",
-      "path": "/moderation/block-thread/:id",
-      "handler": "comments.blockCommentThread",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.moderate.block.thread"]]]
-      }
-    },
-    {
-      "method": "PATCH",
-      "path": "/moderation/abuse-reports/:commentId/resolve/:id",
-      "handler": "comments.resolveAbuseReport",
-      "config": {
-        "policies": [["admin::hasPermissions", ["plugins::comments.moderate.reports"]]]
-      }
-    }
-  ]
-}

package/config/schema.graphql.js

@@ -1,270 +0,0 @@
-const BASE_COMMENTS = `
-  id: ID!
-  content: String!
-  blocked: Boolean
-  blockedThread: Boolean
-  blockReason: String
-  points: Int
-  authorUser: UsersPermissionsUser
-  authorType: String
-  authorId: String
-  authorName: String
-  authorAvatar: String
-  removed: Boolean
-  relatedSlug: String
-  reports: [CommentReport]
-`;
-const jsonParse = (json) => {
-  try {
-    return JSON.parse(json);
-  } catch (e) {
-    return {};
-  }
-};
-const configRelatedContentTypes = Object.keys(strapi.config
-  .get('plugins.comments.relatedContentTypes') || {})
-  .map(key => `${key}: CommentsRelatedContentType`)
-  .join('\n');
-//  reports: [CommentReport]
-module.exports = {
-  // language=GraphQL
-  definition: `
-      scalar Relation
-      enum CommentReportReason {
-          BAD_LANGAUGE
-          DISCRIMINATION
-          OTHER
-      }
-      type CommentReport {
-          id: ID!
-          content: String
-          reason: CommentReportReason!
-          resolved: Boolean!
-          related: Comment
-      }
-
-      type Comment {
-         ${BASE_COMMENTS}
-      }
-
-      type CommentsInHierarchy {
-        ${BASE_COMMENTS}
-        children: [Comment]
-      }
-
-      type CommentsPagination {
-        items: [Comment]!
-        total: Int!
-        page: Float
-      }
-
-      type CommentsWithThread {
-        ${BASE_COMMENTS}
-        threadOf: Comment
-      }
-
-      type CommentsFindOne {
-        selected: CommentsWithThread
-        level: [Comment]!
-      }
-
-      type CommentsContentTypes {
-      key: String!
-      value: String!
-      }
-
-      type CommentsRelatedContentType {
-        contentManager: Boolean
-        isSingle: Boolean
-        url: String
-      }
-
-      type CommentsRelatedContentTypes {
-        ${configRelatedContentTypes}
-      }
-
-      type CommentsConfig {
-        contentsTypes: [CommentsContentTypes]!
-        relatedContentTypes: CommentsRelatedContentTypes
-      }
-
-      type CommentsContentType {
-        key: String!
-        value: String
-      }
-      
-      type CommentRemove {
-        id: ID!
-      }
-
-      input NewCommentRelated {
-        refId: String!
-        ref: String!
-        field: String!
-      }
-
-      input CommentNew {
-        authorId: String
-        authorName: String
-        authorEmail: String
-        content: String!
-        authorUsername: String
-        threadOf: String
-        related: [NewCommentRelated!]!
-      }
-  `,
-  // language=GraphQL
-  query: `
-      findAllInHierarchy(relation: Relation!, where: JSON): [CommentsInHierarchy]!
-      findAllFlat(relation: Relation!, where: JSON): [Comment]!
-      findAll(related: Relation, entity: ID, where: JSON): CommentsPagination!
-      findOne(id: ID!): CommentsFindOne
-      config: CommentsConfig
-      contentTypeName(contentType: String!): [CommentsContentType]!
-  `,
-  type: {
-    Relation: 'It is related slug given when comment was created',
-  },
-  // language=GraphQL
-  mutation: `
-      commentAdd(comment: CommentNew): Comment!
-      commentUpdate(id: ID!, content: String!, related: NewCommentRelated): Comment!
-      commentReportAbuse(id: ID!, relation: Relation!, reason: CommentReportReason!, content: String!): CommentReport
-      commentLike(id: ID!, relation: Relation!): Comment
-      commentRemove(id: ID!, relation: Relation!, authorId: ID!): CommentRemove
-      commentBlock(id: ID!): Comment
-      commentThreadBlock(id: ID!): Comment
-      commentResolveReport(reportId: ID!, commentId: ID!): CommentReport
-  `,
-  resolver: {
-    Query: {
-      findAllInHierarchy: {
-        resolverOf: 'plugins::comments.comments.findAllInHierarchy',
-        resolver(obj, options) {
-          const { relation, where } = options;
-          const query = jsonParse(where);
-          return strapi.plugins.comments.services.comments.findAllInHierarchy({
-            relation,
-            query,
-            dropBlockedThreads: true,
-          });
-        },
-      },
-      findAllFlat: {
-        resolverOf: 'plugins::comments.comments.findAllFlat',
-        resolver(obj, options) {
-          const { relation, where } = options;
-          const query = jsonParse(where);
-          return strapi.plugins.comments.services.comments.findAllFlat(relation, query);
-        },
-      },
-      findAll: {
-        resolverOf: 'plugins::comments.comments.findAll',
-        resolver(obj, options) {
-          const { related, entity, where } = options;
-          const query = jsonParse(where);
-          return strapi.plugins.comments.services.comments.findAll({
-            ...query,
-            related,
-            entity,
-          });
-        },
-      },
-      findOne: {
-        resolverOf: 'plugins::comments.comments.findOne',
-        resolver(obj, options) {
-          const { id } = options;
-          return strapi.plugins.comments.services.comments.findOneAndThread(id);
-        },
-      },
-      config: {
-        resolverOf: 'plugins::comments.comments.config',
-        resolver(obj, options, { context }) {
-          return strapi.plugins.comments.controllers.comments.config(context);
-        },
-      },
-      contentTypeName: {
-        resolverOf: 'plugins::comments.comments.contentTypeName',
-        resolver(obj, options) {
-          const { contentType } = options;
-          return strapi.plugins.comments.services.comments.contentTypeName(contentType);
-        },
-      },
-    },
-    Mutation: {
-      commentAdd: {
-        resolverOf: 'plugins::comments.comments.post',
-        policies: ['plugins::users-permissions.isAuthenticated'],
-        resolver(obj, options, { context }) {
-          const user = context.state.user;
-          const { comment } = options;
-          return strapi.plugins.comments.services.comments
-            .create(comment, user);
-        },
-      },
-      commentUpdate: {
-        resolverOf: 'plugins::comments.comments.put',
-        policies: ['plugins::users-permissions.isAuthenticated'],
-        resolver(obj, options, { context }) {
-          const user = context.state.user;
-          const { id, ...data } = options;
-          return strapi.plugins.comments.services.comments
-            .update(id, data, user);
-        },
-      },
-      commentReportAbuse: {
-        resolverOf: 'plugins::comments.comments.reportAbuse',
-        policies: ['plugins::users-permissions.isAuthenticated'],
-        resolver(obj, options, { context }) {
-          const user = context.state.user;
-          const { id, relation, reason, content } = options;
-          return strapi.plugins.comments.services.comments
-            .reportAbuse(id, relation, { reason, content }, user);
-        },
-      },
-      commentLike: {
-        resolverOf: 'plugins::comments.comments.pointsUp',
-        policies: ['plugins::users-permissions.isAuthenticated'],
-        resolver(obj, options, { context }) {
-          const user = context.state.user;
-          const { id, relation } = options;
-          return strapi.plugins.comments.services.comments
-            .pointsUp(id, relation, user);
-        },
-      },
-      commentRemove: {
-        resolverOf: 'plugins::comments.comments.removeComment',
-        resolver(obj, options) {
-          const { id, relation, authorId } = options;
-          return strapi.plugins.comments.services.comments
-            .markAsRemoved(relation, id, authorId);
-        },
-      },
-      commentBlock: {
-        resolverOf: 'plugins::comments.comments.blockComment',
-        resolver(obj, options) {
-          const { id } = options;
-          return strapi.plugins.comments.services.comments
-            .blockComment(id);
-        },
-      },
-      commentThreadBlock: {
-        resolverOf: 'plugins::comments.comments.blockCommentThread',
-        resolver(obj, options) {
-          const { id } = options;
-          return strapi.plugins.comments.services.comments
-            .blockCommentThread(id);
-        },
-      },
-      commentResolveReport: {
-        resolverOf: 'plugins::comments.comments.resolveAbuseReport',
-        resolver(obj, options) {
-          const { reportId, commentId } = options;
-          return strapi.plugins.comments.services.comments
-            .resolveAbuseReport(reportId, commentId);
-        },
-      },
-    },
-  },
-};
-

package/controllers/comments.js

@@ -1,211 +0,0 @@
-'use strict';
-
-const { parseParams, throwError } = require('./utils/functions');
-const _ = require('lodash');
-
-/**
- * comments.js controller
- *
- * @description: A set of functions called "actions" of the `comments` plugin.
- */
-
-module.exports = {
-
-  getService() {
-    return strapi.plugins.comments.services.comments;
-  },
-
-  /**
-   * Default action.
-   *
-   * @return {Object}
-   */
-  async findAll(ctx) {
-    return strapi.plugins.comments.services.comments.findAll(ctx.query);
-  },
-
-  async findAllFlat(ctx) {
-    const { params = {}, query } = ctx;
-    const { relation } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.findAllFlat(relation, query);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async findAllInHierarchy(ctx) {
-    const { params = {}, query } = ctx;
-    const { relation } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.findAllInHierarchy({
-        relation,
-        query,
-        dropBlockedThreads: true,
-      });
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async post(ctx) {
-    const { request, state = {} } = ctx;
-    const { user } = state;
-    const { body = {} } = request;
-    try {
-      const entity = await strapi.plugins.comments.services.comments.create(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 } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.update(commentId, body, user);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async pointsUp(ctx) {
-    const { state, params = {} } = ctx;
-    const { user } = state;
-    const { relation, commentId } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.pointsUp(commentId, relation, 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 strapi.plugins.comments.services.comments.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');
-  },
-
-  //
-  // Moderation
-  //
-
-  async findOne(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.findOneAndThread(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async blockComment(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.blockComment(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async blockCommentThread(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.blockCommentThread(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async resolveAbuseReport(ctx) {
-    const { params = {} } = ctx;
-    const { id, commentId } = parseParams(params);
-    try {
-      return await strapi.plugins.comments.services.comments.resolveAbuseReport(id, commentId);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async config(ctx) {
-    const configRelatedContentTypes = _.get(strapi.config, ['plugins', 'comments', 'relatedContentTypes'], {});
-    const contentsTypes = this.getContentsTypes();
-    const relatedContentTypes = Object
-      .keys(configRelatedContentTypes)
-      .reduce((acc, currentKey) => {
-          const current = configRelatedContentTypes[currentKey];
-          const { key } = contentsTypes.find(content => content.value === currentKey) || {};
-          return {
-            ...acc,
-            [currentKey]: {
-              ...current,
-              globalName: _.snakeCase(key),
-            },
-          };
-        },
-        {},
-      );
-    return {
-      relatedContentTypes,
-      contentsTypes,
-    };
-  },
-
-  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 strapi.plugins.comments.services.comments.contentTypeName(contentTypeName);
-      return { list: result };
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-};

package/models/comment.js

@@ -1,8 +0,0 @@
-'use strict';
-
-/**
- * Read the documentation (https://strapi.io/documentation/3.0.0-beta.x/concepts/models.html#life-cycle-callbacks)
- * to customize this model
- */
-
-module.exports = {};