legispro-cli 1.0.7

package/dist/commands/collection/perms.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const utils_1 = require("../../lib/utils");
+const enquirer_1 = require("enquirer");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+class CollectionPerms extends core_1.Command {
+    async run() {
+        utils_1.client.setConfig(this);
+        const { flags } = await this.parse(CollectionPerms);
+        // prompts
+        if (Object.keys(flags).length == 0) {
+            const res = await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Collection name',
+                    required: true
+                },
+                {
+                    type: 'select',
+                    name: 'type',
+                    message: 'Collection type',
+                    required: true,
+                    choices: ['shared', 'library', 'user']
+                },
+            ]);
+            for (const key in res) {
+                if (res.hasOwnProperty(key)) {
+                    // @ts-ignore
+                    flags[key] = res[key];
+                }
+            }
+        }
+        if (flags.name && flags.type) {
+            let collection_uri = '/db/repository/' + flags.name;
+            // check if collection exists
+            let exists = await utils_1.client.existsCollection(collection_uri);
+            if (!exists) {
+                this.log(`Collection: ${chalk_1.default.magenta(flags.name)} not found.`);
+                this.exit();
+            }
+            // update collection modes and owners based on type
+            let update_perms_response = {};
+            if (flags.type == 'user') {
+                update_perms_response = await utils_1.client.updateUserCollectionPerms(flags.name);
+                this.log(update_perms_response);
+            }
+            if (flags.type == 'shared') {
+                update_perms_response = await utils_1.client.updateSharedCollectionPerms(flags.name);
+            }
+            if (flags.type == 'library') {
+                update_perms_response = await utils_1.client.updateLibraryCollectionPerms(flags.name);
+            }
+            if (update_perms_response.status == 200) {
+                this.log("Collection permissions complete.");
+            }
+            else {
+                this.log("Error updating collection permissions...");
+            }
+            this.exit();
+        }
+    }
+}
+CollectionPerms.flags = {
+    name: core_1.Flags.string({
+        description: 'Collection name',
+        required: false
+    }),
+    source: core_1.Flags.string({
+        description: 'Source folder',
+        required: false
+    }),
+    type: core_1.Flags.string({
+        description: 'Collection type',
+        required: false
+    }),
+};
+CollectionPerms.description = "Update file permissions for a collection.";
+CollectionPerms.examples = [`$ legispro collection:perms`,];
+exports.default = CollectionPerms;

package/dist/commands/collection/update.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+declare class CollectionUpdate extends Command {
+    run(): Promise<void>;
+    static flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        title: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        baseURI: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        defaultExt: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        owner: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+}
+export default CollectionUpdate;

package/dist/commands/collection/update.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const utils_1 = require("../../lib/utils");
+const enquirer_1 = require("enquirer");
+const treeify = require('treeify');
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+class CollectionUpdate extends core_1.Command {
+    async run() {
+        const configFile = path_1.default.join(this.config.configDir, 'config.json');
+        const env = require(configFile);
+        utils_1.client.setConfig(this);
+        const { flags } = await this.parse(CollectionUpdate);
+        // get existing collection properties
+        let projectObject = {};
+        let collectionObject = {};
+        let collection_uri = '';
+        if (Object.keys(flags).length == 0) {
+            const answers1 = await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Name',
+                    required: true
+                },
+            ]);
+            if (answers1.hasOwnProperty('name')) {
+                // @ts-ignore
+                flags['name'] = answers1['name'];
+                collection_uri = '/db/repository/' + flags.name;
+                let collection_exists = await utils_1.client.existsCollection(collection_uri);
+                if (!collection_exists) {
+                    this.log(`${chalk_1.default.red("Error")} : collection ${flags.name} not found`);
+                    this.exit();
+                }
+                projectObject = await utils_1.client.getCollectionProject(collection_uri);
+                this.log(projectObject);
+                if (projectObject == null) {
+                    this.log(`${chalk_1.default.red("Error")} : no .project.xml file found in ${flags.name}`);
+                    this.exit();
+                }
+                collectionObject = await utils_1.client.getCollectionObject(collection_uri);
+                this.log(collectionObject);
+            }
+            const answers2 = await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: 'title',
+                    message: 'Title',
+                    initial: (typeof projectObject.title !== "undefined") ? projectObject.title.toString() : '',
+                    required: true,
+                    skip: false
+                },
+                {
+                    type: 'input',
+                    name: 'baseURI',
+                    message: 'Base URI',
+                    initial: (typeof projectObject.baseURI !== "undefined") ? projectObject.baseURI.toString() : '',
+                    required: true,
+                    skip: false
+                },
+                {
+                    type: 'input',
+                    name: 'defaultExt',
+                    message: 'Default Extension',
+                    initial: (typeof projectObject.defaultExt !== "undefined") ? projectObject.defaultExt.toString() : '',
+                    required: true,
+                    skip: false
+                },
+                {
+                    type: 'select',
+                    name: 'type',
+                    message: 'Type',
+                    initial: (typeof projectObject.type !== "undefined") ?
+                        ['shared', 'library', 'user'].indexOf(projectObject.type.toString()) : 0,
+                    required: true,
+                    choices: ['shared', 'library', 'user'],
+                    skip: false
+                },
+                {
+                    type: 'input',
+                    name: 'owner',
+                    message: 'Owner',
+                    initial: (typeof collectionObject.owner !== "undefined") ? collectionObject.owner.toString() : 'admin',
+                    required: true,
+                    skip: false
+                },
+                {
+                    type: 'input',
+                    name: 'group',
+                    message: 'Group',
+                    initial: (typeof collectionObject.group !== "undefined") ? collectionObject.group.toString() : 'users',
+                    required: true,
+                    skip: false
+                },
+            ]);
+            for (const key in answers2) {
+                if (answers2.hasOwnProperty(key)) {
+                    // @ts-ignore
+                    flags[key] = answers2[key];
+                    //this.log("key: "+key);
+                    // @ts-ignore
+                    //this.log("value: "+answers2[key]);
+                }
+            }
+        }
+        // mode types
+        let mode = '';
+        if (flags.type == 'shared') {
+            mode = 'rwxrwsr-T';
+        }
+        if (flags.type == 'library') {
+            mode = 'rwxr-sr-T';
+        }
+        if (flags.type == 'user') {
+            mode = 'rwxrwsr-T';
+        }
+        let collection = {
+            uri: '/db/repository/' + flags.name,
+            owner: flags.owner,
+            group: flags.group,
+            mode: mode,
+        };
+        // @ts-ignore
+        this.log(collection);
+        let modify_response = await utils_1.client.modifyCollection(collection);
+        // this.log(modify_response);
+        this.exit();
+        let list_response = await utils_1.client.getCollection(collection.uri);
+        // this.log(treeify.asTree(list_response, true));
+        if (list_response.status == 200) {
+            this.log(`Collection: ${flags.name}  updated`);
+        }
+        else {
+            this.log(list_response);
+        }
+        this.exit();
+    }
+}
+CollectionUpdate.flags = {
+    name: core_1.Flags.string({
+        description: 'Name',
+        required: false
+    }),
+    title: core_1.Flags.string({
+        description: 'Title',
+        required: false
+    }),
+    baseURI: core_1.Flags.string({
+        description: 'Base URI',
+        required: false
+    }),
+    defaultExt: core_1.Flags.string({
+        description: 'Default extension',
+        required: false
+    }),
+    type: core_1.Flags.string({
+        description: 'Collection type',
+        required: false
+    }),
+    owner: core_1.Flags.string({
+        description: 'Collection owner',
+        required: false
+    }),
+    group: core_1.Flags.string({
+        description: 'Collection group',
+        required: false
+    }),
+};
+CollectionUpdate.description = "Update a collection";
+CollectionUpdate.examples = [`$ legispro collection:update`,];
+exports.default = CollectionUpdate;

package/dist/commands/collection/upload.d.ts

@@ -0,0 +1,12 @@
+import { Command } from '@oclif/core';
+declare class CollectionUpload extends Command {
+    run(): Promise<void>;
+    static flags: {
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        source: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        type: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+    };
+    static description: string;
+    static examples: string[];
+}
+export default CollectionUpload;

package/dist/commands/collection/upload.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const utils_1 = require("../../lib/utils");
+const enquirer_1 = require("enquirer");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const rclone = require("rclone.js").promises;
+const fs = require('fs');
+class CollectionUpload extends core_1.Command {
+    async run() {
+        const configFile = path_1.default.join(this.config.configDir, 'config.json');
+        const env = require(configFile);
+        utils_1.client.setConfig(this);
+        const { flags } = await this.parse(CollectionUpload);
+        // prompts
+        if (Object.keys(flags).length == 0) {
+            const res = await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: 'Collection name',
+                    required: true
+                },
+                {
+                    type: 'select',
+                    name: 'type',
+                    message: 'Collection type',
+                    required: true,
+                    choices: ['shared', 'library', 'user']
+                },
+                {
+                    type: 'input',
+                    name: 'source',
+                    message: 'Source folder',
+                    required: true
+                },
+            ]);
+            for (const key in res) {
+                if (res.hasOwnProperty(key)) {
+                    // @ts-ignore
+                    flags[key] = res[key];
+                }
+            }
+        }
+        if (flags.name && flags.source) {
+            let collection_uri = '/db/repository/' + flags.name;
+            // check if collection exists
+            let exists = await utils_1.client.existsCollection(collection_uri);
+            if (!exists) {
+                this.log(`Collection: ${chalk_1.default.magenta(flags.name)} not found.`);
+                this.exit();
+            }
+            // check if local folder exists
+            fs.access(flags.source, (err) => {
+                if (err) {
+                    this.log(`Source folder: ${flags.source} not found.`);
+                    //this.exit();
+                    process.exit();
+                }
+            });
+            const Spinner = (0, ora_1.default)({
+                text: `${chalk_1.default.bold(chalk_1.default.blue('Uploading files...'))}`
+            }).start();
+            let obscured_password = (await rclone.obscure(env.password)).toString().trim();
+            let copy_response;
+            try {
+                copy_response = await rclone.copy(flags.source, ":webdav:" + collection_uri, {
+                    "webdav-url": env.protocol + "://" + env.hostname + ":" + env.port + "/exist/webdav/",
+                    "webdav-user": env.user,
+                    "webdav-pass": obscured_password,
+                    "ignore-size": true,
+                    "update": true
+                });
+            }
+            catch (error) {
+                console.log('\r\n');
+                console.log(error.toString());
+            }
+            //(JSON.stringify(copy_response,null, '\t'));
+            // console.log("response: " + copy_response);
+            // this.exit();
+            // update collection modes and owners based on type
+            let update_perms_response = {};
+            if (flags.type == 'user') {
+                update_perms_response = await utils_1.client.updateUserCollectionPerms(flags.name);
+                this.log(update_perms_response);
+            }
+            if (flags.type == 'shared') {
+                update_perms_response = await utils_1.client.updateSharedCollectionPerms(flags.name);
+            }
+            if (flags.type == 'library') {
+                update_perms_response = await utils_1.client.updateLibraryCollectionPerms(flags.name);
+            }
+            let response_buffer = copy_response;
+            //console.log(response_buffer.toJSON());
+            Spinner.stopAndPersist({
+                symbol: "✨",
+                text: `${chalk_1.default.bold(chalk_1.default.green('File upload complete'))}`
+            });
+            // success or failure?
+            if (update_perms_response.status != 200) {
+                this.log("Error uploading files...");
+            }
+            this.exit();
+        }
+    }
+}
+CollectionUpload.flags = {
+    name: core_1.Flags.string({
+        description: 'Collection name',
+        required: false
+    }),
+    source: core_1.Flags.string({
+        description: 'Source folder',
+        required: false
+    }),
+    type: core_1.Flags.string({
+        description: 'Collection type',
+        required: false
+    }),
+};
+CollectionUpload.description = "Upload files to collection";
+CollectionUpload.examples = [`$ legispro collection:upload`,];
+exports.default = CollectionUpload;

package/dist/commands/config/get.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/get.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+class ConfigGet extends core_1.Command {
+    async run() {
+        const configPath = path_1.default.join(this.config.configDir, 'config.json');
+        const data = fs_extra_1.default.readFileSync(configPath);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const config = JSON.parse(data);
+        this.log(config);
+        this.exit();
+    }
+}
+ConfigGet.description = 'Get your current configuration.';
+module.exports.ConfigSet = ConfigGet;

package/dist/commands/config/set.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/set.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const enquirer_1 = require("enquirer");
+const path_1 = tslib_1.__importDefault(require("path"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+class ConfigSet extends core_1.Command {
+    async run() {
+        const { flags } = await this.parse(ConfigSet);
+        const config = path_1.default.join(this.config.configDir, 'config.json');
+        if (!flags.hostname ||
+            !flags.protocol ||
+            !flags.port ||
+            !flags.user ||
+            !flags.password ||
+            !flags.webdav ||
+            !flags.group) {
+            const res = await (0, enquirer_1.prompt)([
+                {
+                    type: 'input',
+                    name: 'hostname',
+                    message: 'What is the hostname?',
+                    required: true,
+                },
+                {
+                    type: 'input',
+                    name: 'protocol',
+                    message: 'What is the protocol?',
+                    initial: 'http',
+                    required: true,
+                },
+                {
+                    type: 'numeral',
+                    name: 'port',
+                    message: 'What is the db port number?',
+                    initial: 8080,
+                    required: true,
+                },
+                {
+                    type: 'input',
+                    name: 'user',
+                    message: 'What is the db admin username?',
+                    initial: 'admin',
+                    required: true,
+                },
+                {
+                    type: 'password',
+                    name: 'password',
+                    message: 'What is the db admin password?',
+                    required: true,
+                },
+                {
+                    type: 'input',
+                    name: 'webdav',
+                    message: 'What the path to the WebDAV interface?',
+                    initial: 'exist/webdav',
+                    required: true,
+                },
+                {
+                    type: 'input',
+                    name: 'group',
+                    message: 'What the default user group?',
+                    required: true,
+                },
+            ]);
+            for (const key in res) {
+                // eslint-disable-next-line no-prototype-builtins
+                if (res.hasOwnProperty(key)) {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    flags[key] = res[key];
+                }
+            }
+        }
+        await fs_extra_1.default.ensureDir(this.config.configDir);
+        await fs_extra_1.default.writeJson(config, {
+            hostname: flags.hostname,
+            protocol: flags.protocol,
+            port: flags.port,
+            user: flags.user,
+            password: flags.password,
+            webdav: flags.webdav,
+            group: flags.group,
+        });
+        // if (flags.json) {
+        //   this.log(JSON.stringify(await credentials(this)));
+        //   this.exit();
+        // }
+        this.log('Your LegisPro CLI configuration has been generated!');
+        this.exit();
+    }
+}
+ConfigSet.flags = {
+    hostname: core_1.Flags.string({
+        description: 'Hostname',
+        required: false,
+    }),
+    protocol: core_1.Flags.string({
+        description: 'Protocol',
+        required: false,
+    }),
+    port: core_1.Flags.string({
+        description: 'Port',
+        required: false,
+    }),
+    user: core_1.Flags.string({
+        description: 'Admin user',
+        required: false,
+    }),
+    password: core_1.Flags.string({
+        description: 'Admin password',
+        required: false,
+    }),
+    webdav: core_1.Flags.string({
+        description: 'WebDAV path',
+        required: false,
+    }),
+    group: core_1.Flags.string({
+        description: 'User group',
+        required: false,
+    }),
+};
+ConfigSet.description = 'Sets your user configuration.';
+module.exports.ConfigSet = ConfigSet;

package/dist/commands/db/init.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+declare class DbInit extends Command {
+    run(): Promise<void>;
+    static description: string;
+    static examples: string[];
+}
+export default DbInit;

package/dist/commands/db/init.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const utils_1 = require("../../lib/utils");
+const path_1 = tslib_1.__importDefault(require("path"));
+const add_1 = tslib_1.__importDefault(require("../locks/add"));
+class DbInit extends core_1.Command {
+    async run() {
+        const configFile = path_1.default.join(this.config.configDir, 'config.json');
+        const env = require(configFile);
+        utils_1.client.setConfig(this);
+        // [1] create repository collection
+        let collection_exists = await utils_1.client.existsCollection('/db/repository');
+        if (!collection_exists) {
+            this.log("Creating /db/repository collection...");
+            let collection = {
+                uri: '/db/repository',
+                owner: 'admin',
+                group: 'dba',
+                mode: 'rwxr-xr-x',
+            };
+            let create_response = await utils_1.client.createCollection(collection);
+            let modify_response = await utils_1.client.modifyCollection(collection);
+        }
+        else {
+            this.log("/db/repository already exists.");
+        }
+        // [2] create users group
+        let res = await utils_1.client.getGroup('users');
+        if (res.status != 200) {
+            this.log("Creating users group...");
+            let meta = [];
+            meta.push({
+                key: "http://axschema.org/contact/email",
+                value: ""
+            });
+            meta.push({
+                key: "http://exist-db.org/security/description",
+                value: "Users"
+            });
+            meta.push({
+                key: "http://axschema.org/pref/language",
+                value: "en-US"
+            });
+            let users_group = {
+                groupName: 'users',
+                managers: ["admin"],
+                metadata: meta,
+            };
+            let create_group_response = await utils_1.client.createGroup(users_group);
+        }
+        else {
+            this.log("Users group already exists.");
+        }
+        // [3] create primary group
+        let res_primary_group = await utils_1.client.getGroup(env.group);
+        if (res_primary_group.status != 200) {
+            this.log("Creating primary group...");
+            let meta = [];
+            meta.push({
+                key: "http://axschema.org/contact/email",
+                value: ""
+            });
+            meta.push({
+                key: "http://exist-db.org/security/description",
+                value: "Primary user group"
+            });
+            meta.push({
+                key: "http://axschema.org/pref/language",
+                value: "en-US"
+            });
+            let primary_user_group = {
+                groupName: env.group,
+                managers: ["admin"],
+                metadata: meta,
+            };
+            let create_primary_user_group_response = await utils_1.client.createGroup(primary_user_group);
+        }
+        else {
+            this.log("Primary user group already exists.");
+        }
+        // [4] add locks
+        await add_1.default.run();
+        this.exit();
+    }
+}
+DbInit.description = "Initialize a new database";
+DbInit.examples = [`$ legispro db:init`];
+exports.default = DbInit;

package/dist/commands/db/memory.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '@oclif/core';
+declare class DbMemory extends Command {
+    run(): Promise<void>;
+    static description: string;
+    static examples: string[];
+}
+export default DbMemory;