saherelm
f7040490c8
add XCHVWAP Indicator, extends it's Helper class and implement it's usage inside XCH strategy ...
890 lines
18 KiB
JavaScript
890 lines
18 KiB
JavaScript
/**
|
|
* XFile Tools Module ...
|
|
* a module for handle all file/folder manipulating task in node js ...
|
|
*
|
|
* Maintainer
|
|
*
|
|
* Hadi Khazaee Asl <https://saherelm.ir> (hadi_khazaee_asl@yahoo.com)
|
|
*/
|
|
|
|
//
|
|
//#region Module Imports ...
|
|
const fs = require('fs');
|
|
const os = require('os');
|
|
const Path = require('path');
|
|
const http = require('http');
|
|
const https = require('https');
|
|
const XValueTools = require('./x-value.tools');
|
|
//#endregion
|
|
|
|
//
|
|
//#region Constants ...
|
|
/**
|
|
* current os path separators ...
|
|
*/
|
|
const PathSeparator = Path.sep;
|
|
|
|
/**
|
|
* current directory ...
|
|
*/
|
|
const CurrentDir = __dirname;
|
|
//#endregion
|
|
|
|
//
|
|
//#region Actions ...
|
|
//
|
|
//#region Global ...
|
|
/**
|
|
* retrieve a path status ...
|
|
*
|
|
* @param {string} path a path value to check ...
|
|
* @returns an stat object ...
|
|
*/
|
|
function getStatus(path = '') {
|
|
//
|
|
if (!XValueTools.isValidArg(path)) {
|
|
return undefined;
|
|
}
|
|
|
|
//
|
|
return fs.statSync(path);
|
|
}
|
|
|
|
/**
|
|
* retrieve user's Home path ...
|
|
*
|
|
* @returns {string} a path ...
|
|
*/
|
|
function getHomePath() {
|
|
return os.homedir();
|
|
}
|
|
//#endregion
|
|
|
|
//
|
|
//#region Path ...
|
|
/**
|
|
* retrieve the base name of specific address path ...
|
|
*
|
|
* @param {string} path address of file or folder ...
|
|
* @returns string ...
|
|
*/
|
|
function basename(path = '') {
|
|
//
|
|
if (!XValueTools.isValidArg(path)) {
|
|
return '';
|
|
}
|
|
|
|
//
|
|
const result = Path.basename(path);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* join several path segments together ...
|
|
*
|
|
* @param {...string} path path params ...
|
|
* @returns a joined paths ...
|
|
*/
|
|
function joinPath(...path) {
|
|
return Path.join(...path);
|
|
}
|
|
|
|
/**
|
|
* resolve a relative path to absolute ...
|
|
*
|
|
* @param {string[]} path a path value to check ...
|
|
* @returns {string}
|
|
*/
|
|
function resolvePath(...path) {
|
|
return Path.resolve(...path);
|
|
}
|
|
//#endregion
|
|
|
|
//
|
|
//#region File ...
|
|
/**
|
|
* determines a path destination is a file or not ...
|
|
*
|
|
* @param {string} path a path value to check ...
|
|
* @returns a boolean value ...
|
|
*/
|
|
function isFileExists(path = '') {
|
|
//
|
|
if (!XValueTools.isValidArg(path)) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
try {
|
|
const stat = getStatus(path);
|
|
if (!stat) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
return stat.isFile();
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* remove a file ...
|
|
*
|
|
* @param {string} path a file path ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
function removeFile(path = '') {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isFileExists(path)) {
|
|
resolve(false);
|
|
}
|
|
|
|
//
|
|
fs.unlink(path, (err) => {
|
|
//
|
|
if (err) {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* copy a file to destination path ...
|
|
*
|
|
* @param {string} source source file path ...
|
|
* @param {string} dest dest folder path ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
function copyFile(
|
|
source = '',
|
|
dest = ''
|
|
) {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (
|
|
!isFileExists(source) ||
|
|
!isDirectoryExists(dest)
|
|
) {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
const destFilePath = Path.join(dest, Path.basename(source));
|
|
fs.copyFile(source, destFilePath, (err) => {
|
|
//
|
|
if (err) {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* reading specified file content ...
|
|
*
|
|
* @param {string} path a file path ...
|
|
* @returns {Promise<string>} file content ...
|
|
*/
|
|
function readFile(path = '') {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isFileExists(path)) {
|
|
resolve('');
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.readFile(path, 'utf8', (err, content) => {
|
|
//
|
|
if (err) {
|
|
resolve(undefined);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(content);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* write content to a file ...
|
|
*
|
|
* @param {string} path a file path ...
|
|
* @param {string} content the content which going to write to the file ...
|
|
* @param {bool} overwrite determines file overwrite if exists ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
function writeFile(
|
|
path = '',
|
|
content = '',
|
|
overwrite = true
|
|
) {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (isFileExists(path) && !overwrite) {
|
|
//
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Normalize Content ...
|
|
content = XValueTools.isValidArg(content) ?
|
|
content :
|
|
'';
|
|
|
|
//
|
|
fs.writeFile(path, content, (err) => {
|
|
//
|
|
if (err) {
|
|
//
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* create a file ...
|
|
*
|
|
* @param {string} path file path ...
|
|
* @param {string} fileName file name ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
function createFile(
|
|
path = '',
|
|
fileName = ''
|
|
) {
|
|
return new Promise((resolve) => {
|
|
//
|
|
const filePath = Path.join(path, fileName);
|
|
if (
|
|
isFileExists(filePath) ||
|
|
!XValueTools.isValidArg(path) ||
|
|
!XValueTools.isValidArg(fileName)
|
|
) {
|
|
//
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.writeFile(filePath, '', (err) => {
|
|
//
|
|
if (err) {
|
|
//
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* remove a file name extension ...
|
|
*
|
|
* @param {string} name
|
|
* @returns {string} name without extension ...
|
|
*/
|
|
function removeFileExtension(name = '') {
|
|
return name.substring(0, name.lastIndexOf('.')) || name;
|
|
}
|
|
|
|
/**
|
|
* retrieve a file extension ...
|
|
*
|
|
* @param {string} path a path which locate a file ...
|
|
* @returns {string}
|
|
*/
|
|
function getFileExtension(path = '') {
|
|
//
|
|
let result = "";
|
|
|
|
//
|
|
// Validate Arg ...
|
|
if (
|
|
!XValueTools.isValidArg(path)
|
|
|| !isFileExists(path)
|
|
) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Retrieve just file name ...
|
|
const fileName = basename(path);
|
|
result = fileName.replace(
|
|
removeFileExtension(fileName),
|
|
""
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* retrieve all files list recursively from specific path ...
|
|
*
|
|
* @param {string} path a source folder path ...
|
|
* @param {string[]} extensions which file extensions need to be listed, live empty for all files ...
|
|
* @returns {Promise<string[]>}
|
|
*/
|
|
async function getRecursiveFilesList(
|
|
path = "",
|
|
extensions = []
|
|
) {
|
|
//
|
|
let result = [];
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
!XValueTools.isValidArg(path)
|
|
|| !isDirectoryExists(path)
|
|
) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
const contents = await getDirectoryContents(path);
|
|
for (const item of contents) {
|
|
//
|
|
const itemPath = joinPath(
|
|
path,
|
|
item
|
|
);
|
|
|
|
//
|
|
const isItemFile = isFileExists(itemPath);
|
|
if (isItemFile) {
|
|
//
|
|
const itemFileExtension = getFileExtension(itemPath);
|
|
const isFileInSupportedExtensions =
|
|
extensions === undefined || extensions.length === 0
|
|
? true
|
|
: extensions.includes(itemFileExtension)
|
|
;
|
|
if (isFileInSupportedExtensions) {
|
|
result.push(itemPath);
|
|
}
|
|
} else if (isDirectoryExists(itemPath)) {
|
|
//
|
|
const itemPathFiles = await getRecursiveFilesList(itemPath, extensions);
|
|
result.push(...itemPathFiles);
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Extract Specific files from a folder and it's content ...
|
|
*
|
|
* @param {string} path Folder Path ...
|
|
* @returns
|
|
*/
|
|
async function extractFiles(path = "", ext = [], excludeWorkspaceFolders = []) {
|
|
//
|
|
const result = [];
|
|
|
|
//
|
|
if (!ext || ext.length == 0) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
const pathContent = await getDirectoryContents(path);
|
|
if (!pathContent || pathContent.length == 0) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Loop through Content ...
|
|
for (const c of pathContent) {
|
|
//
|
|
// Prepare full path ...
|
|
const cPath = joinPath(path, c);
|
|
|
|
//
|
|
// check content path is file or not ...
|
|
const isCFile = isFileExists(cPath);
|
|
const isCDirectory = isDirectoryExists(cPath);
|
|
if (isCFile) {
|
|
//
|
|
// Check it is MQL file or not ...
|
|
const cExt = getFileExtension(cPath);
|
|
if (ext.includes(cExt)) {
|
|
result.push(cPath);
|
|
}
|
|
} else if (isCDirectory) {
|
|
//
|
|
const destFolderName = basename(cPath);
|
|
const isExcluded = excludeWorkspaceFolders.includes(destFolderName);
|
|
if (isExcluded) {
|
|
continue;
|
|
}
|
|
|
|
//
|
|
const cFiles = await extractFiles(cPath, ext);
|
|
if (cFiles && cFiles.length > 0) {
|
|
result.push(...cFiles);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
//#endregion
|
|
|
|
//
|
|
//#region Directory ...
|
|
/**
|
|
* create a directory ...
|
|
*
|
|
* @param {string} path destination path including dir name ...
|
|
* @param {boolean} recursive create directories recursively ...
|
|
* @returns action done or not ...
|
|
*/
|
|
function createDirectory(
|
|
path = '',
|
|
recursive = true
|
|
) {
|
|
//
|
|
let result = false;
|
|
|
|
//
|
|
if (
|
|
isDirectoryExists(path) ||
|
|
!XValueTools.isValidArg(path)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
try {
|
|
//
|
|
fs.mkdirSync(path, { recursive: recursive });
|
|
result = true;
|
|
return result;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* remove a directory ...
|
|
*
|
|
* @param {string} path destination path including dir name ...
|
|
* @param {boolean} recursive removes directories recursively ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
function removeDirectory(
|
|
path = '',
|
|
recursive = false
|
|
) {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isDirectoryExists(path)) {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.rm(path, {
|
|
recursive
|
|
}, (err) => {
|
|
//
|
|
if (err) {
|
|
resolve(false);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(true);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* determines a path destination is a directory or not ...
|
|
*
|
|
* @param {string} path a folder path ...
|
|
* @returns represent destnation path is Directory or not ...
|
|
*/
|
|
function isDirectoryExists(path = '') {
|
|
//
|
|
if (!XValueTools.isValidArg(path)) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
try {
|
|
//
|
|
const isExists = fs.existsSync(path);
|
|
if (!isExists) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
const stat = getStatus(path);
|
|
if (!stat) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
const result = stat.isDirectory();
|
|
return result;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* retrieve a directory content ...
|
|
*
|
|
* @param {string} path a folder path ...
|
|
* @returns {Promise<string[]>} a collection of folder files ...
|
|
*/
|
|
function getDirectoryContents(path = '') {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isDirectoryExists(path)) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.readdir(path, (err, content) => {
|
|
//
|
|
if (err) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
resolve(content);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* retrieve a directory files ...
|
|
*
|
|
* @param {string} path a folder path ...
|
|
* @returns {Promise<string[]>} a collection of folder files ...
|
|
*/
|
|
function getDirectoryFiles(
|
|
path = '',
|
|
containsHiddenFiles = false
|
|
) {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isDirectoryExists(path)) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.readdir(path, (err, content) => {
|
|
//
|
|
if (err) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
if (!containsHiddenFiles) {
|
|
content = content.filter(c => !c.startsWith('.'));
|
|
}
|
|
|
|
//
|
|
const result = [];
|
|
content
|
|
.forEach(c => {
|
|
//
|
|
const cPath = Path.join(path, c);
|
|
if (isFileExists(cPath)) {
|
|
result.push(c);
|
|
}
|
|
});
|
|
|
|
//
|
|
resolve(result);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* retrieve a directory folders ...
|
|
*
|
|
* @param {string} path a folder path ...
|
|
* @returns {Promise<string[]>} a collection of folder names ...
|
|
*/
|
|
function getDirectoryFolders(path = '') {
|
|
return new Promise((resolve) => {
|
|
//
|
|
if (!isDirectoryExists(path)) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
fs.readdir(path, (err, content) => {
|
|
//
|
|
if (err) {
|
|
resolve([]);
|
|
return;
|
|
}
|
|
|
|
//
|
|
const result = [];
|
|
content.forEach(c => {
|
|
//
|
|
const cPath = Path.join(path, c);
|
|
if (isDirectoryExists(cPath)) {
|
|
result.push(c);
|
|
}
|
|
});
|
|
|
|
//
|
|
resolve(result);
|
|
});
|
|
});
|
|
}
|
|
|
|
/**
|
|
* copy a folder with all of it's content to dest ...
|
|
*
|
|
* @param {string} source source folder path ...
|
|
* @param {string} dest dest folder path ...
|
|
* @returns {Promise<boolean>} action done or not ...
|
|
*/
|
|
async function copyFolder(
|
|
source = '',
|
|
dest = ''
|
|
) {
|
|
//
|
|
if (
|
|
!isDirectoryExists(source) ||
|
|
!XValueTools.isValidArg(dest) ||
|
|
!XValueTools.isValidArg(source)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
//
|
|
const folderName = Path.basename(source);
|
|
const destPath = Path.join(dest, folderName);
|
|
|
|
//
|
|
// Create Dest Path folder if not exists ...
|
|
if (!isDirectoryExists(destPath)) {
|
|
//
|
|
let result = createDirectory(destPath, true);
|
|
if (!result) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Files ...
|
|
const files = await getDirectoryFiles(source);
|
|
if (files && files.constructor === Array && files.length > 0) {
|
|
//
|
|
const filesPromises = files.map(file => copyFile(Path.join(source, file), destPath));
|
|
const filesResult = (await Promise.all(filesPromises)).every(r => !!r);
|
|
if (!filesResult) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Folders ...
|
|
const folders = await getDirectoryFolders(source);
|
|
if (folders && folders.constructor === Array && folders.length > 0) {
|
|
//
|
|
const folderPromises = folders.map(folder => copyFolder(Path.join(source, folder), destPath));
|
|
const filesResult = (await Promise.all(folderPromises)).every(r => !!r);
|
|
if (!filesResult) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//
|
|
return true;
|
|
}
|
|
//#endregion
|
|
|
|
//
|
|
//#region Downloader ...
|
|
/**
|
|
* download a file from specific url and store it ...
|
|
*
|
|
* @param {string} filepath the file name and path which required to put download file on it ...
|
|
* @param {string} url the web url for downloading ...
|
|
*/
|
|
function download(filepath, url) {
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
!XValueTools.isValidArg(url)
|
|
|| !XValueTools.isValidURL(url)
|
|
|| !XValueTools.isValidArg(filepath)
|
|
) {
|
|
return;
|
|
}
|
|
|
|
//
|
|
var file = fs.createWriteStream(filepath);
|
|
|
|
//
|
|
if (url.startsWith('https:')) {
|
|
https.get(url, function (response) {
|
|
response.pipe(file);
|
|
});
|
|
} else if (url.startsWith('http:')) {
|
|
http.get(url, function (response) {
|
|
response.pipe(file);
|
|
});
|
|
}
|
|
}
|
|
//#endregion
|
|
|
|
//
|
|
//#region JSON ...
|
|
/**
|
|
* read and parse a JSON content from a file ...
|
|
*
|
|
* @param {string} path source file path ...
|
|
* @returns {any}
|
|
*/
|
|
function readJSON(path = "") {
|
|
//
|
|
// Validate Args ...
|
|
if (!isFileExists(path)) {
|
|
return undefined;
|
|
}
|
|
|
|
//
|
|
let result = undefined;
|
|
try {
|
|
result = require(path);
|
|
} catch {
|
|
result = undefined;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* write a JSON Object content into a file ...
|
|
*
|
|
* @param {string} path dest file path ...
|
|
* @param {any} content an object which required to write to file ...
|
|
* @returns {Promise<boolean>}
|
|
*/
|
|
async function writeJSON(
|
|
path = "",
|
|
content = undefined
|
|
) {
|
|
//
|
|
let result = false;
|
|
|
|
//
|
|
// Validate Args ...
|
|
if (!XValueTools.isValidArg(path)) {
|
|
return result;
|
|
}
|
|
|
|
//
|
|
// Normallize Content ...
|
|
if (content === undefined) {
|
|
content = {};
|
|
}
|
|
|
|
//
|
|
const contentString = XValueTools.beautifyJSON(content);
|
|
|
|
//
|
|
result = await writeFile(
|
|
path,
|
|
contentString,
|
|
true
|
|
);
|
|
|
|
//
|
|
return result;
|
|
}
|
|
//#endregion
|
|
//#endregion
|
|
|
|
//
|
|
//#region Module Exports ...
|
|
module.exports = {
|
|
//
|
|
CurrentDir,
|
|
PathSeparator,
|
|
|
|
//
|
|
getStatus,
|
|
getHomePath,
|
|
|
|
//
|
|
basename,
|
|
joinPath,
|
|
resolvePath,
|
|
|
|
//
|
|
download,
|
|
|
|
//
|
|
readJSON,
|
|
writeJSON,
|
|
|
|
//
|
|
copyFile,
|
|
readFile,
|
|
writeFile,
|
|
createFile,
|
|
removeFile,
|
|
isFileExists,
|
|
getFileExtension,
|
|
removeFileExtension,
|
|
getRecursiveFilesList,
|
|
extractFiles,
|
|
|
|
//
|
|
copyFolder,
|
|
createDirectory,
|
|
removeDirectory,
|
|
createDirectory,
|
|
removeDirectory,
|
|
isDirectoryExists,
|
|
isDirectoryExists,
|
|
getDirectoryFiles,
|
|
getDirectoryFolders,
|
|
getDirectoryContents,
|
|
};
|
|
//#endregion
|