kaven-utils

Installation

npm i kaven-utils --save

Usage

import * as kavenUtils from "kaven-utils";
kavenUtils.OverrideConsole();

// Create Express server
const app = express();
app.use(kavenUtils.Logger);

Release Notes

1.0.8

Add clipboard support base on clipboardy

Add following functions:

export declare function WriteStringToClipboard(text: string): void;
export declare function WriteStringToClipboardAsync(text: string): Promise<void>;
export declare function ReadStringFromClipboard(): string;
export declare function ReadStringFromClipboardAsync(): Promise<string>;
export declare function SplitStringByNewline(str: string): string[];

1.0.9

Add following functions:

export declare function RemoveInvalidCharactersForPath(path: string): string;
export declare function DownloadFile(url: string, path: string): Promise<string>;
export declare function GetFileSizeInBytes(path: string): Promise<number>;
export declare function ResetLogFileIf(overBytes?: number): Promise<boolean>;
export declare function MakeDirectory(dir: string): Promise<string>;
export declare function MakeDirectorySync(dir: string): string;

1.0.10

Add following functions:

interface String {
    GetIndent(): string;
}

1.0.11

Add:

export declare let IsDebugMode: boolean;

Improve:

export declare function CopyFileSync(dest: string, src: string): any;

1.0.12

Add:

interface String {
    OnlyContains(...characters: string[]): boolean;
    ToArray(): string[];
    Distinct(): string;
}

interface Array < T > {
    Distinct(): Array < T > ;
    First(): T;
    Last(): T;
}

export declare let IsDebugMode: boolean;
export declare function LoadJsonFile(path: string): Promise<{[index: string]: any;}>;
export declare function GetNextVersion(version: string): string | number;

Dependencies

• ansi_up
• chalk
• clipboardy
• forever
• ftp
• jszip
• lodash
• mkdirp
• moment
• morgan
• node-schedule
• nodemailer
• pem
• qrcode
• typescript-collections

Example

import * as Utility from "kaven-utils";
import { performance } from "perf_hooks";

kavenUtils.OverrideConsole();

// console.log(utils.HttpStatusCode.InternalServerError);
// console.log(utils.Strings.HTML_BR);

//#region BitString Test

if (false) {
    const bitStr = new kavenUtils.BitString();

    let count = 5;
    while (count-- > 0) {
        for (let i = 1; i < 100; i++) {
            console.log(bitStr.SetBit(i, kavenUtils.RandomBoolean()).toString());
        }

        for (let i = 1; i < 100; i++) {
            console.log(bitStr.GetBit(i));
        }
    }
}

//#endregion

//#region GenerateRandomString Test

if (false) {
    kavenUtils.RunTest(() => {
        console.log(kavenUtils.GenerateRandomString(10));
    }, 2);
}

//#endregion

//#region GenerateYearMonthId Test

if (false) {
    const total = 10000;
    let count = total;
    const ids1: string[] = [];

    const t0 = performance.now();
    while (count-- > 0) {

        // const start = performance.now();
        const id = kavenUtils.GenerateYearMonthId(4, id => {
            // return !ids.includes(id);
            if (ids1.includes(id)) {
                // console.warn(`ID already exist: ${id}`);
                return false;
            }

            return true;
        });
        // console.log(`====== 1: ${performance.now() - start}`);

        ids1.push(id);
        // console.log(`${total - count}: ${id}`);
    }
    const t1 = performance.now();

    count = total;
    const ids2: string[] = [];

    const t2 = performance.now();
    const guid = kavenUtils.GenerateGuid();
    while (count-- > 0) {
        // const start = performance.now();
        const id = kavenUtils.GenerateYearMonthId(4, undefined, ids2, guid);
        // console.log(`====== 2: ${performance.now() - start}`);

        ids2.push(id);
        // console.log(`${total - count}: ${id}`);
    }
    kavenUtils.RemoveCache(guid);
    const t3 = performance.now();

    console.log(`${t1 - t0}ms, ${t3 - t2}ms`);
}
//#endregion

//#region GenerateYearMonthIdAsync Test

if (false) {
    // https://github.com/tc39/ecmascript-asyncawait/issues/9
    (async function () {
        const total = 100;
        let count = total;
        const ids1: string[] = [];

        const t0 = performance.now();
        while (count-- > 0) {

            // const start = performance.now();
            const id = await kavenUtils.GenerateYearMonthIdAsync(4, id => {
                // return !ids.includes(id);
                if (ids1.includes(id)) {
                    console.warn(`ID already exist: ${id}`);
                    return Promise.resolve(false);
                }

                return Promise.resolve(true);
            });
            // console.log(`====== 1: ${performance.now() - start}`);

            ids1.push(id);
            console.log(`${total - count}: ${id}`);
        }
        const t1 = performance.now();

        count = total;
        const ids2: string[] = [];

        const t2 = performance.now();
        const guid = kavenUtils.GenerateGuid();
        while (count-- > 0) {
            // const start = performance.now();
            const id = await kavenUtils.GenerateYearMonthId(4, undefined, ids2, guid);
            // console.log(`====== 2: ${performance.now() - start}`);

            ids2.push(id);
            console.log(`${total - count}: ${id}`);
        }
        kavenUtils.RemoveCache(guid);
        const t3 = performance.now();

        console.log(`${t1 - t0}ms, ${t3 - t2}ms`);
    })();
}
//#endregion

//#region DB backup

if (false) {

    let backupDir;
    kavenUtils.BackupMongoDB("Z:\\123\\Backup\\222", "DB")
        .then<string>(success => {
            console.log(`MongoDB dump: ${success}`);
            backupDir = success;
            // return utils.ZipFolder(success, utils.ChangeFileExtension(success, "zip"));
            return kavenUtils.SevenZipFolder(success, kavenUtils.ChangeFileExtension(success, "7z"), "123456");
        })
        .then(success => {
            console.log(`Create ZIP file: ${success}`);
            return Promise.all([kavenUtils.DeleteFolder(backupDir), kavenUtils.UploadFileToFTPServer(success, "127.0.0.1", 21, "test", "123456")]);
        }).then(values => {
            console.log(`Delete ${values[0].length} files.`);
            console.log(`Upload to FTP: ${values[1]}`);

            /* cSpell:disable */
            const pwd = "password for [e-mail]";
            /* cSpell:enable */

            const mailConfig = new kavenUtils.MailConfig("smtp.mxhichina.com", 25, false, "[e-mail]", pwd);
            const mailOption = new kavenUtils.MailOption("[e-mail]", "[e-mail]", "Test", "Test Email", "");

            mailOption.HTML = "<b>DB backup success.</b>";

            // mailConfig.Verify();
            kavenUtils.SendEmail(mailConfig, mailOption);

        }).catch(err => {
            console.error(err);
        });


    // utils.ZipFolder("Z:\\123", "Z:\\666.zip").then(success => {
    //     console.log(success);
    // }, err => {
    //     console.error(err);
    // });
}

//#endregion

//#region 7z

if (false) {
    // utils.SevenZipFiles(["Z:\\123\\HID.exe", "Z:\\123\\media\\0ecad205df88143d691b4851fcbbb52f.png"],
    //     `Z:\\temp\\${utils.GetFileNameByDateTime()}.7z`).then(success => {
    //         console.log(success);
    //     }).catch(err => {
    //         console.error(err);
    //     });

    kavenUtils.SevenZipFolder("Z:\\123",
        `Z:\\temp\\${kavenUtils.GetFileNameByDateTime()}.7z`,
        "12345"
    )
        .then(success => {
            console.log(success);
        }).catch(err => {
            console.error(err);
        });
}

//#endregion

//#region GeneratePassword Test

if (false) {
    kavenUtils.RunTest(() => {
        console.log(kavenUtils.GeneratePassword(10, true, true, true, false));
    }, 100);
}

//#endregion

//#region QR Code

if (false) {
    const link = "http://kavenblog.com";
    kavenUtils.GenerateQRCode(link).then(code => {
        console.log(code);
    }).catch(err => {
        console.error(err);
    });
}

//#endregion

//#region Schedule

if (false) {
    kavenUtils.StartSchedule(() => {
        console.log("exec");
    }, undefined, undefined, undefined, undefined, undefined, undefined, kavenUtils.CreateArray(10, 0, 2));
}

//#endregion

//#region base64

if (false) {
    const temp = kavenUtils.Base64Encode("some test data");
    console.log(kavenUtils.Base64Decode(temp));

    /* cSpell:disable */
    console.log(kavenUtils.Base64Decode("Ny4xLjguMTE=", "ascii"));
    /* cSpell:enable */
}

//#endregion

//#region CreateCertificate

if (false) {
    (async function () {
        const key = await kavenUtils.CreateCertificate({ days: 365 * 10, selfSigned: true });
        // console.log(key);

        await kavenUtils.SaveStringToFile(key.serviceKey, "Z:/temp/gogs.pem");
        await kavenUtils.SaveStringToFile(key.certificate, "Z:/temp/gogs.cert");
    }());
}

//#endregion

//#region GetStringBetween

if (false) {
    const str = "Unknown word: \"check\"";
    console.log(kavenUtils.GetStringBetween(str, "\"", "\""));
}

//#endregion

//#region Clipboard

if (false) {
    kavenUtils.WriteStringToClipboard(kavenUtils.GetFileNameByDateTime());
    console.log(kavenUtils.ReadStringFromClipboard());

    kavenUtils.WriteStringToClipboardAsync(kavenUtils.GetFileNameByDateTime()).then(() => {
        kavenUtils.ReadStringFromClipboardAsync().then(text => {
            console.log(text);
        });
    });
}


//#endregion

if (false) {
    console.log("_" + "     asd".GetIndent() + "_");
}

if (true) {
    kavenUtils.LoadJsonFile("./package.json").then(data => {
        const version = data["version"];
        console.log(version);
        console.log(kavenUtils.GetNextVersion(version))
    }).catch (ex => {
        console.error(ex);
    });
}