@webbio/strapi-plugin-page-builder 0.12.2-platform → 0.12.3-platform

package/server/controllers/index.ts

@@ -1,19 +1,19 @@
-import page from './page';
-import pageType from './page-type';
-import collectionTypes from './collection-types';
-import template from './template';
-import platform from './platform';
-import sitemap from './sitemap';
-import privateContent from './private-content';
-import userCategory from './user-category';
-
-export default {
-	page,
-	'page-type': pageType,
-	'collection-types': collectionTypes,
-	template,
-	platform,
-	sitemap,
-	'private-content': privateContent,
-	'user-category': userCategory
-};
+import page from './page';
+import pageType from './page-type';
+import collectionTypes from './collection-types';
+import template from './template';
+import platform from './platform';
+import sitemap from './sitemap';
+import privateContent from './private-content';
+import userCategory from './user-category';
+
+export default {
+	page,
+	'page-type': pageType,
+	'collection-types': collectionTypes,
+	template,
+	platform,
+	sitemap,
+	'private-content': privateContent,
+	'user-category': userCategory
+};

package/server/controllers/page-type.ts

@@ -1,18 +1,18 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async findOneByUid(ctx: any) {
-		const uid = ctx?.params?.uid;
-		const platformId = ctx?.params?.platformId;
-
-		if (!uid) {
-			return ctx.badRequest('uid is missing.');
-		}
-
-		if (!platformId) {
-			return ctx.badRequest('PlatformId is missing.');
-		}
-
-		return await (strapi as Strapi).service('plugin::page-builder.page-type').findOneByUid(uid, platformId);
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async findOneByUid(ctx: any) {
+		const uid = ctx?.params?.uid;
+		const platformId = ctx?.params?.platformId;
+
+		if (!uid) {
+			return ctx.badRequest('uid is missing.');
+		}
+
+		if (!platformId) {
+			return ctx.badRequest('PlatformId is missing.');
+		}
+
+		return await (strapi as Strapi).service('plugin::page-builder.page-type').findOneByUid(uid, platformId);
+	}
+};

package/server/controllers/page.ts

@@ -1,9 +1,9 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async getPage(ctx) {
-		const id = ctx.params?.id;
-
-		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async getPage(ctx) {
+		const id = ctx.params?.id;
+
+		return (strapi as Strapi).service('plugin::page-builder.page')?.getPage(id);
+	}
+};

package/server/controllers/platform.ts

@@ -1,21 +1,21 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async findAll() {
-		return await (strapi as Strapi).service('plugin::page-builder.platform').findAll();
-	},
-
-	async findOneById(ctx: any) {
-		const id = ctx?.params?.id;
-
-		if (!id) {
-			return ctx.badRequest('id is missing.');
-		}
-
-		return await strapi.service('plugin::page-builder.platform').findOneById(id);
-	},
-	async findPageTypesByPlatform(ctx: any) {
-		const platform = ctx?.params?.platform;
-		return await (strapi as Strapi).services['plugin::page-builder.platform'].findPageTypesByPlatform(platform);
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async findAll() {
+		return await (strapi as Strapi).service('plugin::page-builder.platform').findAll();
+	},
+
+	async findOneById(ctx: any) {
+		const id = ctx?.params?.id;
+
+		if (!id) {
+			return ctx.badRequest('id is missing.');
+		}
+
+		return await strapi.service('plugin::page-builder.platform').findOneById(id);
+	},
+	async findPageTypesByPlatform(ctx: any) {
+		const platform = ctx?.params?.platform;
+		return await (strapi as Strapi).services['plugin::page-builder.platform'].findPageTypesByPlatform(platform);
+	}
+};

package/server/controllers/private-content.ts

@@ -1,17 +1,17 @@
-import { Context } from 'koa';
-
-export default {
-	async activateUser(ctx: Context): Promise<any> {
-		try {
-			const user = await strapi.service('plugin::page-builder.private-content').activateUser(ctx.params.token);
-			const callbackUrl = `${user.platform.domain}/inloggen`;
-			return ctx.redirect(callbackUrl);
-		} catch (error) {
-			console.log(ctx);
-			return ctx.unauthorized('User is already confirmed or token is invalid');
-		}
-	},
-	removeInactiveUsers(ctx: Context) {
-		return strapi.service('plugin::page-builder.private-content').removeInactiveUsers();
-	}
-};
+import { Context } from 'koa';
+
+export default {
+	async activateUser(ctx: Context): Promise<any> {
+		try {
+			const user = await strapi.service('plugin::page-builder.private-content').activateUser(ctx.params.token);
+			const callbackUrl = `${user.platform.domain}/inloggen`;
+			return ctx.redirect(callbackUrl);
+		} catch (error) {
+			console.log(ctx);
+			return ctx.unauthorized('User is already confirmed or token is invalid');
+		}
+	},
+	removeInactiveUsers(ctx: Context) {
+		return strapi.service('plugin::page-builder.private-content').removeInactiveUsers();
+	}
+};

package/server/controllers/sitemap.ts

@@ -1,32 +1,32 @@
-import { errors } from '@strapi/utils';
-import { PLATFORM_UID } from '../../shared/utils/constants';
-import { Context } from 'koa';
-
-export default {
-	async generate(ctx: Context) {
-		try {
-			ctx.set('Content-Type', 'text/xml');
-
-			const domain = ctx.query?.domain;
-
-			if (domain == null) {
-				return ctx.badRequest('Domain is required.');
-			}
-
-			const platform = await strapi.query(PLATFORM_UID).findOne({
-				select: ['domain'],
-				where: {
-					domain
-				}
-			});
-
-			if (platform == null) {
-				return ctx.notFound('No platform found for specified domain.');
-			}
-
-			return strapi.service('plugin::page-builder.sitemap').generateSitemap(domain);
-		} catch (error) {
-			throw new errors.ApplicationError('Unknown error while generating the sitemap.');
-		}
-	}
-};
+import { errors } from '@strapi/utils';
+import { PLATFORM_UID } from '../../shared/utils/constants';
+import { Context } from 'koa';
+
+export default {
+	async generate(ctx: Context) {
+		try {
+			ctx.set('Content-Type', 'text/xml');
+
+			const domain = ctx.query?.domain;
+
+			if (domain == null) {
+				return ctx.badRequest('Domain is required.');
+			}
+
+			const platform = await strapi.query(PLATFORM_UID).findOne({
+				select: ['domain'],
+				where: {
+					domain
+				}
+			});
+
+			if (platform == null) {
+				return ctx.notFound('No platform found for specified domain.');
+			}
+
+			return strapi.service('plugin::page-builder.sitemap').generateSitemap(domain);
+		} catch (error) {
+			throw new errors.ApplicationError('Unknown error while generating the sitemap.');
+		}
+	}
+};

package/server/controllers/template.ts

@@ -1,16 +1,16 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async findOneById(ctx: any) {
-		const id = ctx?.params?.id;
-
-		if (!id) {
-			return ctx.badRequest('id is missing.');
-		}
-
-		return await (strapi as Strapi).service('plugin::page-builder.template').findOne(id);
-	},
-	async findAll() {
-		return await (strapi as Strapi).service('plugin::page-builder.template').findAll();
-	}
-};
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async findOneById(ctx: any) {
+		const id = ctx?.params?.id;
+
+		if (!id) {
+			return ctx.badRequest('id is missing.');
+		}
+
+		return await (strapi as Strapi).service('plugin::page-builder.template').findOne(id);
+	},
+	async findAll() {
+		return await (strapi as Strapi).service('plugin::page-builder.template').findAll();
+	}
+};

package/server/controllers/user-category.ts

@@ -1,3 +1,3 @@
-import { factories } from '@strapi/strapi';
-
-export default factories.createCoreController('plugin::page-builder.user-category');
+import { factories } from '@strapi/strapi';
+
+export default factories.createCoreController('plugin::page-builder.user-category');

package/server/destroy.ts

@@ -1,5 +1,5 @@
-import { Strapi } from '@strapi/strapi';
-
-export default ({ strapi }: { strapi: Strapi }) => {
-	// destroy phase
-};
+import { Strapi } from '@strapi/strapi';
+
+export default ({ strapi }: { strapi: Strapi }) => {
+	// destroy phase
+};

package/server/graphql/index.ts

@@ -1,9 +1,9 @@
-import pageType from './page-type';
-import pageByPath from './page-by-path';
-import getPageInfoFromUID from './pages-by-uid';
-
-export default {
-	getPageInfoFromUID,
-	pageType,
-	pageByPath
-};
+import pageType from './page-type';
+import pageByPath from './page-by-path';
+import getPageInfoFromUID from './pages-by-uid';
+
+export default {
+	getPageInfoFromUID,
+	pageType,
+	pageByPath
+};

package/server/graphql/page-by-path.ts

@@ -1,132 +1,135 @@
-import { Strapi } from '@strapi/strapi';
-
-import { PAGE_UID } from '../../shared/utils/constants';
-
-import { ForbiddenError as ApolloForbiddenError } from 'apollo-server-koa';
-import { getConfig } from '../utils/strapi';
-
-const getPageByPath = (strapi: Strapi) => {
-	const typeDefs = () => {
-		return `
-				extend type Page {
-					collectionType: GenericMorph
-				}
-
-        type Query {
-          getPageByPath(path: String, domain: String, publicationState: PublicationState): PageEntity
-        }
-
-      `;
-	};
-
-	const resolvers = (strapi: Strapi) => {
-		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
-
-		return {
-			Query: {
-				getPageByPath: {
-					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
-						try {
-							const filteredArgs: Record<string, any> = {
-								filters: {
-									path: args.path,
-									platform: args.domain ? { domain: args.domain } : null
-								},
-								publicationState: args.publicationState,
-								locale: args.locale
-							};
-
-							const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
-							const getPage = async () => {
-								const transformedArgs = transformArgs(filteredArgs, {
-									contentType: strapi.contentTypes[PAGE_UID],
-									usePagination: false
-								});
-
-								const results = await strapi.entityService?.findMany(PAGE_UID, {
-									...filteredArgs,
-									populate: '*'
-								});
-
-								const entityResponse = toEntityResponse(results?.[0] || {}, {
-									args: transformedArgs,
-									resourceUID: PAGE_UID
-								});
-
-								if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
-									throw new Error(ctx.koaContext.response.message);
-								}
-
-								const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
-
-								const collectionType: Record<string, any> | null =
-									collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
-
-								const addedAttributes = {
-									collectionType: collectionType
-								};
-
-								const result = {
-									...entityResponse.value,
-									...addedAttributes
-								};
-
-								return result;
-							};
-
-							const results: Record<string, any> = await getPage();
-
-							if (Object.values(results)?.filter(Boolean).length > 0) {
-								if (!results?.platform?.isPrivate && !results?.isPrivate) {
-									return results;
-								}
-								if (
-									(results?.platform?.isPrivate === true && ctx.koaContext.req.headers.authorization) ||
-									(results?.isPrivate === true && ctx.koaContext.req.headers.authorization)
-								) {
-									const auth = ctx.koaContext.req.headers.authorization;
-									const token = auth.split(' ');
-
-									const jwtService = strapi.plugin('users-permissions').service('jwt');
-									const decodedToken = await jwtService.verify(token[1]);
-									if (decodedToken) {
-										const user = ctx.state.user;
-
-										if (user?.platform?.id === results?.platform?.id) {
-											return results;
-										}
-									}
-								}
-
-								return new ApolloForbiddenError('Forbidden access');
-							} else {
-								throw new Error(ctx.koaContext.response.message);
-							}
-						} catch (error) {
-							console.log('Error in [getPageByPath], args:', args, 'ERROR:', error);
-
-							throw new Error(ctx.koaContext.response.message);
-						}
-					}
-				}
-			}
-		};
-	};
-
-	const pageBuilderConfig = getConfig();
-
-	const resolversConfig = {
-		'Query.getPageByPath': {
-			policies: pageBuilderConfig?.privateContent === true ? ['plugin::page-builder.isAuthorizedForPage'] : [],
-			auth: false
-		}
-	};
-
-	return {
-		typeDefs: typeDefs(),
-		resolvers: resolvers(strapi),
-		resolversConfig
-	};
-};
-
-export default getPageByPath;
+import { Strapi } from '@strapi/strapi';
+
+import { PAGE_UID } from '../../shared/utils/constants';
+
+import { ForbiddenError as ApolloForbiddenError } from 'apollo-server-koa';
+import { getConfig } from '../utils/strapi';
+
+const getPageByPath = (strapi: Strapi) => {
+	const typeDefs = () => {
+		return `
+				extend type Page {
+					collectionType: GenericMorph
+				}
+
+        type Query {
+          getPageByPath(path: String, domain: String, publicationState: PublicationState): PageEntity
+        }
+
+      `;
+	};
+
+	const resolvers = (strapi: Strapi) => {
+		const { transformArgs } = strapi.plugin('graphql').service('builders').utils;
+
+		return {
+			Query: {
+				getPageByPath: {
+					resolve: async (_parent: any, args: Record<string, any>, ctx: any) => {
+						try {
+							const filteredArgs: Record<string, any> = {
+								filters: {
+									path: args.path,
+									platform: args.domain ? { domain: args.domain } : null
+								},
+								publicationState: args.publicationState,
+								locale: args.locale
+							};
+
+							const { toEntityResponse } = strapi.plugin('graphql').service('format').returnTypes;
+							const getPage = async () => {
+								const transformedArgs = transformArgs(filteredArgs, {
+									contentType: strapi.contentTypes[PAGE_UID],
+									usePagination: false
+								});
+
+								const results = await strapi.entityService?.findMany(PAGE_UID, {
+									...filteredArgs,
+									populate: '*'
+								});
+
+								const entityResponse = toEntityResponse(results?.[0] || {}, {
+									args: transformedArgs,
+									resourceUID: PAGE_UID
+								});
+
+								if (!entityResponse?.value || Object.keys(entityResponse.value).length === 0) {
+									throw new Error(ctx.koaContext.response.message);
+								}
+
+								const collectionTypeDataFilter = entityResponse?.value?.collectionTypeData?.filter(Boolean);
+
+								const collectionType: Record<string, any> | null =
+									collectionTypeDataFilter.length === 1 ? collectionTypeDataFilter?.[0] : null;
+
+								const addedAttributes = {
+									collectionType: collectionType
+								};
+
+								const result = {
+									...entityResponse.value,
+									...addedAttributes
+								};
+
+								return result;
+							};
+
+							const result: Record<string, any> = await getPage();
+
+							if (Object.values(result)?.filter(Boolean).length > 0) {
+								if (result?.path === '404' || result.path === '500') {
+									return result;
+								}
+								if (!result?.platform?.isPrivate && !result?.isPrivate) {
+									return result;
+								}
+								if (
+									(result?.platform?.isPrivate === true && ctx.koaContext.req.headers.authorization) ||
+									(result?.isPrivate === true && ctx.koaContext.req.headers.authorization)
+								) {
+									const auth = ctx.koaContext.req.headers.authorization;
+									const token = auth.split(' ');
+
+									const jwtService = strapi.plugin('users-permissions').service('jwt');
+									const decodedToken = await jwtService.verify(token[1]);
+									if (decodedToken) {
+										const user = ctx.state.user;
+
+										if (user?.platform?.id === result?.platform?.id) {
+											return result;
+										}
+									}
+								}
+
+								return new ApolloForbiddenError('Forbidden access');
+							} else {
+								throw new Error(ctx.koaContext.response.message);
+							}
+						} catch (error) {
+							console.log('Error in [getPageByPath], args:', args, 'ERROR:', error);
+
+							throw new Error(ctx.koaContext.response.message);
+						}
+					}
+				}
+			}
+		};
+	};
+
+	const pageBuilderConfig = getConfig();
+
+	const resolversConfig = {
+		'Query.getPageByPath': {
+			policies: pageBuilderConfig?.privateContent === true ? ['plugin::page-builder.isAuthorizedForPage'] : [],
+			auth: false
+		}
+	};
+
+	return {
+		typeDefs: typeDefs(),
+		resolvers: resolvers(strapi),
+		resolversConfig
+	};
+};
+
+export default getPageByPath;