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

package/server/bootstrap.ts

@@ -1,260 +1,261 @@
-import { Common, Strapi } from '@strapi/strapi';
-import { errors } from '@strapi/utils';
-import {
-	PAGE_BUILDER_EMAIL_PLUGIN,
-	PAGE_TYPE_UID,
-	PAGE_UID,
-	PLATFORM_UID,
-	USER_PERMISSION_USER_PLUGIN
-} from '../shared/utils/constants';
-import permissions from './bootstrap/permissions';
-import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
-
-export default async ({ strapi }: { strapi: Strapi }) => {
-	await permissions({ strapi });
-	await collectionTypeLifecycles({ strapi });
-
-	const updateCollectionTypeData = (data: any, collectionTypeId: number, uid: string) => {
-		data.collectionTypeData = {
-			id: collectionTypeId,
-			__type: uid,
-			__pivot: {
-				field: 'page'
-			}
-		};
-
-		return data;
-	};
-
-	const plugin = strapi.plugin('users-permissions');
-
-	plugin.services.user.fetchAuthenticatedUser = async (id: any) => {
-		return strapi.query('plugin::users-permissions.user').findOne({ where: { id }, populate: ['role', 'platform'] });
-	};
-
-	strapi.db?.lifecycles.subscribe({
-		models: [USER_PERMISSION_USER_PLUGIN],
-		async beforeUpdate(event) {
-			if (event.params.data.id) {
-				const userToUpdate = await strapi.entityService?.findOne(USER_PERMISSION_USER_PLUGIN, event.params.data.id, {
-					populate: { platform: { populate: { platformEmails: { populate: '*' } } } }
-				});
-				if (userToUpdate) {
-					if (event.params.data.activateUser && event.params.data.confirmed && !userToUpdate.confirmMailSend) {
-						await strapi.service(PAGE_BUILDER_EMAIL_PLUGIN).sendMail({
-							// @ts-ignore strapi typings
-							from: userToUpdate.platform.platformEmails.accountAcceptedMail.fromEmail,
-							to: event.params.data.email,
-							// @ts-ignore
-							subject: userToUpdate.platform.platformEmails.accountAcceptedMail.subject,
-							// @ts-ignore
-							text: userToUpdate.platform.platformEmails.accountAcceptedMail.message,
-							firstName: event.params.data.firstName,
-							lastName: event.params.data.lastName
-						});
-					}
-				}
-			}
-		}
-	});
-
-	strapi.db?.lifecycles.subscribe({
-		// @ts-ignore
-		models: [PAGE_UID],
-		async beforeCreate(event) {
-			let { data } = event.params;
-			const collectionTypeId = data?.collectionTypeId;
-			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
-			const platformId = data?.platform.connect?.[0]?.id;
-
-			if (collectionTypeId && pageTypeId) {
-				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
-					PAGE_TYPE_UID,
-					pageTypeId
-				);
-				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
-					populate: { page: true }
-				});
-
-				const page: Record<string, any>[] = collectionToConnect?.page as any;
-
-				const foundPlatforms: Record<string, any> | undefined | null = await strapi.entityService?.findMany(
-					PLATFORM_UID,
-					{
-						populate: '*',
-						filters: {
-							pagetype: {
-								uid: pageType?.uid
-							}
-						}
-					}
-				);
-
-				if (page && page.length > 0) {
-					throw new errors.ValidationError('You can only link one CollectionType to one page');
-				}
-
-				if (platformId && !foundPlatforms?.some((platform) => platform.id === platformId)) {
-					throw new errors.ValidationError('Platform not found');
-				}
-
-				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
-			}
-		},
-		async beforeUpdate(event) {
-			let { data, where } = event?.params;
-
-			const collectionTypeId = data?.collectionTypeId;
-			const pageTypeId = data?.pageType?.connect?.[0]?.id || data?.initialPageType;
-			const removedPageType = data?.pageType?.disconnect?.[0]?.id;
-
-			const originalEntity = await strapi.entityService?.findOne(
-				event.model.uid as Common.UID.CollectionType,
-				data.id || where.id,
-				{
-					populate: {
-						collectionTypeData: true
-					}
-				} as Record<string, any>
-			);
-
-			if (removedPageType || collectionTypeId === null) {
-				data.collectionTypeData = undefined;
-
-				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
-					strapi.entityService?.update(
-						originalEntity.collectionTypeData[0].__type,
-						originalEntity.collectionTypeData[0].id,
-						{
-							data: {
-								id: originalEntity.collectionTypeData.id,
-								hasPage: false
-							}
-						}
-					);
-				}
-			}
-
-			if (collectionTypeId && pageTypeId && !removedPageType) {
-				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
-					PAGE_TYPE_UID,
-					pageTypeId
-				);
-				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
-					populate: { page: true }
-				});
-
-				const page: Record<string, any>[] = collectionToConnect?.page as any;
-
-				if (page && page?.length > 0 && !page.some((p) => p.id === data.id)) {
-					throw new errors.ValidationError('You can only link one CollectionType to one page');
-				}
-
-				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
-			}
-
-			if (
-				data.collectionTypeData &&
-				originalEntity?.collectionTypeData?.[0]?.__type &&
-				originalEntity?.collectionTypeData?.[0]?.id &&
-				Number(data.collectionTypeData.id) !== Number(originalEntity.collectionTypeData[0].id)
-			) {
-				await strapi.entityService?.update(
-					originalEntity.collectionTypeData[0].__type,
-					originalEntity.collectionTypeData[0].id,
-					{
-						data: {
-							id: originalEntity.collectionTypeData[0].id,
-							hasPage: false,
-							lifecycleState: {
-								exit: true
-							}
-						}
-					}
-				);
-			}
-		},
-		async afterUpdate(event) {
-			await afterUpdate(event?.['result']);
-		},
-		async afterUpdateMany(event) {
-			try {
-				const pagesToUpdate = event.params.where?.id?.['$in'];
-				const pages: Record<string, any>[] | undefined = (await strapi.entityService?.findMany(PAGE_UID, {
-					populate: {
-						collectionTypeData: true
-					},
-					filters: {
-						id: {
-							$in: pagesToUpdate
-						}
-					}
-				})) as any;
-
-				if (pages && pages.length > 0) {
-					await Promise.all(pages?.map((p) => afterUpdate(p)));
-				}
-			} catch (error) {
-				console.error('Failed to save hasPage many data', error);
-			}
-		},
-		async beforeDelete(event) {
-			await beforeDelete(event.params.where.id);
-		},
-		async beforeDeleteMany(event) {
-			const pagesToDisconnect = event.params.where?.['$and']?.[0]?.id?.['$in'];
-
-			for (const pageId of pagesToDisconnect) {
-				await beforeDelete(pageId);
-			}
-		}
-	});
-};
-
-const beforeDelete = async (id: number) => {
-	const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, id, {
-		populate: {
-			collectionTypeData: true
-		}
-	})) as Record<string, any> | undefined;
-
-	if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
-		await strapi.entityService?.update(
-			originalEntity.collectionTypeData[0].__type,
-			originalEntity.collectionTypeData[0].id,
-			{
-				data: {
-					id: originalEntity.collectionTypeData[0].id,
-					hasPage: false
-				}
-			}
-		);
-	}
-};
-
-const afterUpdate = async (result: Record<string, any>) => {
-	try {
-		const hasCollectionTypeRelation =
-			result &&
-			result?.collectionTypeData?.[0] &&
-			result?.collectionTypeData[0].__type &&
-			result?.collectionTypeData[0];
-
-		if (hasCollectionTypeRelation) {
-			const isPublished = result.publishedAt !== undefined;
-			const pageData = isPublished ? { hasPage: !!result.publishedAt } : {};
-
-			await strapi.entityService?.update(result.collectionTypeData[0].__type, result.collectionTypeData[0].id, {
-				data: {
-					...pageData,
-					id: result.collectionTypeData[0].id,
-					lifecycleState: {
-						exit: true
-					}
-				}
-			});
-		}
-	} catch (error) {
-		console.error('Failed to save hasPage data', error);
-	}
-};
+import { Common, Strapi } from '@strapi/strapi';
+import { errors } from '@strapi/utils';
+import {
+	PAGE_BUILDER_EMAIL_PLUGIN,
+	PAGE_TYPE_UID,
+	PAGE_UID,
+	PLATFORM_UID,
+	USER_PERMISSION_USER_PLUGIN
+} from '../shared/utils/constants';
+import permissions from './bootstrap/permissions';
+import collectionTypeLifecycles from './bootstrap/collection-type-lifecycles';
+
+export default async ({ strapi }: { strapi: Strapi }) => {
+	await permissions({ strapi });
+	await collectionTypeLifecycles({ strapi });
+
+	const updateCollectionTypeData = (data: any, collectionTypeId: number, uid: string) => {
+		data.collectionTypeData = {
+			id: collectionTypeId,
+			__type: uid,
+			__pivot: {
+				field: 'page'
+			}
+		};
+
+		return data;
+	};
+
+	const plugin = strapi.plugin('users-permissions');
+
+	plugin.services.user.fetchAuthenticatedUser = async (id: any) => {
+		return strapi.query('plugin::users-permissions.user').findOne({ where: { id }, populate: ['role', 'platform'] });
+	};
+
+	strapi.db?.lifecycles.subscribe({
+		models: [USER_PERMISSION_USER_PLUGIN],
+		async beforeUpdate(event) {
+			if (event.params.data.id) {
+				const userToUpdate = await strapi.entityService?.findOne(USER_PERMISSION_USER_PLUGIN, event.params.data.id, {
+					populate: { platform: { populate: { platformEmails: { populate: '*' } } } }
+				});
+				if (userToUpdate) {
+					if (event.params.data.activateUser && event.params.data.confirmed && !userToUpdate.confirmMailSend) {
+						await strapi.service(PAGE_BUILDER_EMAIL_PLUGIN).sendMail({
+							// @ts-ignore strapi typings
+							from: userToUpdate.platform.platformEmails.accountAcceptedMail.fromEmail,
+							to: event.params.data.email,
+							// @ts-ignore
+							subject: userToUpdate.platform.platformEmails.accountAcceptedMail.subject,
+							// @ts-ignore
+							text: userToUpdate.platform.platformEmails.accountAcceptedMail.message,
+							firstName: event.params.data.firstName,
+							lastName: event.params.data.lastName
+						});
+					}
+				}
+			}
+		}
+	});
+
+	strapi.db?.lifecycles.subscribe({
+		// @ts-ignore
+		models: [PAGE_UID],
+		async beforeCreate(event) {
+			let { data } = event.params;
+			const collectionTypeId = data?.collectionTypeId;
+			const pageTypeId = data?.pageType.connect?.[0]?.id || data.initialPageType;
+			const platformId = data?.platform.connect?.[0]?.id;
+
+			if (collectionTypeId && pageTypeId) {
+				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
+					PAGE_TYPE_UID,
+					pageTypeId
+				);
+				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
+					populate: { page: true }
+				});
+
+				const page: Record<string, any>[] = collectionToConnect?.page as any;
+
+				const foundPlatforms: Record<string, any> | undefined | null = await strapi.entityService?.findMany(
+					PLATFORM_UID,
+					{
+						populate: '*',
+						filters: {
+							pagetype: {
+								uid: pageType?.uid
+							}
+						}
+					}
+				);
+
+				if (page && page.length > 0) {
+					throw new errors.ValidationError('You can only link one CollectionType to one page');
+				}
+
+				if (platformId && !foundPlatforms?.some((platform) => platform.id === platformId)) {
+					throw new errors.ValidationError('Platform not found');
+				}
+
+				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
+			}
+		},
+		async beforeUpdate(event) {
+			let { data, where } = event?.params;
+
+			const collectionTypeId = data?.collectionTypeId;
+			const pageTypeId = data?.pageType?.connect?.[0]?.id || data?.initialPageType;
+			const removedPageType = data?.pageType?.disconnect?.[0]?.id;
+
+			const originalEntity = await strapi.entityService?.findOne(
+				event.model.uid as Common.UID.CollectionType,
+				data.id || where.id,
+				{
+					populate: {
+						collectionTypeData: true
+					}
+				} as Record<string, any>
+			);
+
+			if (removedPageType || collectionTypeId === null) {
+				data.collectionTypeData = undefined;
+
+				if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
+					strapi.entityService?.update(
+						originalEntity.collectionTypeData[0].__type,
+						originalEntity.collectionTypeData[0].id,
+						{
+							data: {
+								id: originalEntity.collectionTypeData.id,
+								hasPage: false
+							}
+						}
+					);
+				}
+			}
+
+			if (collectionTypeId && pageTypeId && !removedPageType) {
+				const pageType: Record<string, any> | undefined | null = await strapi.entityService?.findOne(
+					PAGE_TYPE_UID,
+					pageTypeId
+				);
+				const collectionToConnect = await strapi.entityService?.findOne(pageType?.uid, collectionTypeId, {
+					populate: { page: true }
+				});
+
+				const page: Record<string, any>[] = collectionToConnect?.page as any;
+
+				if (page && page?.length > 0 && !page.some((p) => p.id === data.id)) {
+					throw new errors.ValidationError('You can only link one CollectionType to one page');
+				}
+
+				data = updateCollectionTypeData(data, collectionTypeId, pageType?.uid);
+			}
+
+			if (
+				data.collectionTypeData &&
+				originalEntity?.collectionTypeData?.[0]?.__type &&
+				originalEntity?.collectionTypeData?.[0]?.id &&
+				Number(data.collectionTypeData.id) !== Number(originalEntity.collectionTypeData[0].id)
+			) {
+				await strapi.entityService?.update(
+					originalEntity.collectionTypeData[0].__type,
+					originalEntity.collectionTypeData[0].id,
+					{
+						data: {
+							id: originalEntity.collectionTypeData[0].id,
+							hasPage: false,
+							lifecycleState: {
+								exit: true
+							}
+						}
+					}
+				);
+			}
+		},
+		async afterUpdate(event) {
+			await afterUpdate(event?.['result']);
+		},
+		async afterUpdateMany(event) {
+			try {
+				const pagesToUpdate = event.params.where?.id?.['$in'];
+				const pages: Record<string, any>[] | undefined = (await strapi.entityService?.findMany(PAGE_UID, {
+					populate: {
+						collectionTypeData: true
+					},
+					filters: {
+						id: {
+							$in: pagesToUpdate
+						}
+					}
+				})) as any;
+
+				if (pages && pages.length > 0) {
+					await Promise.all(pages?.map((p) => afterUpdate(p)));
+				}
+			} catch (error) {
+				console.error('Failed to save hasPage many data', error);
+			}
+		},
+		async beforeDelete(event) {
+			await beforeDelete(event.params.where.id);
+		},
+		async beforeDeleteMany(event) {
+			const pagesToDisconnect = event.params.where?.['$and']?.[0]?.id?.['$in'];
+
+			for (const pageId of pagesToDisconnect) {
+				await beforeDelete(pageId);
+			}
+		}
+	});
+};
+
+const beforeDelete = async (id: number) => {
+	const originalEntity = (await strapi.entityService?.findOne(PAGE_UID, id, {
+		populate: {
+			collectionTypeData: true
+		}
+	})) as Record<string, any> | undefined;
+
+	if (originalEntity?.collectionTypeData?.[0]?.__type && originalEntity?.collectionTypeData?.[0]?.id) {
+		await strapi.entityService?.update(
+			originalEntity.collectionTypeData[0].__type,
+			originalEntity.collectionTypeData[0].id,
+			{
+				data: {
+					id: originalEntity.collectionTypeData[0].id,
+					hasPage: false
+				}
+			}
+		);
+	}
+};
+
+const afterUpdate = async (result: Record<string, any>) => {
+	try {
+		const hasCollectionTypeRelation =
+			result &&
+			result?.collectionTypeData?.[0] &&
+			result?.collectionTypeData[0].__type &&
+			result?.collectionTypeData[0];
+
+		if (hasCollectionTypeRelation) {
+			const isPublished = result.publishedAt !== undefined;
+			const pageData = isPublished ? { hasPage: !!result.publishedAt } : {};
+
+			await strapi.entityService?.update(result.collectionTypeData[0].__type, result.collectionTypeData[0].id, {
+				data: {
+					...pageData,
+					id: result.collectionTypeData[0].id,
+					...result.customPublishedAt ? { publishedAt: result.customPublishedAt } : undefined,
+					lifecycleState: {
+						exit: true
+					}
+				}
+			});
+		}
+	} catch (error) {
+		console.error('Failed to save hasPage data', error);
+	}
+};

package/server/config/index.ts

@@ -1,4 +1,4 @@
-export default {
-	default: {},
-	validator() {}
-};
+export default {
+	default: {},
+	validator() {}
+};

package/server/content-types/index.ts

@@ -1,7 +1,7 @@
-import userCategory from './user-category/schema.json';
-
-export default {
-	'user-category': {
-		schema: userCategory
-	}
-};
+import userCategory from './user-category/schema.json';
+
+export default {
+	'user-category': {
+		schema: userCategory
+	}
+};

package/server/content-types/user-category/schema.json

@@ -1,23 +1,23 @@
-{
-	"kind": "collectionType",
-	"collectionName": "user-categories",
-	"info": {
-		"singularName": "user-category",
-		"pluralName": "user-categories",
-		"displayName": "User Categories"
-	},
-	"options": {
-		"draftAndPublish": false,
-		"comment": ""
-	},
-	"attributes": {
-		"title": {
-			"type": "string"
-		},
-		"platform": {
-			"type": "relation",
-			"relation": "oneToOne",
-			"target": "api::platform.platform"
-		}
-	}
-}
+{
+	"kind": "collectionType",
+	"collectionName": "user-categories",
+	"info": {
+		"singularName": "user-category",
+		"pluralName": "user-categories",
+		"displayName": "User Categories"
+	},
+	"options": {
+		"draftAndPublish": false,
+		"comment": ""
+	},
+	"attributes": {
+		"title": {
+			"type": "string"
+		},
+		"platform": {
+			"type": "relation",
+			"relation": "oneToOne",
+			"target": "api::platform.platform"
+		}
+	}
+}

package/server/controllers/collection-types.ts

@@ -1,32 +1,32 @@
-import { Strapi } from '@strapi/strapi';
-
-export default {
-	async hasPageRelation(ctx: any) {
-		const uid = ctx.params?.uid;
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPageRelation(uid);
-	},
-	async hasPlatformRelation(ctx: any) {
-		const uid = ctx.params?.uid;
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPlatformRelation(uid);
-	},
-	async getTranslationPageLinks(ctx: any): Promise<IGetTranslationPageLinks[] | undefined> {
-		const { uid, ids } = ctx.params || {};
-		const idsArr = (ids as string)
-			?.split(',')
-			.map(Number)
-			.filter((x) => !isNaN(x));
-
-		if (!uid || idsArr?.length === 0) {
-			return undefined;
-		}
-
-		return (strapi as Strapi).service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
-	}
-};
-
-export interface IGetTranslationPageLinks {
-	id: number;
-	locale: string;
-}
+import { Strapi } from '@strapi/strapi';
+
+export default {
+	async hasPageRelation(ctx: any) {
+		const uid = ctx.params?.uid;
+
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPageRelation(uid);
+	},
+	async hasPlatformRelation(ctx: any) {
+		const uid = ctx.params?.uid;
+
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').hasPlatformRelation(uid);
+	},
+	async getTranslationPageLinks(ctx: any): Promise<IGetTranslationPageLinks[] | undefined> {
+		const { uid, ids } = ctx.params || {};
+		const idsArr = (ids as string)
+			?.split(',')
+			.map(Number)
+			.filter((x) => !isNaN(x));
+
+		if (!uid || idsArr?.length === 0) {
+			return undefined;
+		}
+
+		return (strapi as Strapi).service('plugin::page-builder.collection-types').getTranslationPageLinks(uid, idsArr);
+	}
+};
+
+export interface IGetTranslationPageLinks {
+	id: number;
+	locale: string;
+}