@webbio/strapi-plugin-page-builder 0.9.1-platform → 0.9.2-platform

package/dist/package.json

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

package/dist/server/bootstrap/permissions.js

@@ -2,99 +2,127 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const constants_1 = require("../../shared/utils/constants");
 exports.default = async ({ strapi }) => {
-    var _a, _b;
+    var _a;
     try {
-        const pageTypes = (await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PAGE_TYPE_UID, {
-            limit: -1
-        })));
-        const platforms = (await ((_b = strapi.entityService) === null || _b === void 0 ? void 0 : _b.findMany(constants_1.PLATFORM_UID, {
+        const platforms = (await ((_a = strapi.entityService) === null || _a === void 0 ? void 0 : _a.findMany(constants_1.PLATFORM_UID, {
             limit: -1
         })));
         const platformPagePermissions = platforms.map((platform) => {
-            return pageTypes.map((pageType) => {
-                const name = `platform-is-${platform.title}-${pageType.uid}`;
-                const displayName = `${platform.title}-${pageType.title}`;
-                return {
-                    plugin: 'page-builder',
-                    name,
-                    displayName,
-                    category: `${platform.title} Page roles`,
-                    handler: async () => {
-                        return {
-                            $and: [
-                                {
-                                    'platform.id': {
-                                        $eq: platform.id
-                                    }
-                                },
-                                {
-                                    'pageType.uid': {
-                                        $eq: pageType.uid
-                                    }
-                                },
-                                {
-                                    uid: {
-                                        $eq: pageType.uid
-                                    }
-                                }
-                            ]
-                        };
-                    }
-                };
-            });
-        });
-        const pageTypePermissions = pageTypes.map((pageType) => {
-            const name = `pageType-permission-${pageType.uid}`;
-            const displayName = `pageType ${pageType.title}`;
-            return {
-                plugin: 'page-builder',
-                name,
-                displayName,
-                category: `Platform pageType roles`,
-                handler: async () => {
-                    return {
-                        uid: {
-                            $eq: pageType.uid
-                        }
-                    };
-                }
-            };
-        });
-        const platformCollectiontypePermissions = platforms.map((platform) => {
             const name = `platform-is-${platform.title}`;
             const displayName = platform.title;
             return {
                 plugin: 'page-builder',
                 name,
                 displayName,
-                category: 'Platform CollectionType roles',
-                handler: async () => {
+                category: `Platform`,
+                handler: async (x) => {
+                    var _a, _b, _c, _d;
+                    if (((_a = x === null || x === void 0 ? void 0 : x.permission) === null || _a === void 0 ? void 0 : _a.subject) === 'api::platform.platform') {
+                        return {
+                            id: {
+                                $eq: platform.id
+                            }
+                        };
+                    }
+                    if (((_b = x === null || x === void 0 ? void 0 : x.permission) === null || _b === void 0 ? void 0 : _b.subject) === 'api::page.page') {
+                        try {
+                            const roles = (await ((_c = strapi.entityService) === null || _c === void 0 ? void 0 : _c.findMany('admin::role', {
+                                limit: -1,
+                                populate: '*'
+                            })));
+                            // checks which role the user has
+                            const foundRole = roles.filter((role) => {
+                                return x.roles.find((userRole) => userRole.name === role.name);
+                            });
+                            // get the right platform permissions, and filters out the platform
+                            // this is neccesary because of multiple platforms. if you can see Vacancy from platform 1 and collegue from platform 2
+                            // it will show both at page level, so this filters out the wrong page
+                            const platformPermission = (_d = foundRole === null || foundRole === void 0 ? void 0 : foundRole[0]) === null || _d === void 0 ? void 0 : _d.permissions.map((permission) => {
+                                return {
+                                    permission: permission.subject,
+                                    condition: permission.conditions.filter((condition) => condition.includes(platform.title))
+                                };
+                            });
+                            // get the right permission for platform
+                            const permissions = platformPermission.map((permission) => {
+                                if (permission.condition.length > 0) {
+                                    return permission.permission;
+                                }
+                            });
+                            return {
+                                $and: [
+                                    {
+                                        'platform.id': {
+                                            $eq: platform.id
+                                        }
+                                    },
+                                    {
+                                        'pageType.uid': {
+                                            $in: permissions
+                                        }
+                                    }
+                                ]
+                            };
+                        }
+                        catch (error) {
+                            console.log(error);
+                        }
+                    }
                     return {
-                        $or: [
+                        $and: [
                             {
                                 'platform.id': {
                                     $eq: platform.id
                                 }
-                            },
-                            {
-                                id: {
-                                    $eq: platform.id
-                                }
                             }
                         ]
                     };
                 }
             };
+            // });
         });
-        const allPermissions = [
-            ...platformPagePermissions.flat(),
-            ...pageTypePermissions.flat(),
-            ...platformCollectiontypePermissions
-        ];
+        const allPermissions = [...platformPagePermissions.flat()];
         // @ts-ignore shitty types
         await strapi.admin.services.permission.conditionProvider.registerMany(allPermissions);
     }
-    catch {
+    catch (error) {
         console.log('Cannot set page permissions');
     }
 };
+// Leave this commented code here, This might be used in the future to change up the permissions IF needed
+// const platformPagePermissions = platforms.map((platform) => {
+// 	const platformPageTypes = pageTypes.filter((pageType) => pageType.platform.id === platform.id);
+// 	return platformPageTypes.map((pageType) => {
+// 		const name = `platform-is-${platform.title}-${pageType.uid}`;
+// 		const displayName = pageType.title;
+// 		return {
+// 			plugin: 'page-builder',
+// 			name,
+// 			displayName,
+// 			category: `${platform.title} pageTypes`,
+// 			handler: async (x) => {
+// 				if (x?.permission?.subject === 'api::platform.platform') {
+// 					return {
+// 						id: {
+// 							$eq: platform.id
+// 						}
+// 					};
+// 				}
+// 				return {
+// 					$and: [
+// 						{
+// 							'platform.id': {
+// 								$eq: platform.id
+// 							}
+// 						},
+// 						{
+// 							'pageType.uid': {
+// 								$eq: pageType.uid
+// 							}
+// 						}
+// 					]
+// 				};
+// 			}
+// 		};
+// 	});
+// });

package/dist/server/middlewares/mikkel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore
+exports.default = (strapi) => {
+    return async (ctx, next) => {
+        console.log(ctx);
+        await next();
+        //           // then logs info
+        // 					console.log('REQUEST:')
+        // 					console.log(ctx.request.body.query);
+        // 					console.log('RESPONSE:')
+        // 					console.log(ctx.body);
+        // const result = JSON.parse(ctx.response.body);
+        // console.log('result');
+        // if (result && result.data.getPageByPath) {
+        // 	console.log(result.data.getPageByPath.attributes);
+        // }
+        // console.log("middleware state")
+        // console.log(context.request.header.host)
+        // if(context.request.header.host == "localhost:1337") {
+        //   return context.badRequest('name is missing', { foo: 'bar' })
+        // }
+        // try {
+        //   if (
+        //     (context.state.user.platform && context.args.domain === context.state.user.platform.domain) ||
+        //     (context.state.user.roles && context.state.user.roles[0].name !== 'Public')
+        //   ) {
+        //     return true;
+        //   }
+        // } catch (error) {
+        //   console.log(error);
+        // }
+        // return false;
+    };
+};

package/dist/server/policies/platformSelector.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (ctx) => {
+    // console.log('user state');
+    // console.log(ctx.state.user);
+    // 	console.log('End User State');
+    // || ctx.state.user.roles && ctx.state.user.roles[0].name !== "Public"
+    try {
+        if ((ctx.state.user.platform && ctx.args.domain === ctx.state.user.platform.domain) ||
+            (ctx.state.user.roles && ctx.state.user.roles[0].name !== 'Public')) {
+            return true;
+        }
+    }
+    catch (error) {
+        console.log(error);
+    }
+    return false;
+};

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;