@wickr-sample-integrations/wickrio-translation-bot/translation_bot.js

Using the AWS SDK for JavaScript V3 to create a Translation chatbot within Wickr.

const WickrIOBotAPI = require('wickrio-bot-api');
const util = require('util')
const logger = require('wickrio-bot-api').logger
const FileReader = require('filereader')

const bot = new WickrIOBotAPI.WickrIOBot();
const WickrIOAPI = bot.apiService().WickrIOAPI;

//const RecognizeCelebritiesCommand = require('@aws-sdk/client-rekognition');
//const { RekognitionClient } = require('@aws-sdk/client-rekognition');
const { fromIni } = require('@aws-sdk/credential-providers');
//const { DetectLabelsCommand } = require("@aws-sdk/client-rekognition");

const { ComprehendClient } = require('@aws-sdk/client-comprehend');
const { CognitoIdentityClient } = require('@aws-sdk/client-cognito-identity');
const { TranslateClient } = require('@aws-sdk/client-translate');
const { DetectDominantLanguageCommand } = require('@aws-sdk/client-comprehend');
const { TranslateTextCommand } = require('@aws-sdk/client-translate');


// snippet-start:[s3.JavaScript.buckets.uploadV3]
//const { PutObjectCommand } = require("@aws-sdk/client-s3");
//const { fileURLToPath } = require("url");


console.log = function () {
  logger.info(util.format.apply(null, arguments))
}
console.error = function () {
  logger.error(util.format.apply(null, arguments))
}

var fs = require('fs');
var path = require('path');

module.exports = WickrIOAPI;
process.stdin.resume(); //so the program will not close instantly

async function exitHandler(options, err) {
  try {
    var closed = await bot.close();
    console.log(closed);
    if (err) {
      console.log("Exit Error:", err);
      process.exit();
    }
    if (options.exit) {
      process.exit();
    } else if (options.pid) {
      process.kill(process.pid);
    }
  } catch (err) {
    console.log(err);
  }
}

//catches ctrl+c and stop.sh events
process.on('SIGINT', exitHandler.bind(null, {
  exit: true
}));

// catches "kill pid" (for example: nodemon restart)
process.on('SIGUSR1', exitHandler.bind(null, {
  pid: true
}));
process.on('SIGUSR2', exitHandler.bind(null, {
  pid: true
}));

//catches uncaught exceptions
process.on('uncaughtException', exitHandler.bind(null, {
  exit: true
}));

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

// Respond to user's input.
async function createResponse(message, vGroupID) {
    // setup the clients
    bot.processesJsonToProcessEnv()
    var tokens = JSON.parse(process.env.tokens)
    const REGION = tokens.AWS_REGION.value
    const profileName = tokens.AWS_PROFILENAME.value

    console.log('entered createResponse')

    // Create an Amazon Comprehend service client object.
    const comprehendClient = new ComprehendClient({
      region: REGION,
      credentials: fromIni({profile: profileName,}),
    })

    // Create an Amazon Translate service client object.
    const translateClient = new TranslateClient({
      region: REGION,
      credentials: fromIni({profile: profileName,}),
    });


    const comprehendParams = {
      Text: message,
    };
    try {
      const data = await comprehendClient.send(
        new DetectDominantLanguageCommand(comprehendParams)
      );
      console.log(
        "Success. The language code is: ",
        data.Languages[0].LanguageCode
      );


      // Hard code from english to french
      var transToLanguage = "fr";
      if (data.Languages[0].LanguageCode === "en") {
        transToLanguage = "fr";
      } else {
        transToLanguage = "en"
      }

      const translateParams = {
        SourceLanguageCode: data.Languages[0].LanguageCode,
        TargetLanguageCode: transToLanguage,
        Text: message,
      };

      // Save the original language
      const sourceLanguageCode = data.Languages[0].LanguageCode

      try {
        const data = await translateClient.send(
          new TranslateTextCommand(translateParams)
        );
        console.log("Success. Translated text: ", data.TranslatedText);

        var sMessage = await WickrIOAPI.cmdSendRoomMessage(vGroupID, data.TranslatedText);
      } catch (err) {
        console.log("Error translating text. ", err);
      }
    } catch (err) {
      console.log("Error identifying language. ", err);
    }
}

async function main() {
  logger.info('entering main')
  try {
    var status;
    if (process.argv[2] === undefined) {
      var bot_username = fs.readFileSync('client_bot_username.txt', 'utf-8');
      bot_username = bot_username.trim();
      status = await bot.start(bot_username)
    } else {
      status = await bot.start(process.argv[2])
    }
    if (!status) {
      exitHandler(null, {
        exit: true,
        reason: 'Client not able to start'
      });
    }

    // set the avatar
    const avatarPath=path.join(process.cwd(), 'awsTranslate.jpeg')
    logger.info(`avatar path:${avatarPath}`)
    if (await WickrIOAPI.cmdSetAvatar(avatarPath)) {
      logger.info('avatar set')
    } else {
      logger.info('avatar NOT set')
    }

    await bot.startListening(listen); //Passes a callback function that will receive incoming messages into the bot client
  } catch (err) {
    logger.error(err);
  }
}


async function listen(rMessage) {
  logger.info('entering listen')
  /*
  try {
    const messageService = bot.messageService({rMessage})
    const {
      user,
      userEmail,
      isAdmin,
    } = messageService
  } catch (err) {
    logger.error(err);
  }
  */

  rMessage = JSON.parse(rMessage);
  var sender = rMessage.sender;
  var vGroupID = rMessage.vgroupid;
  var userArr = [];
  userArr.push(sender);
  if (rMessage.message) {
    var request = rMessage.message;

    console.log('calling createResponse()')
    await createResponse(request, vGroupID)
  }
}

main();