mirror of
https://github.com/n8n-io/n8n.git
synced 2024-09-20 23:07:32 -07:00
2b74b6238e
* 🔥 Deprecate numberStepSize * 🔥 Deprecate color in non-FA nodes * ⚡ Minor node name fixes * 📦 Update package-lock.json * ⏪ Restore Merge node color * 👕 Fix lint
546 lines
14 KiB
TypeScript
546 lines
14 KiB
TypeScript
import {
|
|
IExecuteFunctions,
|
|
} from 'n8n-core';
|
|
|
|
import {
|
|
IDataObject,
|
|
INodeExecutionData,
|
|
INodeType,
|
|
INodeTypeDescription,
|
|
} from 'n8n-workflow';
|
|
|
|
import {
|
|
awsApiRequestREST,
|
|
awsApiRequestRESTAllItems,
|
|
} from './GenericFunctions';
|
|
|
|
export class AwsTranscribe implements INodeType {
|
|
description: INodeTypeDescription = {
|
|
displayName: 'AWS Transcribe',
|
|
name: 'awsTranscribe',
|
|
icon: 'file:transcribe.svg',
|
|
group: ['output'],
|
|
version: 1,
|
|
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
|
|
description: 'Sends data to AWS Transcribe',
|
|
defaults: {
|
|
name: 'AWS Transcribe',
|
|
},
|
|
inputs: ['main'],
|
|
outputs: ['main'],
|
|
credentials: [
|
|
{
|
|
name: 'aws',
|
|
required: true,
|
|
},
|
|
],
|
|
properties: [
|
|
{
|
|
displayName: 'Resource',
|
|
name: 'resource',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'Transcription Job',
|
|
value: 'transcriptionJob',
|
|
},
|
|
],
|
|
default: 'transcriptionJob',
|
|
description: 'Resource to operate on.',
|
|
},
|
|
{
|
|
displayName: 'Operation',
|
|
name: 'operation',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'Create',
|
|
value: 'create',
|
|
description: 'Create a transcription job',
|
|
},
|
|
{
|
|
name: 'Delete',
|
|
value: 'delete',
|
|
description: 'Delete a transcription job',
|
|
},
|
|
{
|
|
name: 'Get',
|
|
value: 'get',
|
|
description: 'Get a transcription job',
|
|
},
|
|
{
|
|
name: 'Get All',
|
|
value: 'getAll',
|
|
description: 'Get all transcription jobs',
|
|
},
|
|
],
|
|
default: 'create',
|
|
description: 'Operation to perform.',
|
|
},
|
|
{
|
|
displayName: 'Job Name',
|
|
name: 'transcriptionJobName',
|
|
type: 'string',
|
|
default: '',
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'create',
|
|
'get',
|
|
'delete',
|
|
],
|
|
},
|
|
},
|
|
description: 'The name of the job.',
|
|
},
|
|
{
|
|
displayName: 'Media File URI',
|
|
name: 'mediaFileUri',
|
|
type: 'string',
|
|
default: '',
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'create',
|
|
],
|
|
},
|
|
},
|
|
description: 'The S3 object location of the input media file. ',
|
|
},
|
|
{
|
|
displayName: 'Detect Language',
|
|
name: 'detectLanguage',
|
|
type: 'boolean',
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'create',
|
|
],
|
|
},
|
|
},
|
|
default: false,
|
|
description: 'Set this field to true to enable automatic language identification.',
|
|
},
|
|
{
|
|
displayName: 'Language',
|
|
name: 'languageCode',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'American English',
|
|
value: 'en-US',
|
|
},
|
|
{
|
|
name: 'British English',
|
|
value: 'en-GB',
|
|
},
|
|
{
|
|
name: 'Irish English',
|
|
value: 'en-IE',
|
|
},
|
|
{
|
|
name: 'Indian English',
|
|
value: 'en-IN',
|
|
},
|
|
{
|
|
name: 'Spanish',
|
|
value: 'es-ES',
|
|
},
|
|
{
|
|
name: 'German',
|
|
value: 'de-DE',
|
|
},
|
|
{
|
|
name: 'Russian',
|
|
value: 'ru-RU',
|
|
},
|
|
],
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'create',
|
|
],
|
|
detectLanguage: [
|
|
false,
|
|
],
|
|
},
|
|
},
|
|
default: 'en-US',
|
|
description: 'Language used in the input media file.',
|
|
},
|
|
// ----------------------------------
|
|
// Transcription Job Settings
|
|
// ----------------------------------
|
|
{
|
|
displayName: 'Options',
|
|
name: 'options',
|
|
type: 'collection',
|
|
placeholder: 'Add Option',
|
|
displayOptions: {
|
|
show: {
|
|
operation: [
|
|
'create',
|
|
],
|
|
},
|
|
},
|
|
default: {},
|
|
options: [
|
|
{
|
|
displayName: 'Channel Identification',
|
|
name: 'channelIdentification',
|
|
type: 'boolean',
|
|
default: false,
|
|
description: `Instructs Amazon Transcribe to process each audiochannel separately and then merge the transcription output of each channel into a single transcription. You can't set both Max Speaker Labels and Channel Identification in the same request. If you set both, your request returns a BadRequestException.`,
|
|
},
|
|
{
|
|
displayName: 'Max Alternatives',
|
|
name: 'maxAlternatives',
|
|
type: 'number',
|
|
default: 2,
|
|
typeOptions: {
|
|
minValue: 2,
|
|
maxValue: 10,
|
|
},
|
|
description: 'The number of alternative transcriptions that the service should return.',
|
|
},
|
|
{
|
|
displayName: 'Max Speaker Labels',
|
|
name: 'maxSpeakerLabels',
|
|
type: 'number',
|
|
default: 2,
|
|
typeOptions: {
|
|
minValue: 2,
|
|
maxValue: 10,
|
|
},
|
|
description: `The maximum number of speakers to identify in the input audio. If there are more speakers in the audio than this number, multiple speakers are identified as a single speaker.`,
|
|
},
|
|
{
|
|
displayName: 'Vocabulary Name',
|
|
name: 'vocabularyName',
|
|
type: 'string',
|
|
default: '',
|
|
description: 'Name of vocabulary to use when processing the transcription job.',
|
|
},
|
|
{
|
|
displayName: 'Vocabulary Filter Name',
|
|
name: 'vocabularyFilterName',
|
|
type: 'string',
|
|
default: '',
|
|
description: `The name of the vocabulary filter to use when transcribing the audio. The filter that you specify must have the same language code as the transcription job.`,
|
|
},
|
|
{
|
|
displayName: 'Vocabulary Filter Method',
|
|
name: 'vocabularyFilterMethod',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'Remove',
|
|
value: 'remove',
|
|
},
|
|
{
|
|
name: 'Mask',
|
|
value: 'mask',
|
|
},
|
|
{
|
|
name: 'Tag',
|
|
value: 'tag',
|
|
},
|
|
|
|
],
|
|
default: 'remove',
|
|
description: `<p>Set to mask to remove filtered text from the transcript and replace it with three asterisks ("***") as placeholder text.</p><p>Set to remove to remove filtered text from the transcript without using placeholder text. Set to tag to mark the word in the transcription output that matches the vocabulary filter. When you set the filter method to tag, the words matching your vocabulary filter are not masked or removed.</p>`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
displayName: 'Return Transcript',
|
|
name: 'returnTranscript',
|
|
type: 'boolean',
|
|
default: true,
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'get',
|
|
],
|
|
},
|
|
},
|
|
description: 'By default, the response only contains metadata about the transcript. Enable this option to retrieve the transcript instead.',
|
|
},
|
|
{
|
|
displayName: 'Simple',
|
|
name: 'simple',
|
|
type: 'boolean',
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'get',
|
|
],
|
|
returnTranscript: [
|
|
true,
|
|
],
|
|
},
|
|
},
|
|
default: true,
|
|
description: 'Return a simplified version of the response instead of the raw data.',
|
|
},
|
|
{
|
|
displayName: 'Return All',
|
|
name: 'returnAll',
|
|
type: 'boolean',
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'getAll',
|
|
],
|
|
},
|
|
},
|
|
default: false,
|
|
description: 'If all results should be returned or only up to a given limit.',
|
|
},
|
|
{
|
|
displayName: 'Limit',
|
|
name: 'limit',
|
|
type: 'number',
|
|
default: 20,
|
|
typeOptions: {
|
|
minValue: 1,
|
|
},
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'getAll',
|
|
],
|
|
returnAll: [
|
|
false,
|
|
],
|
|
},
|
|
},
|
|
description: 'The maximum number of results to return',
|
|
},
|
|
{
|
|
displayName: 'Filters',
|
|
name: 'filters',
|
|
type: 'collection',
|
|
placeholder: 'Add Filter',
|
|
default: {},
|
|
displayOptions: {
|
|
show: {
|
|
resource: [
|
|
'transcriptionJob',
|
|
],
|
|
operation: [
|
|
'getAll',
|
|
],
|
|
},
|
|
},
|
|
options: [
|
|
{
|
|
displayName: 'Job Name Contains',
|
|
name: 'jobNameContains',
|
|
type: 'string',
|
|
description: 'Return only transcription jobs whose name contains the specified string.',
|
|
default: '',
|
|
},
|
|
{
|
|
displayName: 'Status',
|
|
name: 'status',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'Completed',
|
|
value: 'COMPLETED',
|
|
},
|
|
{
|
|
name: 'Failed',
|
|
value: 'FAILED',
|
|
},
|
|
{
|
|
name: 'In Progress',
|
|
value: 'IN_PROGRESS',
|
|
},
|
|
{
|
|
name: 'Queued',
|
|
value: 'QUEUED',
|
|
},
|
|
],
|
|
description: 'Return only transcription jobs with the specified status.',
|
|
default: 'COMPLETED',
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
|
|
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
|
|
const items = this.getInputData();
|
|
const returnData: IDataObject[] = [];
|
|
let responseData;
|
|
const resource = this.getNodeParameter('resource', 0) as string;
|
|
const operation = this.getNodeParameter('operation', 0) as string;
|
|
for (let i = 0; i < items.length; i++) {
|
|
try {
|
|
if (resource === 'transcriptionJob') {
|
|
//https://docs.aws.amazon.com/comprehend/latest/dg/API_DetectDominantLanguage.html
|
|
if (operation === 'create') {
|
|
const transcriptionJobName = this.getNodeParameter('transcriptionJobName', i) as string;
|
|
const mediaFileUri = this.getNodeParameter('mediaFileUri', i) as string;
|
|
const detectLang = this.getNodeParameter('detectLanguage', i) as boolean;
|
|
|
|
const options = this.getNodeParameter('options', i, {}) as IDataObject;
|
|
|
|
const body: IDataObject = {
|
|
TranscriptionJobName: transcriptionJobName,
|
|
Media: {
|
|
MediaFileUri: mediaFileUri,
|
|
},
|
|
Settings: {},
|
|
};
|
|
|
|
if (detectLang) {
|
|
body.IdentifyLanguage = detectLang;
|
|
} else {
|
|
body.LanguageCode = this.getNodeParameter('languageCode', i) as string;
|
|
}
|
|
|
|
if (options.channelIdentification) {
|
|
Object.assign(body.Settings, { ChannelIdentification: options.channelIdentification });
|
|
}
|
|
|
|
if (options.maxAlternatives) {
|
|
Object.assign(body.Settings, {
|
|
ShowAlternatives: true,
|
|
MaxAlternatives: options.maxAlternatives,
|
|
});
|
|
}
|
|
|
|
if (options.maxSpeakerLabels) {
|
|
Object.assign(body.Settings, {
|
|
ShowSpeakerLabels: true,
|
|
MaxSpeakerLabels: options.maxSpeakerLabels,
|
|
});
|
|
}
|
|
|
|
if (options.vocabularyName) {
|
|
Object.assign(body.Settings, {
|
|
VocabularyName: options.vocabularyName,
|
|
});
|
|
}
|
|
|
|
if (options.vocabularyFilterName) {
|
|
Object.assign(body.Settings, {
|
|
VocabularyFilterName: options.vocabularyFilterName,
|
|
});
|
|
}
|
|
|
|
if (options.vocabularyFilterMethod) {
|
|
Object.assign(body.Settings, {
|
|
VocabularyFilterMethod: options.vocabularyFilterMethod,
|
|
});
|
|
}
|
|
|
|
const action = 'Transcribe.StartTranscriptionJob';
|
|
responseData = await awsApiRequestREST.call(this, 'transcribe', 'POST', '', JSON.stringify(body), { 'x-amz-target': action, 'Content-Type': 'application/x-amz-json-1.1' });
|
|
responseData = responseData.TranscriptionJob;
|
|
}
|
|
//https://docs.aws.amazon.com/transcribe/latest/dg/API_DeleteTranscriptionJob.html
|
|
if (operation === 'delete') {
|
|
const transcriptionJobName = this.getNodeParameter('transcriptionJobName', i) as string;
|
|
|
|
const body: IDataObject = {
|
|
TranscriptionJobName: transcriptionJobName,
|
|
};
|
|
|
|
const action = 'Transcribe.DeleteTranscriptionJob';
|
|
responseData = await awsApiRequestREST.call(this, 'transcribe', 'POST', '', JSON.stringify(body), { 'x-amz-target': action, 'Content-Type': 'application/x-amz-json-1.1' });
|
|
responseData = { success: true };
|
|
}
|
|
//https://docs.aws.amazon.com/transcribe/latest/dg/API_GetTranscriptionJob.html
|
|
if (operation === 'get') {
|
|
const transcriptionJobName = this.getNodeParameter('transcriptionJobName', i) as string;
|
|
const resolve = this.getNodeParameter('returnTranscript', 0) as boolean;
|
|
|
|
const body: IDataObject = {
|
|
TranscriptionJobName: transcriptionJobName,
|
|
};
|
|
|
|
const action = 'Transcribe.GetTranscriptionJob';
|
|
responseData = await awsApiRequestREST.call(this, 'transcribe', 'POST', '', JSON.stringify(body), { 'x-amz-target': action, 'Content-Type': 'application/x-amz-json-1.1' });
|
|
responseData = responseData.TranscriptionJob;
|
|
|
|
if (resolve === true && responseData.TranscriptionJobStatus === 'COMPLETED') {
|
|
responseData = await this.helpers.request({ method: 'GET', uri: responseData.Transcript.TranscriptFileUri, json: true });
|
|
const simple = this.getNodeParameter('simple', 0) as boolean;
|
|
if (simple === true) {
|
|
responseData = { transcript: responseData.results.transcripts.map((data: IDataObject) => data.transcript).join(' ') };
|
|
}
|
|
}
|
|
}
|
|
//https://docs.aws.amazon.com/transcribe/latest/dg/API_ListTranscriptionJobs.html
|
|
if (operation === 'getAll') {
|
|
const returnAll = this.getNodeParameter('returnAll', i) as boolean;
|
|
const filters = this.getNodeParameter('filters', i) as IDataObject;
|
|
const action = 'Transcribe.ListTranscriptionJobs';
|
|
const body: IDataObject = {};
|
|
|
|
if (filters.status) {
|
|
body['Status'] = filters.status;
|
|
}
|
|
|
|
if (filters.jobNameContains) {
|
|
body['JobNameContains'] = filters.jobNameContains;
|
|
}
|
|
|
|
if (returnAll === true) {
|
|
responseData = await awsApiRequestRESTAllItems.call(this, 'TranscriptionJobSummaries', 'transcribe', 'POST', '', JSON.stringify(body), { 'x-amz-target': action, 'Content-Type': 'application/x-amz-json-1.1' });
|
|
|
|
} else {
|
|
const limit = this.getNodeParameter('limit', i) as number;
|
|
body['MaxResults'] = limit;
|
|
responseData = await awsApiRequestREST.call(this, 'transcribe', 'POST', '', JSON.stringify(body), { 'x-amz-target': action, 'Content-Type': 'application/x-amz-json-1.1' });
|
|
responseData = responseData.TranscriptionJobSummaries;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Array.isArray(responseData)) {
|
|
returnData.push.apply(returnData, responseData as IDataObject[]);
|
|
} else {
|
|
returnData.push(responseData as IDataObject);
|
|
}
|
|
|
|
} catch (error) {
|
|
if (this.continueOnFail()) {
|
|
returnData.push({ error: error.message });
|
|
continue;
|
|
}
|
|
throw error;
|
|
}
|
|
}
|
|
return [this.helpers.returnJsonArray(returnData)];
|
|
}
|
|
}
|