intermediate-component-sa 1.1.0 → 1.1.2

package/server/customRequest.js

@@ -0,0 +1,373 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var sy = require("systeminformation");
+var md5 = require("md5");
+var request = require("request-promise-native");
+var routes_centralized_1 = require("./routes-centralized");
+var crypt_1 = require("./crypt");
+var moment = require("moment");
+var file_manager_1 = require("./shared/file-manager");
+var fs = require('fs');
+var CENTRALIZED_API_BASE_URL = 'http://localhost:9002/';
+function InconcertRequest(installationId, path, data) {
+    var systemInformationData = null;
+    var route = routes_centralized_1.RoutesCentralized[path];
+    return DummyPromise()
+        .then(function (result) {
+        if (installationId && route && data)
+            return GetSystemInformation(installationId);
+        else
+            throw 'SERVER_ERROR_MISSING_REQUIRED_PARAMETERS';
+    })
+        .then(function (result) {
+        systemInformationData = result;
+        var plaformHash = '';
+        if (systemInformationData) {
+            plaformHash = GenerateMD5Content(systemInformationData);
+        }
+        var options = {
+            method: 'POST',
+            uri: CENTRALIZED_API_BASE_URL + route,
+            body: data,
+            headers: {
+                'Content-Type': 'application/json',
+                'Platform-Hash': plaformHash
+            },
+            json: true,
+            resolveWithFullResponse: false
+        };
+        return request(options);
+    })
+        .then(function (result) {
+        if (result === null)
+            throw 'SERVER_ERROR_EXTERNAL_REQUEST_FAILED';
+        return Promise.resolve(result);
+    })
+        .catch(function (err) {
+        var clientMsg = (typeof err === 'string' ? err : 'Cannot process request');
+        var errorMsg = (typeof err === 'string' ? err : err.message || err.description || 'SERVER_ERROR_REQUESTING_ERROR');
+        return Promise.reject(err);
+    });
+}
+exports.InconcertRequest = InconcertRequest;
+function GetSystemInformation(instalationId) {
+    var systemInformationData = {
+        installationId: instalationId,
+        macAddress: '',
+        publicIp: ''
+    };
+    return DummyPromise()
+        .then(function (result) {
+        var sys = sy.networkInterfaces();
+        return sys;
+    })
+        .then(function (result) {
+        if (result === null)
+            throw 'SERVER_ERROR_NOT_FOUND_NETWORK_INTERFACE_INFORMATION';
+        if (result && result.length) {
+            var myNetworkInterface = null;
+            myNetworkInterface = result.filter(function (r) { return r.operstate === 'up'; })[0];
+            systemInformationData.macAddress = myNetworkInterface.mac;
+            systemInformationData.ip = myNetworkInterface.ip4;
+        }
+        return Promise.resolve(systemInformationData);
+    })
+        .catch(function (err) {
+        var errorMsg = (err && err.procName ? 'Error al ejecutar \'' + err.procName + '\': ' : 'Error al ejecutar consulta: ') + (err ? typeof err === 'string' ? err : err.message || err.description || '' : '');
+        return Promise.reject(err);
+    });
+}
+exports.GetSystemInformation = GetSystemInformation;
+function GenerateMD5Content(data) {
+    var result = '';
+    if (data) {
+        result += data.installationId;
+        result += data.macAddress;
+        result = md5(result);
+    }
+    return result;
+}
+exports.GenerateMD5Content = GenerateMD5Content;
+function DummyPromise() {
+    return new Promise(function (resolve, reject) {
+        resolve(true);
+    });
+}
+exports.DummyPromise = DummyPromise;
+function SleepPromise(secondTime) {
+    return new Promise(function (resolve, reject) {
+        setTimeout(resolve, (1000 * secondTime));
+    });
+}
+exports.SleepPromise = SleepPromise;
+var rootPath = '/sq/';
+var storagePath = rootPath + 'storage/';
+var generalFilePath = rootPath + 'storage/file.txt';
+var segmentedFileFolderPath = rootPath + 'storage/out/';
+var completedFileFolderPath = rootPath + 'storage/completed/';
+function InconcertCheckSystemFolder() {
+    return DummyPromise()
+        .then(function (result) {
+        return file_manager_1.CreateFolder(rootPath);
+    })
+        .then(function (result) {
+        return file_manager_1.CreateFolder(storagePath);
+    })
+        .then(function (result) {
+        return file_manager_1.CreateFolder(segmentedFileFolderPath);
+    })
+        .then(function (result) {
+        return file_manager_1.CreateFolder(completedFileFolderPath);
+    })
+        .then(function (result) {
+        return Promise.resolve(result);
+    })
+        .catch(function (err) {
+        return Promise.resolve(false);
+    });
+}
+exports.InconcertCheckSystemFolder = InconcertCheckSystemFolder;
+function InconcertExistsGeneralFile() {
+    try {
+        if (fs.existsSync(generalFilePath)) {
+            return true;
+        }
+        else {
+            fs.writeFile(generalFilePath, '', function (err) {
+                if (err) {
+                    console.error(err);
+                    return false;
+                }
+                return true;
+            });
+            return true;
+        }
+    }
+    catch (err) {
+        console.error(err);
+        return false;
+    }
+}
+exports.InconcertExistsGeneralFile = InconcertExistsGeneralFile;
+function InconcertAddDataToGeneralFile(myText, myTextStatus) {
+    if (InconcertExistsGeneralFile()) {
+        if (myTextStatus !== undefined)
+            return InconcertAddEncryptTextToFile(generalFilePath, myText, myTextStatus);
+        else
+            return InconcertAddEncryptTextToFile(generalFilePath, myText);
+    }
+    else {
+        if (myTextStatus)
+            return InconcertAddDataToGeneralFile(myText, myTextStatus);
+        else
+            return InconcertAddDataToGeneralFile(myText);
+    }
+}
+exports.InconcertAddDataToGeneralFile = InconcertAddDataToGeneralFile;
+function InconcertAddDataToSegmentedFile(myText) {
+    var blockFileNewNamePath = segmentedFileFolderPath + moment().format('x') + '1-NEW.txt';
+    var blockFileUpdateNamePath = segmentedFileFolderPath + moment().format('x') + '2-UPDATE.txt';
+    var blockFileCompletedNamePath = segmentedFileFolderPath + moment().format('x') + '3-COMPLETED.txt';
+    var newInsertCounter = 0;
+    var updateInsertCounter = 0;
+    var completedInsertCounter = 0;
+    myText.map(function (s) {
+        if (s && s.length) {
+            var operation = s.split('::');
+            if (operation.length === 1) {
+                newInsertCounter++;
+                InconcertAddTextToFile(blockFileNewNamePath, s);
+            }
+            else {
+                switch (operation[1]) {
+                    case 'new':
+                        newInsertCounter++;
+                        InconcertAddTextToFile(blockFileNewNamePath, s);
+                        break;
+                    case 'update':
+                        updateInsertCounter++;
+                        InconcertAddTextToFile(blockFileUpdateNamePath, s);
+                        break;
+                    case 'success':
+                        completedInsertCounter++;
+                        InconcertAddTextToFile(blockFileCompletedNamePath, s);
+                        break;
+                    case 'failed':
+                        completedInsertCounter++;
+                        InconcertAddTextToFile(blockFileCompletedNamePath, s);
+                        break;
+                }
+            }
+        }
+    });
+    return true;
+}
+exports.InconcertAddDataToSegmentedFile = InconcertAddDataToSegmentedFile;
+function InconcertAddEncryptTextToFile(myFile, myText, myTextResult) {
+    var insertText = '';
+    if (myTextResult !== undefined) {
+        insertText += crypt_1.InconcertEncrypt(myText) + '::' + myTextResult;
+    }
+    else {
+        insertText += crypt_1.InconcertEncrypt(myText);
+    }
+    try {
+        fs.appendFileSync(myFile, insertText + '\n');
+    }
+    catch (err) {
+        console.log('Save failed!');
+    }
+    return true;
+}
+exports.InconcertAddEncryptTextToFile = InconcertAddEncryptTextToFile;
+function InconcertAddTextToFile(myFile, myText) {
+    try {
+        fs.appendFileSync(myFile, myText + '\n');
+    }
+    catch (err) {
+        fs.writeFile(myFile, '', function (err) {
+            if (err) {
+                console.error(err);
+                return false;
+            }
+            return true;
+        });
+        InconcertAddTextToFile(myFile, myText);
+        console.log('Save failed!');
+    }
+    return true;
+}
+exports.InconcertAddTextToFile = InconcertAddTextToFile;
+function InconcertSplitGeneralFileData() {
+    var data = fs.readFileSync(generalFilePath, 'utf-8');
+    var blockSize = 50;
+    var content = data.toString().split('\n');
+    var totalRows = content.filter(function (r) { return r.length > 0; }).length;
+    var blocks = Math.ceil(totalRows / blockSize);
+    for (var i = 0; i < blocks; i++) {
+        var blockContent = content.splice(0, blockSize);
+        InconcertAddDataToSegmentedFile(blockContent);
+    }
+    fs.writeFileSync(generalFilePath, content.join('\n'), 'utf-8');
+}
+exports.InconcertSplitGeneralFileData = InconcertSplitGeneralFileData;
+function InconcertSegmentedFileUpload(installationId) {
+    var segmentedFiles = [];
+    var segmentedNewFiles = [];
+    var segmentedUpdateFiles = [];
+    var segmentedCloseFiles = [];
+    var segmentedFilesResult = [];
+    return DummyPromise()
+        .then(function (result) {
+        return InconcertCheckSystemFolder();
+    })
+        .then(function (result) {
+        return file_manager_1.GetFolderTree(segmentedFileFolderPath);
+    })
+        .then(function (result) {
+        if (result && result.length > 0 && result[0].children && result[0].children.length > 0) {
+            segmentedFiles = result[0].children;
+            var fileContentPromises = [];
+            for (var i = 0; i < 25; i++) {
+                if (segmentedFiles[i])
+                    fileContentPromises.push(file_manager_1.ReadFileContent(segmentedFiles[i].fullPath, 'utf8'));
+            }
+            return Promise.all(fileContentPromises);
+        }
+        else {
+            throw 'SERVER_ERROR_NOT_FOUND_FILE';
+        }
+    })
+        .then(function (result) {
+        var arrSummary = [];
+        if (result && result.length) {
+            for (var i = 0; i < 25; i++) {
+                if (result[i]) {
+                    var body = {
+                        'installationId': installationId,
+                        'file': segmentedFiles[i].name,
+                        'data': result[i]
+                    };
+                    arrSummary.push(body);
+                }
+            }
+        }
+        else {
+            throw 'SERVER_ERROR_NOT_FOUND_FILE_CONTENT';
+        }
+        return InconcertSegmenteFileRecursiveSend(arrSummary);
+    })
+        .then(function (result) {
+        if (result && result.status) {
+            return Promise.resolve({ 'res': true, 'data': result });
+        }
+        else
+            throw 'SERVER_ERROR_MASSIVE_UPLOAD_FAILED';
+    })
+        .catch(function (err) {
+        return Promise.resolve({ 'res': false, 'err': err });
+    });
+}
+exports.InconcertSegmentedFileUpload = InconcertSegmentedFileUpload;
+function InconcertSegmenteFileRecursiveSend(arrSummary) {
+    var myBody = arrSummary.shift();
+    return SleepPromise(1)
+        .then(function (result) {
+        return InconcertRequest(myBody.installationId, 'IC_PARAM_URL_BATCH_DETAIL_SAVE', myBody);
+    })
+        .then(function (result) {
+        if (result === null)
+            throw 'SERVER_ERROR_NOT_RECEIVED_RESULT';
+        if (result.status !== true) {
+            throw 'SERVER_ERROR_FILE_UPLOAD_FAILED';
+        }
+        else {
+            return InconcertSegmentedFileToCompletedFolder(result.data);
+        }
+    })
+        .then(function (result) {
+        if (result) {
+            if (arrSummary.length > 0) {
+                return InconcertSegmenteFileRecursiveSend(arrSummary);
+            }
+            else
+                return Promise.resolve({ 'res': true, 'data': result });
+        }
+        else {
+            throw 'SERVER_ERROR_FILE_MOVE_FAILED';
+        }
+    })
+        .catch(function (err) {
+        return Promise.resolve({ 'res': false, 'err': err });
+    });
+}
+function InconcertSegmentedFileToCompletedFolder(segmentedFileName) {
+    var sourcePath = segmentedFileFolderPath + segmentedFileName;
+    var targetPath = completedFileFolderPath + segmentedFileName;
+    return DummyPromise()
+        .then(function (result) {
+        return file_manager_1.CreateFolder(completedFileFolderPath);
+    })
+        .then(function (result) {
+        return file_manager_1.CopyFile(sourcePath, targetPath);
+    })
+        .then(function (result) {
+        if (result) {
+            return file_manager_1.DeleteFile(sourcePath);
+        }
+        else {
+            throw 'SERVER_ERROR_COPY_FILE_FAILED';
+        }
+    })
+        .then(function (result) {
+        if (result) {
+            return Promise.resolve(true);
+        }
+        else {
+            throw 'SERVER_ERROR_DELETE_FILE_FAILED';
+        }
+    })
+        .catch(function (err) {
+        return Promise.resolve(false);
+    });
+}

package/server/index.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var http = require("http");
+var https = require("https");
+var express = require("express");
+var bodyParser = require("body-parser");
+var cookieParser = require("cookie-parser");
+var compression = require("compression");
+var path = require("path");
+var fs = require("fs");
+var log4js = require("log4js");
+var services = require("./services");
+var securityShared = require("./shared/security.shared");
+var logger_config_1 = require("./config/logger.config");
+var promises_shared_1 = require("./shared/promises.shared");
+var server_config_1 = require("./config/server.config");
+var app_config_1 = require("./config/app.config");
+var app = express();
+var httpServer;
+var httpsServer;
+function init() {
+    var clientPath = '../client';
+    var logsPath = path.resolve(__dirname, 'logs');
+    if (!fs.existsSync(logsPath))
+        fs.mkdirSync(logsPath);
+    log4js.configure(logger_config_1.LOGGER_CONFIG);
+    var logger = log4js.getLogger('ServerScripts');
+    logger.info('********************************************************');
+    logger.info('* Inicializando servicio                               *');
+    logger.info('********************************************************');
+    app.use(log4js.connectLogger(log4js.getLogger('AccessLog'), { level: 'auto' }));
+    app.use(bodyParser.urlencoded({ extended: false }));
+    app.use(bodyParser.json({ limit: '5mb' }));
+    app.use(bodyParser.text({ limit: '5mb' }));
+    app.use(bodyParser.raw({ limit: '5mb' }));
+    app.use(cookieParser());
+    app.use(compression());
+    app.use(function (err, req, res, next) {
+        if (err && err instanceof SyntaxError && err.status >= 400 && err.status < 500 && err.message.indexOf('JSON')) {
+            logger.warn('No se pudo parsear contenido JSON de request ' + req.method + ' para \'' + req.path + '\'');
+            res.status(400).json({ status: false, description: 'Invalid JSON', error: 'Invalid JSON' });
+        }
+    });
+    securityShared.InitHeaders(app);
+    logger.info('Servicio ejecutando en modo \'' + server_config_1.SERVER_MODE + '\'');
+    app.enable('trust proxy');
+    app.set('trust proxy', true);
+    app.use(function (req, res, next) {
+        if (req.headers.host.slice(0, 4) !== 'www.' && req.secure) {
+            next();
+        }
+        else if (server_config_1.SERVER_MODE === 'prod') {
+            var newHost = req.headers.host.slice(0, 4) === 'www.' ? req.headers.host.slice(4) : req.headers.host;
+            return res.redirect(301, 'https://' + newHost + req.originalUrl);
+        }
+        else {
+            next();
+        }
+    });
+    if (server_config_1.SERVER_MODE === 'prod') {
+    }
+    else {
+    }
+    app.use('/static', express.static(path.resolve(__dirname, 'static')));
+    if (!app_config_1.IS_DISTRIBUTED_SERVICE) {
+        app.use(securityShared.HstsGuard);
+        app.disable('etag');
+        services.init(app);
+        app.get('/*', function (req, res, next) {
+            if (req.url.match('^\/(api|auth|public|internal|popup|builder|payments|distributed|static|template|client|assets|favicon)(.*)$')) {
+                res.status(404).type('txt').send('Page not found');
+            }
+            else {
+                res.sendFile(path.resolve(__dirname, clientPath + '/index.html'));
+            }
+        });
+    }
+    else {
+        app.get('/*', function (req, res, next) {
+            res.status(404).type('txt').send('Page not found');
+        });
+    }
+    return promises_shared_1.DummyPromise().then().then(function (result) {
+        return new Promise(function (resolve, reject) {
+            if (!server_config_1.HTTP_ENABLED)
+                return resolve(true);
+            logger.info('Iniciando servicio HTTP');
+            console.log('Iniciando servicio HTTP');
+            httpServer = http.createServer(app);
+            httpServer.listen(server_config_1.HTTP_BINDING_PORT, server_config_1.HTTP_BINDING_HOST)
+                .on('listening', function () {
+                logger.info('Servicio HTTP escuchando en: ' + httpServer.address().address + ':' + server_config_1.HTTP_BINDING_PORT.toString());
+                console.log('Servicio HTTP escuchando en: ' + httpServer.address().address + ':' + server_config_1.HTTP_BINDING_PORT.toString());
+                resolve(true);
+            });
+        });
+    }).then(function (result) {
+        return new Promise(function (resolve, reject) {
+            if (!server_config_1.HTTPS_ENABLED)
+                return resolve(true);
+            logger.info('Iniciando servicio HTTPS');
+            console.log('Iniciando servicio HTTPS');
+            httpsServer = https.createServer({
+                key: fs.readFileSync(server_config_1.HTTPS_KEY),
+                cert: fs.readFileSync(server_config_1.HTTPS_CERT)
+            }, app);
+            httpsServer.listen(server_config_1.HTTPS_BINDING_PORT, server_config_1.HTTP_BINDING_HOST)
+                .on('listening', function () {
+                logger.info('Servicio HTTPS escuchando en: ' + httpsServer.address().address + ':' + server_config_1.HTTPS_BINDING_PORT.toString());
+                console.log('Servicio HTTPS escuchando en: ' + httpsServer.address().address + ':' + server_config_1.HTTPS_BINDING_PORT.toString());
+                resolve(true);
+            });
+        });
+    }).then(function (result) {
+        if (!result)
+            logger.error('No se pudo establecer conexión con el servicio de mail.');
+        logger.info('Servicio inicializado correctamente');
+        console.log('Servicio inicializado correctamente');
+    }).catch(function (err) {
+        var errorMsg = (typeof err === 'string' ? err : err.message || err.description || '');
+        logger.info('Error al inicializar el servicio: ' + errorMsg);
+        console.error('Error al inicializar el servicio: ' + errorMsg);
+    });
+}
+exports.init = init;

package/server/interfaces/cleaner.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/server/interfaces/supervisor.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/{src/server/routes-centralized.ts → server/routes-centralized.js}

@@ -1,36 +1,39 @@
-//Rutas que apuntan al centralizado
-export const RoutesCentralized: any = {
-    IC_PARAM_URL_API_USER_AUTH: 'api/api_user/auth',
-    IC_PARAM_URL_API_USER_CREATE: 'api/api_user/create_api_user',
-    IC_PARAM_URL_API_USER_DELETE: 'api/api_user/delete_api_user',
-    IC_PARAM_URL_API_USER_SAVE: 'api/api_user/save_api_user',
-    IC_PARAM_URL_API_USERS_DELETE: 'api/api_user/delete_api_users',
-    IC_PARAM_URL_API_USERS_GET: 'api/api_user/get_api_users/',
-    IC_PARAM_URL_BATCH_BALANCE_DETAIL: 'api/batch/get_batch_balance_detail',
-    IC_PARAM_URL_BATCH_DETAIL_SAVE: 'api/batch/save_batch_detail',
-    IC_PARAM_URL_BATCH_SUMMARY_CLOSE: 'api/batch/close_batch_summary',
-    IC_PARAM_URL_BATCH_SUMMARY_CREATE: 'api/batch/save_batch_summary',
-    IC_PARAM_URL_PLATFORM_ACTIVATE: 'api/activation/activate_platform',
-    IC_PARAM_URL_PLATFORM_AVAILABLE_LICENSE: 'api/activation/get_platform_available_licenses',
-    IC_PARAM_URL_PLATFORM_GET_STATUS: 'api/activation/get_platform_status',
-    IC_PARAM_URL_PLATFORM_VERSION_UPDATE: 'api/platform/save_version',
-    IC_PARAM_URL_VCC_BALANCE_ALLOCATION: 'api/vcc/balance_allocation',
-    IC_PARAM_URL_VCC_CREATE: 'api/vcc/create_vcc',
-    IC_PARAM_URL_VCC_UPDATE: 'api/vcc/update_vcc',
-    IC_PARAM_URL_VCC_GET_STATUS: 'api/vcc/get_vcc_status',
-    IC_PARAM_URL_VCC_GET_RATES: 'api/vcc/get_vcc_rates',
-    IC_PARAM_URL_VCC_GET_BALANCE: 'api/vcc/get_vcc_balance',
-    IC_PARAM_URL_ACCOUNT_GET_ACCOUNT_STATUS_BY_VCC: 'api/account/get_account_status_by_vcc',
-    IC_PARAM_URL_ACCOUNT_GET_BALANCE: 'api/account/get_account_balance',
-    IC_PARAM_URL_ACCOUNT_GET_COSTS: 'api/account/get_costs',
-    IC_PARAM_URL_ACCOUNT_GET_MOVEMENT_CURRENCIES: 'api/account/get_movement_currencies',
-    IC_PARAM_URL_ACCOUNT_GET_MOVEMENTS: 'api/account/get_movements',
-    IC_PARAM_URL_ACCOUNT_GET_VCC: 'api/account/get_vccs_by_account',
-    IC_PARAM_URL_PLATFORM_INSTALLATION_DATA: 'api/platform/get_installation_ids/',
-    IC_PARAM_URL_REPORT_GET_PARAMETERS: 'api/report/get_report_procedure_parameters',
-    IC_PARAM_URL_REPORT_EXECUTE: 'api/report/execute_report',
-    IC_PARAM_URL_BATCH_ID_SEARCH: 'api/batch/search_batch_id',
-    IC_PARAM_URL_BATCH_SUMMARY_CANCEL: 'api/batch/cancel_batch_summary',
-    IC_PARAM_URL_BATCH_SUMMARY_RESUME: 'api/batch/resume_batch_summary',
-    IC_PARAM_URL_CURRENT_BATCHES_GET: 'api/batch/get_current_batches'
-};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesCentralized = {
+    IC_PARAM_URL_API_USER_AUTH: 'api/api_user/auth',
+    IC_PARAM_URL_API_USER_CREATE: 'api/api_user/create_api_user',
+    IC_PARAM_URL_API_USER_DELETE: 'api/api_user/delete_api_user',
+    IC_PARAM_URL_API_USER_SAVE: 'api/api_user/save_api_user',
+    IC_PARAM_URL_API_USERS_DELETE: 'api/api_user/delete_api_users',
+    IC_PARAM_URL_API_USERS_GET: 'api/api_user/get_api_users/',
+    IC_PARAM_URL_BATCH_BALANCE_DETAIL: 'api/batch/get_batch_balance_detail',
+    IC_PARAM_URL_BATCH_DETAIL_SAVE: 'api/batch/save_batch_detail',
+    IC_PARAM_URL_BATCH_SUMMARY_CLOSE: 'api/batch/close_batch_summary',
+    IC_PARAM_URL_BATCH_SUMMARY_CREATE: 'api/batch/save_batch_summary',
+    IC_PARAM_URL_PLATFORM_ACTIVATE: 'api/activation/activate_platform',
+    IC_PARAM_URL_PLATFORM_AVAILABLE_LICENSE: 'api/activation/get_platform_available_licenses',
+    IC_PARAM_URL_PLATFORM_GET_STATUS: 'api/activation/get_platform_status',
+    IC_PARAM_URL_PLATFORM_VERSION_UPDATE: 'api/platform/save_version',
+    IC_PARAM_URL_VCC_BALANCE_ALLOCATION: 'api/vcc/balance_allocation',
+    IC_PARAM_URL_VCC_CREATE: 'api/vcc/create_vcc',
+    IC_PARAM_URL_VCC_UPDATE: 'api/vcc/update_vcc',
+    IC_PARAM_URL_VCC_GET_STATUS: 'api/vcc/get_vcc_status',
+    IC_PARAM_URL_VCC_GET_RATES: 'api/vcc/get_vcc_rates',
+    IC_PARAM_URL_VCC_GET_BALANCE: 'api/vcc/get_vcc_balance',
+    IC_PARAM_URL_ACCOUNT_GET_ACCOUNT_STATUS_BY_VCC: 'api/account/get_account_status_by_vcc',
+    IC_PARAM_URL_ACCOUNT_GET_BALANCE: 'api/account/get_account_balance',
+    IC_PARAM_URL_ACCOUNT_GET_COSTS: 'api/account/get_costs',
+    IC_PARAM_URL_ACCOUNT_GET_MOVEMENT_CURRENCIES: 'api/account/get_movement_currencies',
+    IC_PARAM_URL_ACCOUNT_GET_MOVEMENTS: 'api/account/get_movements',
+    IC_PARAM_URL_ACCOUNT_GET_VCC: 'api/account/get_vccs_by_account',
+    IC_PARAM_URL_PLATFORM_INSTALLATION_DATA: 'api/platform/get_installation_ids/',
+    IC_PARAM_URL_REPORT_GET_PARAMETERS: 'api/report/get_report_procedure_parameters',
+    IC_PARAM_URL_REPORT_EXECUTE: 'api/report/execute_report',
+    IC_PARAM_URL_BATCH_ID_SEARCH: 'api/batch/search_batch_id',
+    IC_PARAM_URL_BATCH_SUMMARY_CANCEL: 'api/batch/cancel_batch_summary',
+    IC_PARAM_URL_BATCH_SUMMARY_RESUME: 'api/batch/resume_batch_summary',
+    IC_PARAM_URL_CURRENT_BATCHES_GET: 'api/batch/get_current_batches',
+    IC_PARAM_URL_TRANSCRIPTION_ENGINE_STATUS_GET: 'api/batch/get_transcription_engine_availability',
+    IC_PARAM_URL_TRANSCRIPTION_ENGINE_STATUS_SAVE: 'api/batch/save_transcription_engine_availability'
+};

package/server/routes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var services = require("./services/index");
+function init(app) {
+    services.init(app);
+}
+exports.init = init;

package/server/services/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var log4js = require("log4js");
+var logger = log4js.getLogger('ServerScripts');
+function init(app) {
+    logger.info('Incializando servicios');
+}
+exports.init = init;

package/server/services/routes.service.js

@@ -0,0 +1,18 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@angular/core");
+var LanguageService = (function () {
+    function LanguageService() {
+    }
+    LanguageService = __decorate([
+        core_1.Injectable()
+    ], LanguageService);
+    return LanguageService;
+}());
+exports.LanguageService = LanguageService;