@playkit-js/playkit-js-providers 2.40.1-canary.0-f2a1cb3 → 2.40.2-canary.0-c7a43ae

package/src/k-provider/ovp/response-types/kaltura-flavor-asset.ts

@@ -0,0 +1,108 @@
+export class KalturaFlavorAsset {
+  public static Status: {[status: string]: number} = {
+    ERROR: -1,
+    QUEUED: 0,
+    CONVERTING: 1,
+    READY: 2,
+    DELETED: 3,
+    NOT_APPLICABLE: 4,
+    TEMP: 5,
+    WAIT_FOR_CONVERT: 6,
+    IMPORTING: 7,
+    VALIDATING: 8,
+    EXPORTING: 9
+  };
+
+  /**
+   * @member - The ID of the Flavor Asset
+   * @type {string}
+   */
+  public id: string;
+  /**
+   * @member -The Flavor Params used to create this Flavor Asset
+   * @type {string}
+   */
+  public flavorParamsId: string;
+  /**
+   * @member -The file extension
+   * @type {string}
+   */
+  public fileExt: string;
+  /**
+   * @member - The overall bitrate (in KBits) of the Flavor Asset
+   *  @type {string}
+   */
+  public bitrate: number;
+  /**
+   * @member - The width of the Flavor Asset
+   * @type {number}
+   */
+  public width: number;
+  /**
+   * @member - The height of the Flavor Asset
+   * @type {number}
+   */
+  public height: number;
+  /**
+   * @member - The frame rate (in FPS) of the Flavor Asset
+   * @type {number}
+   */
+  public frameRate: number;
+  /**
+   * @member - True if this Flavor Asset is the original source
+   * @type {number}
+   */
+  public isOriginal: boolean;
+  /**
+   * @member - True if this Flavor Asset is playable in KDP
+   * @type {boolean}
+   */
+  public isWeb: boolean;
+  /**
+   * @member - The container format
+   * @type {boolean}
+   */
+  public containerFormat: string;
+  /**
+   *@member - The video codec
+   * @type {boolean}
+   */
+  public videoCodecId: string;
+  /**
+   * @member - The status of the Flavor Asset
+   * @type {number}
+   */
+  public status: number;
+  /**
+   * @member - The language of the flavor asset
+   * @type {Status}
+   */
+  public language: string;
+  /**
+   * @member - The label of the flavor asset
+   * @type {string}
+   */
+  public label: string;
+
+  /**
+   * @constructor
+   * @param {Object} data The json response
+   */
+  constructor(data: any) {
+    this.id = data.id;
+    this.flavorParamsId = data.flavorParamsId;
+    this.fileExt = data.fileExt;
+    this.bitrate = data.bitrate;
+    this.width = data.width;
+    this.height = data.height;
+    this.id = data.id;
+    this.frameRate = data.frameRate;
+    this.isOriginal = data.isOriginal;
+    this.isWeb = data.isWeb;
+    this.containerFormat = data.containerFormat;
+    this.videoCodecId = data.videoCodecId;
+    this.status = data.status;
+    this.language = data.language;
+    this.label = data.label;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-media-entries.ts

@@ -0,0 +1,28 @@
+import ServiceResult from '../../common/base-service-result';
+import {KalturaMediaEntry} from './kaltura-media-entry';
+
+export class KalturaMediaEntries extends ServiceResult {
+  /**
+   * @member - The entries
+   * @type {Array<KalturaMediaEntry>}
+   */
+  public entries!: Array<KalturaMediaEntry>;
+
+  /**
+   * @constructor
+   * @param {Object} responseObj The json response
+   */
+  constructor(responseObj: any) {
+    super(responseObj);
+    if (!this.hasError) {
+      this.entries = [];
+      responseObj.map(entry => {
+        const kalturaMediaEntry = new KalturaMediaEntry(entry);
+        if (kalturaMediaEntry.type !== KalturaMediaEntry.EntryType.DOCUMENT.value) {
+          // filter out documents
+          this.entries.push(kalturaMediaEntry);
+        }
+      });
+    }
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-media-entry.ts

@@ -0,0 +1,189 @@
+export class KalturaMediaEntry {
+  public static EntryType: {[entryType: string]: {value: number | string}} = {
+    AUTOMATIC: {value: -1},
+    EXTERNAL_MEDIA: {value: 'externalMedia.externalMedia'},
+    MEDIA_CLIP: {value: 1},
+    MIX: {value: 2},
+    PLAYLIST: {value: 5},
+    DATA: {value: 6},
+    LIVE_STREAM: {value: 7},
+    LIVE_CHANNEL: {value: 8},
+    DOCUMENT: {value: 10}
+  };
+
+  public static MediaType: {[mediaType: string]: {value: number}} = {
+    VIDEO: {value: 1},
+    IMAGE: {value: 2},
+    AUDIO: {value: 5},
+    LIVE_STREAM_FLASH: {value: 201},
+    LIVE_STREAM_WINDOWS_MEDIA: {value: 202},
+    LIVE_STREAM_REAL_MEDIA: {value: 203},
+    LIVE_STREAM_QUICK_TIME: {value: 204}
+  };
+
+  public static EntryStatus: {[status: string]: string | number} = {
+    ERROR_IMPORTING: -2,
+    ERROR_CONVERTING: -1,
+    SCAN_FAILURE: 'virusScan.ScanFailure',
+    IMPORT: 0,
+    INFECTED: 'virusScan.Infected',
+    PRECONVERT: 1,
+    READY: 2,
+    DELETED: 3,
+    PENDING: 4,
+    MODERATE: 5,
+    BLOCKED: 6,
+    NO_CONTENT: 7
+  };
+
+  public static EntryModerationStatus: {[status: string]: number} = {
+    PENDING_MODERATION: 1,
+    APPROVED: 2,
+    REJECTED: 3,
+    FLAGGED_FOR_REVIEW: 4,
+    MODERATE: 5,
+    AUTO_APPROVED: 6
+  };
+
+  /**
+   * @member - The entry id
+   * @type {string}
+   */
+  public id: string;
+  /**
+   * @member - The entry referenceId
+   * @type {string}
+   */
+  public referenceId: string;
+  /**
+   * @member - The entry externalSourceType
+   * @type {string}
+   */
+  public externalSourceType: string;
+  /**
+   * @member - Entry name (Min 1 chars)
+   * @type {string}
+   */
+  public name: string;
+  /**
+   * @member - Entry description
+   * @type {string}
+   */
+  public description: string;
+  /**
+   * @member - The URL used for playback. This is not the download URL.
+   * @type {string}
+   */
+  public dataUrl: string;
+  /**
+   * @member - Comma separated flavor params ids that exists for this media entry
+   * @type {string}
+   */
+  public flavorParamsIds: string;
+  /**
+   * @member - The entry duration
+   * @type {number}
+   */
+  public duration: number;
+  /**
+   * @member - The type of the entry, this is auto filled by the derived entry object
+   * @type {string | number}
+   */
+  public type: string | number;
+  /**
+   * @member - The type of the entry, this is auto filled by the derived entry object (Image, Audio etc.)
+   * @type {number}
+   */
+  public entryType: number;
+  /**
+   * @member - Entry poster image
+   * @type {string}
+   */
+  public poster: string;
+  /**
+   * @member - DVR status
+   * @type {number}
+   */
+  public dvrStatus: number;
+  /**
+   * @member - Entry tags
+   * @type {string}
+   */
+  public tags: string;
+
+  /**
+   * @member - Entry status
+   * @type {number}
+   */
+  public status: number;
+
+  /**
+   * @member - Entry creation date as Unix timestamp (In seconds)
+   * @type {number}
+   */
+  public createdAt: number;
+
+  /**
+   * @member - Entry updation date as Unix timestamp (In seconds)
+   * @type {number}
+   */
+  public updatedAt: number;
+
+  /**
+   * @member - Entry end date as Unix timestamp (In seconds)
+   * @type {number}
+   */
+  public endDate: number;
+
+  /**
+   * @member - Number of plays
+   * @type {number}
+   */
+  public plays: number;
+
+  /**
+   * @member - Number of views
+   * @type {number}
+   */
+  public views: number;
+
+  /**
+   * @member - The download URL of the entry.
+   * @type {string}
+   */
+  public downloadUrl: string;
+
+  /**
+   * @member - ID of entry creator.
+   * @type {string}
+   */
+  public creatorId: string;
+
+  /**
+   * @constructor
+   * @param {Object} entry The json response
+   */
+  constructor(entry: any) {
+    this.id = entry.id;
+    this.referenceId = entry.referenceId;
+    this.externalSourceType = entry.externalSourceType;
+    this.name = entry.name;
+    this.description = entry.description;
+    this.dataUrl = entry.dataUrl;
+    this.type = entry.type;
+    this.entryType = entry.mediaType;
+    this.flavorParamsIds = entry.flavorParamsIds;
+    this.duration = entry.duration;
+    this.poster = entry.thumbnailUrl;
+    this.status = entry.status;
+    this.dvrStatus = entry.dvrStatus;
+    this.tags = entry.tags;
+    this.createdAt = entry.createdAt;
+    this.updatedAt = entry.updatedAt;
+    this.creatorId = entry.creatorId;
+    this.endDate = entry.endDate;
+    this.plays = entry.plays;
+    this.views = entry.views;
+    this.downloadUrl = entry.downloadUrl;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-metadata-list-response.ts

@@ -0,0 +1,22 @@
+import ServiceResult from '../../common/base-service-result';
+import {KalturaMetadata} from './kaltura-metadata';
+
+export class KalturaMetadataListResponse extends ServiceResult {
+  public totalCount!: number;
+  public metas!: Array<KalturaMetadata>;
+
+  /**
+   * @constructor
+   * @param {Object} responseObj The response
+   */
+  constructor(responseObj: any) {
+    super(responseObj);
+    if (!this.hasError) {
+      this.totalCount = responseObj.totalCount;
+      if (this.totalCount > 0) {
+        this.metas = [];
+        responseObj.objects.map(meta => this.metas.push(new KalturaMetadata(meta)));
+      }
+    }
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-metadata.ts

@@ -0,0 +1,50 @@
+export class KalturaMetadata {
+  public static ObjectType: {[type: string]: string | number} = {
+    AD_CUE_POINT: 'adCuePointMetadata.AdCuePoint',
+    ANNOTATION: 'annotationMetadata.Annotation',
+    CODE_CUE_POINT: 'codeCuePointMetadata.CodeCuePoint',
+    THUMB_CUE_POINT: 'thumbCuePointMetadata.thumbCuePoint',
+    ENTRY: 1,
+    CATEGORY: 2,
+    USER: 3,
+    PARTNER: 4,
+    DYNAMIC_OBJECT: 5
+  };
+
+  public static Status: {[status: string]: number} = {
+    VALID: 1,
+    INVALID: 2,
+    DELETED: 3
+  };
+
+  public id: number;
+  public metadataProfileId: number;
+  public metadataProfileVersion: number;
+  public metadataObjectType: string | number;
+  public objectId: string;
+  public version: number;
+  public created: Date;
+  public updated: Date;
+  public status: number;
+  public xml: string;
+
+  /**
+   * @constructor
+   * @param {Object} data The response
+   */
+  constructor(data: any) {
+    this.id = data.id;
+    this.metadataProfileId = data.metadataProfileId;
+    this.metadataProfileVersion = data.metadataProfileVersion;
+    this.metadataProfileId = data.metadataProfileId;
+    this.metadataObjectType = data.metadataObjectType;
+    this.objectId = data.objectId;
+    this.version = data.version;
+    this.created = new Date(0);
+    this.created.setUTCSeconds(data.createdAt);
+    this.updated = new Date(0);
+    this.updated.setUTCSeconds(data.updatedAt);
+    this.status = data.status;
+    this.xml = data.xml;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-playback-context.ts

@@ -0,0 +1,95 @@
+import ServiceResult from '../../common/base-service-result';
+import {KalturaAccessControlMessage} from '../../common/response-types/kaltura-access-control-message';
+import {KalturaPlaybackSource} from './kaltura-playback-source';
+import {KalturaAccessControlModifyRequestHostRegexAction} from './kaltura-access-control-modify-request-host-regex-action';
+import {KalturaRuleAction} from './kaltura-rule-action';
+import {KalturaFlavorAsset} from './kaltura-flavor-asset';
+import {KalturaBumper} from './kaltura-bumper';
+
+export class KalturaPlaybackContext extends ServiceResult {
+  /**
+   * @member - The playback sources
+   * @type {Array<KalturaPlaybackSource>}
+   */
+  public sources: Array<KalturaPlaybackSource> = [];
+  /**
+   * @member - Array of actions as received from the rules that invalidated
+   * @type {Array<KalturaRuleAction>}
+   */
+  public actions: Array<KalturaRuleAction> = [];
+  /**
+   * @member - Array of actions as received from the rules that invalidated
+   * @type {Array<KalturaAccessControlMessage>}
+   */
+  public messages: Array<KalturaAccessControlMessage> = [];
+  /**
+   * @member - The flavor assets
+   * @type {Array<KalturaFlavorAsset>}
+   */
+  public flavorAssets: Array<KalturaFlavorAsset> = [];
+  /**
+   * @member - The bumper data
+   * @type {Array<KalturaBumper>}
+   */
+  public bumperData: Array<KalturaBumper> = [];
+
+  /**
+   * @constructor
+   * @param {Object} response The response
+   */
+  constructor(response: any) {
+    super(response);
+    if (!this.hasError) {
+      const messages = response.messages;
+      if (messages) {
+        messages.map(message => this.messages.push(new KalturaAccessControlMessage(message)));
+      }
+      const actions = response.actions;
+      if (actions) {
+        actions.map(action => {
+          if (action.type === KalturaRuleAction.Type.REQUEST_HOST_REGEX) {
+            this.actions.push(new KalturaAccessControlModifyRequestHostRegexAction(action));
+          } else {
+            this.actions.push(new KalturaRuleAction(action));
+          }
+        });
+      }
+      const sources = response.sources;
+      if (sources) {
+        sources.map(source => this.sources.push(new KalturaPlaybackSource(source)));
+      }
+      const flavorAssets = response.flavorAssets;
+      if (flavorAssets) {
+        flavorAssets.map(flavor => this.flavorAssets.push(new KalturaFlavorAsset(flavor)));
+      }
+      const bumperData = response.bumperData;
+      if (bumperData) {
+        bumperData.map(bumper => this.bumperData.push(new KalturaBumper(bumper)));
+      }
+    }
+  }
+
+  public hasBlockAction(): boolean {
+    return this.getBlockAction() !== undefined;
+  }
+
+  public getBlockAction(): KalturaRuleAction | undefined {
+    return this.actions.find(action => action.type === KalturaRuleAction.Type.BLOCK);
+  }
+
+  public getErrorMessages(): Array<KalturaAccessControlMessage> {
+    return this.messages;
+  }
+
+  /**
+   * Get the KalturaAccessControlModifyRequestHostRegexAction action
+   * @function getRequestHostRegexAction
+   * @returns {?KalturaAccessControlModifyRequestHostRegexAction} The action
+   * */
+  public getRequestHostRegexAction(): KalturaAccessControlModifyRequestHostRegexAction | undefined {
+    const action = this.actions.find(action => action.type === KalturaRuleAction.Type.REQUEST_HOST_REGEX);
+    if (action instanceof KalturaAccessControlModifyRequestHostRegexAction) {
+      return action;
+    }
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-playback-source.ts

@@ -0,0 +1,89 @@
+import {KalturaDrmPlaybackPluginData} from '../../common/response-types/kaltura-drm-playback-plugin-data';
+
+export type OVPKalturaPlaybackSource = KalturaPlaybackSource;
+
+export class KalturaPlaybackSource {
+  /**
+   * @member - source format according to delivery profile streamer type (applehttp, mpegdash etc.)
+   * @type {string}
+   */
+  public format: string;
+  /**
+   * @member - delivery profile Id
+   * @type {string}
+   */
+  public deliveryProfileId: string;
+  /**
+   * @member - The source URL
+   * @type {string}
+   */
+  public url: string;
+  /**
+   * @member - comma separated string according to deliveryProfile media protocols ('http,https' etc.)
+   * @type {string}
+   */
+  public protocols: string;
+  /**
+   * @member - comma separated string of flavor ids
+   * @type {string}
+   */
+  public flavorIds: string;
+  /**
+   * @member - drm data object containing relevant license url ,scheme name and certificate
+   * @type {Array<KalturaDrmPlaybackPluginData>}
+   */
+  public drm: Array<KalturaDrmPlaybackPluginData> = [];
+
+  /**
+   * @constructor
+   * @param {Object} source The response
+   */
+  constructor(source: any) {
+    this.format = source.format;
+    this.deliveryProfileId = source.deliveryProfileId;
+    this.url = source.url;
+    this.protocols = source.protocols;
+    this.flavorIds = source.flavorIds;
+    if (source.drm) {
+      source.drm.map(drm => this.drm.push(new KalturaDrmPlaybackPluginData(drm)));
+    }
+  }
+
+  /**
+   * Checks if source has DRM data
+   * @function hasDrmData
+   * @returns {boolean} Is source has DRM
+   */
+  public hasDrmData(): boolean {
+    return this.drm && this.drm.length > 0;
+  }
+
+  /**
+   * Checks if source has flavor IDs
+   * @function hasFlavorIds
+   * @returns {boolean} Is source ha flavor IDs
+   */
+  public hasFlavorIds(): boolean {
+    return !!this.flavorIds && this.flavorIds.length > 0;
+  }
+
+  /**
+   * Returns source desired protocol if supported
+   * @param {string} protocol - the desired protocol for the source (base play url protocol)
+   * @returns {string} - protocol if protocol is in the protocols list - if not empty string returned
+   */
+  public getProtocol(protocol: string): string {
+    let returnValue: string = '';
+    if (this.protocols && this.protocols.length > 0) {
+      const protocolsArr: Array<string> = this.protocols.split(',');
+      protocolsArr.forEach(p => {
+        if (p === protocol) {
+          returnValue = p;
+        }
+      });
+    } else if (protocol === 'http') {
+      return protocol;
+    }
+    return returnValue;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-playlist.ts

@@ -0,0 +1,33 @@
+export class KalturaPlaylist {
+  /**
+   * @member - playlist id
+   * @type {string}
+   */
+  public id: string;
+  /**
+   * @member - playlist name
+   * @type {string}
+   */
+  public name: string;
+  /**
+   * @member - playlist description
+   * @type {string}
+   */
+  public description: string;
+  /**
+   * @member - playlist poster image
+   * @type {string}
+   */
+  public poster: string;
+
+  /**
+   * @constructor
+   * @param {Object} playlist - The json response
+   */
+  constructor(playlist: any) {
+    this.id = playlist.id;
+    this.name = playlist.name;
+    this.description = playlist.description;
+    this.poster = playlist.thumbnailUrl;
+  }
+}

package/src/k-provider/ovp/response-types/kaltura-rule-action.ts

@@ -0,0 +1,27 @@
+export class KalturaRuleAction {
+  public static Type: {[type: string]: string | number} = {
+    DRM_POLICY: 'drm.DRM_POLICY',
+    BLOCK: 1,
+    PREVIEW: 2,
+    LIMIT_FLAVORS: 3,
+    ADD_TO_STORAGE: 4,
+    LIMIT_DELIVERY_PROFILES: 5,
+    SERVE_FROM_REMOTE_SERVER: 6,
+    REQUEST_HOST_REGEX: 7,
+    LIMIT_THUMBNAIL_CAPTURE: 8
+  };
+
+  /**
+   * @member - The type of the action
+   * @type {string|number}
+   */
+  public type: string | number;
+
+  /**
+   * @constructor
+   * @param {Object} data - The response
+   */
+  constructor(data: any) {
+    this.type = data.type;
+  }
+}