strapi-plugin-comments 2.0.10 → 2.0.11

package/build/server/services/admin.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+const functions_1 = require("./../utils/functions");
+const lodash_1 = require("lodash");
+const error_1 = __importDefault(require("./../utils/error"));
+const functions_2 = require("./utils/functions");
+const constants_1 = require("./../utils/constants");
+module.exports = ({ strapi }) => ({
+  getCommonService() {
+    return (0, functions_1.getPluginService)("common");
+  },
+  async config(viaSettingsPage = false) {
+    const pluginStore = await this.getCommonService().getPluginStore();
+    const config = await pluginStore.get({
+      key: "config",
+    });
+    const additionalConfiguration = {
+      regex: Object.keys(constants_1.REGEX).reduce(
+        (prev, curr) => ({
+          ...prev,
+          [curr]: constants_1.REGEX[curr].toString(),
+        }),
+        {}
+      ),
+    };
+    const getConfigProp = (key) => this.getCommonService().getLocalConfig(key);
+    const isGQLPluginEnabled = !(0, lodash_1.isNil)(strapi.plugin("graphql"));
+    if (config) {
+      return {
+        ...config,
+        ...additionalConfiguration,
+        isGQLPluginEnabled: viaSettingsPage ? isGQLPluginEnabled : undefined,
+      };
+    }
+    const entryLabel = getConfigProp("entryLabel");
+    const approvalFlow = getConfigProp("approvalFlow");
+    const reportReasons = getConfigProp("reportReasons");
+    const result = {
+      entryLabel,
+      approvalFlow,
+      reportReasons,
+      ...additionalConfiguration,
+    };
+    if (viaSettingsPage) {
+      const enabledCollections = getConfigProp("enabledCollections");
+      const moderatorRoles = getConfigProp("moderatorRoles");
+      return {
+        ...result,
+        enabledCollections,
+        moderatorRoles,
+        isGQLPluginEnabled,
+      };
+    }
+    return result;
+  },
+  async updateConfig(body) {
+    const pluginStore = await this.getCommonService().getPluginStore();
+    await pluginStore.set({ key: "config", value: body });
+    return this.config();
+  },
+  async restoreConfig() {
+    const pluginStore = await this.getCommonService().getPluginStore();
+    await pluginStore.delete({ key: "config" });
+    return this.config();
+  },
+  async restart() {
+    setImmediate(() => strapi.reload());
+  },
+  async findAll({ related, entity, ...query }) {
+    const {
+      _q,
+      orderBy,
+      pageSize = 10,
+      page = 1,
+      filters,
+    } = (0, functions_1.parseParams)(query);
+    const defaultWhere = {
+      $or: [{ removed: false }, { removed: null }],
+    };
+    let params = {
+      where: !(0, lodash_1.isEmpty)(filters)
+        ? {
+            ...defaultWhere,
+            ...filters,
+          }
+        : { ...defaultWhere },
+      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((0, functions_2.getModelUid)("comment"))
+      .findMany({
+        ...params,
+        populate: {
+          authorUser: true,
+          threadOf: true,
+          reports: {
+            where: {
+              resolved: false,
+            },
+          },
+        },
+      });
+    const total = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .count({
+        where: params.where,
+      });
+    const relatedEntities =
+      await this.getCommonService().findRelatedEntitiesFor(entities);
+    const result = entities
+      .map((_) =>
+        (0, functions_2.filterOurResolvedReports)(
+          this.getCommonService().sanitizeCommentEntity(_)
+        )
+      )
+      .map((_) =>
+        this.getCommonService().mergeRelatedEntityTo(_, relatedEntities)
+      );
+    const pageCount = Math.floor(total / pageSize);
+    return {
+      result,
+      pagination: {
+        page: page,
+        pageSize: pageSize,
+        pageCount: total % pageSize === 0 ? pageCount : pageCount + 1,
+        total,
+      },
+    };
+  },
+  async findOneAndThread(id, { removed, ...query }) {
+    const defaultWhere = !removed
+      ? {
+          $or: [{ removed: false }, { removed: null }],
+        }
+      : {};
+    const reportsPopulation = {
+      reports: {
+        where: {
+          resolved: false,
+        },
+      },
+    };
+    const defaultPopulate = {
+      populate: {
+        authorUser: true,
+        threadOf: {
+          populate: {
+            authorUser: true,
+            ...reportsPopulation,
+          },
+        },
+        ...reportsPopulation,
+      },
+    };
+    const entity = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .findOne({
+        where: {
+          id,
+        },
+        ...defaultPopulate,
+      });
+    if (!entity) {
+      throw new error_1.default(404, "Not found");
+    }
+    const [relatedUid, relatedStringId] = (0, functions_2.getRelatedGroups)(
+      entity.related
+    );
+    const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
+    const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
+      ? parsedRelatedId
+      : relatedStringId;
+    const relatedEntity = await strapi.db
+      .query(relatedUid)
+      .findOne({
+        where: { id: relatedId },
+      })
+      .then((_) => ({
+        ..._,
+        uid: relatedUid,
+      }));
+    if (!relatedEntity) {
+      throw new error_1.default(404, "Relation not found");
+    }
+    const levelThreadId = entity?.threadOf?.id || null;
+    const entitiesOnSameLevel =
+      await this.getCommonService().findAllInHierarchy(
+        {
+          query: {
+            ...defaultWhere,
+            ...query,
+            threadOf: levelThreadId,
+            related: entity.related,
+          },
+          ...defaultPopulate,
+          startingFromId: levelThreadId,
+          isAdmin: true,
+        },
+        false
+      );
+    const selectedEntity = this.getCommonService().sanitizeCommentEntity({
+      ...entity,
+      threadOf: entity.threadOf || null,
+    });
+    return {
+      entity: relatedEntity,
+      selected: selectedEntity,
+      level: entitiesOnSameLevel,
+    };
+  },
+  async blockComment(id, forceStatus) {
+    const existingEntity = await this.getCommonService().findOne({ id });
+    const changedEntity = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .update({
+        where: { id },
+        data: {
+          blocked: !(0, lodash_1.isNil)(forceStatus)
+            ? forceStatus
+            : !existingEntity.blocked,
+        },
+      });
+    return this.getCommonService().sanitizeCommentEntity(changedEntity);
+  },
+  async blockCommentThread(id, forceStatus) {
+    const existingEntity = await this.getCommonService().findOne({ id });
+    const status = !(0, lodash_1.isNil)(forceStatus)
+      ? forceStatus
+      : !existingEntity.blockedThread;
+    const changedEntity = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .update({
+        where: { id },
+        data: {
+          blocked: status,
+          blockedThread: status,
+        },
+      });
+    await this.blockNestedThreads(id, changedEntity.blockedThread);
+    return this.getCommonService().sanitizeCommentEntity(changedEntity);
+  },
+  async approveComment(id) {
+    const changedEntity = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .update({
+        where: { id },
+        data: { approvalStatus: constants_1.APPROVAL_STATUS.APPROVED },
+      });
+    return this.getCommonService().sanitizeCommentEntity(changedEntity);
+  },
+  async rejectComment(id) {
+    const changedEntity = await strapi.db
+      .query((0, functions_2.getModelUid)("comment"))
+      .update({
+        where: { id },
+        data: { approvalStatus: constants_1.APPROVAL_STATUS.REJECTED },
+      });
+    return this.getCommonService().sanitizeCommentEntity(changedEntity);
+  },
+  async blockNestedThreads(id, blockStatus) {
+    return await this.getCommonService().modifiedNestedNestedComments(
+      id,
+      "blockedThread",
+      blockStatus
+    );
+  },
+  async resolveAbuseReport(id, commentId) {
+    return strapi.db
+      .query((0, functions_2.getModelUid)("comment-report"))
+      .update({
+        where: {
+          id,
+          related: commentId,
+        },
+        data: { resolved: true },
+      });
+  },
+});
+//# sourceMappingURL=admin.js.map

package/build/server/services/client.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { IServiceClient } from "../../types";
+declare const _default: ({ strapi }: StrapiContext) => IServiceClient;
+export = _default;
+//# sourceMappingURL=client.d.ts.map

package/build/server/services/client.js

@@ -0,0 +1,247 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const functions_1 = require("./../utils/functions");
+const lodash_1 = require("lodash");
+const error_1 = __importDefault(require("./../utils/error"));
+const functions_2 = require("./utils/functions");
+const constants_1 = require("./../utils/constants");
+module.exports = ({ strapi }) => ({
+    getCommonService() {
+        return (0, functions_1.getPluginService)("common");
+    },
+    async create(relation, data, user = undefined) {
+        const { content, threadOf } = data;
+        const singleRelationFulfilled = relation && constants_1.REGEX.relatedUid.test(relation);
+        if (!singleRelationFulfilled) {
+            throw new error_1.default(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
+        }
+        const [uid, relatedId] = await this.getCommonService().parseRelationString(relation);
+        const relatedEntity = await strapi.db
+            .query(uid)
+            .findOne(relatedId);
+        if (!relatedEntity) {
+            throw new error_1.default(400, `Relation for field "related" does not exist. Check your payload please.`);
+        }
+        const approvalFlow = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.APPROVAL_FLOW, []);
+        const isApprovalFlowEnabled = approvalFlow.includes(uid) || relatedEntity.requireCommentsApproval;
+        const linkToThread = !(0, lodash_1.isNil)(threadOf)
+            ? await this.getCommonService().findOne({
+                id: threadOf,
+                related: relation,
+            })
+            : null;
+        const validContext = this.getCommonService().isValidUserContext(user);
+        if (linkToThread === null && !(0, lodash_1.isNil)(threadOf)) {
+            throw new error_1.default(400, "Thread does not exist");
+        }
+        if (!validContext) {
+            throw (0, functions_2.resolveUserContextError)(user);
+        }
+        if ((await this.getCommonService().checkBadWords(content)) &&
+            singleRelationFulfilled) {
+            const { author, ...rest } = data;
+            let authorData = {};
+            if (validContext && user) {
+                authorData = {
+                    authorUser: user?.id,
+                };
+            }
+            else if (author) {
+                if (author.email && !constants_1.REGEX.email.test(author.email)) {
+                    throw new error_1.default(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 (!(0, lodash_1.isEmpty)(authorData) &&
+                !(authorData.authorId || authorData.authorUser)) {
+                throw new error_1.default(400, `Not able to recognise author of a comment. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
+            }
+            if (isApprovalFlowEnabled &&
+                !(0, lodash_1.isNil)(data.approvalStatus) &&
+                data.approvalStatus !== constants_1.APPROVAL_STATUS.PENDING) {
+                throw new error_1.default(400, "Invalid approval status");
+            }
+            const entity = await strapi.db
+                .query((0, functions_2.getModelUid)("comment"))
+                .create({
+                data: {
+                    ...rest,
+                    ...authorData,
+                    related: relation,
+                    approvalStatus: isApprovalFlowEnabled
+                        ? constants_1.APPROVAL_STATUS.PENDING
+                        : null,
+                },
+                populate: {
+                    authorUser: true,
+                },
+            });
+            return this.getCommonService().sanitizeCommentEntity({
+                ...entity,
+                threadOf: linkToThread,
+            });
+        }
+        throw new error_1.default(400, "No content received");
+    },
+    async update(id, relation, data, user = undefined) {
+        const { content } = data;
+        const singleRelationFulfilled = relation && constants_1.REGEX.relatedUid.test(relation);
+        if (!singleRelationFulfilled) {
+            throw new error_1.default(400, `Request property "relation" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
+        }
+        await this.getCommonService().parseRelationString(relation);
+        const existingEntity = await this.getCommonService().findOne({
+            id,
+            related: relation,
+        });
+        const validContext = this.getCommonService().isValidUserContext(user);
+        if (!validContext) {
+            throw (0, functions_2.resolveUserContextError)(user);
+        }
+        if ((0, functions_2.isEqualEntity)(existingEntity, data, user) && content) {
+            if (await this.getCommonService().checkBadWords(content)) {
+                const entity = await strapi.db
+                    .query((0, functions_2.getModelUid)("comment"))
+                    .update({
+                    where: { id },
+                    data: { content },
+                    populate: { threadOf: true, authorUser: true },
+                });
+                return this.getCommonService().sanitizeCommentEntity(entity);
+            }
+        }
+        throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
+    },
+    async reportAbuse(id, relation, payload, user = undefined) {
+        if (!this.getCommonService().isValidUserContext(user)) {
+            throw (0, functions_2.resolveUserContextError)(user);
+        }
+        await this.getCommonService().parseRelationString(relation);
+        const reportAgainstEntity = await this.getCommonService().findOne({
+            id,
+            related: relation,
+        });
+        if (reportAgainstEntity) {
+            const entity = await strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .create({
+                data: {
+                    ...payload,
+                    resolved: false,
+                    related: id,
+                },
+            });
+            if (entity) {
+                const response = {
+                    ...entity,
+                    related: reportAgainstEntity,
+                };
+                try {
+                    await this.sendAbuseReportEmail(entity.reason, entity.content);
+                    return response;
+                }
+                catch (err) {
+                    return response;
+                }
+            }
+            else {
+                throw new error_1.default(500, "Report cannot be created");
+            }
+        }
+        throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure that comment exist or you've authenticated your request properly.`);
+    },
+    async markAsRemoved(id, relation, authorId, user = undefined) {
+        if (!this.getCommonService().isValidUserContext(user)) {
+            throw (0, functions_2.resolveUserContextError)(user);
+        }
+        const author = user?.id || authorId;
+        if (!author) {
+            throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure that you've provided proper "authorId" or authenticated your request properly.`);
+        }
+        await this.getCommonService().parseRelationString(relation);
+        try {
+            const byAuthor = user?.id
+                ? {
+                    authorUser: author,
+                }
+                : {
+                    authorId: author,
+                };
+            const entity = await this.getCommonService().findOne({
+                id,
+                related: relation,
+                ...byAuthor,
+            });
+            if (entity) {
+                const removedEntity = await strapi.db
+                    .query((0, functions_2.getModelUid)("comment"))
+                    .update({
+                    where: {
+                        id,
+                        related: relation,
+                    },
+                    data: { removed: true },
+                    populate: { threadOf: true, authorUser: true },
+                });
+                await this.markAsRemovedNested(id, true);
+                return this.getCommonService().sanitizeCommentEntity(removedEntity);
+            }
+            else {
+                throw new error_1.default(404, `Entity does not exist or you're not allowed to take an action on it`);
+            }
+        }
+        catch (e) {
+            throw new error_1.default(404, `Entity does not exist or you're not allowed to take an action on it`);
+        }
+    },
+    async sendAbuseReportEmail(reason, content) {
+        const rolesToBeNotified = (await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.MODERATOR_ROLES)) || ["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;
+            }
+        }
+    },
+    async markAsRemovedNested(id, status) {
+        return this.getCommonService().modifiedNestedNestedComments(id, "removed", status);
+    },
+});
+//# sourceMappingURL=client.js.map

package/build/server/services/common.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { IServiceCommon } from "../../types";
+declare const _default: ({ strapi }: StrapiContext) => IServiceCommon;
+export = _default;
+//# sourceMappingURL=common.d.ts.map