@webiny/api-audit-logs 0.0.0-unstable.eb196ccd2f → 0.0.0-unstable.eb81deee7e

package/subscriptions/websiteBuilder/pages/PageAfterDeleteHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterDeleteEventHandler } from "@webiny/api-website-builder/features/pages/DeletePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterDeleteHandlerImpl implements PageAfterDeleteEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterDeleteAuditHandler: typeof PageAfterDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/DeletePage/abstractions").PageAfterDeletePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterDeleteHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterDeleteEventHandler } from "@webiny/api-website-builder/features/pages/DeletePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterDeleteHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.DELETE,
+                message: "Website Page Delete",
+                content: page,
+                entityId: page.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterDeleteEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_DELETE_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterDeleteAuditHandler = PageAfterDeleteEventHandler.createImplementation({
+    implementation: PageAfterDeleteHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterDeleteAuditHandler };
+
+//# sourceMappingURL=PageAfterDeleteHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterDeleteHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterDeleteEventHandler } from \"@webiny/api-website-builder/features/pages/DeletePage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterDeleteHandlerImpl implements PageAfterDeleteEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterDeleteEventHandler.Event): Promise<void> {\n        try {\n            const { page } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.DELETE,\n                message: \"Website Page Delete\",\n                content: page,\n                entityId: page.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterDeleteEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterDeleteAuditHandler = PageAfterDeleteEventHandler.createImplementation({\n    implementation: PageAfterDeleteHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterDeleteHandlerImpl","recordAuditLog","event","page","recordResult","AUDIT","error","WebinyError","PageAfterDeleteAuditHandler","PageAfterDeleteEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAwC,EAAiB;QAClE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;YAC9B,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,MAAM;gBACxC,SAAS;gBACT,SAASF;gBACT,UAAUA,KAAK,EAAE;YACrB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,8BAA8BC,4BAA4B,oBAAoB,CAAC;IACxF,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/pages/PageAfterDuplicateHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterDuplicateEventHandler } from "@webiny/api-website-builder/features/pages/DuplicatePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterDuplicateHandlerImpl implements PageAfterDuplicateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterDuplicateEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterDuplicateAuditHandler: typeof PageAfterDuplicateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/DuplicatePage/abstractions").PageAfterDuplicatePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterDuplicateHandler.js

@@ -0,0 +1,38 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterDuplicateEventHandler } from "@webiny/api-website-builder/features/pages/DuplicatePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterDuplicateHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page, original } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.DUPLICATE,
+                message: "Website Page Duplicate",
+                content: {
+                    original,
+                    page
+                },
+                entityId: original.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterDuplicateEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_DUPLICATE_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterDuplicateAuditHandler = PageAfterDuplicateEventHandler.createImplementation({
+    implementation: PageAfterDuplicateHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterDuplicateAuditHandler };
+
+//# sourceMappingURL=PageAfterDuplicateHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterDuplicateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterDuplicateHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterDuplicateHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterDuplicateEventHandler } from \"@webiny/api-website-builder/features/pages/DuplicatePage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterDuplicateHandlerImpl implements PageAfterDuplicateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterDuplicateEventHandler.Event): Promise<void> {\n        try {\n            const { page, original } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.DUPLICATE,\n                message: \"Website Page Duplicate\",\n                content: { original, page },\n                entityId: original.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterDuplicateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_DUPLICATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterDuplicateAuditHandler = PageAfterDuplicateEventHandler.createImplementation({\n    implementation: PageAfterDuplicateHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterDuplicateHandlerImpl","recordAuditLog","event","page","original","recordResult","AUDIT","error","WebinyError","PageAfterDuplicateAuditHandler","PageAfterDuplicateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA2C,EAAiB;QACrE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;YACxC,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,SAAS;gBAC3C,SAAS;gBACT,SAAS;oBAAEF;oBAAUD;gBAAK;gBAC1B,UAAUC,SAAS,EAAE;YACzB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,iCAAiCC,+BAA+B,oBAAoB,CAAC;IAC9F,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/pages/PageAfterMoveHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterMoveEventHandler } from "@webiny/api-website-builder/features/pages/MovePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterMoveHandlerImpl implements PageAfterMoveEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterMoveEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterMoveAuditHandler: typeof PageAfterMoveHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/MovePage/abstractions").PageAfterMovePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterMoveHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterMoveEventHandler } from "@webiny/api-website-builder/features/pages/MovePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterMoveHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.MOVE,
+                message: "Website Page Move",
+                content: page,
+                entityId: page.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterMoveEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_MOVE_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterMoveAuditHandler = PageAfterMoveEventHandler.createImplementation({
+    implementation: PageAfterMoveHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterMoveAuditHandler };
+
+//# sourceMappingURL=PageAfterMoveHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterMoveHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterMoveHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterMoveHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterMoveEventHandler } from \"@webiny/api-website-builder/features/pages/MovePage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterMoveHandlerImpl implements PageAfterMoveEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterMoveEventHandler.Event): Promise<void> {\n        try {\n            const { page } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.MOVE,\n                message: \"Website Page Move\",\n                content: page,\n                entityId: page.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterMoveEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_MOVE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterMoveAuditHandler = PageAfterMoveEventHandler.createImplementation({\n    implementation: PageAfterMoveHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterMoveHandlerImpl","recordAuditLog","event","page","recordResult","AUDIT","error","WebinyError","PageAfterMoveAuditHandler","PageAfterMoveEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAsC,EAAiB;QAChE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;YAC9B,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,IAAI;gBACtC,SAAS;gBACT,SAASF;gBACT,UAAUA,KAAK,EAAE;YACrB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,4BAA4BC,0BAA0B,oBAAoB,CAAC;IACpF,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/pages/PageAfterPublishHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterPublishEventHandler } from "@webiny/api-website-builder/features/pages/PublishPage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterPublishHandlerImpl implements PageAfterPublishEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterPublishEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterPublishAuditHandler: typeof PageAfterPublishHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/PublishPage/abstractions").PageAfterPublishPayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterPublishHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterPublishEventHandler } from "@webiny/api-website-builder/features/pages/PublishPage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterPublishHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.PUBLISH,
+                message: "Website Page Published",
+                content: page,
+                entityId: page.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterPublishEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_PUBLISH_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterPublishAuditHandler = PageAfterPublishEventHandler.createImplementation({
+    implementation: PageAfterPublishHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterPublishAuditHandler };
+
+//# sourceMappingURL=PageAfterPublishHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterPublishHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterPublishHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterPublishHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterPublishEventHandler } from \"@webiny/api-website-builder/features/pages/PublishPage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterPublishHandlerImpl implements PageAfterPublishEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterPublishEventHandler.Event): Promise<void> {\n        try {\n            const { page } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.PUBLISH,\n                message: \"Website Page Published\",\n                content: page,\n                entityId: page.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterPublishEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_PUBLISH_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterPublishAuditHandler = PageAfterPublishEventHandler.createImplementation({\n    implementation: PageAfterPublishHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterPublishHandlerImpl","recordAuditLog","event","page","recordResult","AUDIT","error","WebinyError","PageAfterPublishAuditHandler","PageAfterPublishEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAyC,EAAiB;QACnE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;YAC9B,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,OAAO;gBACzC,SAAS;gBACT,SAASF;gBACT,UAAUA,KAAK,EAAE;YACrB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,+BAA+BC,6BAA6B,oBAAoB,CAAC;IAC1F,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/pages/PageAfterUnpublishHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterUnpublishEventHandler } from "@webiny/api-website-builder/features/pages/UnpublishPage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterUnpublishHandlerImpl implements PageAfterUnpublishEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterUnpublishEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterUnpublishAuditHandler: typeof PageAfterUnpublishHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/UnpublishPage/abstractions").PageAfterUnpublishPayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterUnpublishHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterUnpublishEventHandler } from "@webiny/api-website-builder/features/pages/UnpublishPage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterUnpublishHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.UNPUBLISH,
+                message: "Website Page Unpublished",
+                content: page,
+                entityId: page.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterUnpublishEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_UNPUBLISH_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterUnpublishAuditHandler = PageAfterUnpublishEventHandler.createImplementation({
+    implementation: PageAfterUnpublishHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterUnpublishAuditHandler };
+
+//# sourceMappingURL=PageAfterUnpublishHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterUnpublishHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterUnpublishHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterUnpublishHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterUnpublishEventHandler } from \"@webiny/api-website-builder/features/pages/UnpublishPage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterUnpublishHandlerImpl implements PageAfterUnpublishEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterUnpublishEventHandler.Event): Promise<void> {\n        try {\n            const { page } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.UNPUBLISH,\n                message: \"Website Page Unpublished\",\n                content: page,\n                entityId: page.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterUnpublishEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_UNPUBLISH_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterUnpublishAuditHandler = PageAfterUnpublishEventHandler.createImplementation({\n    implementation: PageAfterUnpublishHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterUnpublishHandlerImpl","recordAuditLog","event","page","recordResult","AUDIT","error","WebinyError","PageAfterUnpublishAuditHandler","PageAfterUnpublishEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA2C,EAAiB;QACrE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;YAC9B,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,SAAS;gBAC3C,SAAS;gBACT,SAASF;gBACT,UAAUA,KAAK,EAAE;YACrB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,iCAAiCC,+BAA+B,oBAAoB,CAAC;IAC9F,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/pages/PageAfterUpdateHandler.d.ts

@@ -0,0 +1,11 @@
+import { PageAfterUpdateEventHandler } from "@webiny/api-website-builder/features/pages/UpdatePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class PageAfterUpdateHandlerImpl implements PageAfterUpdateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: PageAfterUpdateEventHandler.Event): Promise<void>;
+}
+export declare const PageAfterUpdateAuditHandler: typeof PageAfterUpdateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/pages/UpdatePage/abstractions").PageAfterUpdatePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/pages/PageAfterUpdateHandler.js

@@ -0,0 +1,38 @@
+import { WebinyError } from "@webiny/error";
+import { PageAfterUpdateEventHandler } from "@webiny/api-website-builder/features/pages/UpdatePage/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class PageAfterUpdateHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { page, original } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.PAGE.UPDATE,
+                message: "Website Page Updated",
+                content: {
+                    before: original,
+                    after: page
+                },
+                entityId: page.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing PageAfterUpdateEventHandler",
+                code: "AUDIT_LOGS_AFTER_PAGE_UPDATE_HANDLER"
+            });
+        }
+    }
+}
+const PageAfterUpdateAuditHandler = PageAfterUpdateEventHandler.createImplementation({
+    implementation: PageAfterUpdateHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { PageAfterUpdateAuditHandler };
+
+//# sourceMappingURL=PageAfterUpdateHandler.js.map

package/subscriptions/websiteBuilder/pages/PageAfterUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/pages/PageAfterUpdateHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/pages/PageAfterUpdateHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { PageAfterUpdateEventHandler } from \"@webiny/api-website-builder/features/pages/UpdatePage/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass PageAfterUpdateHandlerImpl implements PageAfterUpdateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: PageAfterUpdateEventHandler.Event): Promise<void> {\n        try {\n            const { page, original } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.PAGE.UPDATE,\n                message: \"Website Page Updated\",\n                content: { before: original, after: page },\n                entityId: page.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing PageAfterUpdateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_PAGE_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const PageAfterUpdateAuditHandler = PageAfterUpdateEventHandler.createImplementation({\n    implementation: PageAfterUpdateHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["PageAfterUpdateHandlerImpl","recordAuditLog","event","page","original","recordResult","AUDIT","error","WebinyError","PageAfterUpdateAuditHandler","PageAfterUpdateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAAwC,EAAiB;QAClE,IAAI;YACA,MAAM,EAAEC,IAAI,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;YACxC,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,IAAI,CAAC,MAAM;gBACxC,SAAS;gBACT,SAAS;oBAAE,QAAQF;oBAAU,OAAOD;gBAAK;gBACzC,UAAUA,KAAK,EAAE;YACrB;YACA,IAAIE,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,8BAA8BC,4BAA4B,oBAAoB,CAAC;IACxF,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/redirects/RedirectAfterCreateHandler.d.ts

@@ -0,0 +1,11 @@
+import { RedirectAfterCreateEventHandler } from "@webiny/api-website-builder/features/redirects/CreateRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class RedirectAfterCreateHandlerImpl implements RedirectAfterCreateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: RedirectAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const RedirectAfterCreateAuditHandler: typeof RedirectAfterCreateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/redirects/CreateRedirect/abstractions").RedirectAfterCreatePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/redirects/RedirectAfterCreateHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { RedirectAfterCreateEventHandler } from "@webiny/api-website-builder/features/redirects/CreateRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class RedirectAfterCreateHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { redirect } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.CREATE,
+                message: "Website Redirect Created",
+                content: redirect,
+                entityId: redirect.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing RedirectAfterCreateEventHandler",
+                code: "AUDIT_LOGS_AFTER_REDIRECT_CREATE_HANDLER"
+            });
+        }
+    }
+}
+const RedirectAfterCreateAuditHandler = RedirectAfterCreateEventHandler.createImplementation({
+    implementation: RedirectAfterCreateHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { RedirectAfterCreateAuditHandler };
+
+//# sourceMappingURL=RedirectAfterCreateHandler.js.map

package/subscriptions/websiteBuilder/redirects/RedirectAfterCreateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/redirects/RedirectAfterCreateHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/redirects/RedirectAfterCreateHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { RedirectAfterCreateEventHandler } from \"@webiny/api-website-builder/features/redirects/CreateRedirect/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass RedirectAfterCreateHandlerImpl implements RedirectAfterCreateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: RedirectAfterCreateEventHandler.Event): Promise<void> {\n        try {\n            const { redirect } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.CREATE,\n                message: \"Website Redirect Created\",\n                content: redirect,\n                entityId: redirect.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing RedirectAfterCreateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_REDIRECT_CREATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const RedirectAfterCreateAuditHandler = RedirectAfterCreateEventHandler.createImplementation(\n    {\n        implementation: RedirectAfterCreateHandlerImpl,\n        dependencies: [RecordAuditLogUseCase]\n    }\n);\n"],"names":["RedirectAfterCreateHandlerImpl","recordAuditLog","event","redirect","recordResult","AUDIT","error","WebinyError","RedirectAfterCreateAuditHandler","RedirectAfterCreateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA4C,EAAiB;QACtE,IAAI;YACA,MAAM,EAAEC,QAAQ,EAAE,GAAGD,MAAM,OAAO;YAClC,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,QAAQ,CAAC,MAAM;gBAC5C,SAAS;gBACT,SAASF;gBACT,UAAUA,SAAS,EAAE;YACzB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,kCAAkCC,gCAAgC,oBAAoB,CAC/F;IACI,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/redirects/RedirectAfterDeleteHandler.d.ts

@@ -0,0 +1,11 @@
+import { RedirectAfterDeleteEventHandler } from "@webiny/api-website-builder/features/redirects/DeleteRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class RedirectAfterDeleteHandlerImpl implements RedirectAfterDeleteEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: RedirectAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const RedirectAfterDeleteAuditHandler: typeof RedirectAfterDeleteHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/redirects/DeleteRedirect/abstractions").RedirectAfterDeletePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/redirects/RedirectAfterDeleteHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { RedirectAfterDeleteEventHandler } from "@webiny/api-website-builder/features/redirects/DeleteRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class RedirectAfterDeleteHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { redirect } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.DELETE,
+                message: "Website Redirect Deleted",
+                content: redirect,
+                entityId: redirect.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing RedirectAfterDeleteEventHandler",
+                code: "AUDIT_LOGS_AFTER_REDIRECT_DELETE_HANDLER"
+            });
+        }
+    }
+}
+const RedirectAfterDeleteAuditHandler = RedirectAfterDeleteEventHandler.createImplementation({
+    implementation: RedirectAfterDeleteHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { RedirectAfterDeleteAuditHandler };
+
+//# sourceMappingURL=RedirectAfterDeleteHandler.js.map

package/subscriptions/websiteBuilder/redirects/RedirectAfterDeleteHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/redirects/RedirectAfterDeleteHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/redirects/RedirectAfterDeleteHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { RedirectAfterDeleteEventHandler } from \"@webiny/api-website-builder/features/redirects/DeleteRedirect/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass RedirectAfterDeleteHandlerImpl implements RedirectAfterDeleteEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: RedirectAfterDeleteEventHandler.Event): Promise<void> {\n        try {\n            const { redirect } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.DELETE,\n                message: \"Website Redirect Deleted\",\n                content: redirect,\n                entityId: redirect.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing RedirectAfterDeleteEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_REDIRECT_DELETE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const RedirectAfterDeleteAuditHandler = RedirectAfterDeleteEventHandler.createImplementation(\n    {\n        implementation: RedirectAfterDeleteHandlerImpl,\n        dependencies: [RecordAuditLogUseCase]\n    }\n);\n"],"names":["RedirectAfterDeleteHandlerImpl","recordAuditLog","event","redirect","recordResult","AUDIT","error","WebinyError","RedirectAfterDeleteAuditHandler","RedirectAfterDeleteEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA4C,EAAiB;QACtE,IAAI;YACA,MAAM,EAAEC,QAAQ,EAAE,GAAGD,MAAM,OAAO;YAClC,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,QAAQ,CAAC,MAAM;gBAC5C,SAAS;gBACT,SAASF;gBACT,UAAUA,SAAS,EAAE;YACzB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,kCAAkCC,gCAAgC,oBAAoB,CAC/F;IACI,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/redirects/RedirectAfterMoveHandler.d.ts

@@ -0,0 +1,11 @@
+import { RedirectAfterMoveEventHandler } from "@webiny/api-website-builder/features/redirects/MoveRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class RedirectAfterMoveHandlerImpl implements RedirectAfterMoveEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: RedirectAfterMoveEventHandler.Event): Promise<void>;
+}
+export declare const RedirectAfterMoveAuditHandler: typeof RedirectAfterMoveHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/redirects/MoveRedirect/abstractions").RedirectAfterMovePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/redirects/RedirectAfterMoveHandler.js

@@ -0,0 +1,35 @@
+import { WebinyError } from "@webiny/error";
+import { RedirectAfterMoveEventHandler } from "@webiny/api-website-builder/features/redirects/MoveRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class RedirectAfterMoveHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { redirect } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.MOVE,
+                message: "Website Redirect Moved",
+                content: redirect,
+                entityId: redirect.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing RedirectAfterMoveEventHandler",
+                code: "AUDIT_LOGS_AFTER_REDIRECT_MOVE_HANDLER"
+            });
+        }
+    }
+}
+const RedirectAfterMoveAuditHandler = RedirectAfterMoveEventHandler.createImplementation({
+    implementation: RedirectAfterMoveHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { RedirectAfterMoveAuditHandler };
+
+//# sourceMappingURL=RedirectAfterMoveHandler.js.map

package/subscriptions/websiteBuilder/redirects/RedirectAfterMoveHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/redirects/RedirectAfterMoveHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/redirects/RedirectAfterMoveHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { RedirectAfterMoveEventHandler } from \"@webiny/api-website-builder/features/redirects/MoveRedirect/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass RedirectAfterMoveHandlerImpl implements RedirectAfterMoveEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: RedirectAfterMoveEventHandler.Event): Promise<void> {\n        try {\n            const { redirect } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.MOVE,\n                message: \"Website Redirect Moved\",\n                content: redirect,\n                entityId: redirect.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing RedirectAfterMoveEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_REDIRECT_MOVE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const RedirectAfterMoveAuditHandler = RedirectAfterMoveEventHandler.createImplementation({\n    implementation: RedirectAfterMoveHandlerImpl,\n    dependencies: [RecordAuditLogUseCase]\n});\n"],"names":["RedirectAfterMoveHandlerImpl","recordAuditLog","event","redirect","recordResult","AUDIT","error","WebinyError","RedirectAfterMoveAuditHandler","RedirectAfterMoveEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA0C,EAAiB;QACpE,IAAI;YACA,MAAM,EAAEC,QAAQ,EAAE,GAAGD,MAAM,OAAO;YAClC,MAAME,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,QAAQ,CAAC,IAAI;gBAC1C,SAAS;gBACT,SAASF;gBACT,UAAUA,SAAS,EAAE;YACzB;YACA,IAAIC,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,gCAAgCC,8BAA8B,oBAAoB,CAAC;IAC5F,gBAAgBT;IAChB,cAAc;QAACU;KAAsB;AACzC"}

package/subscriptions/websiteBuilder/redirects/RedirectAfterUpdateHandler.d.ts

@@ -0,0 +1,11 @@
+import { RedirectAfterUpdateEventHandler } from "@webiny/api-website-builder/features/redirects/UpdateRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+declare class RedirectAfterUpdateHandlerImpl implements RedirectAfterUpdateEventHandler.Interface {
+    private recordAuditLog;
+    constructor(recordAuditLog: RecordAuditLogUseCase.Interface);
+    handle(event: RedirectAfterUpdateEventHandler.Event): Promise<void>;
+}
+export declare const RedirectAfterUpdateAuditHandler: typeof RedirectAfterUpdateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-core/features/eventPublisher").DomainEvent<import("@webiny/api-website-builder/features/redirects/UpdateRedirect/abstractions").RedirectAfterUpdatePayload>>>;
+};
+export {};

package/subscriptions/websiteBuilder/redirects/RedirectAfterUpdateHandler.js

@@ -0,0 +1,38 @@
+import { WebinyError } from "@webiny/error";
+import { RedirectAfterUpdateEventHandler } from "@webiny/api-website-builder/features/redirects/UpdateRedirect/index.js";
+import { RecordAuditLogUseCase } from "../../../features/RecordAuditLog/abstractions.js";
+import { AUDIT } from "../../../config.js";
+class RedirectAfterUpdateHandlerImpl {
+    constructor(recordAuditLog){
+        this.recordAuditLog = recordAuditLog;
+    }
+    async handle(event) {
+        try {
+            const { redirect, original } = event.payload;
+            const recordResult = await this.recordAuditLog.execute({
+                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.UPDATE,
+                message: "Website Redirect Updated",
+                content: {
+                    before: original,
+                    after: redirect
+                },
+                entityId: redirect.id
+            });
+            if (recordResult.isFail()) throw recordResult.error;
+        } catch (error) {
+            throw WebinyError.from(error, {
+                message: "Error while executing RedirectAfterUpdateEventHandler",
+                code: "AUDIT_LOGS_AFTER_REDIRECT_UPDATE_HANDLER"
+            });
+        }
+    }
+}
+const RedirectAfterUpdateAuditHandler = RedirectAfterUpdateEventHandler.createImplementation({
+    implementation: RedirectAfterUpdateHandlerImpl,
+    dependencies: [
+        RecordAuditLogUseCase
+    ]
+});
+export { RedirectAfterUpdateAuditHandler };
+
+//# sourceMappingURL=RedirectAfterUpdateHandler.js.map

package/subscriptions/websiteBuilder/redirects/RedirectAfterUpdateHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions/websiteBuilder/redirects/RedirectAfterUpdateHandler.js","sources":["../../../../src/subscriptions/websiteBuilder/redirects/RedirectAfterUpdateHandler.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { RedirectAfterUpdateEventHandler } from \"@webiny/api-website-builder/features/redirects/UpdateRedirect/index.js\";\nimport { RecordAuditLogUseCase } from \"~/features/RecordAuditLog/abstractions.js\";\nimport { AUDIT } from \"~/config.js\";\n\nclass RedirectAfterUpdateHandlerImpl implements RedirectAfterUpdateEventHandler.Interface {\n    constructor(private recordAuditLog: RecordAuditLogUseCase.Interface) {}\n\n    async handle(event: RedirectAfterUpdateEventHandler.Event): Promise<void> {\n        try {\n            const { redirect, original } = event.payload;\n            const recordResult = await this.recordAuditLog.execute({\n                audit: AUDIT.WEBSITE_BUILDER.REDIRECT.UPDATE,\n                message: \"Website Redirect Updated\",\n                content: { before: original, after: redirect },\n                entityId: redirect.id\n            });\n            if (recordResult.isFail()) {\n                throw recordResult.error;\n            }\n        } catch (error) {\n            throw WebinyError.from(error, {\n                message: \"Error while executing RedirectAfterUpdateEventHandler\",\n                code: \"AUDIT_LOGS_AFTER_REDIRECT_UPDATE_HANDLER\"\n            });\n        }\n    }\n}\n\nexport const RedirectAfterUpdateAuditHandler = RedirectAfterUpdateEventHandler.createImplementation(\n    {\n        implementation: RedirectAfterUpdateHandlerImpl,\n        dependencies: [RecordAuditLogUseCase]\n    }\n);\n"],"names":["RedirectAfterUpdateHandlerImpl","recordAuditLog","event","redirect","original","recordResult","AUDIT","error","WebinyError","RedirectAfterUpdateAuditHandler","RedirectAfterUpdateEventHandler","RecordAuditLogUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,cAA+C,CAAE;aAAjDA,cAAc,GAAdA;IAAkD;IAEtE,MAAM,OAAOC,KAA4C,EAAiB;QACtE,IAAI;YACA,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;YAC5C,MAAMG,eAAe,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBACnD,OAAOC,MAAM,eAAe,CAAC,QAAQ,CAAC,MAAM;gBAC5C,SAAS;gBACT,SAAS;oBAAE,QAAQF;oBAAU,OAAOD;gBAAS;gBAC7C,UAAUA,SAAS,EAAE;YACzB;YACA,IAAIE,aAAa,MAAM,IACnB,MAAMA,aAAa,KAAK;QAEhC,EAAE,OAAOE,OAAO;YACZ,MAAMC,YAAY,IAAI,CAACD,OAAO;gBAC1B,SAAS;gBACT,MAAM;YACV;QACJ;IACJ;AACJ;AAEO,MAAME,kCAAkCC,gCAAgC,oBAAoB,CAC/F;IACI,gBAAgBV;IAChB,cAAc;QAACW;KAAsB;AACzC"}