strapi-plugin-comments 2.1.7 → 2.2.0-beta.0

package/server/services/admin.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const functions_1 = require("./../utils/functions");
 const lodash_1 = require("lodash");
 const error_1 = __importDefault(require("./../utils/error"));
+const utils_1 = require("./../../types/utils");
 const functions_2 = require("./utils/functions");
 const constants_1 = require("./../utils/constants");
 module.exports = ({ strapi }) => ({
@@ -125,11 +126,87 @@ module.exports = ({ strapi }) => ({
             },
         };
     },
+    async findReports(query) {
+        const { _q, filters, orderBy, page = 1, pageSize = 10, } = (0, functions_1.parseParams)(query);
+        const defaultWhere = {
+            resolved: { $notNull: true },
+        };
+        const defaultAuthorUserPopulate = this.getDefaultAuthorPopulate();
+        let params = {
+            where: !(0, lodash_1.isEmpty)(filters)
+                ? {
+                    ...defaultWhere,
+                    ...filters,
+                }
+                : { ...defaultWhere },
+            offset: (page - 1) * pageSize,
+            limit: pageSize,
+            orderBy: orderBy || [{ resolved: "asc" }, { createdAt: "desc" }],
+        };
+        if (_q) {
+            params = {
+                ...params,
+                where: {
+                    ...params.where,
+                    content: {
+                        $contains: _q,
+                    },
+                },
+            };
+        }
+        const entities = await strapi.db
+            .query((0, functions_2.getModelUid)("comment-report"))
+            .findMany({
+            ...params,
+            populate: ["related"],
+        });
+        const total = await strapi.db
+            .query((0, functions_2.getModelUid)("comment-report"))
+            .count({
+            where: params.where,
+        });
+        const reportedCommentsIds = entities.map((report) => report.related.id);
+        const commentsInThreads = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .findMany({
+            where: {
+                threadOf: reportedCommentsIds,
+            },
+            populate: ["threadOf"],
+            limit: Number.MAX_SAFE_INTEGER,
+        });
+        const commentWithThreadIds = [
+            ...new Set(commentsInThreads.map(({ threadOf }) => {
+                (0, utils_1.assertComment)(threadOf);
+                return threadOf.id;
+            })),
+        ];
+        const result = entities.map((_) => {
+            const isCommentWithThread = commentWithThreadIds.includes(_.related.id);
+            return (0, functions_2.filterOurResolvedReports)(this.getCommonService().sanitizeCommentEntity({
+                ..._,
+                related: this.getCommonService().sanitizeCommentEntity({
+                    ..._.related,
+                    gotThread: isCommentWithThread,
+                }),
+            }, defaultAuthorUserPopulate?.populate));
+        });
+        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 defaultAuthorUserPopulate = this.getDefaultAuthorPopulate();
         const defaultWhere = !removed
             ? {
-                $or: [{ removed: false }, { removed: null }],
+                $or: [{ removed: false }, { removed: { $notNull: false } }],
             }
             : {};
         const reportsPopulation = {
@@ -213,6 +290,17 @@ module.exports = ({ strapi }) => ({
         });
         return this.getCommonService().sanitizeCommentEntity(changedEntity);
     },
+    async deleteComment(id) {
+        const changedEntity = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .update({
+            where: { id },
+            data: {
+                removed: true,
+            },
+        });
+        return this.getCommonService().sanitizeCommentEntity(changedEntity);
+    },
     async blockCommentThread(id, forceStatus) {
         const existingEntity = await this.getCommonService().findOne({ id });
         const status = !(0, lodash_1.isNil)(forceStatus)
@@ -262,7 +350,7 @@ module.exports = ({ strapi }) => ({
             data: { resolved: true },
         });
     },
-    async resolveMultipleAbuseReports(ids, commentId) {
+    async resolveCommentMultipleAbuseReports(ids, commentId) {
         const reportsToResolve = await strapi.db
             .query((0, functions_2.getModelUid)("comment-report"))
             .findMany({
@@ -270,7 +358,7 @@ module.exports = ({ strapi }) => ({
                 id: ids,
                 related: commentId,
             },
-            populate: ['related']
+            populate: ["related"],
         });
         if (reportsToResolve.length === ids.length) {
             return strapi.db
@@ -280,20 +368,118 @@ module.exports = ({ strapi }) => ({
                 data: { resolved: true },
             });
         }
-        throw new error_1.default(400, 'At least one of selected reports got invalid comment entity relation. Try again.');
+        throw new error_1.default(400, "At least one of selected reports got invalid comment entity relation. Try again.");
+    },
+    async resolveAllAbuseReportsForComment(commentId) {
+        if (commentId) {
+            const blockedCommentReports = strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .findMany({
+                where: {
+                    related: commentId,
+                    resolved: false,
+                },
+                populate: ["related"],
+            });
+            const reportIds = (await blockedCommentReports).map((report) => report.id);
+            return strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .updateMany({
+                where: {
+                    id: reportIds,
+                },
+                data: { resolved: true },
+            });
+        }
+        throw new error_1.default(400, "There is something wrong with comment Id. Try again.");
+    },
+    async resolveAllAbuseReportsForThread(commentId) {
+        if (commentId) {
+            const commentsInThread = strapi.db
+                .query((0, functions_2.getModelUid)("comment"))
+                .findMany({
+                where: {
+                    threadOf: commentId,
+                },
+            });
+            const commentsInThreadIds = (await commentsInThread).map((comment) => comment.id);
+            commentsInThreadIds.push(commentId);
+            const reportsInThread = strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .findMany({
+                where: {
+                    related: commentsInThreadIds,
+                    resolved: false,
+                },
+                populate: ["related"],
+            });
+            const reportsInThreadIds = (await reportsInThread).map((report) => report.id);
+            return strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .updateMany({
+                where: {
+                    id: reportsInThreadIds,
+                },
+                data: { resolved: true },
+            });
+        }
+        throw new error_1.default(400, "There is something wrong with comment Id. Try again.");
+    },
+    async resolveMultipleAbuseReports(ids) {
+        if (!!ids.length) {
+            return strapi.db
+                .query((0, functions_2.getModelUid)("comment-report"))
+                .updateMany({
+                where: { id: { $in: ids } },
+                data: { resolved: true },
+            });
+        }
+        throw new error_1.default(400, "At least one of selected reports got invalid comment entity relation. Try again.");
+    },
+    async postComment(threadId, body, author) {
+        const entity = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .findOne({
+            where: {
+                id: threadId,
+            },
+        });
+        return await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .create({
+            data: {
+                approvalStatus: "APPROVED",
+                authorId: author.id,
+                authorName: author.username,
+                authorEmail: author.email,
+                content: body,
+                threadOf: threadId,
+                related: entity.related
+            },
+        });
+    },
+    async updateComment(id, body) {
+        const updateComment = await strapi.db
+            .query((0, functions_2.getModelUid)("comment"))
+            .update({
+            where: { id },
+            data: {
+                content: body
+            }
+        });
+        return this.getCommonService().sanitizeCommentEntity(updateComment);
     },
     getDefaultAuthorPopulate() {
-        const strapiUserTypeUid = 'plugin::users-permissions.user';
-        const allowedTypes = ['media', 'relation'];
+        const strapiUserTypeUid = "plugin::users-permissions.user";
+        const allowedTypes = ["media", "relation"];
         const { attributes } = strapi.contentTypes[strapiUserTypeUid] || {};
-        const relationTypes = Object.keys(attributes)
-            ?.filter((key) => allowedTypes.includes(attributes[key]?.type));
-        if (relationTypes.includes('avatar')) {
+        const relationTypes = Object.keys(attributes)?.filter((key) => allowedTypes.includes(attributes[key]?.type));
+        if (relationTypes.includes("avatar")) {
             return {
                 populate: { avatar: true },
             };
         }
         return undefined;
-    }
+    },
 });
 //# sourceMappingURL=admin.js.map

package/server/services/client.js

@@ -24,7 +24,7 @@ module.exports = ({ strapi }) => ({
         }
         const relatedEntity = await strapi.db
             .query(uid)
-            .findOne(relatedId);
+            .findOne({ where: { id: relatedId } });
         if (!relatedEntity) {
             throw new error_1.default(400, `Relation for field "related" does not exist. Check your payload please.`);
         }

package/server/utils/error.js

@@ -17,9 +17,9 @@ class PluginError extends Error {
     toJSON() {
         if (this.payload) {
             return {
+                ...this.payload,
                 name: this.name,
                 message: this.message,
-                ...(this.payload || {}),
             };
         }
         return this;

package/strapi-server.d.ts

@@ -154,7 +154,7 @@ declare const _default: () => {
         };
         validator: (config: CommentsPluginConfig) => void;
     };
-    register: () => void;
+    register: (context: import("strapi-typed").StrapiContext) => void;
     bootstrap: ({ strapi }: import("strapi-typed").StrapiContext) => Promise<void>;
     destroy: () => void;
     controllers: {