gyomu 0.1.0

package/lib/holidays.js

@@ -0,0 +1,200 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _MarketDateAccess_instances, _MarketDateAccess_market, _MarketDateAccess_holidays, _MarketDateAccess_initDataLoad;
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_1 = __importDefault(require("date-fns/format"));
+const addDays_1 = __importDefault(require("date-fns/addDays"));
+const subDays_1 = __importDefault(require("date-fns/subDays"));
+const date_fns_1 = require("date-fns");
+const dateOperation_1 = require("./dateOperation");
+const dbsingleton_1 = __importDefault(require("./dbsingleton"));
+const dbutil_1 = require("./dbutil");
+const result_1 = require("./result");
+class MarketDateAccess {
+    constructor(market) {
+        _MarketDateAccess_instances.add(this);
+        _MarketDateAccess_market.set(this, void 0);
+        _MarketDateAccess_holidays.set(this, new Array());
+        __classPrivateFieldSet(this, _MarketDateAccess_market, market, "f");
+        //console.log('__marketHolidays', MarketDateAccess.__marketHolidays);
+        if (market in MarketDateAccess.__marketHolidays) {
+            __classPrivateFieldSet(this, _MarketDateAccess_holidays, MarketDateAccess.__marketHolidays[market], "f");
+            return;
+        }
+    }
+    //static async getMarketAccess(market: string, ctx: Context) {
+    static getMarketAccess(market) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const access = new MarketDateAccess(market);
+            const result = yield __classPrivateFieldGet(access, _MarketDateAccess_instances, "m", _MarketDateAccess_initDataLoad).call(access);
+            if (result.isFailure())
+                return result;
+            return (0, result_1.success)(access);
+        });
+    }
+    isBusinessDay(targetDate) {
+        const dayOfWeek = targetDate.getDay();
+        const targetYYYYMMDD = (0, format_1.default)(targetDate, 'yyyyMMdd');
+        if (dayOfWeek === 0 || dayOfWeek === 6)
+            return false;
+        const holidayArray = __classPrivateFieldGet(this, _MarketDateAccess_holidays, "f").filter((val) => val === targetYYYYMMDD);
+        return !holidayArray || holidayArray.length === 0;
+    }
+    businessDay(targetDate, dayOffset) {
+        if (dayOffset === 0)
+            return this.__getNextBusinessDay(this.__getPreviousBusinessDay(targetDate, 1), 1);
+        if (dayOffset > 0)
+            return this.__getNextBusinessDay(targetDate, dayOffset);
+        return this.__getPreviousBusinessDay(targetDate, -dayOffset);
+    }
+    __getNextBusinessDay(targetDate, dayOffset) {
+        let businessDay = targetDate;
+        while (dayOffset > 0) {
+            businessDay = (0, addDays_1.default)(businessDay, 1);
+            if (this.isBusinessDay(businessDay))
+                dayOffset--;
+        }
+        return businessDay;
+    }
+    __getPreviousBusinessDay(targetDate, dayOffset) {
+        let businessDay = targetDate;
+        while (dayOffset > 0) {
+            businessDay = (0, subDays_1.default)(businessDay, 1);
+            if (this.isBusinessDay(businessDay))
+                dayOffset--;
+        }
+        return businessDay;
+    }
+    businessDayOfBeginningMonthWithOffset(targetDate, dayOffset = 1) {
+        let businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), targetDate.getMonth() + 1, 1);
+        if (this.isBusinessDay(businessDay)) {
+            if (dayOffset > 1)
+                return this.businessDay(businessDay, dayOffset - 1);
+            else
+                return businessDay;
+        }
+        return this.businessDay(businessDay, dayOffset);
+    }
+    businessDayOfBeginningOfNextMonthWithOffset(targetDate, dayOffset = 1) {
+        let businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + (targetDate.getMonth() === 11 ? 1 : 0), targetDate.getMonth() + 2 + (targetDate.getMonth() === 11 ? -11 : 0), 1);
+        let result = businessDay;
+        if (dayOffset === 0)
+            dayOffset = 1;
+        if (this.isBusinessDay(businessDay)) {
+            if (dayOffset > 1)
+                result = this.businessDay(businessDay, dayOffset - 1);
+        }
+        else
+            result = this.businessDay(businessDay, dayOffset);
+        // if (isEqual(result, targetDate) || isAfter(targetDate, result)) {
+        //   businessDay = addMonths(businessDay, 1);
+        //   if (this.isBusinessDay(businessDay)) {
+        //     if (dayOffset > 1)
+        //       result = this.businessDay(businessDay, dayOffset - 1);
+        //   } else result = this.businessDay(businessDay, dayOffset);
+        // }
+        return result;
+    }
+    businessDayOfBeginningOfPreviousMonthWithOffset(targetDate, dayOffset = 1) {
+        let businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + (targetDate.getMonth() === 0 ? -1 : 0), targetDate.getMonth() + 1 + (targetDate.getMonth() === 0 ? 11 : -1), 1);
+        let result = businessDay;
+        if (this.isBusinessDay(businessDay)) {
+            if (dayOffset > 1)
+                result = this.businessDay(businessDay, dayOffset - 1);
+        }
+        else
+            result = this.businessDay(businessDay, dayOffset);
+        // if (isEqual(result, targetDate) || isAfter(targetDate, result)) {
+        //   businessDay = addMonths(businessDay, 1);
+        //   if (this.isBusinessDay(businessDay)) {
+        //     if (dayOffset > 1)
+        //       result = this.businessDay(businessDay, dayOffset - 1);
+        //   } else result = this.businessDay(businessDay, dayOffset);
+        // }
+        return result;
+    }
+    businessDayOfEndMonthWithOffset(targetDate, dayOffset) {
+        let businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + (targetDate.getMonth() === 11 ? 1 : 0), targetDate.getMonth() + 1 + (targetDate.getMonth() === 11 ? -11 : 1), 1);
+        if (dayOffset === 0)
+            dayOffset = 1;
+        return this.businessDay(businessDay, -dayOffset);
+    }
+    businessDayOfEndOfNextMonthWithOffset(targetDate, dayOffset) {
+        let businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + (targetDate.getMonth() === 11 ? 1 : 0), targetDate.getMonth() + 1 + (targetDate.getMonth() === 11 ? -11 : 1), 1);
+        if (dayOffset === 0)
+            dayOffset = 1;
+        let result = this.businessDay(businessDay, -dayOffset);
+        if ((0, date_fns_1.isEqual)(targetDate, result) || (0, date_fns_1.isBefore)(targetDate, result)) {
+            businessDay = (0, date_fns_1.addMonths)(businessDay, 1);
+            result = this.businessDay(businessDay, -dayOffset);
+        }
+        return result;
+    }
+    businessDayOfEndOfPreviousMonthWithOffset(targetDate, dayOffset) {
+        const businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), targetDate.getMonth() + 1, 1);
+        if (dayOffset === 0)
+            dayOffset = 1;
+        return this.businessDay(businessDay, -dayOffset);
+    }
+    businessDayOfBeginningOfYear(targetDate, dayOffset) {
+        const businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), 1, 1);
+        if (this.isBusinessDay(businessDay))
+            return this.businessDay(businessDay, dayOffset - 1);
+        return this.businessDay(businessDay, dayOffset);
+    }
+    businessDayOfEndOfYear(targetDate, dayOffset) {
+        const businessDay = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + 1, 1, 1);
+        if (dayOffset === 0)
+            dayOffset = 1;
+        return this.businessDay(businessDay, -dayOffset);
+    }
+}
+exports.default = MarketDateAccess;
+_MarketDateAccess_market = new WeakMap(), _MarketDateAccess_holidays = new WeakMap(), _MarketDateAccess_instances = new WeakSet(), _MarketDateAccess_initDataLoad = function _MarketDateAccess_initDataLoad() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (__classPrivateFieldGet(this, _MarketDateAccess_holidays, "f").length > 0)
+            return (0, result_1.success)(true);
+        __classPrivateFieldSet(this, _MarketDateAccess_holidays, new Array(), "f");
+        const result = yield (0, dbutil_1.genericDBFunction)('load gyomu_market_holiday', () => __awaiter(this, void 0, void 0, function* () {
+            //console.log('loading');
+            const item_values = yield dbsingleton_1.default.gyomu_market_holiday.findMany({
+                where: { market: __classPrivateFieldGet(this, _MarketDateAccess_market, "f") },
+            });
+            //console.log('loaded');
+            return (0, result_1.success)(item_values);
+        }), []);
+        if (result.isFailure())
+            return result;
+        const holidays = result.value;
+        //console.log('holidays', holidays);
+        holidays.forEach((row) => {
+            __classPrivateFieldGet(this, _MarketDateAccess_holidays, "f").push(row.holiday);
+        });
+        //console.log('#holidays', this.#holidays);
+        MarketDateAccess.__marketHolidays[__classPrivateFieldGet(this, _MarketDateAccess_market, "f")] = __classPrivateFieldGet(this, _MarketDateAccess_holidays, "f");
+        return (0, result_1.success)(true);
+    });
+};
+MarketDateAccess.__marketHolidays = {};

package/lib/index.d.ts

@@ -0,0 +1,15 @@
+export * from './base64';
+export * from './buffer';
+export * from './configurator';
+export * from './dictionary';
+export * from './encryption';
+export * from './errors';
+export * from './excel';
+export * from './fileModel';
+export * from './fileOperation';
+export * from './holidays';
+export * from './numberOperation';
+export * from './result';
+export * from './user';
+export * from './web';
+export * from './archive';

package/lib/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base64"), exports);
+__exportStar(require("./buffer"), exports);
+__exportStar(require("./configurator"), exports);
+__exportStar(require("./dictionary"), exports);
+__exportStar(require("./encryption"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./excel"), exports);
+__exportStar(require("./fileModel"), exports);
+__exportStar(require("./fileOperation"), exports);
+__exportStar(require("./holidays"), exports);
+__exportStar(require("./numberOperation"), exports);
+__exportStar(require("./result"), exports);
+__exportStar(require("./user"), exports);
+__exportStar(require("./web"), exports);
+__exportStar(require("./archive"), exports);

package/lib/milestone.d.ts

@@ -0,0 +1,19 @@
+import { gyomu_milestone_daily, gyomu_milestone_cdtbl } from '@prisma/client';
+import { DBError } from './errors';
+import { PromiseResult } from './result';
+interface MilestoneExistResultType {
+    exists: boolean;
+    updateTime: Date | undefined;
+}
+export declare class Milestone {
+    #private;
+    static exists(milestoneId: string, targetDate: Date, isMonthly?: boolean): PromiseResult<MilestoneExistResultType, DBError>;
+    static register(milestoneId: string, targetDate: Date, isMonthly?: boolean): Promise<import("./result").Result<Date, DBError>>;
+    static wait(milestoneId: string, targetDate: Date, timeoutSecond: number): Promise<import("./result").Result<boolean, import("./errors").TimeoutError>>;
+    static retrieveMilestoneDailyList(targetDateYYYYMMDD: string): Promise<import("./result").Result<gyomu_milestone_daily[], DBError>>;
+    static deleteMilestoneDaily(milestoneId: string, targetDateYYYYMMDD: string): Promise<import("./result").Result<gyomu_milestone_daily, DBError>>;
+    static milestoneList(): Promise<import("./result").Result<gyomu_milestone_cdtbl[], DBError>>;
+    static upsertMilestoneCode(record: gyomu_milestone_cdtbl, milestoneId?: string): Promise<import("./result").Result<gyomu_milestone_cdtbl, DBError>>;
+    static deleteMilestoneCode(milestoneId: string): Promise<import("./result").Result<gyomu_milestone_cdtbl, DBError>>;
+}
+export {};

package/lib/milestone.js

@@ -0,0 +1,169 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _Milestone_convertTargetDate;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Milestone = void 0;
+const date_fns_1 = require("date-fns");
+const dbsingleton_1 = __importDefault(require("./dbsingleton"));
+const result_1 = require("./result");
+const timer_1 = require("./timer");
+const dbutil_1 = require("./dbutil");
+class Milestone {
+    static exists(milestoneId, targetDate, isMonthly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let targetDateYYYYMMDD = __classPrivateFieldGet(this, _a, "m", _Milestone_convertTargetDate).call(this, targetDate, isMonthly);
+            return yield (0, dbutil_1.genericDBFunction)('check gyomu_milestone_daily existence', (milestoneId, targetDate, isMonthly) => __awaiter(this, void 0, void 0, function* () {
+                const record = yield dbsingleton_1.default.gyomu_milestone_daily.findUnique({
+                    where: {
+                        target_date_milestone_id: {
+                            milestone_id: milestoneId,
+                            target_date: targetDateYYYYMMDD,
+                        },
+                    },
+                });
+                if (!!record)
+                    return (0, result_1.success)({
+                        exists: true,
+                        updateTime: new Date(Number(record.update_time)),
+                    });
+                else
+                    return (0, result_1.success)({ exists: false, updateTime: undefined });
+            }), [milestoneId, targetDate, isMonthly]);
+        });
+    }
+    static register(milestoneId, targetDate, isMonthly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const existsResult = yield this.exists(milestoneId, targetDate, isMonthly);
+            if (existsResult.isFailure())
+                return existsResult;
+            if (existsResult.value.exists)
+                return (0, result_1.success)(new Date(Number(existsResult.value.updateTime)));
+            let targetDateYYYYMMDD = __classPrivateFieldGet(this, _a, "m", _Milestone_convertTargetDate).call(this, targetDate, isMonthly);
+            return yield (0, dbutil_1.genericDBFunction)('register gyomu_milestone_daily record', (milestoneId, targetDate, isMonthly) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield dbsingleton_1.default.gyomu_milestone_daily.create({
+                    data: { milestone_id: milestoneId, target_date: targetDateYYYYMMDD },
+                });
+                return (0, result_1.success)(new Date(Number(result.update_time)));
+            }), [milestoneId, targetDate, isMonthly]);
+        });
+    }
+    static wait(milestoneId, targetDate, timeoutSecond) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let interval = 5;
+            if (timeoutSecond < 60)
+                interval = 1;
+            return yield (0, timer_1.polling)(`Wait for milestone ${milestoneId} on ${(0, date_fns_1.format)(targetDate, 'yyyyMMdd')} to be on`, timeoutSecond, interval, (milestoneId, targetDate) => __awaiter(this, void 0, void 0, function* () {
+                const existsResult = yield this.exists(milestoneId, targetDate);
+                if (existsResult.isFailure())
+                    return existsResult;
+                return (0, result_1.success)(existsResult.value.exists);
+            }), milestoneId, targetDate);
+        });
+    }
+    static retrieveMilestoneDailyList(targetDateYYYYMMDD) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetDateMonthly = targetDateYYYYMMDD.substring(0, 6) + '**';
+            return (0, dbutil_1.genericDBFunction)('search milestone_daily', (targetDateYYYYMMDD, targetDateMonthly) => __awaiter(this, void 0, void 0, function* () {
+                const records = yield dbsingleton_1.default.gyomu_milestone_daily.findMany({
+                    where: {
+                        OR: [
+                            {
+                                target_date: targetDateYYYYMMDD,
+                            },
+                            { target_date: targetDateMonthly },
+                        ],
+                    },
+                });
+                return (0, result_1.success)(records);
+            }), [targetDateYYYYMMDD, targetDateMonthly]);
+        });
+    }
+    static deleteMilestoneDaily(milestoneId, targetDateYYYYMMDD) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, dbutil_1.genericDBFunction)('delete gyomu_milestone_daily', (milestoneId, targetDateYYYYMMDD) => __awaiter(this, void 0, void 0, function* () {
+                const deletedRecord = yield dbsingleton_1.default.gyomu_milestone_daily.delete({
+                    where: {
+                        target_date_milestone_id: {
+                            milestone_id: milestoneId,
+                            target_date: targetDateYYYYMMDD,
+                        },
+                    },
+                });
+                return (0, result_1.success)(deletedRecord);
+            }), [milestoneId, targetDateYYYYMMDD]);
+        });
+    }
+    static milestoneList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, dbutil_1.genericDBFunction)('retrieve gyomu_milestone_cdtbl records', () => __awaiter(this, void 0, void 0, function* () {
+                const records = yield dbsingleton_1.default.gyomu_milestone_cdtbl.findMany();
+                return (0, result_1.success)(records);
+            }), []);
+        });
+    }
+    static upsertMilestoneCode(record, milestoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let needCreate = true;
+            if (!!milestoneId) {
+                const result = yield (0, dbutil_1.genericDBFunction)('check existence of gyomu_milestone_cdtbl record', (milestoneId) => __awaiter(this, void 0, void 0, function* () {
+                    const record = yield dbsingleton_1.default.gyomu_milestone_cdtbl.findUnique({
+                        where: { milestone_id: milestoneId },
+                    });
+                    return (0, result_1.success)(!!record);
+                }), [milestoneId]);
+                if (result.isFailure())
+                    return result;
+                needCreate = !result.value;
+            }
+            return yield (0, dbutil_1.genericDBFunction)('Insert gyomu_milestone_cdtbl record', (record, needCreate, milestoneId) => __awaiter(this, void 0, void 0, function* () {
+                let result;
+                if (needCreate) {
+                    result = yield dbsingleton_1.default.gyomu_milestone_cdtbl.create({
+                        data: record,
+                    });
+                }
+                else {
+                    result = yield dbsingleton_1.default.gyomu_milestone_cdtbl.update({
+                        data: record,
+                        where: { milestone_id: milestoneId },
+                    });
+                }
+                return (0, result_1.success)(result);
+            }), [record, needCreate, milestoneId]);
+        });
+    }
+    static deleteMilestoneCode(milestoneId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield (0, dbutil_1.genericDBFunction)('delete gyomu_milestone_cdtbl record', (milestoneId) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield dbsingleton_1.default.gyomu_milestone_cdtbl.delete({
+                    where: { milestone_id: milestoneId },
+                });
+                return (0, result_1.success)(result);
+            }), [milestoneId]);
+        });
+    }
+}
+exports.Milestone = Milestone;
+_a = Milestone, _Milestone_convertTargetDate = function _Milestone_convertTargetDate(targetDate, isMonthly) {
+    let targetDateYYYYMMDD = (0, date_fns_1.format)(targetDate, 'yyyyMMdd');
+    if (isMonthly) {
+        targetDateYYYYMMDD = (0, date_fns_1.format)(targetDate, 'yyyyMM') + '**';
+    }
+    return targetDateYYYYMMDD;
+};

package/lib/net/_ftp.js

@@ -0,0 +1,228 @@
+"use strict";
+// import FtpClient from 'ftp';
+// import fs from 'fs';
+// import { PeerCertificate } from 'tls';
+// import { NetworkError } from '../errors';
+// import { FileTransportInfo } from '../fileModel';
+// import { success, fail, Failure, PromiseResult, Result } from '../result';
+// import { RemoteConnection } from './remoteConnection';
+// import path from 'path';
+// export class Ftp {
+//   #connectionInformation: RemoteConnection;
+//   constructor(connectionConfig: RemoteConnection) {
+//     this.#connectionInformation = connectionConfig;
+//     this.client = new FtpClient();
+//     this.isConnected = false;
+//   }
+//   client: FtpClient;
+//   isConnected: boolean;
+//   async #init(): PromiseResult<boolean, NetworkError> {
+//     return new Promise((resolve, reject) => {
+//       const errProcess = (err: Error) => {
+//         resolve(new Failure(new NetworkError('FTP connection Error', err)));
+//       };
+//       this.client.on('ready', () => {
+//         this.isConnected = true;
+//         this.client.off('error', errProcess);
+//         resolve(success(true));
+//       });
+//       this.client.once('error', errProcess);
+//       const ftpOptions: FtpClient.Options = {
+//         host: this.#connectionInformation.serverURL,
+//         port: this.#connectionInformation.port,
+//         user: this.#connectionInformation.userId,
+//         password: this.#connectionInformation.password,
+//         secure: this.#connectionInformation.sslEnabled,
+//         secureOptions: !this.#connectionInformation.sslEnabled
+//           ? undefined
+//           : {
+//               host: this.#connectionInformation.serverURL,
+//               port: this.#connectionInformation.port,
+//               checkServerIdentity: (
+//                 hostname: string,
+//                 cert: PeerCertificate
+//               ) => {
+//                 return undefined;
+//               },
+//             },
+//       };
+//       this.client.connect(ftpOptions);
+//     });
+//   }
+//   async download(transportInformation: FileTransportInfo) {
+//     let result;
+//     if (!this.isConnected) {
+//       result = await this.#init();
+//       if (result.isFailure()) return result;
+//       if (!result.value) return result;
+//     }
+//     result = await new Promise<Result<boolean, NetworkError>>(
+//       (resolve, reject) => {
+//         //if(isBinary)
+//         {
+//           this.client.binary(async (err: Error) => {
+//             if (err)
+//               resolve(
+//                 new Failure(new NetworkError('Fail to set binary mode', err))
+//               );
+//             this.client.get(
+//               transportInformation.sourceFullName.replace(path.sep, '/'),
+//               (err, stream) => {
+//                 if (err)
+//                   resolve(
+//                     new Failure(
+//                       new NetworkError(
+//                         `Fail to download file ${transportInformation.sourceFileName}`,
+//                         err
+//                       )
+//                     )
+//                   );
+//                 stream.on('error', (err) => {
+//                   resolve(
+//                     new Failure(
+//                       new NetworkError(
+//                         `Fail to download file ${transportInformation.sourceFileName}`,
+//                         err as Error
+//                       )
+//                     )
+//                   );
+//                 });
+//                 stream.once('close', () => {
+//                   this.client.end();
+//                   resolve(success(true));
+//                 });
+//                 stream.pipe(
+//                   fs.createWriteStream(transportInformation.destinationFullName)
+//                 );
+//               }
+//             );
+//           });
+//         }
+//       }
+//     );
+//     return result;
+//   }
+//   async upload(transportInformation: FileTransportInfo) {
+//     let result;
+//     if (!this.isConnected) {
+//       result = await this.#init();
+//       if (result.isFailure()) return result;
+//       if (!result.value) return result;
+//     }
+//     result = await new Promise<Result<boolean, NetworkError>>(
+//       (resolve, reject) => {
+//         //if(isBinary)
+//         {
+//           this.client.binary(async (err: Error) => {
+//             if (err)
+//               resolve(
+//                 new Failure(new NetworkError('Fail to set binary mode', err))
+//               );
+//             this.client.put(
+//               transportInformation.sourceFullName,
+//               transportInformation.destinationFullName,
+//               (err) => {
+//                 if (err)
+//                   resolve(
+//                     new Failure(
+//                       new NetworkError(
+//                         `Fail to upload file ${transportInformation.sourceFileName}`,
+//                         err
+//                       )
+//                     )
+//                   );
+//                 resolve(success(true));
+//               }
+//             );
+//           });
+//         }
+//       }
+//     );
+//     return result;
+//   }
+//   async getFileInfo(transportInformation: FileTransportInfo) {
+//     let result;
+//     if (!this.isConnected) {
+//       result = await this.#init();
+//       if (result.isFailure()) return result;
+//     }
+//     let result2 = await new Promise<
+//       Result<{ size: number; date: Date }, NetworkError>
+//     >((resolve, reject) => {
+//       //if(isBinary)
+//       {
+//         this.client.list(
+//           transportInformation.sourceFolderName ?? ''.replace(path.sep, '/'),
+//           (err: Error, listing) => {
+//             if (err)
+//               resolve(
+//                 new Failure(
+//                   new NetworkError('Fail to retrieve file information', err)
+//                 )
+//               );
+//             for (var information of listing) {
+//               if (
+//                 information.name.toUpperCase() !==
+//                 transportInformation.sourceFileName.toUpperCase()
+//               )
+//                 continue;
+//               resolve(
+//                 success({ size: information.size, date: information.date })
+//               );
+//               return;
+//             }
+//           }
+//         );
+//       }
+//     });
+//     return result2;
+//   }
+//   async listFiles(transportInformation: FileTransportInfo) {
+//     let result;
+//     if (!this.isConnected) {
+//       result = await this.#init();
+//       if (result.isFailure()) return result;
+//     }
+//     let result2 = await new Promise<Result<string[], NetworkError>>(
+//       (resolve, reject) => {
+//         //if(isBinary)
+//         {
+//           this.client.list(
+//             transportInformation.sourceFolderName ?? ''.replace(path.sep, '/'),
+//             (err: Error, listing) => {
+//               if (err)
+//                 resolve(
+//                   new Failure(
+//                     new NetworkError('Fail to retrieve file information', err)
+//                   )
+//                 );
+//               const files = new Array<string>();
+//               for (var information of listing) {
+//                 files.push(information.name);
+//               }
+//               resolve(success(files));
+//             }
+//           );
+//         }
+//       }
+//     );
+//     return result2;
+//   }
+//   async close() {
+//     return new Promise<Result<boolean, NetworkError>>((resolve, reject) => {
+//       if (!this.isConnected) {
+//         return;
+//       }
+//       this.client.once('error', (err) => {
+//         resolve(
+//           new Failure(new NetworkError('Fail to disconnect', err as Error))
+//         );
+//       });
+//       this.client.on('end', () => {
+//         this.isConnected = false;
+//         resolve(success(true));
+//       });
+//       this.client.end();
+//     });
+//   }
+// }