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

package/src/k-provider/ott/provider-parser.ts

@@ -0,0 +1,285 @@
+import getLogger from '../../util/logger';
+import KalturaPlaybackSource from './response-types/kaltura-playback-source';
+import KalturaPlaybackContext from './response-types/kaltura-playback-context';
+import KalturaAsset from './response-types/kaltura-asset';
+import MediaEntry from '../../entities/media-entry';
+import Drm from '../../entities/drm';
+import MediaSource from '../../entities/media-source';
+import MediaSources from '../../entities/media-sources';
+import EntryList from '../../entities/entry-list';
+import Bumper from '../../entities/bumper';
+import {SupportedStreamFormat, isProgressiveSource} from '../../entities/media-format';
+import {KalturaDrmPlaybackPluginData} from '../common/response-types/kaltura-drm-playback-plugin-data';
+import KalturaRuleAction from './response-types/kaltura-rule-action';
+import {KalturaAccessControlMessage} from '../common/response-types/kaltura-access-control-message';
+import type {OTTAssetLoaderResponse} from './loaders/asset-loader';
+import KalturaBumpersPlaybackPluginData from './response-types/kaltura-bumper-playback-plugin-data';
+import {ProviderMediaInfoObject, Poster} from '../../types';
+
+const LIVE_ASST_OBJECT_TYPE: string = 'KalturaLiveAsset';
+
+const MediaTypeCombinations: {[mediaType: string]: any} = {
+  [KalturaAsset.Type.MEDIA]: {
+    [KalturaPlaybackContext.Type.TRAILER]: () => ({type: MediaEntry.Type.VOD}),
+    [KalturaPlaybackContext.Type.PLAYBACK]: mediaAssetData => {
+      if (mediaAssetData.objectType === LIVE_ASST_OBJECT_TYPE) {
+        return {type: MediaEntry.Type.LIVE, dvrStatus: mediaAssetData.enableTrickPlay ? MediaEntry.DvrStatus.ON : MediaEntry.DvrStatus.OFF};
+      } else if (parseInt(mediaAssetData.externalIds) > 0) {
+        return {type: MediaEntry.Type.LIVE, dvrStatus: MediaEntry.DvrStatus.OFF};
+      }
+      return {type: MediaEntry.Type.VOD};
+    }
+  },
+  [KalturaAsset.Type.EPG]: {
+    [KalturaPlaybackContext.Type.CATCHUP]: () => ({type: MediaEntry.Type.VOD}),
+    [KalturaPlaybackContext.Type.START_OVER]: () => ({type: MediaEntry.Type.LIVE, dvrStatus: MediaEntry.DvrStatus.ON})
+  },
+  [KalturaAsset.Type.RECORDING]: {
+    [KalturaPlaybackContext.Type.PLAYBACK]: () => ({type: MediaEntry.Type.VOD})
+  }
+};
+
+export default class OTTProviderParser {
+  private static _logger = getLogger('OTTProviderParser');
+
+  /**
+   * Returns parsed media entry by given OTT response objects.
+   * @function getMediaEntry
+   * @param {any} assetResponse - The asset response.
+   * @param {Object} requestData - The request data object.
+   * @returns {MediaEntry} - The media entry
+   * @static
+   * @public
+   */
+  public static getMediaEntry(assetResponse: any, requestData: any): MediaEntry {
+    const mediaEntry = new MediaEntry();
+    OTTProviderParser._fillBaseData(mediaEntry, assetResponse, requestData);
+    const playbackContext = assetResponse.playBackContextResult;
+    const mediaAsset = assetResponse.mediaDataResult;
+    const kalturaSources = playbackContext.sources;
+    const filteredKalturaSources = OTTProviderParser._filterSourcesByFormats(kalturaSources, requestData.formats);
+    mediaEntry.sources = OTTProviderParser._getParsedSources(filteredKalturaSources);
+    const typeData = OTTProviderParser._getMediaType(mediaAsset.data, requestData.mediaType, requestData.contextType);
+    mediaEntry.type = typeData.type;
+    mediaEntry.dvrStatus = typeData.dvrStatus;
+    // eslint-disable-next-line prefer-spread
+    mediaEntry.duration = Math.max.apply(
+      Math,
+      kalturaSources.map(source => source.duration)
+    );
+    return mediaEntry;
+  }
+
+  /**
+   * Returns parsed entry list by given OTT response objects
+   * @function getEntryList
+   * @param {any} playlistResponse - response
+   * @param {Array<ProviderMediaInfoObject>} requestEntries - entries list
+   * @returns {Playlist} - The entry list
+   * @static
+   * @public
+   */
+  public static getEntryList(playlistResponse: any, requestEntries: Array<ProviderMediaInfoObject>): EntryList {
+    const entryList = new EntryList();
+    const playlistItems = playlistResponse.playlistItems.entries;
+    playlistItems.forEach(entry => {
+      const mediaEntry = new MediaEntry();
+      const requestData = requestEntries.find(requestEntry => requestEntry.entryId === entry.mediaDataResult.id);
+      OTTProviderParser._fillBaseData(mediaEntry, entry, requestData);
+      entryList.items.push(mediaEntry);
+    });
+    return entryList;
+  }
+
+  /**
+   * Returns parsed bumper by given OTT response objects.
+   * @function getBumper
+   * @param {any} assetResponse - The asset response.
+   * @returns {?Bumper} - The bumper
+   * @static
+   * @public
+   */
+  public static getBumper(assetResponse: any): Bumper | unknown {
+    const playbackContext = assetResponse.playBackContextResult;
+    const progressiveBumper = playbackContext.plugins.find(
+      bumper => bumper.streamertype === KalturaBumpersPlaybackPluginData.StreamerType.PROGRESSIVE
+    );
+    if (progressiveBumper) {
+      return new Bumper(progressiveBumper);
+    }
+  }
+
+  private static _fillBaseData(mediaEntry: MediaEntry, assetResponse: any, requestData: any): MediaEntry {
+    const mediaAsset = assetResponse.mediaDataResult;
+    const metaData = OTTProviderParser.reconstructMetadata(mediaAsset);
+    metaData.description = mediaAsset.description;
+    metaData.name = mediaAsset.name;
+    if (mediaAsset.createDate) metaData.createdAt = mediaAsset.createDate;
+    if (mediaAsset.endDate) metaData.endDate = mediaAsset.endDate;
+    if (mediaAsset.data.entryId) metaData.entryId = mediaAsset.data.entryId;
+    if (mediaAsset.data.epgId) metaData.epgId = mediaAsset.data.epgId;
+    if (mediaAsset.data.recordingId) metaData.recordingId = mediaAsset.data.recordingId;
+    if (requestData && requestData.mediaType) metaData.mediaType = requestData.mediaType;
+    if (requestData && requestData.contextType) metaData.contextType = requestData.contextType;
+    mediaEntry.metadata = metaData;
+    mediaEntry.poster = OTTProviderParser._getPoster(mediaAsset.pictures);
+    mediaEntry.id = mediaAsset.id;
+    return mediaEntry;
+  }
+
+  /**
+   * reconstruct the metadata
+   * @param {Object} mediaAsset the mediaAsset that contains the response with the metadata.
+   * @returns {Object} reconstructed metadata object
+   */
+  public static reconstructMetadata(mediaAsset: any): any {
+    const metadata = {
+      metas: OTTProviderParser.addToMetaObject(mediaAsset.metas),
+      tags: OTTProviderParser.addToMetaObject(mediaAsset.tags)
+    };
+    return metadata;
+  }
+
+  /**
+   * transform an array of [{key: value},{key: value}...] to an object
+   * @param {Array<Object>} list a list of objects
+   * @returns {Object} an mapped object of the arrayed list.
+   */
+  public static addToMetaObject(list: Array<any>): any {
+    const categoryObj = {};
+    if (list) {
+      list.forEach(item => {
+        categoryObj[item.key] = item.value;
+      });
+    }
+    return categoryObj;
+  }
+
+  /**
+   * Gets the poster url without width and height.
+   * @param {Array<Object>} pictures - Media pictures.
+   * @returns {string | Array<Object>} - Poster base url or array of poster candidates.
+   * @private
+   */
+  public static _getPoster(pictures: Poster[]): string | Poster[] {
+    if (pictures && pictures.length > 0) {
+      const picObj = pictures[0];
+      const url = picObj.url;
+      // Search for thumbnail service
+      const regex = /.*\/thumbnail\/.*(?:width|height)\/\d+\/(?:height|width)\/\d+/;
+      if (regex.test(url)) {
+        return url;
+      }
+      return pictures.map(pic => ({url: pic.url, width: pic.width, height: pic.height}));
+    }
+    return '';
+  }
+
+  /**
+   * Gets the media type (LIVE/VOD)
+   * @param {Object} mediaAssetData - The media asset data.
+   * @param {string} mediaType - The asset media type.
+   * @param {string} contextType - The asset context type.
+   * @returns {Object} - The type data object.
+   * @private
+   */
+  public static _getMediaType(mediaAssetData: any, mediaType: string, contextType: string): any {
+    let typeData = {type: MediaEntry.Type.UNKNOWN};
+    if (MediaTypeCombinations[mediaType] && MediaTypeCombinations[mediaType][contextType]) {
+      typeData = MediaTypeCombinations[mediaType][contextType](mediaAssetData);
+    }
+    return typeData;
+  }
+
+  /**
+   * Filtered the kalturaSources array by device type.
+   * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources.
+   * @param {Array<string>} formats - Partner device formats.
+   * @returns {Array<KalturaPlaybackSource>} - Filtered kalturaSources array.
+   * @private
+   */
+  public static _filterSourcesByFormats(kalturaSources: Array<KalturaPlaybackSource>, formats: Array<string>): Array<KalturaPlaybackSource> {
+    if (formats.length > 0) {
+      kalturaSources = kalturaSources.filter(source => formats.includes(source.type));
+    }
+    return kalturaSources;
+  }
+
+  /**
+   * Returns the parsed sources
+   * @function _getParsedSources
+   * @param {Array<KalturaPlaybackSource>} kalturaSources - The kaltura sources
+   * @param {Object} playbackContext - The playback context
+   * @return {MediaSources} - A media sources
+   * @static
+   * @private
+   */
+  public static _getParsedSources(kalturaSources: Array<KalturaPlaybackSource>): MediaSources {
+    const sources = new MediaSources();
+    const addAdaptiveSource = (source: KalturaPlaybackSource): void => {
+      const parsedSource = OTTProviderParser._parseAdaptiveSource(source);
+      if (parsedSource) {
+        const sourceFormat = SupportedStreamFormat.get(source.format);
+        sources.map(parsedSource, sourceFormat);
+      }
+    };
+    const parseAdaptiveSources = (): void => {
+      kalturaSources.filter(source => !isProgressiveSource(source.format)).forEach(addAdaptiveSource);
+    };
+    const parseProgressiveSources = (): void => {
+      kalturaSources.filter(source => isProgressiveSource(source.format)).forEach(addAdaptiveSource);
+    };
+    if (kalturaSources && kalturaSources.length > 0) {
+      parseAdaptiveSources();
+      parseProgressiveSources();
+    }
+    return sources;
+  }
+
+  /**
+   * Returns a parsed adaptive source
+   * @function _parseAdaptiveSource
+   * @param {KalturaPlaybackSource} kalturaSource - A kaltura source
+   * @returns {?MediaSource} - The parsed adaptive kalturaSource
+   * @static
+   * @private
+   */
+  public static _parseAdaptiveSource(kalturaSource?: KalturaPlaybackSource): MediaSource | null {
+    const mediaSource = new MediaSource();
+    if (kalturaSource) {
+      const playUrl = kalturaSource.url;
+      const mediaFormat = SupportedStreamFormat.get(kalturaSource.format);
+      if (mediaFormat) {
+        mediaSource.mimetype = mediaFormat.mimeType;
+      }
+      if (!playUrl) {
+        OTTProviderParser._logger.error(
+          `failed to create play url from source, discarding source: (${kalturaSource.fileId}), ${kalturaSource.format}.`
+        );
+        return null;
+      }
+      mediaSource.url = playUrl;
+      mediaSource.id = kalturaSource.fileId + ',' + kalturaSource.format;
+      if (kalturaSource.hasDrmData()) {
+        const drmParams: Array<Drm> = [];
+        kalturaSource.drm.forEach(drm => {
+          drmParams.push(new Drm(drm.licenseURL, KalturaDrmPlaybackPluginData.Scheme[drm.scheme], drm.certificate));
+        });
+        mediaSource.drmData = drmParams;
+      }
+    }
+    return mediaSource;
+  }
+
+  public static hasBlockAction(response: OTTAssetLoaderResponse): boolean {
+    return response.playBackContextResult.hasBlockAction();
+  }
+
+  public static getBlockAction(response: OTTAssetLoaderResponse): KalturaRuleAction | undefined {
+    return response.playBackContextResult.getBlockAction();
+  }
+
+  public static getErrorMessages(response: OTTAssetLoaderResponse): Array<KalturaAccessControlMessage> {
+    return response.playBackContextResult.getErrorMessages();
+  }
+}

package/src/k-provider/ott/provider.ts

@@ -0,0 +1,252 @@
+import BaseProvider from '../common/base-provider';
+import getLogger from '../../util/logger';
+import OTTConfiguration from './config';
+import OTTDataLoaderManager from './loaders/data-loader-manager';
+import OTTSessionLoader from './loaders/session-loader';
+import OTTAssetLoader from './loaders/asset-loader';
+import OTTAssetListLoader from './loaders/asset-list-loader';
+import OTTProviderParser from './provider-parser';
+import KalturaAsset from './response-types/kaltura-asset';
+import KalturaPlaybackContext from './response-types/kaltura-playback-context';
+import MediaEntry from '../../entities/media-entry';
+import Error from '../../util/error/error';
+import {
+  ILoader,
+  OTTProviderMediaInfoObject,
+  ProviderEntryListObject,
+  ProviderMediaConfigObject,
+  ProviderMediaConfigSourcesObject, ProviderMediaInfoObject,
+  ProviderOptionsObject,
+  ProviderPlaybackContextOptions,
+  ProviderPlaylistObject
+} from '../../types';
+
+export default class OTTProvider extends BaseProvider<OTTProviderMediaInfoObject> {
+  /**
+   * @constructor
+   * @param {ProviderOptionsObject} options - provider options
+   * @param {string} playerVersion - player version
+   */
+  constructor(options: ProviderOptionsObject, playerVersion: string) {
+    super(options, playerVersion);
+    this._logger = getLogger('OTTProvider');
+    OTTConfiguration.set(options.env);
+    this._networkRetryConfig = Object.assign(this._networkRetryConfig, options.networkRetryParameters);
+  }
+
+  public get env(): any {
+    return OTTConfiguration.get();
+  }
+
+  /**
+   * Gets the backend media config.
+   * @param {OTTProviderMediaInfoObject} mediaInfo - ott media info
+   * @returns {Promise<ProviderMediaConfigObject>} - The provider media config
+   */
+  public getMediaConfig(mediaInfo: OTTProviderMediaInfoObject): Promise<ProviderMediaConfigObject> {
+    if (mediaInfo.ks) {
+      this.ks = mediaInfo.ks;
+      this._isAnonymous = false;
+    }
+    this._dataLoader = new OTTDataLoaderManager(this.partnerId, this.ks, this._networkRetryConfig);
+    return new Promise((resolve, reject) => {
+      const entryId = mediaInfo.entryId;
+      if (entryId) {
+        let ks: string = this.ks;
+        if (!ks) {
+          ks = '{1:result:ks}';
+          this._dataLoader.add(OTTSessionLoader, {partnerId: this.partnerId});
+        }
+        const contextType = mediaInfo.contextType || KalturaPlaybackContext.Type.PLAYBACK;
+        const mediaType = mediaInfo.mediaType || KalturaAsset.Type.MEDIA;
+        const assetReferenceType = mediaInfo.assetReferenceType || KalturaAsset.AssetReferenceType.MEDIA;
+        const playbackContext: ProviderPlaybackContextOptions = {
+          mediaProtocol: mediaInfo.protocol,
+          assetFileIds: mediaInfo.fileIds,
+          context: contextType
+        };
+        if (mediaInfo.streamerType) {
+          playbackContext.streamerType = mediaInfo.streamerType;
+        }
+        if (mediaInfo.urlType) {
+          playbackContext.urlType = mediaInfo.urlType;
+        }
+        if (mediaInfo.adapterData) {
+          playbackContext.adapterData = mediaInfo.adapterData;
+        }
+        this._dataLoader.add(OTTAssetLoader, {
+          entryId: entryId,
+          ks: ks,
+          type: mediaType,
+          playbackContext: playbackContext,
+          assetReferenceType: assetReferenceType
+        });
+        const requestData = {
+          contextType: contextType,
+          mediaType: mediaType,
+          formats: mediaInfo.formats || []
+        };
+        return this._dataLoader.fetchData().then(
+          response => {
+            try {
+              resolve(this._parseDataFromResponse(response, requestData));
+            } catch (err) {
+              reject(err);
+            }
+          },
+          err => {
+            reject(err);
+          }
+        );
+      } else {
+        reject(new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.MISSING_MANDATORY_PARAMS, {message: 'missing entry id'}));
+      }
+    });
+  }
+
+  private _parseDataFromResponse(data: Map<string, ILoader>, requestData: any): ProviderMediaConfigObject {
+    this._logger.debug('Data parsing started');
+    const mediaConfig: ProviderMediaConfigObject = {
+      session: {
+        isAnonymous: this._isAnonymous,
+        partnerId: this.partnerId
+      },
+      sources: this._getDefaultSourcesObject(),
+      plugins: {}
+    } as ProviderMediaConfigObject;
+    if (this.uiConfId) {
+      mediaConfig.session.uiConfId = this.uiConfId;
+    }
+    if (data) {
+      if (data.has(OTTSessionLoader.id)) {
+        const sessionLoader = data.get(OTTSessionLoader.id);
+        if (sessionLoader && sessionLoader.response) {
+          mediaConfig.session.ks = sessionLoader.response;
+        }
+      } else {
+        mediaConfig.session.ks = this.ks;
+      }
+      if (data.has(OTTAssetLoader.id)) {
+        const assetLoader = data.get(OTTAssetLoader.id);
+        if (assetLoader && assetLoader.response && Object.keys(assetLoader.response).length) {
+          const response = (assetLoader as unknown as OTTAssetLoader).response;
+          if (OTTProviderParser.hasBlockAction(response)) {
+            throw new Error(Error.Severity.CRITICAL, Error.Category.SERVICE, Error.Code.BLOCK_ACTION, {
+              action: OTTProviderParser.getBlockAction(response),
+              messages: OTTProviderParser.getErrorMessages(response)
+            });
+          }
+          const mediaEntry = OTTProviderParser.getMediaEntry(response, requestData);
+          Object.assign(mediaConfig.sources, this._getSourcesObject(mediaEntry));
+          this._verifyHasSources(mediaConfig.sources);
+          const bumper = OTTProviderParser.getBumper(response);
+          if (bumper) {
+            Object.assign(mediaConfig.plugins, {bumper});
+          }
+        }
+      }
+    }
+    this._logger.debug('Data parsing finished', mediaConfig);
+    return mediaConfig;
+  }
+
+  /**
+   * Gets the playlist config from entry list.
+   * @param {ProviderEntryListObject} entryListInfo - ott entry list info
+   * @returns {Promise<ProviderPlaylistObject>} - The provider playlist config
+   */
+  public getEntryListConfig(entryListInfo: ProviderEntryListObject): Promise<ProviderPlaylistObject> {
+    if (entryListInfo.ks) {
+      this.ks = entryListInfo.ks;
+      this._isAnonymous = false;
+    }
+    this._dataLoader = new OTTDataLoaderManager(this.partnerId, this.ks, this._networkRetryConfig);
+    return new Promise((resolve, reject) => {
+      const entries = entryListInfo.entries;
+      if (entries && entries.length) {
+        let ks: string = this.ks;
+        if (!ks) {
+          ks = '{1:result:ks}';
+          this._dataLoader.add(OTTSessionLoader, {partnerId: this.partnerId});
+        }
+        this._dataLoader.add(OTTAssetListLoader, {entries, ks});
+        this._dataLoader.fetchData(false).then(
+          response => {
+            resolve(this._parseEntryListDataFromResponse(response, entries));
+          },
+          err => {
+            reject(err);
+          }
+        );
+      } else {
+        reject({success: false, data: 'Missing mandatory parameter'});
+      }
+    });
+  }
+
+  private _parseEntryListDataFromResponse(data: Map<string, ILoader>, requestEntries: Array<ProviderMediaInfoObject>): ProviderPlaylistObject {
+    this._logger.debug('Data parsing started');
+    const playlistConfig: ProviderPlaylistObject = {
+      id: '',
+      metadata: {
+        name: '',
+        description: ''
+      },
+      poster: '',
+      items: [],
+      playlistLastEntryId: ''
+    };
+    if (data && data.has(OTTAssetListLoader.id)) {
+      const playlistLoader = data.get(OTTAssetListLoader.id);
+      if (playlistLoader && playlistLoader.response) {
+        const entryList = OTTProviderParser.getEntryList(playlistLoader.response, requestEntries);
+        entryList.items.forEach(i => playlistConfig.items.push({sources: this._getSourcesObject(i)}));
+      }
+    }
+    this._logger.debug('Data parsing finished', playlistConfig);
+    return playlistConfig;
+  }
+
+  private _getDefaultSourcesObject(): ProviderMediaConfigSourcesObject {
+    return {
+      hls: [],
+      dash: [],
+      progressive: [],
+      image: [],
+      id: '',
+      duration: 0,
+      type: MediaEntry.Type.UNKNOWN,
+      poster: '',
+      dvr: false,
+      vr: null,
+      metadata: {
+        name: '',
+        description: '',
+        tags: ''
+      }
+    };
+  }
+
+  private _getSourcesObject(mediaEntry: MediaEntry): ProviderMediaConfigSourcesObject {
+    const sourcesObject: ProviderMediaConfigSourcesObject = this._getDefaultSourcesObject();
+    const mediaSources = mediaEntry.sources.toJSON();
+    sourcesObject.hls = mediaSources.hls;
+    sourcesObject.dash = mediaSources.dash;
+    sourcesObject.progressive = mediaSources.progressive;
+    sourcesObject.id = mediaEntry.id;
+    sourcesObject.duration = mediaEntry.duration;
+    sourcesObject.type = mediaEntry.type;
+    sourcesObject.dvr = !!mediaEntry.dvrStatus;
+    sourcesObject.poster = mediaEntry.poster;
+    if (
+      mediaEntry.metadata &&
+      mediaEntry.metadata.metas &&
+      typeof mediaEntry.metadata.metas.tags === 'string' &&
+      mediaEntry.metadata.metas.tags.indexOf('360') > -1
+    ) {
+      sourcesObject.vr = {};
+    }
+    Object.assign(sourcesObject.metadata, mediaEntry.metadata);
+    return sourcesObject;
+  }
+}

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

@@ -0,0 +1,105 @@
+import ServiceResult from '../../common/base-service-result';
+import {Poster} from '../../../types';
+
+export default class KalturaAsset extends ServiceResult {
+  public static Type: {[type: string]: string} = {
+    MEDIA: 'media',
+    RECORDING: 'recording',
+    EPG: 'epg'
+  };
+
+  public static AssetReferenceType: {[type: string]: string} = {
+    MEDIA: 'media',
+    EPG_INTERNAL: 'epg_internal',
+    EPG_EXTERNAL: 'epg_external',
+    NPVR: 'nPVR'
+  };
+  /**
+   * @member - The asset id
+   * @type {number}
+   */
+  public id!: number;
+  /**
+   * @member - The asset createDate - Specifies when was the Asset was created. Date and time represented as epoch
+   * @type {number}
+   */
+  public createDate!: number;
+  /**
+   * @member - The asset endDate - epoch For VOD: till when the asset be available in the catalog. For EPG/Linear: program end time and date
+   * @type {number}
+   */
+  public endDate!: number;
+  /**
+   * @member - The asset name
+   * @type {string}
+   */
+  public name: string = '';
+  /**
+   * @member - The asset name description
+   * @type {string}
+   */
+  public description: string = '';
+  /**
+   * @member - The asset tags
+   * @type {Array<Object>}
+   */
+  public tags: Array<any> = [];
+  /**
+   * @member - The asset metas
+   * @type {Array<Object>}
+   */
+  public metas: Array<any> = [];
+  /**
+   * @member - The asset images
+   * @type {Array<any>}
+   */
+  public pictures: Array<Poster> = [];
+
+  /**
+   * @member - Number of plays
+   * @type {number}
+   */
+  public plays!: number;
+
+  /**
+   * @member - Number of views
+   * @type {number}
+   */
+  public views!: number;
+
+  /**
+   * @constructor
+   * @param {Object} response The response
+   */
+  constructor(response: any) {
+    super(response);
+    if (!this.hasError) {
+      this.id = response.id;
+      this.name = response.name;
+      this.description = response.description;
+      this.createDate = response.createDate;
+      this.endDate = response.endDate;
+      this.plays = response.plays;
+      this.views = response.views;
+      this.metas = this._formatTagsMetas(response.metas);
+      this.tags = this._formatTagsMetas(response.tags);
+      this.pictures = response.images;
+    }
+  }
+
+  private _formatTagsMetas(objectToParse: any): Array<any> {
+    const parsed: { key: string; value: any; }[] = [];
+    Object.keys(objectToParse).forEach((key) => {
+      if (objectToParse[key].objects) {
+        let value = '';
+        objectToParse[key].objects.forEach((object) => {
+          value += object.value + '|';
+        });
+        parsed.push({key: key, value: value});
+      } else {
+        parsed.push({key: key, value: objectToParse[key].value});
+      }
+    });
+    return parsed;
+  }
+}

package/src/k-provider/ott/response-types/kaltura-bumper-playback-plugin-data.ts

@@ -0,0 +1,27 @@
+export default class KalturaBumpersPlaybackPluginData {
+  public static StreamerType: {[type: string]: string} = {
+    HLS: 'hls',
+    DASH: 'dash',
+    PROGRESSIVE: 'progressive'
+  };
+
+  /**
+   * @member - The streamer type
+   * @type {string}
+   */
+  public streamertype: string;
+  /**
+   * @member - The url
+   * @type {string}
+   */
+  public url: string;
+
+  /**
+   * @constructor
+   * @param {Object} data - The response
+   */
+  constructor(data: any) {
+    this.streamertype = data.streamertype;
+    this.url = data.url;
+  }
+}