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

package/config/schema.graphql.js

@@ -1,268 +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]
-  approvalStatus: CommentApprovalStatus
-`;
-
-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
-      }
-      enum CommentApprovalStatus {
-          PENDING
-          APPROVED
-          REJECTED
-      }
-      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!]!
-        approvalStatus: CommentApprovalStatus
-      }
-  `,
-  // 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;
-          return strapi.plugins.comments.services.comments.findAllInHierarchy({
-            relation,
-            where,
-            dropBlockedThreads: true,
-          });
-        },
-      },
-      findAllFlat: {
-        resolverOf: 'plugins::comments.comments.findAllFlat',
-        resolver(obj, options) {
-          const { relation, where } = options;
-          return strapi.plugins.comments.services.comments.findAllFlat(relation, where);
-        },
-      },
-      findAll: {
-        resolverOf: 'plugins::comments.comments.findAll',
-        resolver(obj, options) {
-          const { related, entity, where } = options;
-          return strapi.plugins.comments.services.comments.findAll({
-            ...where,
-            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,228 +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 approveComment(ctx) {
-    const { id } = parseParams(ctx.params || {});
-    try {
-      return await strapi.plugins.comments.services.comments.approveComment(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async rejectComment(ctx) {
-    const { id } = parseParams(ctx.params || {});
-    try {
-      return await strapi.plugins.comments.services.comments.rejectComment(id);
-    } 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 = {};

package/models/comment.settings.json

@@ -1,102 +0,0 @@
-{
-  "collectionName": "comments",
-  "info": {
-    "name": "comment",
-    "description": ""
-  },
-  "options": {
-    "increments": true,
-    "timestamps": true,
-    "isManaged": false,
-    "comment": ""
-  },
-  "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
-    },
-    "points": {
-      "type": "integer",
-      "default": 0,
-      "configurable": false
-    },
-    "authorUser": {
-      "model": "user",
-      "plugin": "users-permissions",
-      "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
-    },
-    "relatedSlug": {
-      "type": "string",
-      "private": true,
-      "configurable": false
-    },
-    "related": {
-      "collection": "*",
-      "filter": "field",
-      "configurable": false
-    },
-    "reports": {
-      "collection": "report",
-      "plugin": "comments",
-      "via": "related",
-      "configurable": false
-    },
-    "threadOf": {
-      "columnName": "threadOf",
-      "model": "comment",
-      "plugin": "comments",
-      "configurable": false
-    },
-    "approvalStatus": {
-      "type": "string",
-      "configurable": false
-    }
-  }
-}

package/models/report.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 = {};

package/models/report.settings.json

@@ -1,49 +0,0 @@
-{
-  "collectionName": "comments_report",
-  "info": {
-    "name": "report",
-    "description": ""
-  },
-  "options": {
-    "increments": true,
-    "timestamps": true,
-    "isManaged": false,
-    "comment": ""
-  },
-  "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": {
-      "fieldName": "related",
-      "model": "comment",
-      "plugin": "comments",
-      "configurable": false
-    }
-  }
-}