@eui/tools 5.1.12 → 5.2.1

package/.version.properties

@@ -1 +1 @@
-5.1.12
+5.2.1

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 5.2.1 (2022-05-02)
+
+##### Bug Fixes
+
+* **other:**
+  * wrong initial version set for envTarget remote delivery - EUI-5632 [EUI-5632](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-5632)  ([cc894439](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/cc8944393d48bb9b7ae2ee5afb3ab5052983f4a5))
+
+* * *
+* * *
+## 5.2.0 (2022-04-29)
+
+##### New Features
+
+* **other:**
+  * added script for translating i18n files EUI-5847 [EUI-5847](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-5847)  ([3e0740f4](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/3e0740f40386d87f2baa4045ae14fe93adf40655))
+
+* * *
+* * *
+## 5.1.13 (2022-04-28)
+
+##### Bug Fixes
+
+* **other:**
+  * broken version generated for remote snapshot - EUI-5632 [EUI-5632](https://webgate.ec.europa.eu/CITnet/jira/browse/EUI-5632)  ([21a5afd7](https://webgate.ec.europa.eu/CITnet/stash/scm/csdr/eui-tools.git/commits/21a5afd7c07bcea1c4bed4e0ed7c417667e87673))
+
+* * *
+* * *
 ## 5.1.12 (2022-04-28)
 
 ##### Bug Fixes

package/bin/eui-scripts.js

@@ -35,6 +35,7 @@ const scriptIndex = args.findIndex(
     x === 'csdr-stats' ||
     x === 'generate-app-metadata' ||
     x === 'help' ||
+    x === 'i18n-translate' ||
     x === 'inject-config-app' ||
     x === 'version'
 );
@@ -70,6 +71,7 @@ switch (script) {
     case 'csdr-stats':
     case 'generate-app-metadata':
     case 'help':
+    case 'i18n-translate':
     case 'inject-config-app':
     case 'version': {
         const result = spawn.sync(

package/bin/scripts/i18n-translate.js

@@ -0,0 +1,12 @@
+'use strict';
+
+const i18nTranslate = require('../../scripts/utils/translate/translate-utils');
+
+Promise.resolve()
+  .then(() => {
+    return i18nTranslate.translateI18nFile();
+  })
+  .catch((e) => {
+    console.log(e);
+    process.exit(1);
+  })

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@eui/tools",
-    "version": "5.1.12",
+    "version": "5.2.1",
     "tag": "latest",
     "license": "EUPL-1.1",
     "description": "eUI common tools and scripts",

package/sandbox.js

@@ -790,7 +790,7 @@ const versionUtils = require('./scripts/csdr/version/version-utils');
 // METADATA API TESTING
 // --------------------
 // const metadataModule = require('./scripts/csdr/metadata/v2');
-// const pkg = configUtils.packages.getPackage('mywp-dummy-eui10-remote-el-ui');
+// const pkg = configUtils.packages.getPackage('cc-task-details-eui10-remote-el-ui');
 
 // Promise.resolve()
 //   .then(() => {
@@ -840,12 +840,33 @@ const versionUtils = require('./scripts/csdr/version/version-utils');
 // })
 
 
-const pkg = configUtils.packages.getPackage('opsys-epc-esub-bo-ui', true);
+// METADATA ESTING
+// --------------------
+const pkg = configUtils.packages.getPackage('cc-task-details-eui10-remote-el-ui');
+const envTarget = 'DEV';
+
+let versionsMetadata, envsMetadata;
 
 Promise.resolve()
+  // generating new version based on the env target and the envs cycle type
   .then(() => {
-    return metadataUtils.package.getPackageVersionsByMajor(pkg, '10', false)
+    return versionUtils.packageRemote.getNewVersion(pkg, envTarget);
   })
-  .then((versions) => {
-    console.log(versions);
+  .then((version) => {
+    console.log(version);
   })
+
+
+
+
+
+
+// const pkg = configUtils.packages.getPackage('opsys-epc-esub-bo-ui', true);
+
+// Promise.resolve()
+//   .then(() => {
+//     return metadataUtils.package.getPackageVersionsByMajor(pkg, '10', false)
+//   })
+//   .then((versions) => {
+//     console.log(versions);
+//   })

package/scripts/csdr/release/package/common.js

@@ -260,7 +260,8 @@ module.exports.updateVersion = (pkg, pkgMetadata, envTarget) => {
       (branches.isSnapshot || branches.isSupportSnapshot),
       branches.isNext,
       branches.isSupport,
-      branches.isHotfix
+      branches.isHotfix,
+      envTarget
     );
   })
 

package/scripts/csdr/version/common.js

@@ -7,7 +7,7 @@ const semver = require('semver');
 const tools = require('../../utils/tools');
 
 
-const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
+const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv, currentVersion) => {
   let version;
   const lastIntMetadata = envsMetadata[rootEnv];
 
@@ -19,7 +19,11 @@ const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
 
   } else {
     tools.logInfo('No INT metadata found : initializing version');
-    version = '1.0.0-SNAPSHOT';
+    if (currentVersion) {
+      version = semver.coerce(currentVersion).raw + '-SNAPSHOT';
+    } else {
+      version = '1.0.0-SNAPSHOT';
+    }
     tools.logInfo(`version intialized : ${version}`);
   }
 
@@ -48,6 +52,7 @@ const getNewVersionForDev = (versionsMetadata, envsMetadata, rootEnv) => {
 
       // if it's a branch new DEV stream release, the snapshot is itialized
     } else {
+      tools.logInfo(`prevVersions matching: ${version} not found initializing first release of raw version`);
       version += '.0';
     }
   }
@@ -132,7 +137,7 @@ const getNewVersionForEnv = (versionsMetadata, envsMetadata, rootEnv, envTarget)
 
 
 
-module.exports.getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata) => {
+module.exports.getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata, currentVersion) => {
   tools.logInfo(`Retrieve version for ${envTarget}`);
 
   return Promise.resolve()
@@ -145,7 +150,7 @@ module.exports.getNewVersionDefault = (envTarget, versionsMetadata, envsMetadata
       // =====================================================================
 
       if (envTarget === 'DEV') {
-        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT');
+        version = getNewVersionForDev(versionsMetadata, envsMetadata, 'INT', currentVersion);
       }
 
 

package/scripts/csdr/version/package-common.js

@@ -16,7 +16,7 @@ const configUtils = require('../config/config-utils');
 const { dryRun, nexusUser, nexusPassword } = tools.getArgs();
 
 
-const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget) => {
   return Promise.resolve()
     .then(() => {
       const pkgJsonFile = path.resolve(folder, 'package.json');
@@ -24,14 +24,18 @@ const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSu
 
       let tag;
 
-      if (isSnapshot) {
+      if (envTarget && envTarget === 'DEV') {
         tag = 'snapshot';
-      } else if (isNextBranch) {
-        tag = 'next';
-      } else if (isSupportBranch) {
-        tag = 'prev';
       } else {
-        tag = 'latest';
+        if (isSnapshot) {
+          tag = 'snapshot';
+        } else if (isNextBranch) {
+          tag = 'next';
+        } else if (isSupportBranch) {
+          tag = 'prev';
+        } else {
+          tag = 'latest';
+        }
       }
 
       pkgJson.version = newVersion;
@@ -48,7 +52,7 @@ const writePackageJsonCore = (newVersion, folder, isSnapshot, isNextBranch, isSu
     })
 }
 
-const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget) => {
   return Promise.resolve()
     .then(() => {
       tools.logTitle('updating package version');
@@ -56,11 +60,11 @@ const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBr
       if (!pkg.parent) {
         return Promise.resolve()
           .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
           })
           .then(() => {
             if (!pkg.element && !pkg.config) {
-              return writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+              return writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
             }
           })
           .catch((e) => {
@@ -70,7 +74,7 @@ const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBr
       } else {
         return Promise.resolve()
           .then(() => {
-            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+            return writePackageJsonCore(newVersion, pkg.paths.pkgDirectory, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
           })
           .then(() => {
             let linkedPackages = Object.keys(pkg.packages)
@@ -85,7 +89,7 @@ const writePackageJson = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBr
           .then((linkedPackages) => Promise.resolve().then(() => {
             return linkedPackages.reduce((promise, pkg) => {
               return promise.then(() => (
-                writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch)
+                writePackageJsonCore(newVersion, pkg.paths.pkgPublish, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget)
               ));
             }, Promise.resolve());
           }))
@@ -113,7 +117,7 @@ const writePomXml = (pkg, newVersion, isSnapshot, isForceTimestamp = true) => {
   if (dryRun) {
       return;
   }
-  
+
   return Promise.resolve()
     .then(() => {
       return templateUtils.generateMavenSettings(nexusUser, nexusPassword);
@@ -146,13 +150,56 @@ const writePomXml = (pkg, newVersion, isSnapshot, isForceTimestamp = true) => {
 
 
 
-module.exports.updateVersion = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch) => {
+module.exports.updateVersion = (pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget) => {
   if (pkg.backend) {
     return writePomXml(pkg, newVersion, isSnapshot);
   }
   else {
-    return writePackageJson(pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch);
+    return writePackageJson(pkg, newVersion, isSnapshot, isNextBranch, isSupportBranch, isHotfixBranch, envTarget);
   }
 }
 
 
+module.exports.getCurrentVersion = (pkg) => {
+  return Promise.resolve()
+    .then(() => {
+      let currentVersion;
+
+      tools.logTitle('Extracting current version');
+
+      if (pkg.backend) {
+        // if nodejs backend, explicitely declared
+        if (pkg.build && pkg.build.nodejs) {
+          tools.logInfo('UI package => extracting from package.json');
+
+          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+          const pkgJson = require(pathPkgJson);
+          currentVersion = pkgJson.version;
+
+          // by default maven java backend is taken into account
+        } else {
+          tools.logInfo('Backend => extracting pom.xml');
+          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.pkgDirectory, 'pom.xml'));
+
+          tools.logInfo('Content found:');
+          console.log(xmlContent);
+
+          currentVersion = xmlContent.project.version.toString();
+        }
+
+      } else {
+        tools.logInfo('UI package => extracting from package.json');
+
+        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
+        const pkgJson = require(pathPkgJson);
+        currentVersion = pkgJson.version;
+      }
+
+      tools.logSuccess('Current version found : ' + currentVersion);
+      return currentVersion;
+    })
+    .catch((e) => {
+      throw e;
+    })
+}
+

package/scripts/csdr/version/package-default.js

@@ -2,87 +2,14 @@
 
 // externals
 const semver = require('semver');
-const path = require('path');
 
 // local
 const tools = require('../../utils/tools');
 
-
-const getCurrentVersion = (pkg) => {
-  return Promise.resolve()
-    .then(() => {
-      let currentVersion;
-
-      tools.logTitle('Extracting current version');
-
-      if (pkg.backend) {
-        // if nodejs backend, explicitely declared
-        if (pkg.build && pkg.build.nodejs) {
-          tools.logInfo('UI package => extracting from package.json');
-
-          const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
-          const pkgJson = require(pathPkgJson);
-          currentVersion = pkgJson.version;
-
-          // by default maven java backend is taken into account
-        } else {
-          tools.logInfo('Backend => extracting pom.xml');
-          const xmlContent = tools.getXMLJsContent(path.join(pkg.paths.pkgDirectory, 'pom.xml'));
-
-          tools.logInfo('Content found:');
-          console.log(xmlContent);
-
-          currentVersion = xmlContent.project.version.toString();
-        }
-
-      } else {
-        tools.logInfo('UI package => extracting from package.json');
-
-        const pathPkgJson = path.resolve(pkg.paths.pkgDirectory, 'package.json');
-        const pkgJson = require(pathPkgJson);
-        currentVersion = pkgJson.version;
-      }
-
-      tools.logSuccess('Current version found : ' + currentVersion);
-      return currentVersion;
-    })
-    .catch((e) => {
-      throw e;
-    })
-}
-
-
-const getReleaseType = (commitsMetadata) => {
-  tools.logInfo('Getting release type based on commits metadata parsed from last tag');
-
-  const RELEASE_TYPES = ['major', 'minor', 'patch'];
-
-  let level = 2;
-  let breakings = 0;
-  let features = 0;
-
-  commitsMetadata.forEach((commit) => {
-    if (commit.breakingChange) {
-      breakings += commit.body;
-      level = 1; // no major bump on "breaking changes"
-    } else if (commit.type === 'feat') {
-      features += 1;
-      if (level === 2) {
-        level = 1;
-      }
-    }
-  });
-
-  return {
-    level: level,
-    reason: 'There are ' + breakings + ' BREAKING CHANGES and ' + features + ' features',
-    releaseType: RELEASE_TYPES[level]
-  };
-}
+// inner
+const innerPackageCommon = require('./package-common');
 
 
-// PUBLIC METHODS
-
 module.exports.getNewVersion = (
     pkg,
     commits,
@@ -90,7 +17,7 @@ module.exports.getNewVersion = (
   ) => {
   return Promise.resolve()
     .then(() => {
-      return getCurrentVersion(pkg);
+      return innerPackageCommon.getCurrentVersion(pkg);
     })
 
     .then((currentVersion) => {
@@ -98,10 +25,36 @@ module.exports.getNewVersion = (
 
       tools.logInfo(`Current version found : ${currentVersion}`);
 
+      const RELEASE_TYPES = ['major', 'minor', 'patch'];
+
       let newVersion = '1.0.0';
 
       if (commits) {
-        const release = getReleaseType(commits);
+
+        tools.logInfo('Commits found for processing version, extracting...');
+
+        let level = 2;
+        let breakings = 0;
+        let features = 0;
+
+        commits.forEach((commit) => {
+          if (commit.breakingChange) {
+            breakings += commit.body;
+            level = 1; // no major bump on "breaking changes"
+          } else if (commit.type === 'feat') {
+            features += 1;
+            if (level === 2) {
+              level = 1;
+            }
+          }
+        });
+
+        const release = {
+          level: level,
+          reason: 'There are ' + breakings + ' BREAKING CHANGES and ' + features + ' features',
+          releaseType: RELEASE_TYPES[level]
+        };
+
         tools.logInfo('release info found : ' + JSON.stringify(release));
 
         if (isNextBranch) {
@@ -110,37 +63,39 @@ module.exports.getNewVersion = (
           newVersion = semver.valid(release.releaseType) || semver.inc(currentVersion, release.releaseType)
         }
 
-        tools.logInfo('probable new version : ' + newVersion);
 
-        if (isSnapshot) {
-          if (pkg.backend) {
-            if (pkg.build && pkg.build.nodejs) {
-              newVersion += '-snapshot-' + Date.now();
-            } else {
-              newVersion += '-SNAPSHOT';
-            }
-          } else {
-            newVersion += '-snapshot-' + Date.now();
-          }
+      } else {
+          tools.logInfo('No commits found for version processing...applying minor version upgrade');
 
-        } else if (isSupportBranch) {
-          if (pkg.backend) {
+          if (isNextBranch) {
             newVersion = semver.inc(currentVersion, 'prerelease');
+          } else {
+            newVersion = semver.inc(currentVersion, 'minor');
           }
-        } else if (isHotfixBranch) {
-          newVersion = semver.inc(currentVersion, 'prerelease');
-        }
+      }
 
-      } else {
-        tools.logInfo('No commits found for version processing...applying minor version upgrade');
+      tools.logInfo('probable new version : ' + newVersion);
 
-        if (isNextBranch) {
-          newVersion = semver.inc(currentVersion, 'prerelease');
+      if (isSnapshot) {
+        if (pkg.backend) {
+          if (pkg.build && pkg.build.nodejs) {
+            newVersion += '-snapshot-' + Date.now();
+          } else {
+            newVersion += '-SNAPSHOT';
+          }
         } else {
-          newVersion = semver.inc(currentVersion, 'minor');
+          newVersion += '-snapshot-' + Date.now();
         }
       }
 
+      if (isSupportBranch && pkg.backend) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      }
+
+      if (isHotfixBranch) {
+        newVersion = semver.inc(currentVersion, 'prerelease');
+      }
+
       tools.logSuccess('new version generated : ' + newVersion);
 
       return newVersion;

package/scripts/csdr/version/package-remote.js

@@ -12,6 +12,7 @@ const metadataUtils = require('../metadata/metadata-utils');
 
 // inner modules
 const innerCommon = require('./common');
+const innerPackageCommon = require('./package-common');
 
 // constants
 const { dryRun } = tools.getArgs();
@@ -21,8 +22,17 @@ const { dryRun } = tools.getArgs();
 module.exports.getNewVersion = (pkg, envTarget) => {
   let versionsMetadata;
   let envsMetadata;
+  let currentVersion;
 
   return Promise.resolve()
+    // get current version
+    .then(() => {
+      return innerPackageCommon.getCurrentVersion(pkg);
+    })
+    .then((version) => {
+      currentVersion = version;
+    })
+
     // fetch versions history and store
     .then(() => {
       return metadataUtils.packageVersions.getMetadata(pkg);
@@ -42,7 +52,7 @@ module.exports.getNewVersion = (pkg, envTarget) => {
 
     // generating new version based on the env target and the envs cycle type
     .then(() => {
-      return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata);
+      return innerCommon.getNewVersionDefault(envTarget, versionsMetadata, envsMetadata, currentVersion);
     })
 
     .catch((e) => {

package/scripts/csdr/version/version-utils.js

@@ -9,6 +9,7 @@ const innerPackage = require('./package');
 const innerPackageCommon = require('./package-common');
 const innerPackageRemote = require('./package-remote');
 const innerPackageDefault = require('./package-default');
+const innerCommon = require('./common');
 
 // re-exports inner modules
 module.exports.app = innerApp;
@@ -19,3 +20,4 @@ module.exports.package = innerPackage;
 module.exports.packageCommon = innerPackageCommon;
 module.exports.packageRemote = innerPackageRemote;
 module.exports.packageDefault = innerPackageDefault;
+module.exports.common = innerCommon;

package/scripts/utils/translate/translate-utils.js

@@ -0,0 +1,124 @@
+'use strict';
+
+const tools = require('../../utils/tools');
+const https = require('https');
+var fs = require('fs');
+const { filePath, sourceLang, targetLang } = require('../tools').getArgs();
+const TEXT = '<text>';
+const TEXT_END = '</text>';
+const CONTENT = '<content>';
+const CONTENT_END = '</content>';
+
+// example: node translate-utils.js --filePath c:\i18n\en.json --sourceLang en --targetLang bg
+
+const readFile = (filePath) => {
+    return JSON.parse(fs.readFileSync(filePath));
+}
+
+const translate = (text, sourceLang, targetLang) => {
+    tools.logTitle(`Translating file : ${filePath} from ${sourceLang} to ${targetLang}.`);
+    return new Promise((resolve, reject) => {
+        const data = JSON.stringify({
+            textToTranslate: text,
+            sourceLanguage: sourceLang,
+            targetLanguage: targetLang
+        });
+
+        const options = {
+            hostname: 'europa.eu',
+            path: '/webtools/rest/etrans/translate',
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Content-Length': data.length
+            }
+        };
+
+        const req = https.request(options, res => {
+            let chunks_of_data = [];
+
+            res.on('data', d => {
+                chunks_of_data.push(d);
+            });
+            res.on('end', () => {
+                tools.logInfo('Received response from eTrans service.');
+                let response_body = Buffer.concat(chunks_of_data);
+                var response = JSON.parse(response_body);
+                resolve(Buffer.from(response.translation, 'base64').toString());
+            });
+        });
+
+        req.on('error', error => {
+            reject(error);
+            return;
+        });
+
+        tools.logInfo('Sending request to eTrans service.');
+        req.write(data);
+        req.end();
+    });
+}
+
+const  prepareStringToTranslate = (arrLines, result) => {
+    var keys = Object.keys(arrLines);
+    keys.forEach((key) => {
+        if (arrLines[key] instanceof Object && !(arrLines[key] instanceof Array)) {
+            result += prepareStringToTranslate(arrLines[key], '');
+        } else {
+            result += `${TEXT}${arrLines[key]}${TEXT_END}`;
+        }
+    });
+    return result;
+}
+
+const  createResultJsonFile = (arrLines, res) => {
+    const resString = res.split(`${CONTENT}${TEXT}`).pop().split(`${TEXT_END}${CONTENT_END}`)[0];
+    const resArr = resString.split(`${TEXT_END}${TEXT}`);
+    var resultJson = Object.assign({}, arrLines);
+    var finalRes = iterateResultToJson(resultJson, resArr);
+    return finalRes;
+}
+
+const iterateResultToJson = (resultJson, resArr) => {
+    var keys = Object.keys(resultJson);
+    keys.forEach((key, index) => {
+        if (resultJson[key] instanceof Object && !(resultJson[key] instanceof Array)) { // If there is nested JSON
+            resultJson[key] = iterateResultToJson(resultJson[key], resArr.slice(index));
+            var subKeys = Object.keys(resultJson[key]);
+            resArr.splice(index, subKeys.length - 1); // remove elements for nested JSON from results array
+        } else {
+            if (resultJson[key] instanceof Array) {
+                resultJson[key] = resArr[index].split(',').map(el => el.trim());
+            } else {
+                resultJson[key] = resArr[index];
+            }
+        }
+    });
+    return resultJson;
+}
+
+const translateI18nFile = () => {
+    return Promise.resolve()
+        .then(() => {
+            const arrLines = readFile(filePath);
+            const destFolder = filePath.substring(0, filePath.lastIndexOf("\\") + 1);
+            var stringToTranslate = prepareStringToTranslate(arrLines, '');
+            translate(`${CONTENT}${stringToTranslate}${CONTENT_END}`, sourceLang, targetLang)
+                .then((res) => {
+                    const resultJson = createResultJsonFile(arrLines, res);
+                    fs.writeFile(`${destFolder}${targetLang}.json`, JSON.stringify(resultJson, null, 2), function (err) {
+                        if (err)  { tools.logError(err); }
+                        tools.logInfo(`File ${targetLang}.json created.`);
+                    });
+
+                }, (err) => {
+                    tools.logInfo(`Error: ${err}`);
+                });
+        }).catch((error) => {
+            tools.logError(error);
+          });
+}
+
+translateI18nFile();
+
+module.exports.translateI18nFile = translateI18nFile;