@eluvio/elv-client-js 4.0.105 → 4.0.108

package/src/client/LiveStream.js

@@ -415,16 +415,23 @@ exports.StreamStatus = async function({name, stopLro=false, showParams=false}) {
 
     status.edge_write_token = edgeWriteToken;
     status.stream_id = edgeWriteToken; // By convention the stream ID is its write token
-    let edgeMeta = await this.ContentObjectMetadata({
-      libraryId: libraryId,
-      objectId: objectId,
-      writeToken: edgeWriteToken,
-      select: [
-        "live_recording"
-      ]
-    });
+    let edgeMeta;
+    try {
+      edgeMeta = await this.ContentObjectMetadata({
+        libraryId: libraryId,
+        objectId: objectId,
+        writeToken: edgeWriteToken,
+        select: [
+          "live_recording"
+        ]
+      });
+    } catch(error) {
+      console.error("Unable to read edge write token metadata. Has token been deleted?", error);
+      status.state = "inactive";
+      return status;
+    }
 
-    status.edge_meta_size = JSON.stringify(edgeMeta).length;
+    status.edge_meta_size = JSON.stringify(edgeMeta || "").length;
 
     // If a stream has never been started return state 'inactive'
     if(edgeMeta.live_recording === undefined ||
@@ -1785,26 +1792,36 @@ exports.StreamCopyToVod = async function({
  *
  * @methodGroup Live Stream
  * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
  * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
  * @param {Array<string>} types - Specify which type of watermark to remove. Possible values:
  * - "image"
  * - "text"
+ * - "forensic"
  * @param {boolean=} finalize - If enabled, target object will be finalized after removing watermark
  *
  * @return {Promise<Object>} - The finalize response
  */
 exports.StreamRemoveWatermark = async function({
+  libraryId,
   objectId,
+  writeToken,
   types,
   finalize=true
 }) {
   ValidateObject(objectId);
 
-  const libraryId = await this.ContentObjectLibraryId({objectId});
-  const {writeToken} = await this.EditContentObject({
-    objectId,
-    libraryId
-  });
+  if(!libraryId) {
+    libraryId = await this.ContentObjectLibraryId({objectId});
+  }
+
+  if(!writeToken) {
+    ({writeToken} = await this.EditContentObject({
+      objectId,
+      libraryId
+    }));
+  }
 
   this.Log(`Removing watermark types: ${types.join(", ")} ${libraryId} ${objectId}`);
 
@@ -1814,25 +1831,27 @@ exports.StreamRemoveWatermark = async function({
     metadataSubtree: "/live_recording/fabric_config/edge_write_token"
   });
 
-  const recordingParamsPath = "live_recording/recording_config/recording_params";
+  const metadataPath = "live_recording/playout_config";
 
-  const recordingMetadata = await this.ContentObjectMetadata({
+  const objectMetadata = await this.ContentObjectMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
+    metadataSubtree: metadataPath,
     resolveLinks: false
   });
 
-  if(!recordingMetadata) {
-    throw Error("Stream object must be configured");
+  if(!objectMetadata) {
+    throw Error("Stream object must be configured before removing a watermark");
   }
 
   types.forEach(type => {
     if(type === "text") {
-      delete recordingMetadata.simple_watermark;
+      delete objectMetadata.simple_watermark;
     } else if(type === "image") {
-      delete recordingMetadata.image_watermark;
+      delete objectMetadata.image_watermark;
+    } else if(type === "forensic") {
+      delete objectMetadata.forensic_watermark;
     }
   });
 
@@ -1840,8 +1859,8 @@ exports.StreamRemoveWatermark = async function({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
-    metadata: recordingMetadata
+    metadataSubtree: metadataPath,
+    metadata: objectMetadata
   });
 
   if(edgeWriteToken) {
@@ -1849,8 +1868,8 @@ exports.StreamRemoveWatermark = async function({
       libraryId,
       objectId,
       writeToken: edgeWriteToken,
-      metadataSubtree: recordingParamsPath,
-      metadata: recordingMetadata
+      metadataSubtree: metadataPath,
+      metadata: objectMetadata
     });
   }
 
@@ -1871,26 +1890,72 @@ exports.StreamRemoveWatermark = async function({
  *
  * @methodGroup Live Stream
  * @namedParams
+ * @param {string=} libraryId - Library ID of the live stream
  * @param {string} objectId - Object ID of the live stream
+ * @param {string=} writeToken - Write token of the draft
  * @param {Object} simpleWatermark - Text watermark
  * @param {Object} imageWatermark - Image watermark
+ * @param {Object} forensicWatermark - Forensic watermark
  * @param {boolean=} finalize - If enabled, target object will be finalized after adding watermark
+ * Watermark examples:
+ *
+ * Simple Watermark:
+   {
+     "font_color": "",
+     "font_relative_height": 0,
+     "shadow": false,
+     "template": "",
+     "timecode": "",
+     "timecode_rate": 0,
+     "x": "",
+     "y": ""
+   }
+ *
+ * Image watermark:
+   {
+     "image": "",
+     "align_h": "",
+     "align_v": "",
+     "target_video_height": 0,
+     "wm_enabled": false
+   }
+ *
+ * Forensic watermark:
+   {
+     "algo": 6,
+     "forensic_duration": 0,
+     "forensic_start": "",
+     "image_a": <path_to_image>,
+     "image_b": <path_to_image>,
+     "is_stub": true,
+     "payload_bit_nb": 23,
+     "wm_enabled": true
+   }
+ *
  *
  * @return {Promise<Object>} - The finalize response
  */
 exports.StreamAddWatermark = async function({
+  libraryId,
   objectId,
+  writeToken,
   simpleWatermark,
   imageWatermark,
+  forensicWatermark,
   finalize=true
 }) {
   ValidateObject(objectId);
 
-  const libraryId = await this.ContentObjectLibraryId({objectId});
-  const {writeToken} = await this.EditContentObject({
-    objectId,
-    libraryId
-  });
+  if(!libraryId) {
+    libraryId = await this.ContentObjectLibraryId({objectId});
+  }
+
+  if(!writeToken) {
+    ({writeToken} = await this.EditContentObject({
+      objectId,
+      libraryId
+    }));
+  }
 
   const edgeWriteToken = await this.ContentObjectMetadata({
     objectId,
@@ -1898,34 +1963,46 @@ exports.StreamAddWatermark = async function({
     metadataSubtree: "/live_recording/fabric_config/edge_write_token"
   });
 
-  this.Log(`Adding watermarking type: ${imageWatermark ? "image" : "text"} ${libraryId} ${objectId}`);
+  const watermarkType = imageWatermark ? "image" : forensicWatermark ? "forensic" : "text";
+  const metadataPath = "live_recording/playout_config";
 
-  const recordingParamsPath = "live_recording/recording_config/recording_params";
+  this.Log(`Adding watermarking type: ${watermarkType} ${libraryId} ${objectId}`);
 
-  const recordingMetadata = await this.ContentObjectMetadata({
+  const objectMetadata = await this.ContentObjectMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
+    metadataSubtree: metadataPath,
     resolveLinks: false
   });
 
-  if(!recordingMetadata) {
-    throw Error("Stream object must be configured");
+  if(!objectMetadata) {
+    throw Error("Stream object must be configured before adding a watermark");
+  }
+
+  const watermarkArgCount = [simpleWatermark, imageWatermark, forensicWatermark].filter(i => !!i).length;
+  console.log("watermark arg count", watermarkArgCount)
+
+  if(watermarkArgCount === 0) {
+    throw Error("No watermark was provided");
+  } else if(watermarkArgCount > 1) {
+    throw Error("Only one watermark is allowed")
   }
 
   if(simpleWatermark) {
-    recordingMetadata.simple_watermark = simpleWatermark;
+    objectMetadata.simple_watermark = simpleWatermark;
   } else if(imageWatermark) {
-    recordingMetadata.image_watermark = imageWatermark;
+    objectMetadata.image_watermark = imageWatermark;
+  } else if(forensicWatermark) {
+    objectMetadata.forensic_watermark = forensicWatermark;
   }
 
   await this.ReplaceMetadata({
     libraryId,
     objectId,
     writeToken,
-    metadataSubtree: recordingParamsPath,
-    metadata: recordingMetadata
+    metadataSubtree: metadataPath,
+    metadata: objectMetadata
   });
 
   if(edgeWriteToken) {
@@ -1933,14 +2010,15 @@ exports.StreamAddWatermark = async function({
       libraryId,
       objectId,
       writeToken: edgeWriteToken,
-      metadataSubtree: recordingParamsPath,
-      metadata: recordingMetadata
+      metadataSubtree: metadataPath,
+      metadata: objectMetadata
     });
   }
 
   const response = {
-    "imageWatermark": recordingMetadata.image_watermark,
-    "textWatermark": recordingMetadata.simple_watermark
+    "imageWatermark": objectMetadata.image_watermark,
+    "textWatermark": objectMetadata.simple_watermark,
+    "forensicWatermark": objectMetadata.forensic_watermark
   };
 
   if(finalize) {

package/testScripts/TestAddTenantContractId.js

@@ -7,15 +7,28 @@ const argv = yargs
     description: "Fabric configuration URL (e.g. https://main.net955210.contentfabric.io/config)"
   })
   .option("tenantContractId", {
-    description: "tenant Contract Id to set for the user"
+    description: "tenant Contract Id to set for the objects"
+  })
+  .option("tenantIdToBeReplaced", {
+    description: "tenant Id to be changed for the objects"
   })
   .demandOption(
-    ["configUrl", "tenantContractId"],
-    "\nUsage: PRIVATE_KEY=<private-key> node CreateUserWithTenantId --configUrl <config-url> --tenantContractId <tenant_id>\n"
+    ["configUrl", "tenantContractId", "tenantIdToBeReplaced" ],
+    "\nUsage: PRIVATE_KEY=<private-key> node TestAddTenantContractId --configUrl <config-url> --tenantContractId <tenant_contract_id> --tenantIdToBeReplaced <tenant_id>\n"
   )
   .argv;
 
-const TestAddTenantContractId = async ({configUrl, tenantContractId}) => {
+/**
+ * TestAddTenantContractId adds tenantContractId to wallet,library,group,content-type object
+ * and change tenantId to value provided.
+ *
+ * @param {string} configUrl - Config Url
+ * @param {string} tenantContractId - Id of tenantContract to be set
+ * @param {string} tenantIdToBeReplaced - Id of tenant admin group to be replaced
+ * @returns {Promise<void>}
+ * @constructor
+ */
+const TestAddTenantContractId = async ({configUrl, tenantContractId, tenantIdToBeReplaced}) => {
   try {
     if(!process.env.PRIVATE_KEY) {
       console.log("ERROR: 'PRIVATE_KEY' environment variable must be set");
@@ -79,6 +92,34 @@ const TestAddTenantContractId = async ({configUrl, tenantContractId}) => {
     //   libraryId: client.contentSpaceLibraryId,
     //   objectId: client.utils.AddressToObjectId(groupAddress)}));
 
+
+    // Change tenantID (which in turn changes tenantContractId) to user, group, library and content-type
+    await client.userProfileClient.SetTenantId({id: tenantIdToBeReplaced});
+    const newTenantId = await client.userProfileClient.TenantId();
+    if(newTenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log();
+    console.log(`tenantId for user changed to ${tenantIdToBeReplaced}`);
+
+    tenantInfo = await client.SetTenantId({objectId: libraryId, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for library changed to ${tenantIdToBeReplaced}`);
+
+    tenantInfo = await client.SetTenantId({contractAddress: contentTypeAddress, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for content-type object changed to ${tenantIdToBeReplaced}`)
+
+    tenantInfo = await client.SetTenantId({contractAddress: groupAddress, tenantId: tenantIdToBeReplaced});
+    if(tenantInfo.tenantId !== tenantIdToBeReplaced) {
+      throw Error(`tenant mismatch, actual: ${tenantInfo.tenantId}, expected: ${tenantIdToBeReplaced}`);
+    }
+    console.log(`tenantId for group-address changed to ${tenantIdToBeReplaced}`)
+
   } catch(e){
     console.error(e);
   }