@signiant/media-shuttle-sdk-base
Version:
The base parent sdk behind other media shuttle sdks (e.g. media-shuttle-sdk)
185 lines (184 loc) • 8.92 kB
JavaScript
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var _a, _b, _c;
/* eslint-disable import/first */
import { supportedEncryptionModes } from './constants';
import { TransferEventType, TransferProtocol, TransferState, } from '../../external';
import { AppTransferEventType, AppTransferProtocol } from '../enums';
import AppTransferEventStatus from '../enums/AppTransferEventStatus';
import { LogManager } from '../system';
import appErrorCodeMapper from './appErrorCodeMapper';
// eslint-disable-next-line @typescript-eslint/no-var-requires
var forge = require('node-forge');
forge.options.usePureJavaScript = true;
export var generateEncryptionInfo = function () {
var encryptionMode = supportedEncryptionModes;
var symmetricKey = forge.util.encode64(forge.random.getBytesSync(32));
return {
encryptionMode: encryptionMode,
symmetricKey: symmetricKey,
};
};
/**
* Parses the input value into a Number (integer or float value)
* @param input
*/
var safeParseNumber = function (input) {
var number = Number(input);
if (Number.isNaN(number)) {
return null;
}
return number;
};
var AppProtocolTransferProtocolMap = (_a = {},
_a[AppTransferProtocol.UDP] = TransferProtocol.UDP,
_a[AppTransferProtocol.TCP] = TransferProtocol.TCP,
_a[AppTransferProtocol.HTTP] = TransferProtocol.HTTP,
_a);
var externalToAppEventTypeMap = (_b = {},
_b[TransferEventType.TRANSFER_STARTED] = AppTransferEventType.TRANSFER_STARTING,
_b[TransferEventType.TRANSFER_PROGRESS] = AppTransferEventType.TRANSFER_PROGRESS,
_b[TransferEventType.TRANSFER_COMPLETED] = AppTransferEventType.TRANSFER_COMPLETED,
_b[TransferEventType.TRANSFER_CANCELED] = AppTransferEventType.TRANSFER_CANCELLED,
_b[TransferEventType.TRANSFER_ERROR] = AppTransferEventType.TRANSFER_WARN,
_b[TransferEventType.TRANSFER_RETRY] = AppTransferEventType.TRANSFER_RETRY,
_b[TransferEventType.TRANSFER_FILE] = AppTransferEventType.TRANSFER_BEGIN_FILE,
_b);
var appToExternalEventStatusTypeMap = (_c = {},
_c[AppTransferEventStatus.CONNECTING] = TransferEventType.TRANSFER_CONNECTING,
_c[AppTransferEventStatus.CONNECTED] = TransferEventType.TRANSFER_CONNECTED,
_c[AppTransferEventStatus.DISCONNECTING] = TransferEventType.TRANSFER_DISCONNECTING,
_c[AppTransferEventStatus.DISCONNECTED] = TransferEventType.TRANSFER_DISCONNECTED,
_c[AppTransferEventStatus.FAILURE] = TransferEventType.TRANSFER_COMPLETED,
_c[AppTransferEventStatus.CANCELLED] = TransferEventType.TRANSFER_CANCELED,
_c[AppTransferEventStatus.PAUSED] = TransferEventType.TRANSFER_PAUSED,
_c[AppTransferEventStatus.RESUMED] = TransferEventType.TRANSFER_RESUMED,
_c);
export var mapToAppEventType = function (eventType) {
return externalToAppEventTypeMap[eventType];
};
var mapTransferCompletedEvent = function (eventData, appEventData, transferId) {
var state, mappedEventType;
eventData = {
destination: appEventData.destination,
bytesTransferred: safeParseNumber(appEventData.transferSize),
transferId: transferId,
};
if (appEventData.status === AppTransferEventStatus.SUCCESS) {
state = TransferState.SUCCESSFUL;
mappedEventType = TransferEventType.TRANSFER_COMPLETED;
}
else if (appEventData.status === AppTransferEventStatus.CANCELLED) {
state = TransferState.CANCELED;
mappedEventType = TransferEventType.TRANSFER_CANCELED;
}
else if (appEventData.status === AppTransferEventStatus.FAILURE) {
state = TransferState.FAILURE;
mappedEventType = TransferEventType.TRANSFER_ERROR;
}
return { eventData: eventData, state: state, mappedEventType: mappedEventType };
};
var mapConnectionStatusChangeEvent = function (appEventData) {
var state;
var mappedEventType = appToExternalEventStatusTypeMap[appEventData.status];
if ([AppTransferEventStatus.CONNECTED, AppTransferEventStatus.CONNECTING].includes(appEventData.status)) {
state = TransferState.STARTING;
}
if ([
AppTransferEventStatus.DISCONNECTED,
AppTransferEventStatus.DISCONNECTING,
AppTransferEventStatus.RESUMED,
AppTransferEventStatus.PAUSED,
].includes(appEventData.status)) {
state = TransferState.IN_PROGRESS;
}
return { mappedEventType: mappedEventType, state: state };
};
var mapTransferProgressEvent = function (appEventData, eventData, transferId) {
var bytesSent = appEventData.bytesSent, eta = appEventData.eta, rawRate = appEventData.rawRate, totalBytes = appEventData.totalBytes;
eventData = {
etaSeconds: safeParseNumber(eta),
totalBytes: safeParseNumber(totalBytes),
transferRateInBitsPerSec: safeParseNumber(rawRate),
bytesTransferred: safeParseNumber(bytesSent),
transferId: transferId,
};
var state = TransferState.IN_PROGRESS;
var mappedEventType = TransferEventType.TRANSFER_PROGRESS;
return { eventData: eventData, state: state, mappedEventType: mappedEventType };
};
var mapTransferConnectedEvent = function (appEventData, eventData, transferId) {
var connectedServer = appEventData.connectedServer, protocol = appEventData.protocol, usedRelay = appEventData.usedRelay;
eventData = {
protocol: AppProtocolTransferProtocolMap[protocol],
server: connectedServer,
relayServer: usedRelay,
transferId: transferId,
};
var state = TransferState.STARTING;
var mappedEventType = TransferEventType.TRANSFER_STARTED;
return { eventData: eventData, state: state, mappedEventType: mappedEventType };
};
var mapTransferWarnEvent = function (appEventData, eventData, transferId) {
var mappedEventType = TransferEventType.TRANSFER_WARN;
var resolvedCodeMessage = appErrorCodeMapper.getMessageForTransport(appEventData.errorCode);
var state = appEventData.status === AppTransferEventStatus.FAILURE ? TransferState.FAILURE : null;
if (resolvedCodeMessage !== null) {
var description = appEventData.shortMessage;
var code = resolvedCodeMessage.code, message = resolvedCodeMessage.message;
eventData = __assign({ transferId: transferId, code: code, message: message }, (description && { description: description }));
}
return { mappedEventType: mappedEventType, eventData: eventData, state: state };
};
export var mapFromAppTransferEvent = function (_a) {
var _b, _c, _d, _e, _f;
var transferId = _a.transferId, appEventType = _a.eventType, appEventData = _a.eventData;
var eventData = { transferId: transferId };
var mappedEventType;
var state;
switch (appEventType) {
case AppTransferEventType.TRANSFER_COMPLETED:
(_b = mapTransferCompletedEvent(eventData, appEventData, transferId), eventData = _b.eventData, state = _b.state, mappedEventType = _b.mappedEventType);
break;
case AppTransferEventType.TRANSFER_CONNECTION_STATUS_CHANGE:
(_c = mapConnectionStatusChangeEvent(appEventData), state = _c.state, mappedEventType = _c.mappedEventType);
break;
case AppTransferEventType.TRANSFER_STARTING:
mappedEventType = TransferEventType.TRANSFER_STARTING;
state = TransferState.STARTING;
break;
case AppTransferEventType.TRANSFER_WARN: {
(_d = mapTransferWarnEvent(appEventData, eventData, transferId), eventData = _d.eventData, mappedEventType = _d.mappedEventType, state = _d.state);
break;
}
case AppTransferEventType.TRANSFER_BEGIN_FILE:
eventData = {
transferId: transferId,
localFilePath: appEventData.fileName,
};
mappedEventType = TransferEventType.TRANSFER_FILE_STARTING;
state = TransferState.IN_PROGRESS;
break;
case AppTransferEventType.TRANSFER_PROGRESS:
(_e = mapTransferProgressEvent(appEventData, eventData, transferId), eventData = _e.eventData, state = _e.state, mappedEventType = _e.mappedEventType);
break;
case AppTransferEventType.TRANSFER_CONNECTED_SERVER:
(_f = mapTransferConnectedEvent(appEventData, eventData, transferId), eventData = _f.eventData, state = _f.state, mappedEventType = _f.mappedEventType);
break;
default:
LogManager.logger.warn("Unexpected event type received from the App [".concat(appEventType, "]"));
}
return {
state: state,
transferEvent: { type: mappedEventType, eventData: eventData },
};
};