Add Content History

Author: alexcibotari

functions/src/contents.ts

@@ -1,18 +1,30 @@
 import { logger } from 'firebase-functions/v2';
 import { HttpsError, onCall } from 'firebase-functions/v2/https';
 import { onDocumentDeleted, onDocumentUpdated, onDocumentWritten } from 'firebase-functions/v2/firestore';
-import { FieldValue, UpdateData } from 'firebase-admin/firestore';
+import { FieldValue, UpdateData, WithFieldValue } from 'firebase-admin/firestore';
 import { canPerform } from './utils/security-utils';
 import { bucket, firestoreService } from './config';
-import { Content, ContentDocument, ContentDocumentStorage, ContentKind, PublishContentData, Schema, Space, UserPermission } from './models';
-import { extractContent, findContentByFullSlug, findContentById, findSchemas, findSpaceById } from './services';
+import {
+  Content,
+  ContentDocument,
+  ContentDocumentStorage,
+  ContentHistory,
+  ContentHistoryType,
+  ContentKind,
+  PublishContentData,
+  Schema,
+  Space,
+  UserPermission,
+} from './models';
+import { extractContent, findContentByFullSlug, findContentById, findContentsHistory, findSchemas, findSpaceById } from './services';
 
 // Publish
-const contentPublish = onCall<PublishContentData>(async request => {
+const publish = onCall<PublishContentData>(async request => {
   logger.info('[Content::contentPublish] data: ' + JSON.stringify(request.data));
   logger.info('[Content::contentPublish] context.auth: ' + JSON.stringify(request.auth));
-  if (!canPerform(UserPermission.CONTENT_PUBLISH, request.auth)) throw new HttpsError('permission-denied', 'permission-denied');
-  const { spaceId, contentId } = request.data;
+  const { auth, data } = request;
+  if (!canPerform(UserPermission.CONTENT_PUBLISH, auth)) throw new HttpsError('permission-denied', 'permission-denied');
+  const { spaceId, contentId } = data;
   const spaceSnapshot = await findSpaceById(spaceId).get();
   const contentSnapshot = await findContentById(spaceId, contentId).get();
   const schemasSnapshot = await findSchemas(spaceId).get();
@@ -44,6 +56,13 @@ const contentPublish = onCall<PublishContentData>(async request => {
     await bucket.file(`spaces/${spaceId}/contents/${contentId}/cache.json`).save('');
     // Update publishedAt
     await contentSnapshot.ref.update({ publishedAt: FieldValue.serverTimestamp() });
+    const addHistory: WithFieldValue<ContentHistory> = {
+      type: ContentHistoryType.PUBLISHED,
+      name: auth?.token['name'] || FieldValue.delete(),
+      email: auth?.token.email || FieldValue.delete(),
+      createdAt: FieldValue.serverTimestamp(),
+    };
+    await findContentsHistory(spaceId, contentId).add(addHistory);
     return;
   } else {
     logger.info(`[Content::contentPublish] Content ${contentId} does not exist.`);
@@ -129,17 +148,21 @@ const onContentDelete = onDocumentDeleted('spaces/{spaceId}/contents/{contentId}
   const { spaceId, contentId } = event.params;
   // No Data
   if (!event.data) return;
+  // TODO add 500 LIMIT
+  const batch = firestoreService.batch();
+  const contentsHistorySnapshot = await findContentsHistory(spaceId, contentId).get();
+  contentsHistorySnapshot.docs.forEach(it => batch.delete(it.ref));
   const content = event.data.data() as Content;
   logger.info(`[Content::onDelete] eventId='${event.id}' id='${event.data.id}' fullSlug='${content.fullSlug}'`);
   // Logic related to delete, in case a folder is deleted it should be cascaded to all childs
   if (content.kind === ContentKind.DOCUMENT) {
-    return bucket.deleteFiles({
+    await bucket.deleteFiles({
       prefix: `spaces/${spaceId}/contents/${contentId}`,
     });
+    return batch.commit();
   } else if (content.kind === ContentKind.FOLDER) {
     // cascade changes to all child's in case it is a FOLDER
     // It will create recursion
-    const batch = firestoreService.batch();
     const contentsSnapshot = await findContentByFullSlug(spaceId, content.fullSlug).get();
     contentsSnapshot.docs.filter(it => it.exists).forEach(it => batch.delete(it.ref));
     return batch.commit();
@@ -150,15 +173,58 @@ const onContentDelete = onDocumentDeleted('spaces/{spaceId}/contents/{contentId}
 const onContentWrite = onDocumentWritten('spaces/{spaceId}/contents/{contentId}', async event => {
   logger.info(`[Content::onWrite] eventId='${event.id}'`);
   logger.info(`[Content::onWrite] params='${JSON.stringify(event.params)}'`);
-  const { spaceId } = event.params;
+  const { spaceId, contentId } = event.params;
   // Save Cache, to make sure LINKS are cached correctly with cache version
   logger.info(`[Content::onWrite] Save file to spaces/${spaceId}/contents/cache.json`);
   await bucket.file(`spaces/${spaceId}/contents/cache.json`).save('');
+  // History
+  // No Data
+  if (!event.data) return;
+  const { before, after } = event.data;
+  const beforeData = before.data() as Content | undefined;
+  const afterData = after.data() as Content | undefined;
+  let addHistory: WithFieldValue<ContentHistory> = {
+    type: ContentHistoryType.PUBLISHED,
+    createdAt: FieldValue.serverTimestamp(),
+  };
+  if (beforeData && afterData) {
+    // change
+    if (beforeData.kind === ContentKind.DOCUMENT && afterData.kind === ContentKind.DOCUMENT) {
+      if (beforeData.publishedAt?.nanoseconds !== afterData.publishedAt?.nanoseconds) {
+        // SKIP Publish event
+        return;
+      }
+    }
+    addHistory = {
+      type: ContentHistoryType.UPDATE,
+      createdAt: FieldValue.serverTimestamp(),
+    };
+    if (beforeData.name !== afterData.name) {
+      addHistory.cName = afterData.name;
+    }
+    if (beforeData.slug !== afterData.slug) {
+      addHistory.cSlug = afterData.slug;
+    }
+    if (beforeData.kind === ContentKind.DOCUMENT && afterData.kind === ContentKind.DOCUMENT) {
+      if (JSON.stringify(beforeData.data) !== JSON.stringify(afterData.data)) {
+        addHistory.cData = true;
+      }
+    }
+  } else if (afterData) {
+    // create
+    addHistory = {
+      type: ContentHistoryType.CREATE,
+      cName: afterData.name,
+      cSlug: afterData.slug,
+      createdAt: FieldValue.serverTimestamp(),
+    };
+  }
+  await findContentsHistory(spaceId, contentId).add(addHistory);
   return;
 });
 
 export const content = {
-  publish: contentPublish,
+  publish: publish,
   onupdate: onContentUpdate,
   ondelete: onContentDelete,
   onwrite: onContentWrite,

functions/src/models/content-history.model.ts

@@ -0,0 +1,38 @@
+import { Timestamp } from 'firebase-admin/firestore';
+
+export enum ContentHistoryType {
+  PUBLISHED = 'PUBLISHED',
+  CREATE = 'CREATE',
+  UPDATE = 'UPDATE',
+  DELETE = 'DELETE',
+}
+
+export type ContentHistory = ContentHistoryPublish | ContentHistoryCreate | ContentHistoryUpdate | ContentHistoryDelete;
+
+export interface ContentHistoryBase {
+  type: ContentHistoryType;
+  createdAt: Timestamp;
+}
+
+export interface ContentHistoryPublish extends ContentHistoryBase {
+  type: ContentHistoryType.PUBLISHED;
+  name?: string;
+  email?: string;
+}
+
+export interface ContentHistoryCreate extends ContentHistoryBase {
+  type: ContentHistoryType.CREATE;
+  cName: string;
+  cSlug: string;
+}
+
+export interface ContentHistoryUpdate extends ContentHistoryBase {
+  type: ContentHistoryType.UPDATE;
+  cName?: string;
+  cSlug?: string;
+  cData?: boolean;
+}
+
+export interface ContentHistoryDelete extends ContentHistoryBase {
+  type: ContentHistoryType.DELETE;
+}

functions/src/models/index.ts

@@ -1,5 +1,6 @@
 export * from './asset.model';
 export * from './content.model';
+export * from './content-history.model';
 export * from './firebase.model';
 export * from './locale.model';
 export * from './plugin.model';

functions/src/models/translation-history.model.ts

@@ -7,11 +7,30 @@ export enum TranslationHistoryType {
   DELETE = 'DELETE',
 }
 
-export interface TranslationHistory {
+export type TranslationHistory = TranslationHistoryPublish | TranslationHistoryCreate | TranslationHistoryUpdate | TranslationHistoryDelete;
+
+export interface TranslationHistoryBase {
   type: TranslationHistoryType;
-  description?: string;
-  key?: string;
+  createdAt: Timestamp;
+}
+
+export interface TranslationHistoryPublish extends TranslationHistoryBase {
+  type: TranslationHistoryType.PUBLISHED;
   name?: string;
   email?: string;
-  createdAt: Timestamp;
+}
+
+export interface TranslationHistoryCreate extends TranslationHistoryBase {
+  type: TranslationHistoryType.CREATE;
+  key: string;
+}
+
+export interface TranslationHistoryUpdate extends TranslationHistoryBase {
+  type: TranslationHistoryType.UPDATE;
+  key: string;
+}
+
+export interface TranslationHistoryDelete extends TranslationHistoryBase {
+  type: TranslationHistoryType.DELETE;
+  key: string;
 }

functions/src/services/content-history.service.ts

@@ -0,0 +1,23 @@
+import { firestoreService } from '../config';
+import { CollectionReference, DocumentReference } from 'firebase-admin/firestore';
+
+/**
+ * find Content History by ID
+ * @param {string} spaceId Space identifier
+ * @param {string} contentId Content identifier
+ * @param {string} id Content identifier
+ * @return {DocumentReference} document reference to the space
+ */
+export function findContentHistoryById(spaceId: string, contentId: string, id: string): DocumentReference {
+  return firestoreService.doc(`spaces/${spaceId}/contents/${contentId}/histories/${id}`);
+}
+
+/**
+ * find Contents History
+ * @param {string} spaceId Space identifier
+ * @param {string} contentId Content identifier
+ * @return {DocumentReference} document reference to the space
+ */
+export function findContentsHistory(spaceId: string, contentId: string): CollectionReference {
+  return firestoreService.collection(`spaces/${spaceId}/contents/${contentId}/histories`);
+}

functions/src/services/index.ts

@@ -1,5 +1,6 @@
 export * from './asset.service';
 export * from './content.service';
+export * from './content-history.service';
 export * from './plugin.service';
 export * from './schema.service';
 export * from './space.service';

functions/src/spaces.ts

@@ -14,6 +14,15 @@ const onSpaceDelete = onDocumentDeleted('spaces/{spaceId}', event => {
   return bucket.deleteFiles({
     prefix: `spaces/${spaceId}/`,
   });
+  // TODO delete all sub collections
+  // assets
+  // contents
+  // plugins
+  // schemas
+  // tasks
+  // tokens
+  // translations
+  // translations_history
 });
 
 const calculateOverview = onCall<SpaceOverviewData>(async request => {

functions/src/translations.ts

@@ -9,12 +9,12 @@ import { PublishTranslationsData, Space, Translation, TranslationHistory, Transl
 import { findSpaceById, findTranslations, findTranslationsHistory } from './services';
 
 // Publish
-const translationsPublish = onCall<PublishTranslationsData>(async request => {
+const publish = onCall<PublishTranslationsData>(async request => {
   logger.info('[translationsPublish] data: ' + JSON.stringify(request.data));
   logger.info('[translationsPublish] context.auth: ' + JSON.stringify(request.auth));
   const { auth, data } = request;
+  if (!canPerform(UserPermission.TRANSLATION_PUBLISH, auth)) throw new HttpsError('permission-denied', 'permission-denied');
   const { spaceId } = data;
-  if (!canPerform(UserPermission.TRANSLATION_PUBLISH, request.auth)) throw new HttpsError('permission-denied', 'permission-denied');
   const spaceSnapshot = await findSpaceById(spaceId).get();
   const translationsSnapshot = await findTranslations(spaceId).get();
   if (spaceSnapshot.exists && !translationsSnapshot.empty) {
@@ -59,7 +59,7 @@ const translationsPublish = onCall<PublishTranslationsData>(async request => {
   }
 });
 
-const onTranslationCreate = onDocumentCreated('spaces/{spaceId}/translations/{translationId}', async event => {
+const onCreate = onDocumentCreated('spaces/{spaceId}/translations/{translationId}', async event => {
   logger.info(`[Translation:onCreate] eventId='${event.id}'`);
   logger.info(`[Translation:onCreate] params='${JSON.stringify(event.params)}'`);
   const { spaceId } = event.params;
@@ -121,7 +121,7 @@ const onTranslationCreate = onDocumentCreated('spaces/{spaceId}/translations/{tr
   return;
 });
 
-const onTranslationWrite = onDocumentWritten('spaces/{spaceId}/translations/{translationId}', async event => {
+const onWriteToHistory = onDocumentWritten('spaces/{spaceId}/translations/{translationId}', async event => {
   logger.info(`[Translation:onWrite] eventId='${event.id}'`);
   logger.info(`[Translation:onWrite] params='${JSON.stringify(event.params)}'`);
   const { spaceId } = event.params;
@@ -131,29 +131,38 @@ const onTranslationWrite = onDocumentWritten('spaces/{spaceId}/translations/{tra
   const { before, after } = event.data;
   const beforeData = before.data() as Translation | undefined;
   const afterData = after.data() as Translation | undefined;
-  const addHistory: WithFieldValue<TranslationHistory> = {
-    type: TranslationHistoryType.CREATE,
+  let addHistory: WithFieldValue<TranslationHistory> = {
+    type: TranslationHistoryType.PUBLISHED,
     createdAt: FieldValue.serverTimestamp(),
   };
   if (beforeData && afterData) {
     // change
-    addHistory.type = TranslationHistoryType.UPDATE;
-    addHistory.key = afterData.name;
+    addHistory = {
+      type: TranslationHistoryType.UPDATE,
+      key: afterData.name,
+      createdAt: FieldValue.serverTimestamp(),
+    };
   } else if (beforeData) {
     // delete
-    addHistory.type = TranslationHistoryType.DELETE;
-    addHistory.key = beforeData.name;
+    addHistory = {
+      type: TranslationHistoryType.DELETE,
+      key: beforeData.name,
+      createdAt: FieldValue.serverTimestamp(),
+    };
   } else if (afterData) {
     // create
-    addHistory.type = TranslationHistoryType.CREATE;
-    addHistory.key = afterData.name;
+    addHistory = {
+      type: TranslationHistoryType.CREATE,
+      key: afterData.name,
+      createdAt: FieldValue.serverTimestamp(),
+    };
   }
   await findTranslationsHistory(spaceId).add(addHistory);
   return;
 });
 
 export const translation = {
-  publish: translationsPublish,
-  oncreate: onTranslationCreate,
-  onwrite: onTranslationWrite,
+  publish: publish,
+  oncreate: onCreate,
+  onwritetohistory: onWriteToHistory,
 };

src/app/features/contents/contents.module.ts

@@ -22,6 +22,7 @@ import { TaskService } from '@shared/services/task.service';
 import { TokenService } from '@shared/services/token.service';
 import { ReferenceSelectComponent } from './shared/reference-select/reference-select.component';
 import { ReferencesSelectComponent } from './shared/references-select/references-select.component';
+import { ContentHistoryService } from '@shared/services/content-history.service';
 
 @NgModule({
   declarations: [
@@ -40,6 +41,15 @@ import { ReferencesSelectComponent } from './shared/references-select/references
     ImportDialogComponent,
   ],
   imports: [SharedModule, ContentsRoutingModule],
-  providers: [SpaceService, SchemaService, ContentService, ContentHelperService, AssetService, TaskService, TokenService],
+  providers: [
+    SpaceService,
+    SchemaService,
+    ContentService,
+    ContentHistoryService,
+    ContentHelperService,
+    AssetService,
+    TaskService,
+    TokenService,
+  ],
 })
 export class ContentsModule {}