feat: added possibility to add, change and remove multiviewers on running production

src/api/ateliereLive/pipelines/multiviews/multiviews.ts

@@ -142,8 +142,14 @@ export async function createMultiviewForPipeline(
       );
 
       if (response.ok) {
+        Log().info(
+          `Created multiview for pipeline '${pipelineUUID}' from preset`
+        );
         return await response.json();
       }
+      Log().info(
+        `ERROR: Could not create multiview for pipeline '${pipelineUUID}' from preset`
+      );
       throw await response.text();
     }
   );
@@ -173,8 +179,14 @@ export async function deleteMultiviewFromPipeline(
   );
 
   if (response.ok) {
+    Log().info(
+      `Deleted multiview ${multiviewId} for pipeline '${pipelineUUID}' from preset`
+    );
     return;
   }
+  Log().info(
+    `ERROR: Could not delete multiview ${multiviewId} for pipeline '${pipelineUUID}' from preset`
+  );
   throw await response.text();
 }
 
@@ -216,7 +228,13 @@ export async function updateMultiviewForPipeline(
     }
   );
   if (response.ok) {
+    Log().info(
+      `Updated multiview ${multiviewId} for pipeline '${pipelineUUID}' from preset`
+    );
     return await response.json();
   }
+  Log().info(
+    `ERROR: Could not update multiview ${multiviewId} for pipeline '${pipelineUUID}' from preset`
+  );
   throw await response.text();
 }

src/api/manager/multiview-presets.ts

@@ -18,13 +18,3 @@ export async function getMultiviewPreset(
     .collection<MultiviewPreset>('multiview-presets')
     .findOne({ _id: new ObjectId(id) })) as WithId<MultiviewPreset>;
 }
-
-// TODO Add this when possibility to update and add mv-presets are added
-// export async function putMultiviewPreset(
-//   newMultiviewPreset: MultiviewPreset
-// ): Promise<void> {
-//   const db = await getDatabase();
-//   await db
-//     .collection('multiview-presets')
-//     .insertOne({ ...newMultiviewPreset, _id: new ObjectId() });
-// }

src/api/manager/multiviews.ts

@@ -1,23 +1,23 @@
 import { ObjectId, WithId } from 'mongodb';
-import { MultiviewPreset } from '../../interfaces/preset';
+import { TMultiviewLayout } from '../../interfaces/preset';
 import { getDatabase } from '../mongoClient/dbClient';
 
-export async function getMultiviewLayouts(): Promise<MultiviewPreset[]> {
+export async function getMultiviewLayouts(): Promise<TMultiviewLayout[]> {
   const db = await getDatabase();
-  return await db.collection<MultiviewPreset>('multiviews').find({}).toArray();
+  return await db.collection<TMultiviewLayout>('multiviews').find({}).toArray();
 }
 
 export async function getMultiviewLayout(
   id: string
-): Promise<WithId<MultiviewPreset>> {
+): Promise<WithId<TMultiviewLayout>> {
   const db = await getDatabase();
   return (await db
-    .collection<MultiviewPreset>('multiviews')
-    .findOne({ _id: new ObjectId(id) })) as WithId<MultiviewPreset>;
+    .collection<TMultiviewLayout>('multiviews')
+    .findOne({ _id: new ObjectId(id) })) as WithId<TMultiviewLayout>;
 }
 
 export async function putMultiviewLayout(
-  newMultiviewLayout: MultiviewPreset
+  newMultiviewLayout: TMultiviewLayout
 ): Promise<void> {
   const db = await getDatabase();
   const collection = db.collection('multiviews');

src/api/manager/productions.ts

@@ -17,6 +17,7 @@ export async function getProduction(id: string): Promise<ProductionWithId> {
     .collection('productions')
     .findOne({ _id: new ObjectId(id) })) as ProductionWithId;
 }
+
 export async function setProductionsIsActiveFalse(): Promise<
   UpdateResult<Document>
 > {
@@ -25,6 +26,7 @@ export async function setProductionsIsActiveFalse(): Promise<
     .collection('productions')
     .updateMany({}, { $set: { isActive: false } });
 }
+
 export async function putProduction(
   id: string,
   production: Production

src/api/manager/workflow.ts

@@ -16,7 +16,9 @@ import {
 } from '../ateliereLive/pipelines/pipelines';
 import {
   createMultiviewForPipeline,
-  deleteAllMultiviewsFromPipeline
+  deleteAllMultiviewsFromPipeline,
+  deleteMultiviewFromPipeline,
+  updateMultiviewForPipeline
 } from '../ateliereLive/pipelines/multiviews/multiviews';
 import {
   getSourceIdFromSourceName,
@@ -52,6 +54,7 @@ import { getDatabase } from '../mongoClient/dbClient';
 import { updatedMonitoringForProduction } from './job/syncMonitoring';
 import { createControlPanelWebSocket } from '../ateliereLive/websocket';
 import { ObjectId } from 'mongodb';
+import { MultiviewSettings } from '../../interfaces/multiview';
 
 const isUsed = (pipeline: ResourcesPipelineResponse) => {
   const hasStreams = pipeline.streams.length > 0;
@@ -808,7 +811,7 @@ export async function startProduction(
           { step: 'pipeline_outputs', success: false },
           { step: 'multiviews', success: false }
         ],
-        error: 'Unknown error occured'
+        error: 'Could not start multiviews'
       };
     }
     return {
@@ -942,3 +945,265 @@ export async function startProduction(
     };
   }
 }
+
+export async function postMultiviewersOnRunningProduction(
+  production: Production,
+  additions: MultiviewSettings[]
+) {
+  try {
+    const multiview = production.production_settings.pipelines[0].multiviews;
+    if (!multiview) {
+      Log().error(
+        `No multiview settings specified for production: ${production.name}`
+      );
+      throw `No multiview settings specified for production: ${production.name}`;
+    }
+
+    const productionSettings = {
+      ...production.production_settings,
+      pipelines: production.production_settings.pipelines.map((pipeline) => {
+        return {
+          ...pipeline,
+          multiviews: additions
+        };
+      })
+    };
+
+    const runtimeMultiviews = await createMultiviewForPipeline(
+      productionSettings,
+      production.sources
+    ).catch(async (error) => {
+      Log().error(
+        `Failed to create multiview for pipeline '${productionSettings.pipelines[0].pipeline_name}/${productionSettings.pipelines[0].pipeline_id}'`,
+        error
+      );
+      throw `Failed to create multiview for pipeline '${productionSettings.pipelines[0].pipeline_name}/${productionSettings.pipelines[0].pipeline_id}': ${error}`;
+    });
+
+    const multiviewsWithUpdatedId: MultiviewSettings[] = [
+      ...multiview.slice(0, multiview.length - runtimeMultiviews.length),
+      ...runtimeMultiviews.map((runtimeMultiview, index) => {
+        return {
+          ...multiview[multiview.length - runtimeMultiviews.length + index],
+          multiview_id: runtimeMultiview.id
+        };
+      })
+    ];
+
+    await putProduction(production._id.toString(), {
+      ...production,
+      production_settings: {
+        ...production.production_settings,
+        pipelines: production.production_settings.pipelines.map((pipeline) => {
+          return {
+            ...pipeline,
+            multiviews: multiviewsWithUpdatedId
+          };
+        })
+      }
+    }).catch(async (error) => {
+      Log().error(
+        `Failed to save multiviews for pipeline '${productionSettings.pipelines[0].pipeline_name}/${productionSettings.pipelines[0].pipeline_id}' to database`,
+        error
+      );
+      throw error;
+    });
+
+    return {
+      ok: true,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'create_multiview',
+            success: true
+          }
+        ]
+      }
+    };
+  } catch (e) {
+    Log().error('Could not create multiviews');
+    Log().error(e);
+    if (typeof e !== 'string') {
+      return {
+        ok: false,
+        value: {
+          success: true,
+          steps: [
+            {
+              step: 'create_multiview',
+              success: false
+            }
+          ]
+        },
+        error: 'Could not create multiviews'
+      };
+    }
+    return {
+      ok: false,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'create_multiview',
+            success: false,
+            message: e
+          }
+        ]
+      },
+      error: e
+    };
+  }
+}
+
+export async function putMultiviewersOnRunningProduction(
+  production: Production,
+  updates: MultiviewSettings[]
+) {
+  try {
+    updates.map(async (multiview) => {
+      const views = multiview.layout.views;
+
+      if (
+        multiview.multiview_id &&
+        production.production_settings.pipelines[0].pipeline_id
+      ) {
+        await updateMultiviewForPipeline(
+          production.production_settings.pipelines[0].pipeline_id,
+          multiview.multiview_id,
+          views
+        );
+      }
+    });
+
+    return {
+      ok: true,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'update_multiview',
+            success: true
+          }
+        ]
+      }
+    };
+  } catch (e) {
+    Log().error('Could not update multiviews');
+    Log().error(e);
+    if (typeof e !== 'string') {
+      return {
+        ok: false,
+        value: {
+          success: true,
+          steps: [
+            {
+              step: 'update_multiview',
+              success: false
+            }
+          ]
+        },
+        error: 'Could not update multiviews'
+      };
+    }
+    return {
+      ok: false,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'update_multiview',
+            success: false,
+            message: e
+          }
+        ]
+      },
+      error: e
+    };
+  }
+}
+
+export async function deleteMultiviewersOnRunningProduction(
+  production: Production,
+  removals: MultiviewSettings[]
+) {
+  try {
+    const pipeline = production.production_settings.pipelines.find((p) =>
+      p.multiviews ? p.multiviews?.length > 0 : undefined
+    );
+    const multiviewIndexArray = pipeline?.multiviews
+      ? pipeline.multiviews.map((p) => p.for_pipeline_idx)
+      : undefined;
+
+    const multiviewIndex = multiviewIndexArray?.find((p) => p !== undefined);
+
+    const pipelineUUID =
+      multiviewIndex !== undefined
+        ? production.production_settings.pipelines[multiviewIndex].pipeline_id
+        : undefined;
+
+    if (!pipelineUUID) return;
+
+    await Promise.allSettled(
+      removals.map((multiview) => {
+        if (multiview.multiview_id) {
+          deleteMultiviewFromPipeline(
+            pipelineUUID,
+            multiview.multiview_id
+          ).catch((error) => {
+            Log().error(
+              `Failed to remove multiview '${multiview.multiview_id}' from pipeline '${pipelineUUID}'`,
+              error
+            );
+            throw `Failed to remove multiview '${multiview.multiview_id}' from pipeline '${pipelineUUID}': ${error}`;
+          });
+        }
+      })
+    );
+
+    return {
+      ok: true,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'delete_multiview',
+            success: true
+          }
+        ]
+      }
+    };
+  } catch (e) {
+    Log().error('Could not delete multiviews');
+    Log().error(e);
+    if (typeof e !== 'string') {
+      return {
+        ok: false,
+        value: {
+          success: true,
+          steps: [
+            {
+              step: 'delete_multiview',
+              success: false
+            }
+          ]
+        },
+        error: 'Could not delete multiviews'
+      };
+    }
+    return {
+      ok: false,
+      value: {
+        success: true,
+        steps: [
+          {
+            step: 'delete_multiview',
+            success: false,
+            message: e
+          }
+        ]
+      },
+      error: e
+    };
+  }
+}