mirror of
https://github.com/n8n-io/n8n.git
synced 2024-11-10 14:44:05 -08:00
26bdc5c924
* Fixe uninitialized object when settings enabled * 👕 Fix linter warning * ⚡ Fix options name * 🔥 Remove unused setting * ⚡ Improvements Co-authored-by: Alexander Mustafin <sashker@users.noreply.github.com> Co-authored-by: ricardo <ricardoespinoza105@gmail.com>
555 lines
14 KiB
TypeScript
555 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',
|
|
color: '#5aa08d',
|
|
},
|
|
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</br>
|
|
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.</br>
|
|
If there are more speakers in the audio than this number, multiple speakers are</br>
|
|
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.</br>
|
|
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: `Set to mask to remove filtered text from the transcript and replace it with three asterisks ("***") as placeholder text.</br>
|
|
Set to remove to remove filtered text from the transcript without using placeholder text. Set to tag to mark the word in the transcription</br>
|
|
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.`,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
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.<br>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)];
|
|
}
|
|
}
|