@webbio/strapi-plugin-page-builder 0.9.12-authentication → 0.9.14-authentication

package/README.md

@@ -110,6 +110,14 @@ Om private content toe te voegen aan het systeem, moet er bij de config van de p
 
 Zodra deze aan staat, wordt er extra componenten ingeladen en worden er bepaalde functies aangemaakt om gebruikers te kunnen registreren en te laten inloggen.
 
+## Private modules
+
+Wanneer private content aan staat, wordt ook de getPageByPath module private. Dit wordt gedaan om modules private te kunnen maken. Om de data op te kunnen halen van de page moet een header meegestuurd worden: "x-strapi-page-secret". Deze token wordt in de environment variabele gezet `STRAPI_PAGE_SECRET`
+
+Vervolgens kun je private modules maken. Deze hebben wel een structuur nodig. Zo moet het component `auth` bevatten. Voorbeeld: `authBodyText` Op die manier weten we of de module authenticatie bevat. Vervolgens moeten de velden in de module een `public` en een `private` veld bevatten. Voorbeeld: `publicBodyText` en `privateBodyText`.
+
+Binnen strapi kunnen we niet controleren of de public versie of private versie terug gestuurd moet worden. Dit komt doordat de resolvers van dynamic zones niet aangepast kunnen worden. Vandaar dat we de authenticatie op de server doen van de frontend.
+
 ### Voorbeeld
 Ik wil een lijst van vacature relaties selecteren. Deze vacatures moeten van hetzelfde platform zijn als het platform dat globaal is geselecteerd: 
 

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@webbio/strapi-plugin-page-builder",
-    "version": "0.9.12-authentication",
+    "version": "0.9.14-authentication",
     "description": "This is the description of the plugin.",
     "scripts": {
         "develop": "tsc -p tsconfig.server.json -w",

package/dist/server/content-types/category/category.json

@@ -0,0 +1,27 @@
+{
+    "kind": "collectionType",
+    "collectionName": "categories",
+    "info": {
+        "singularName": "category",
+        "pluralName": "categories",
+        "displayName": "Category"
+    },
+    "options": {
+        "draftAndPublish": false
+    },
+    "pluginOptions": {
+        "i18n": {
+            "localized": true
+        }
+    },
+    "attributes": {
+        "title": {
+            "pluginOptions": {
+                "i18n": {
+                    "localized": true
+                }
+            },
+            "type": "string"
+        }
+    }
+}

package/dist/server/content-types/page-version/schema.json

@@ -0,0 +1,16 @@
+{
+    "kind": "collectionType",
+    "collectionName": "page_versions",
+    "info": {
+        "singularName": "page-version",
+        "pluralName": "page-versions",
+        "displayName": "page-version"
+    },
+    "options": {
+        "draftAndPublish": false,
+        "comment": ""
+    },
+    "attributes": {
+        
+    }
+}

package/dist/server/controllers/page-version.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ *  controller
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const strapi_1 = require("@strapi/strapi");
+exports.default = strapi_1.factories.createCoreController('plugin::strapi-plugin-page-builder.page-version');

package/dist/server/graphql/page-by-path.js

@@ -63,7 +63,7 @@ const getPageByPath = (strapi) => {
                             };
                             const results = await getPage();
                             if (((_a = Object.values(results)) === null || _a === void 0 ? void 0 : _a.filter(Boolean).length) > 0) {
-                                if (!((_b = results === null || results === void 0 ? void 0 : results.platform) === null || _b === void 0 ? void 0 : _b.isPrivate) && !results.isPrivate) {
+                                if (!((_b = results === null || results === void 0 ? void 0 : results.platform) === null || _b === void 0 ? void 0 : _b.isPrivate) && !(results === null || results === void 0 ? void 0 : results.isPrivate)) {
                                     return results;
                                 }
                                 if ((((_c = results === null || results === void 0 ? void 0 : results.platform) === null || _c === void 0 ? void 0 : _c.isPrivate) === true && ctx.koaContext.req.headers.authorization) ||

package/dist/server/graphql/page-by-slug.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const filter_underscore_arguments_1 = require("../utils/filter-underscore-arguments");
+const constants_1 = require("../../shared/utils/constants");
+const getPageBySlug = (strapi) => {
+    const typeDefs = () => {
+        return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageBySlug(path: String, _domain: String, _locale: String, _publicationState: PublicationState): PageEntity
+        }
+
+      `;
+    };
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                getPageBySlug: {
+                    resolve: async (_parent, args, ctx) => {
+                        var _a;
+                        try {
+                            const filteredArgs = {
+                                ...(0, filter_underscore_arguments_1.filterUnderscoreArguments)(args),
+                                platform: { domain: args._domain }
+                            };
+                            const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+                            const getPage = async () => {
+                                var _a, _b, _c;
+                                const transformedArgs = transformArgs(filteredArgs, {
+                                    contentType: strapi.contentTypes[constants_1.PAGE_UID],
+                                    usePagination: false
+                                });
+                                const results = await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_UID, {
+                                    filters: filteredArgs,
+                                    locale: args._locale,
+                                    publicationState: args._publicationState,
+                                    populate: '*'
+                                }));
+                                const entityResponse = toEntityResponse((results === null || results === void 0 ? void 0 : results[0]) || {}, {
+                                    args: transformedArgs,
+                                    resourceUID: constants_1.PAGE_UID
+                                });
+                                if (!(entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) || Object.keys(entityResponse.value).length === 0) {
+                                    throw new Error(ctx.koaContext.response.message);
+                                }
+                                const collectionTypeDataFilter = (_c = (_b = entityResponse === null || entityResponse === void 0 ? void 0 : entityResponse.value) === null || _b === void 0 ? void 0 : _b.collectionTypeData) === null || _c === void 0 ? void 0 : _c.filter(Boolean);
+                                const collectionType = collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter === null || collectionTypeDataFilter === void 0 ? void 0 : collectionTypeDataFilter[0] : null;
+                                const addedAttributes = {
+                                    collectionType: collectionType
+                                };
+                                const result = {
+                                    ...entityResponse.value,
+                                    ...addedAttributes
+                                };
+                                return result;
+                            };
+                            const results = await getPage();
+                            if (((_a = Object.values(results)) === null || _a === void 0 ? void 0 : _a.filter(Boolean).length) > 0) {
+                                return results;
+                            }
+                            else {
+                                throw new Error(ctx.koaContext.response.message);
+                            }
+                        }
+                        catch (error) {
+                            console.log('Error in getPageBySlug:', error);
+                            throw new Error(ctx.koaContext.response.message);
+                        }
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.getPageBySlug': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs: typeDefs(),
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+exports.default = getPageBySlug;

package/dist/server/middlewares/private-content.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * `private-content` middleware
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (config, { strapi }) => {
+    // Add your own logic here.
+    return async (ctx, next) => {
+        strapi.log.info('[PRIVATE CONTENT] Before');
+        await next();
+        strapi.log.info('[PRIVATE CONTENT] After');
+    };
+};

package/dist/server/routes/index.js

@@ -6,7 +6,7 @@ const routes = {
         prefix: undefined,
         routes: [
             {
-                method: 'POST',
+                method: 'GET',
                 path: '/activate/:token',
                 handler: 'private-content.activateUser',
                 config: { policies: [], auth: false }

package/dist/server/routes/page-version.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ *  router
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const strapi_1 = require("@strapi/strapi");
+exports.default = strapi_1.factories.createCoreRouter('plugin::strapi-plugin-page-builder.page-version');

package/dist/server/services/authentication.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@strapi/utils");
+const utils_2 = require("@strapi/utils");
+const { ApplicationError } = utils_2.errors;
+const registerSchema = utils_1.yup.object({
+    email: utils_1.yup.string().email().required(),
+    password: utils_1.yup.string().required(),
+    platformId: utils_1.yup.number().required()
+});
+exports.default = {
+    registerAuthentication() {
+        this.extendUser();
+        this.extendGraphQL();
+    },
+    extendUser() {
+        const user = strapi.contentType('plugin::users-permissions.user');
+        user.attributes = {
+            ...user.attributes,
+            firstName: {
+                type: 'string'
+            },
+            lastName: {
+                type: 'string'
+            },
+            company: {
+                type: 'string'
+            },
+            jobTitle: {
+                type: 'string'
+            },
+            address: {
+                type: 'string'
+            },
+            postalCode: {
+                type: 'string'
+            },
+            city: {
+                type: 'string'
+            },
+            country: {
+                type: 'string'
+            },
+            phone: {
+                type: 'string'
+            },
+            platform: {
+                type: 'relation',
+                relation: 'oneToOne',
+                target: 'api::platform.platform'
+            },
+            categories: {
+                type: 'relation',
+                relation: 'oneToMany',
+                target: 'api::category.category'
+            }
+        };
+        delete user.attributes.username;
+    },
+    extendGraphQL() {
+        const extensionService = strapi.plugin('graphql').service('extension');
+        const extension = () => ({
+            typeDefs: `
+      input LoginInput {
+        email: String!
+        password: String!
+        platformId: ID!
+      }
+
+      input RegisterInput {
+        email: String!
+        password: String!
+        firstName: String
+        lastName: String
+        company: String
+        jobTitle: String
+        address: String
+        postalCode: String
+        city: String
+        country: String
+        phone: String
+        subscribeToNewsletter: Boolean
+				categories: [ID]
+        platformId: ID!
+      }
+
+      type LoginResponse {
+        jwt: String
+        user: User
+      }
+
+      type RegisterResponse {
+        user: User
+      }
+
+      type ForgotPasswordResponse {
+        ok: Boolean!
+      }
+
+      type User {
+        id: ID!
+        email: String!
+        confirmed: Boolean
+        blocked: Boolean
+        activated: Boolean
+        platformId: ID!
+      }
+
+      type Mutation {
+        platformLogin(input: LoginInput!): LoginResponse
+        platformRegister(input: RegisterInput!): RegisterResponse
+        platformForgotPassword(email: String!): ForgotPasswordResponse
+      }
+      `,
+            resolversConfig: {
+                'Mutation.platformLogin': {
+                    auth: false
+                },
+                'Mutation.platformRegister': {
+                    auth: false
+                }
+            },
+            resolvers: {
+                Mutation: {
+                    platformLogin: {
+                        resolve() {
+                            return null;
+                        }
+                    },
+                    platformRegister: {
+                        async resolve(parent, args) {
+                            const pluginStore = strapi.store({ type: 'plugin', name: 'users-permissions' });
+                            const settings = await pluginStore.get({ key: 'advanced' });
+                            if (!settings.allow_register) {
+                                throw new ApplicationError('Register action is currently disabled');
+                            }
+                            await (0, utils_1.validateYupSchema)(args.input, registerSchema);
+                            const { email, platformId } = args.input;
+                            const role = await strapi
+                                .query('plugin::users-permissions.role')
+                                .findOne({ where: { type: settings.default_role } });
+                            if (!role) {
+                                throw new ApplicationError('Impossible to find the default role');
+                            }
+                            const conflictingUserCount = await strapi.query('plugin::users-permissions.user').count({
+                                where: {
+                                    email,
+                                    platform: {
+                                        id: platformId
+                                    }
+                                }
+                            });
+                            if (conflictingUserCount > 0) {
+                                throw new ApplicationError('Email is already taken');
+                            }
+                            const userData = {
+                                ...args.input,
+                                role: role.id,
+                                email: email.toLowerCase(),
+                                confirmed: false,
+                                provider: 'local',
+                                categories: args.input.categories,
+                                platform: {
+                                    set: platformId
+                                }
+                            };
+                            const createdUser = await strapi.query('plugin::users-permissions.user').create({
+                                data: userData,
+                                populate: ['role', 'platform', 'categories']
+                            });
+                            const userSchema = strapi.getModel('plugin::users-permissions.user');
+                            const sanitizedUser = await utils_2.sanitize.contentAPI.output(createdUser, userSchema, {
+                                auth: false
+                            });
+                            return {
+                                user: sanitizedUser
+                            };
+                        }
+                    }
+                }
+            }
+        });
+        extensionService.use(extension);
+    },
+    async register(ctx) { }
+};

package/dist/server/services/email.js

@@ -73,11 +73,9 @@ exports.default = {
         });
     },
     async sendConfirmationEmail(user) {
-        console.log('HALLO');
         const foundUser = await strapi.entityService.findOne(constants_1.USER_PERMISSION_USER_PLUGIN, user.id, {
             populate: { platform: { populate: { platformEmails: { populate: '*' } } } }
         });
-        console.log({ foundUser });
         if (foundUser && foundUser.platform) {
             const jwtService = strapi.plugin('users-permissions').service('jwt');
             const confirmationToken = await jwtService.issue(

package/dist/server/services/page-version.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ *  service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const strapi_1 = require("@strapi/strapi");
+exports.default = strapi_1.factories.createCoreService('plugin::strapi-plugin-page-builder.page-version');

package/dist/server/services/private-content/acceptedMail/acceptMail.email.template.text.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.acceptMailTxtEmail = void 0;
+const handlebars_1 = __importDefault(require("handlebars"));
+const acceptMailTxtEmail = (acceptMailData) => {
+    const template = handlebars_1.default.compile(acceptMailData.text);
+    return template(acceptMailData);
+};
+exports.acceptMailTxtEmail = acceptMailTxtEmail;

package/dist/server/services/private-content/acceptedMail/acceptMail.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/services/private-content/graphql/resolvers/findOnePage.js

@@ -16,7 +16,7 @@ exports.page = {
         const sanitizedQuery = await utils_1.sanitize.contentAPI.query(populatedArgs, strapi.contentType(constants_1.PAGE_UID));
         const value = await strapi.entityService.findOne(uid, args.id, (0, fp_1.omit)('id', sanitizedQuery));
         // @ts-ignore Strapi types are the best
-        if (!((_a = value === null || value === void 0 ? void 0 : value.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) && !value.isPrivate) {
+        if (!((_a = value === null || value === void 0 ? void 0 : value.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) && !(value === null || value === void 0 ? void 0 : value.isPrivate)) {
             return toEntityResponse(value, { args: transformedArgs, resourceUID: uid });
         }
         if (

package/dist/server/services/private-content/graphql/resolvers/findPage.js

@@ -21,15 +21,16 @@ exports.pages = {
             if (decodedToken) {
                 // @ts-ignore
                 const filteredItems = value.filter((item) => {
+                    var _a, _b;
                     // @ts-ignore
-                    if (item.platform.isPrivate === true && user.platform.id === item.platform.id) {
+                    if (((_a = item.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) === true && user.platform.id === item.platform.id) {
                         return item;
                     }
-                    if (item.isPrivate === true && user.platform.id === item.platform.id) {
+                    if ((item === null || item === void 0 ? void 0 : item.isPrivate) === true && user.platform.id === item.platform.id) {
                         return item;
                     }
                     // @ts-ignore
-                    if (item.platform.isPrivate !== true && item.isPrivate !== true) {
+                    if (((_b = item.platform) === null || _b === void 0 ? void 0 : _b.isPrivate) !== true && (item === null || item === void 0 ? void 0 : item.isPrivate) !== true) {
                         return item;
                     }
                 });
@@ -37,7 +38,7 @@ exports.pages = {
             }
         }
         // @ts-ignore
-        const filteredItems = value.filter((item) => item.platform.isPrivate !== true && item.isPrivate !== true);
+        const filteredItems = value.filter((item) => { var _a; return ((_a = item.platform) === null || _a === void 0 ? void 0 : _a.isPrivate) !== true && (item === null || item === void 0 ? void 0 : item.isPrivate) !== true; });
         return toEntityResponseCollection(filteredItems, { args: transformedArgs, resourceUID: uid });
     }
 };

package/dist/server/services/private-content/graphql/resolvers/register.js

@@ -8,7 +8,6 @@ const schemas_1 = require("../../schemas");
 const { ApplicationError } = utils_2.errors;
 exports.platformRegister = {
     async resolve(parent, args, context) {
-        console.log('WAAROM LOG JIJ NIKS');
         const pluginStore = await strapi.store({ type: 'plugin', name: 'users-permissions' });
         const settings = await pluginStore.get({ key: 'advanced' });
         await (0, schemas_1.validateRegisterSchema)(args.input);
@@ -16,7 +15,6 @@ exports.platformRegister = {
         const role = await strapi
             .query('plugin::users-permissions.role')
             .findOne({ where: { type: settings.default_role } });
-        console.log('dsfjsdds');
         if (!role) {
             throw new ApplicationError('Impossible to find the default role');
         }
@@ -54,7 +52,6 @@ exports.platformRegister = {
         const sanitizedUser = utils_1.sanitize.contentAPI.output(createdUser, userModel, {
             auth: false
         });
-        console.log('HALLO MADDERFACKKER');
         await strapi.service('plugin::page-builder.email').sendConfirmationEmail(createdUser);
         return {
             user: sanitizedUser

package/dist/server/utils/graphql.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerGraphQLResolvers = void 0;
+const constants_1 = require("../../shared/utils/constants");
+const findPageByPath = (strapi) => {
+    const typeDefs = `
+  type Query {
+    findPageByPath(path: String, locale: I18NLocaleCode): PageEntityResponse 
+  }
+  `;
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        const { toEntityResponse, toEntityResponseCollection } = strapi.plugin('graphql').service('format').returnTypes;
+        return {
+            Query: {
+                findPageByPath: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.PAGE_UID);
+                        const transformedArgs = transformArgs(args, { contentType });
+                        const queryResult = await strapi.entityService.findMany(contentType.uid, {
+                            filters: {
+                                path: {
+                                    $eq: transformedArgs.path
+                                }
+                            },
+                            locale: transformedArgs.locale
+                        });
+                        const result = queryResult === null || queryResult === void 0 ? void 0 : queryResult[0];
+                        return toEntityResponse(result, {
+                            args: transformedArgs,
+                            resourceUID: contentType.uid
+                        });
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.findPageByPath': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs,
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+const findPagePaths = (strapi) => {
+    const typeDefs = `
+  type PageByPath {
+    id: Int!
+    path: String!
+    title: String!
+    locale: String!
+    pageType: ENUM_PAGE_PAGETYPE
+    updatedAt: DateTime!
+    publishedAt: DateTime!
+  }
+
+  type Query {
+    findPagePaths(locale: String, pageType: String = "all"): [PageByPath]
+  }
+  `;
+    const resolvers = (strapi) => {
+        const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+        return {
+            Query: {
+                findPagePaths: {
+                    resolve: async (parent, args, ctx) => {
+                        const contentType = strapi.getModel(constants_1.PAGE_UID);
+                        const transformedArgs = transformArgs(args, { contentType });
+                        const queryResult = await strapi.entityService.findMany(contentType.uid, {
+                            populate: '*',
+                            locale: transformedArgs.locale
+                        });
+                        const result = queryResult.filter((page) => page === null || page === void 0 ? void 0 : page.path);
+                        return result;
+                    }
+                }
+            }
+        };
+    };
+    const resolversConfig = {
+        'Query.findPagePaths': {
+            auth: false
+        }
+    };
+    return {
+        typeDefs,
+        resolvers: resolvers(strapi),
+        resolversConfig
+    };
+};
+const registerGraphQLResolvers = (strapi) => {
+    const extensionService = strapi.plugin('graphql').service('extension');
+    extensionService.use(findPageByPath(strapi));
+    extensionService.use(findPagePaths(strapi));
+};
+exports.registerGraphQLResolvers = registerGraphQLResolvers;

package/dist/server/utils/paginationValidation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pagination = void 0;
+class Pagination {
+    static checkPagination(page, pageSize) {
+        const startPage = page === 1 ? 0 : page - 1;
+        const start = startPage * pageSize;
+        const limit = (startPage + 1) * pageSize;
+        return { start, limit };
+    }
+    static async getPaginationInfo(transformedpageArgs, transformArgs, start, pageSize, entityResponse, uid) {
+        var _a;
+        const total = await ((_a = strapi === null || strapi === void 0 ? void 0 : strapi.entityService) === null || _a === void 0 ? void 0 : _a.count(uid, {
+            filters: {
+                ...transformArgs.filters,
+                hasPage: { $eq: true },
+                page: { ...transformedpageArgs.filters }
+            }
+        }));
+        const pageCount = Math.ceil(total / pageSize);
+        const page = Math.floor(start / pageSize) + 1;
+        entityResponse.metaInfo = {
+            total,
+            pageCount,
+            page,
+            pageSize
+        };
+        return entityResponse;
+    }
+}
+exports.Pagination = Pagination;