@playkit-js/playkit-js-providers 2.40.1 → 2.40.2-canary.0-45b4098

package/src/k-provider/common/multi-request-builder.ts

@@ -0,0 +1,111 @@
+import RequestBuilder from '../../util/request-builder';
+import getLogger from '../../util/logger';
+import ServiceResult from './base-service-result';
+import Error from '../../util/error/error';
+
+export default class MultiRequestBuilder extends RequestBuilder {
+  private static _logger = getLogger('MultiRequestBuilder');
+  /**
+   * @memberof - MultiRequestBuilder
+   * @type {Array<RequestBuilder>}
+   */
+  public requests: Array<RequestBuilder> = [];
+  /**
+   * Adds request to requests array
+   * @function add
+   * @param {RequestBuilder} request The request
+   * @returns {MultiRequestBuilder} The multiRequest
+   */
+  public add(request: RequestBuilder): MultiRequestBuilder {
+    this.requests.push(request);
+    const requestParams = {};
+    const serviceDef: any = {service: request.service, action: request.action};
+    Object.assign(requestParams, {[this.requests.length]: Object.assign(serviceDef, request.params)});
+    Object.assign(requestParams, this.params);
+    this.params = requestParams;
+    return this;
+  }
+
+  /**
+   * Executes a multi request
+   * @function execute
+   * @param {boolean} requestsMustSucceed whether all of the requests must succeed or not
+   * @returns {Promise} The multirequest execution promise
+   */
+  public execute(requestsMustSucceed?: boolean): Promise<any> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.params = JSON.stringify(this.params);
+      } catch (err) {
+        MultiRequestBuilder._logger.error(`${err.message}`);
+        reject(
+          new Error(Error.Severity.CRITICAL, Error.Category.PROVIDER, Error.Code.FAILED_PARSING_REQUEST, {
+            error: err,
+            params: this.params
+          })
+        );
+      }
+      this.doHttpRequest().then(
+        data => {
+          const multiRequestResult = new MultiRequestResult(data, requestsMustSucceed);
+          if (multiRequestResult.success) {
+            resolve({
+              headers: this.responseHeaders,
+              response: multiRequestResult
+            });
+          } else {
+            reject(
+              new Error(Error.Severity.CRITICAL, Error.Category.NETWORK, Error.Code.MULTIREQUEST_API_ERROR, {
+                url: this.url,
+                headers: this.responseHeaders,
+                results: multiRequestResult.results
+              })
+            );
+          }
+        },
+        err => {
+          reject(err);
+        }
+      );
+    });
+  }
+}
+
+export class MultiRequestResult {
+  private static _logger = getLogger('MultiRequestResult');
+  /**
+   * @memberof MultiRequestResult
+   * @type {boolean}
+   */
+  public success: boolean;
+  /**
+   * @memberof MultiRequestResult
+   * @type {Object}
+   */
+  public results: Array<ServiceResult> = [];
+  /**
+   * @constructor
+   * @param {Object} response data
+   * @param {boolean} requestsMustSucceed whether all of the requests must succeed
+   */
+  constructor(response: any, requestsMustSucceed: boolean = true) {
+    const result = response.result ? response.result : response;
+    const responseArr = Array.isArray(result) ? result : [result];
+    const results = responseArr.map(result => new ServiceResult(result));
+    const errorResults = results.filter(serviceResult => serviceResult.hasError);
+
+    errorResults.forEach(serviceResult => {
+      MultiRequestResult._logger.error(
+        `Service returned an error with error code: ${serviceResult.error.code} and message: ${serviceResult.error.message}.`
+      );
+    });
+
+    this.results = results;
+    if ((requestsMustSucceed && errorResults.length) || errorResults.length === this.results.length) {
+      this.success = false;
+    } else {
+      this.results = this.results.filter(serviceResult => !serviceResult.hasError);
+      this.success = true;
+    }
+  }
+}

package/src/k-provider/common/response-types/kaltura-access-control-message.ts

@@ -0,0 +1,21 @@
+export class KalturaAccessControlMessage {
+  /**
+   * @member - The access control message
+   * @type {string}
+   */
+  public message: string;
+  /**
+   *  @member - The access control message code
+   * @@type {string}
+   */
+  public code: string;
+
+  /**
+   * @constructor
+   * @param {Object} data The json response
+   */
+  constructor(data: any) {
+    this.message = data.message;
+    this.code = data.code;
+  }
+}

package/src/k-provider/common/response-types/kaltura-drm-playback-plugin-data.ts

@@ -0,0 +1,38 @@
+export class KalturaDrmPlaybackPluginData {
+  public static Scheme: {[scheme: string]: string} = {
+    'drm.PLAYREADY_CENC': 'com.microsoft.playready',
+    'drm.WIDEVINE_CENC': 'com.widevine.alpha',
+    'fairplay.FAIRPLAY': 'com.apple.fairplay',
+    WIDEVINE_CENC: 'com.widevine.alpha',
+    PLAYREADY_CENC: 'com.microsoft.playready',
+    FAIRPLAY: 'com.apple.fairplay'
+  };
+
+  /**
+   * @member - The drm scheme
+   * @type {string}
+   */
+  public scheme: string;
+
+  /**
+   * @member - The license URL
+   * @type {string}
+   */
+  public licenseURL: string;
+
+  /**
+   * @member - The drm certificate
+   * @type {?string}
+   */
+  public certificate?: string;
+
+  /**
+   * @constructor
+   * @param {Object} drm The json response
+   */
+  constructor(drm: any) {
+    this.scheme = drm.scheme;
+    this.licenseURL = drm.licenseURL;
+    this.certificate = drm.certificate;
+  }
+}

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

@@ -0,0 +1,22 @@
+import {clone} from '../../util/clone';
+import {ProviderEnvConfigObject} from '../../types';
+
+const defaultConfig: any = {
+  serviceParams: {
+    apiVersion: '7.8.1'
+  }
+};
+
+export default class OTTConfiguration {
+  public static set(clientConfig?: ProviderEnvConfigObject): void {
+    if (clientConfig) {
+      Object.assign(defaultConfig, clientConfig);
+    }
+  }
+
+  public static get(): any {
+    return clone(defaultConfig);
+  }
+}
+
+export {OTTConfiguration};

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

@@ -0,0 +1,14 @@
+import OTTProvider from './provider';
+import KalturaPlaybackContext from './response-types/kaltura-playback-context';
+import KalturaAsset from './response-types/kaltura-asset';
+
+declare let __VERSION__: string;
+declare let __NAME__: string;
+
+const NAME = __NAME__ + '-ott';
+const VERSION = __VERSION__;
+
+const ContextType = KalturaPlaybackContext.Type;
+const MediaType = KalturaAsset.Type;
+
+export {OTTProvider as Provider, ContextType, MediaType, NAME, VERSION};

package/src/k-provider/ott/loaders/asset-list-loader.ts

@@ -0,0 +1,68 @@
+import RequestBuilder from '../../../util/request-builder';
+import OTTConfiguration from '../config';
+import OTTAssetService from '../services/asset-service';
+import KalturaAsset from '../response-types/kaltura-asset';
+import {ILoader} from '../../../types';
+
+export default class OTTAssetListLoader implements ILoader {
+  private _entries: Array<string>;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {playlistItems: {entries: []}};
+
+  public static get id(): string {
+    return 'asset_list';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._entries = params.entries;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    response.forEach(item => {
+      this._response.playlistItems.entries.push({mediaDataResult: new KalturaAsset(item.data)});
+    });
+  }
+
+  public get response(): any {
+    return this._response;
+  }
+
+  /**
+   * Builds loader requests
+   * @function
+   * @param {Object} params Requests parameters
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public buildRequests(params: any): Array<RequestBuilder> {
+    const config = OTTConfiguration.get();
+    const requests: Array<RequestBuilder> = [];
+    params.entries.forEach(entry => {
+      const assetReferenceType = entry.assetReferenceType || KalturaAsset.AssetReferenceType.MEDIA;
+      requests.push(OTTAssetService.get(config.serviceUrl, params.ks, entry.entryId || entry, assetReferenceType));
+    });
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!(this._entries && this._entries.length);
+  }
+}

package/src/k-provider/ott/loaders/asset-loader.ts

@@ -0,0 +1,69 @@
+import OTTAssetService from '../services/asset-service';
+import OTTConfiguration from '../config';
+import RequestBuilder from '../../../util/request-builder';
+import KalturaPlaybackContext from '../response-types/kaltura-playback-context';
+import KalturaAsset from '../response-types/kaltura-asset';
+import {ILoader} from '../../../types';
+
+type OTTAssetLoaderResponse = {mediaDataResult: KalturaAsset, playBackContextResult: KalturaPlaybackContext};
+export type {OTTAssetLoaderResponse};
+
+export default class OTTAssetLoader implements ILoader {
+  private _entryId: string;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'asset';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._entryId = params.entryId;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    this._response.mediaDataResult = new KalturaAsset(response[0].data);
+    this._response.playBackContextResult = new KalturaPlaybackContext(response[1].data);
+  }
+
+  public get response(): OTTAssetLoaderResponse {
+    return this._response;
+  }
+
+  /**
+   * Builds loader requests
+   * @function
+   * @param {Object} params Requests parameters
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public buildRequests(params: any): Array<RequestBuilder> {
+    const config = OTTConfiguration.get();
+    const requests: Array<RequestBuilder> = [];
+    requests.push(OTTAssetService.get(config.serviceUrl, params.ks, params.entryId, params.assetReferenceType));
+    requests.push(OTTAssetService.getPlaybackContext(config.serviceUrl, params.ks, params.entryId, params.type, params.playbackContext));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!this._entryId;
+  }
+}

package/src/k-provider/ott/loaders/data-loader-manager.ts

@@ -0,0 +1,15 @@
+import DataLoaderManager from '../../common/data-loader-manager';
+import OTTService from '../services/ott-service';
+import {ProviderNetworkRetryParameters} from '../../../types';
+/**
+ * OTTDataLoaderManager is a class that handles the OTT data loading
+ * @param {string} partnerId - partner id
+ * @param {string} ks - ks
+ * @param {ProviderNetworkRetryParameters} [networkRetryConfig] - network retry configuration
+ */
+export default class OTTDataLoaderManager extends DataLoaderManager {
+  constructor(partnerId: number, ks: string = '', networkRetryConfig: ProviderNetworkRetryParameters) {
+    super(networkRetryConfig);
+    this._multiRequest = OTTService.getMultiRequest(ks, partnerId);
+  }
+}

package/src/k-provider/ott/loaders/session-loader.ts

@@ -0,0 +1,62 @@
+import UserService from '../services/user-service';
+import OTTConfiguration from '../config';
+import RequestBuilder from '../../../util/request-builder';
+import {ILoader} from '../../../types';
+
+export default class OTTSessionLoader implements ILoader {
+  private _partnerId: number;
+  private _requests!: Array<RequestBuilder>;
+  private _response: any = {};
+
+  public static get id(): string {
+    return 'session';
+  }
+
+  /**
+   * @constructor
+   * @param {Object} params loader params
+   */
+  constructor(params: any) {
+    this.requests = this.buildRequests(params);
+    this._partnerId = params.partnerId;
+  }
+
+  public set requests(requests: Array<RequestBuilder>) {
+    this._requests = requests;
+  }
+
+  public get requests(): Array<RequestBuilder> {
+    return this._requests;
+  }
+
+  public set response(response: any) {
+    this._response.ks = response[0].data.ks;
+  }
+
+  public get response(): any {
+    return this._response.ks;
+  }
+
+  /**
+   * Builds loader requests
+   * @function
+   * @param {Object} params Requests parameters
+   * @returns {RequestBuilder} The request builder
+   * @static
+   */
+  public buildRequests(params: any): Array<RequestBuilder> {
+    const config = OTTConfiguration.get();
+    const requests: Array<RequestBuilder> = [];
+    requests.push(UserService.anonymousLogin(config.serviceUrl, params.partnerId, params.udid));
+    return requests;
+  }
+
+  /**
+   * Loader validation function
+   * @function
+   * @returns {boolean} Is valid
+   */
+  public isValid(): boolean {
+    return !!this._partnerId;
+  }
+}