intermediate-component-sa 1.0.5-s → 1.1.1

package/server/shared/file-manager.js

@@ -0,0 +1,616 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var log4js = require("log4js");
+var moment = require("moment");
+var path = require("path");
+var fs = require("fs");
+var ncp = require("ncp");
+var mkdirp = require("mkdirp");
+var rimraf = require("rimraf");
+var multer = require("multer");
+var extract = require("extract-zip");
+var child_process = require("child_process");
+var fse = require('fs-extra');
+var zipFolder = require('zip-folder');
+var mv = require('mv');
+var app_config_1 = require("../config/app.config");
+var promises_shared_1 = require("./promises.shared");
+var exec = child_process.exec;
+var logger = log4js.getLogger('ServerScripts');
+function PipeWriteFile(response, file) {
+    var Promise = require('bluebird');
+    var ended = false;
+    return new Promise(function (resolve, reject) {
+        response.pipe(file);
+        function nice_ending() {
+            if (!ended) {
+                ended = true;
+                resolve(true);
+            }
+        }
+        function error_ending() {
+            if (!ended) {
+                ended = true;
+                reject(false);
+            }
+        }
+        file.on('finish', nice_ending);
+        file.on('end', nice_ending);
+        file.on('error', error_ending);
+        file.on('close', error_ending);
+    }).finally(function () { return file.close(); });
+}
+exports.PipeWriteFile = PipeWriteFile;
+function DeleteFileSync(file) {
+    var fs = require('fs');
+    fs.unlinkSync(file);
+}
+exports.DeleteFileSync = DeleteFileSync;
+function FileProperty(filePath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            var result = {};
+            if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
+                var fileStat = fs.lstatSync(filePath);
+                var creationDate = moment(fileStat.birthtime);
+                var updateDate = moment(fileStat.mtime);
+                result = {
+                    path: filePath,
+                    isFile: fileStat.isFile(),
+                    creationDate: creationDate,
+                    updateDate: updateDate
+                };
+            }
+            resolve(result);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.FileProperty = FileProperty;
+function ListFolderContent(folderPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            var result_1 = [];
+            if (fs.existsSync(folderPath) && fs.lstatSync(folderPath).isDirectory()) {
+                var files = fs.readdirSync(folderPath);
+                files.forEach(function (fileName) {
+                    var filePath = path.join(folderPath, fileName);
+                    var fileStat = fs.lstatSync(filePath);
+                    var creationDate = moment(fileStat.birthtime);
+                    var updateDate = moment(fileStat.mtime);
+                    result_1.push({
+                        name: fileName,
+                        path: filePath,
+                        isFolder: fileStat.isDirectory(),
+                        creationDate: creationDate,
+                        updateDate: updateDate,
+                    });
+                });
+            }
+            resolve(result_1);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.ListFolderContent = ListFolderContent;
+function CreateFolder(folderName) {
+    return ExistInFileSystem(folderName)
+        .then(function (result) {
+        if (result)
+            return true;
+        return new Promise(function (resolve, reject) {
+            try {
+                mkdirp(folderName, function (err) {
+                    resolve(err === null || err === undefined);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+exports.CreateFolder = CreateFolder;
+function ExistInFileSystem(fileSystemPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            fs.stat(fileSystemPath, function (err, stat) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.ExistInFileSystem = ExistInFileSystem;
+function TouchPath(fileSystemPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            var now = moment().toDate();
+            fs.utimes(fileSystemPath, now, now, function (err) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.TouchPath = TouchPath;
+function CopyFile(sourcePath, targetPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            fse.copy(sourcePath, targetPath, function (err) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.CopyFile = CopyFile;
+function CopyFolder(sourcePath, targetPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            fs.stat(targetPath, function (err, stat) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    }).then(function (resultExists) {
+        if (resultExists)
+            return true;
+        return new Promise(function (resolve, reject) {
+            try {
+                mkdirp(targetPath, function (err) {
+                    resolve(err === null || err === undefined);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    }).then(function (resultMkDir) {
+        return new Promise(function (resolve, reject) {
+            try {
+                ncp.ncp(sourcePath, targetPath, function (err) {
+                    resolve(err === null || err === undefined);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+exports.CopyFolder = CopyFolder;
+function MoveFolder(sourceFolder, destFolder) {
+    return ExistInFileSystem(sourceFolder)
+        .then(function (result) {
+        if (!result)
+            throw 'El directorio \'' + sourceFolder + '\' no existe';
+        return new Promise(function (resolve, reject) {
+            try {
+                fs.rename(sourceFolder, destFolder, function (err) {
+                    resolve(err === null || err === undefined);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+exports.MoveFolder = MoveFolder;
+function MoveFolderOtherDevice(sourceFolder, destFolder) {
+    return ExistInFileSystem(sourceFolder)
+        .then(function (result) {
+        if (!result)
+            throw 'El directorio \'' + sourceFolder + '\' no existe';
+        return new Promise(function (resolve, reject) {
+            try {
+                mv(sourceFolder, destFolder, function (err) {
+                    resolve(err === null || err === undefined);
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+exports.MoveFolderOtherDevice = MoveFolderOtherDevice;
+function DeleteFolder(folderPath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            rimraf(folderPath, function (err) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.DeleteFolder = DeleteFolder;
+function DeleteFile(filePath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            fs.unlink(filePath, function (err) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.DeleteFile = DeleteFile;
+function ReadFileContent(fileName, encode, safe) {
+    logger.info('ReadFileContent: ', fileName);
+    return new Promise(function (resolve, reject) {
+        try {
+            fs.readFile(fileName, encode, function (err, data) {
+                if (err) {
+                    if (safe) {
+                        return resolve(null);
+                    }
+                    else {
+                        return reject(err);
+                    }
+                }
+                else {
+                    return resolve(data);
+                }
+            });
+        }
+        catch (e) {
+            logger.info('ReadFileContent - error: ', e);
+            if (safe)
+                resolve(null);
+            else
+                reject(e);
+        }
+    });
+}
+exports.ReadFileContent = ReadFileContent;
+function FileToBase64(file) {
+    return new Promise(function (resolve, reject) {
+        try {
+            var buffer = fs.readFileSync(file);
+            return resolve(new Buffer(buffer).toString('base64'));
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.FileToBase64 = FileToBase64;
+function BufferFile(file) {
+    return new Promise(function (resolve, reject) {
+        try {
+            var buffer = fs.readFileSync(file);
+            return resolve(buffer);
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.BufferFile = BufferFile;
+function WriteFileContent(fileName, data, encode, safe) {
+    return new Promise(function (resolve, reject) {
+        try {
+            fs.writeFile(fileName, data, { encoding: encode }, function (err) {
+                if (err) {
+                    if (safe)
+                        return resolve(null);
+                    else
+                        return reject(err);
+                }
+                else {
+                    return resolve(true);
+                }
+            });
+        }
+        catch (e) {
+            if (safe)
+                resolve(null);
+            else
+                reject(e);
+        }
+    });
+}
+exports.WriteFileContent = WriteFileContent;
+function ZipFolder(srcFolder, zipFilePath) {
+    return new Promise(function (resolve, reject) {
+        try {
+            zipFolder(srcFolder, zipFilePath, function (err) {
+                resolve(err === null || err === undefined);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.ZipFolder = ZipFolder;
+function UnZipFolder(zipFilePath, destinationPath) {
+    destinationPath = destinationPath || zipFilePath;
+    return new Promise(function (resolve, reject) {
+        try {
+            extract(zipFilePath, {
+                dir: destinationPath
+            }, function (err) {
+                if (err) {
+                    return reject(err);
+                }
+                else {
+                    return resolve(true);
+                }
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+exports.UnZipFolder = UnZipFolder;
+function UnRarFolder(rarFilePath, destinationPath) {
+    destinationPath = destinationPath || rarFilePath;
+    return CreateFolder(destinationPath)
+        .then(function (result) {
+        if (!result)
+            throw 'No se pudo crear el directorio \'' + destinationPath + '\'';
+        return new Promise(function (resolve, reject) {
+            try {
+                var cmd = 'unrar x "' + rarFilePath + '" "' + destinationPath + '"';
+                exec(cmd, function (err, stdout, stderr) {
+                    if (err) {
+                        return reject(err);
+                    }
+                    else {
+                        return resolve(true);
+                    }
+                });
+            }
+            catch (e) {
+                reject(e);
+            }
+        });
+    });
+}
+exports.UnRarFolder = UnRarFolder;
+function GetFolderTree(folderPath, extensionExclude, extensionFilter) {
+    return new Promise(function (resolve, reject) {
+        extensionExclude = extensionExclude || [];
+        extensionFilter = extensionFilter || [];
+        var walk = function (dir, obj, done) {
+            fs.readdir(dir, function (err, list) {
+                if (err)
+                    return done(err);
+                var pending = list.length;
+                if (!pending)
+                    return done(null);
+                list.forEach(function (fileName) {
+                    var filePath = path.resolve(dir, fileName);
+                    fs.stat(filePath, function (err, stat) {
+                        if (stat && stat.isDirectory()) {
+                            var objDirectory_1 = {
+                                name: fileName,
+                                relativePath: path.relative(folderPath, filePath).replace(/\\/g, '/'),
+                                fullPath: filePath,
+                                type: 'directory',
+                                children: []
+                            };
+                            obj.push(objDirectory_1);
+                            walk(filePath, objDirectory_1.children, function (err, res) {
+                                objDirectory_1.size = objDirectory_1.children.reduce(function (prev, cur) { return prev + cur.size; }, 0);
+                                if (!--pending)
+                                    done(null);
+                            });
+                        }
+                        else {
+                            var fileExtension = path.extname(fileName).toLowerCase().slice(1);
+                            var skipFile = false;
+                            if (fileExtension && extensionExclude.length && extensionExclude.indexOf(fileExtension) >= 0)
+                                skipFile = true;
+                            if (extensionFilter.length && (extensionFilter.indexOf(fileExtension) === -1 || !fileExtension))
+                                skipFile = true;
+                            if (!skipFile) {
+                                var objFile = {
+                                    name: fileName,
+                                    type: 'file',
+                                    extension: fileExtension,
+                                    relativePath: path.relative(folderPath, filePath).replace(/\\/g, '/'),
+                                    fullPath: filePath,
+                                    size: stat.size
+                                };
+                                obj.push(objFile);
+                            }
+                            if (!--pending)
+                                done(null);
+                        }
+                    });
+                });
+            });
+        };
+        var folderName = path.basename(folderPath);
+        var objMainDirectory = {
+            name: folderName,
+            type: 'directory',
+            relativePath: path.relative(folderPath, folderPath).replace(/\\/g, '/'),
+            fullPath: folderPath,
+            children: []
+        };
+        var folderTree = [];
+        folderTree.push(objMainDirectory);
+        walk(folderPath, objMainDirectory.children, function (err, results) {
+            if (err)
+                return reject(err);
+            objMainDirectory.size = objMainDirectory.children.reduce(function (prev, cur) { return prev + cur.size; }, 0);
+            resolve(folderTree);
+        });
+    });
+}
+exports.GetFolderTree = GetFolderTree;
+function GetFolderFiles(folderPath, extensionExclude, extensionFilter, recursive) {
+    return new Promise(function (resolve, reject) {
+        extensionExclude = extensionExclude || [];
+        extensionFilter = extensionFilter || [];
+        recursive = (recursive === true);
+        var walk = function (dir, obj, done) {
+            fs.readdir(dir, function (err, list) {
+                if (err)
+                    return done(err);
+                var pending = list.length;
+                if (!pending)
+                    return done(null);
+                list.forEach(function (fileName) {
+                    var filePath = path.resolve(dir, fileName);
+                    fs.stat(filePath, function (err, stat) {
+                        if (stat && stat.isDirectory()) {
+                            var objDirectory = {
+                                name: fileName,
+                                relativePath: path.relative(folderPath, filePath).replace(/\\/g, '/'),
+                                fullPath: filePath,
+                                type: 'directory',
+                                children: []
+                            };
+                            obj.push(objDirectory);
+                            if (recursive) {
+                                walk(filePath, obj, function (err, res) {
+                                    if (!--pending)
+                                        done(null);
+                                });
+                            }
+                            else {
+                                if (!--pending)
+                                    done(null);
+                            }
+                        }
+                        else {
+                            var fileExtension = path.extname(fileName).toLowerCase().slice(1);
+                            var skipFile = false;
+                            if (fileExtension && extensionExclude.length && extensionExclude.indexOf(fileExtension) >= 0)
+                                skipFile = true;
+                            if (extensionFilter.length && (extensionFilter.indexOf(fileExtension) === -1 || !fileExtension))
+                                skipFile = true;
+                            if (!skipFile) {
+                                var objFile = {
+                                    name: fileName,
+                                    type: 'file',
+                                    extension: fileExtension,
+                                    relativePath: path.relative(folderPath, filePath).replace(/\\/g, '/'),
+                                    fullPath: filePath,
+                                    size: stat.size
+                                };
+                                obj.push(objFile);
+                            }
+                            if (!--pending)
+                                done(null);
+                        }
+                    });
+                });
+            });
+        };
+        var folderFiles = [];
+        walk(folderPath, folderFiles, function (err, results) {
+            if (err) {
+                var errorMsg = (typeof err === 'string' ? err : err.message || err.description || '');
+                logger.error('Error al consultar archivos de la carpeta snapshot \'' + folderPath + '\': ' + errorMsg);
+                resolve([]);
+            }
+            else {
+                resolve(folderFiles);
+            }
+        });
+    });
+}
+exports.GetFolderFiles = GetFolderFiles;
+function UploadFileToServer(fileName, destFolder, req, res, types, fieldName, single, replace, fileSizeLimit) {
+    single = (single === false ? single : true);
+    fieldName = (fieldName ? fieldName : 'file');
+    replace = (replace === false ? replace : true);
+    fileSizeLimit = (fileSizeLimit ? fileSizeLimit : app_config_1.FILE_UPLOAD_LIMIT);
+    req.multerCounter = 0;
+    var storageEngine = multer.diskStorage({
+        destination: function (req, file, cb) {
+            cb(null, destFolder);
+        },
+        filename: function (req, file, cb) {
+            cb(null, fileName || file.originalname);
+        }
+    });
+    var fileFilter = function (req, file, cb) {
+        req.multerCounter++;
+        var typesRegEx = '\.(' + (types.toLowerCase() || '.+') + ')$';
+        var regEx = new RegExp(typesRegEx);
+        if (types && !file.originalname.toLowerCase().match(regEx)) {
+            logger.error('El archivo recibido no está dentro de los tipos permitidos  (' + types.toLowerCase() + ').');
+            return cb(new Error('Only ' + types.toLowerCase() + ' files are allowed!'));
+        }
+        if (replace) {
+            cb(null, true);
+        }
+        else {
+            ExistInFileSystem(path.join(destFolder, file.originalname))
+                .then(function (result) {
+                return cb(null, !result);
+            });
+        }
+    };
+    var upload;
+    if (single) {
+        upload = multer({
+            storage: storageEngine,
+            fileFilter: fileFilter,
+            limits: { fileSize: fileSizeLimit },
+        }).single(fieldName);
+    }
+    else {
+        upload = multer({
+            storage: storageEngine,
+            fileFilter: fileFilter,
+            limits: { fileSize: fileSizeLimit },
+        }).array(fieldName);
+    }
+    var tempFilename = path.join(destFolder, fileName);
+    return promises_shared_1.DummyPromise()
+        .then(function (result) {
+        if (!fileName)
+            return true;
+        return DeleteFolder(tempFilename);
+    }).then(function (resultDelete) {
+        if (!resultDelete)
+            throw 'Cannot delete existing file \'' + tempFilename + '\'';
+        return new Promise(function (resolve, reject) {
+            return upload(req, res, function (err) {
+                if (err && err.code === 'LIMIT_FILE_SIZE') {
+                    logger.error('El archivo recibido supera el límite permitido (' + fileSizeLimit.toString() + 'bytes).');
+                    reject('ERROR_FILE_UPLOAD_LIMIT' + '|' + (Math.round(100.00 * fileSizeLimit / 1024 / 1024) / 100.00).toString());
+                }
+                else if (err) {
+                    logger.error('Error al subir archivo: ' + err);
+                    reject(err);
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        });
+    });
+}
+exports.UploadFileToServer = UploadFileToServer;
+function JoinPath(route, fileName) {
+    return path.join(route, fileName);
+}
+exports.JoinPath = JoinPath;

package/server/shared/http.shared.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var url = require("url");
+var jwt = require("jsonwebtoken");
+var log4js = require("log4js");
+var jwt_config_1 = require("../config/jwt.config");
+var logger = log4js.getLogger('ServerScripts');
+function GetDomainFromRequestHost(requestHost) {
+    var host = requestHost || '';
+    if (host.match(/^http:\/\//))
+        host = host.substring(7);
+    if (host.match(/^https:\/\//))
+        host = host.substring(8);
+    if (host.match(/^www\./))
+        host = host.substring(4);
+    if (!/http:/.test(host) && !/https:/.test(host))
+        host = 'http://' + host;
+    var requestDomain = url.parse(host).hostname;
+    return requestDomain;
+}
+exports.GetDomainFromRequestHost = GetDomainFromRequestHost;
+function GetRequestUser(authorizationHeader) {
+    var session = authorizationHeader || '';
+    var userId;
+    try {
+        session = session.replace(/^Bearer /i, '');
+        if (session) {
+            var decoded = jwt.verify(session, jwt_config_1.JWT_SECRET);
+            if (decoded.userId)
+                userId = decoded.userId;
+        }
+    }
+    catch (err) {
+        var errMsg = (typeof err === 'string' ? err : err.message || err.description || '');
+        logger.error('Error al decodificar datos de la sesion: ' + errMsg);
+    }
+    return userId;
+}
+exports.GetRequestUser = GetRequestUser;

package/server/shared/promises.shared.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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;