@dynamicweb/cli 1.0.0 → 1.0.2

package/bin/commands/env.js

@@ -76,10 +76,8 @@ async function handleEnv(argv) {
             environment: {
                 type: 'input'
             },
-            protocol: {
-                type: 'input'
-            },
             host: {
+                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
                 type: 'input'
             },
             interactive: {
@@ -96,15 +94,26 @@ export async function interactiveEnv(argv, options) {
         .then(async (result) => {
             getConfig().env = getConfig().env || {};
             getConfig().env[result.environment] = getConfig().env[result.environment] || {};
-            getConfig().env[result.environment].protocol = result.protocol || 'https';
-            if (result.host)
-                getConfig().env[result.environment].host = result.host;
+            if (result.host) {
+                var hostSplit = result.host.split("://");
+                if (hostSplit.length == 1) {
+                    getConfig().env[result.environment].protocol = 'https';
+                    getConfig().env[result.environment].host = hostSplit[0];
+                } else if (hostSplit.length == 2) {
+                    getConfig().env[result.environment].protocol = hostSplit[0];
+                    getConfig().env[result.environment].host = hostSplit[1];
+                } else {
+                    console.log(`Issues resolving host ${result.host}`);
+                    return;
+                }
+            }
             if (result.environment) {
                 getConfig().current = getConfig().current || {};
                 getConfig().current.env = result.environment;
             }
             updateConfig();
             console.log(`Your current environment is now ${getConfig().current.env}`);
+            console.log(`To change the host of your environment, use the command 'dw env'`)
         });
 }
 
@@ -118,6 +127,7 @@ async function changeEnv(argv) {
                 prompt: 'never'
             },
             host: {
+                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
                 type: 'input',
                 prompt: 'always'
             },

package/bin/commands/files.js

@@ -28,26 +28,35 @@ export function filesCommand() {
             .option('export', {
                 alias: 'e',
                 type: 'boolean',
-                describe: 'Exports the directory at [dirPath] to [outPath]'
+                describe: 'Exports the specified directory and all subdirectories at [dirPath] to [outPath]'
             })
             .option('import', {
                 alias: 'i',
                 type: 'boolean',
                 describe: 'Imports the file at [dirPath] to [outPath]'
             })
+            .option('overwrite', {
+                alias: 'o',
+                type: 'boolean',
+                describe: 'Used with import, will overwrite existing files at destrination if set to true'
+            })
+            .option('createEmpty', {
+                type: 'boolean',
+                describe: 'Used with import, will create a file even if its empty'
+            })
             .option('includeFiles', {
                 alias: 'f',
                 type: 'boolean',
-                describe: 'Includes files in list of directories and files'
+                describe: 'Used with export, includes files in list of directories and files'
             })
             .option('recursive', {
                 alias: 'r',
                 type: 'boolean',
-                describe: 'Handles all directories recursively'
+                describe: 'Used with list, import and export, handles all directories recursively'
             })
             .option('raw', {
                 type: 'boolean',
-                describe: 'Keeps zip file instead of unpacking it'
+                describe: 'Used with export, keeps zip file instead of unpacking it'
             })
             .option('iamstupid', {
                 type: 'boolean',
@@ -75,11 +84,11 @@ async function handleFiles(argv) {
 
     if (argv.export) {
         if (argv.dirPath) {
-            await download(env, user, argv.dirPath, argv.outPath, argv.recursive, null, argv.raw, []);
+            await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, []);
         } else {
             await interactiveConfirm('Are you sure you want a full export of files?', async () => {
                 console.log('Full export is starting')
-                let filesStructure = (await getFilesStructure(env, user, '/', false, argv.includeFiles)).model;
+                let filesStructure = (await getFilesStructure(env, user, '/', false, true)).model;
                 let dirs = filesStructure.directories;
                 for (let id = 0; id < dirs.length; id++) {
                     const dir = dirs[id];
@@ -91,12 +100,61 @@ async function handleFiles(argv) {
         }
     } else if (argv.import) {
         if (argv.dirPath && argv.outPath) {
-            let resolvedPath = path.resolve(argv.dirPath)
-            await uploadFile(env, user, resolvedPath, argv.outPath);
+            let resolvedPath = path.resolve(argv.dirPath);
+            let files;
+            if (!argv.overwrite) {
+                files = (await getFilesStructure(env, user, argv.outPath, argv.recursive, true)).model;
+            }
+            if (argv.recursive) {
+                await processDirectory(env, user, resolvedPath, argv.outPath, files, resolvedPath, argv.createEmpty, true);
+            } else {
+                let filesInDir = getFilesInDirectory(resolvedPath);
+                if (files)
+                    filesInDir = getFilesNotInData(filesInDir, files.files.data, resolvedPath);
+                await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty);
+            }
         }
     }
 }
 
+function convertToDataFormat(filePath, resolvedPath) {
+    const relativePath = `/Files${filePath.substring(resolvedPath.length)}`;
+    return path.format(path.parse(relativePath)).replace(/\\/g, '/');
+}
+
+function getFilesNotInData(filesInDir, data, resolvedPath) {
+    const existingPaths = data.map(file => file.filePath);
+    return filesInDir.filter(filePath => {
+        const convertedPath = convertToDataFormat(filePath, resolvedPath);
+        return !existingPaths.includes(convertedPath);
+    });
+}
+
+function getFilesInDirectory(dirPath) {
+    return fs.readdirSync(dirPath)
+            .map(file => path.join(dirPath, file))
+            .filter(file => fs.statSync(file).isFile());
+}
+
+async function processDirectory(env, user, dirPath, outPath, files, originalDir, createEmpty, isRoot = false) {
+    let filesInDir = getFilesInDirectory(dirPath);
+    let missingFiles;
+    if (files === undefined)
+        missingFiles = filesInDir;
+    else
+        missingFiles = getFilesNotInData(filesInDir, files.files.data, originalDir);
+    if (missingFiles.length > 0)
+        await uploadFiles(env, user, missingFiles, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), createEmpty);
+
+    const subDirectories = fs.readdirSync(dirPath)
+                            .map(subDir => path.join(dirPath, subDir))
+                            .filter(subDir => fs.statSync(subDir).isDirectory());
+    for (let subDir of subDirectories) {
+        const remoteSubDir = files?.directories.find(dir => dir.name === path.basename(subDir));
+        await processDirectory(env, user, subDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), remoteSubDir, originalDir, createEmpty);
+    }
+}
+
 function resolveTree(dirs, indentLevel, parentHasFiles) {
     let end = `└──`
     let mid = `├──`
@@ -208,12 +266,15 @@ async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
     }
 }
 
-export async function uploadFile(env, user, localFilePath, destinationPath) {
-    console.log('Uploading file')
+export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false) {
+    console.log('Uploading files')
     let form = new FormData();
     form.append('path', destinationPath);
-    form.append('files', fs.createReadStream(localFilePath));
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/Upload`, {
+    localFilePaths.forEach((localPath, index) => {
+        console.log(localPath)
+        form.append('files', fs.createReadStream(path.resolve(localPath)));
+    });
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/Upload?` + new URLSearchParams({"createEmptyFiles": createEmpty}), {
         method: 'POST',
         body: form,
         headers: {
@@ -223,7 +284,7 @@ export async function uploadFile(env, user, localFilePath, destinationPath) {
     });
     if (res.ok) {
         if (env.verbose) console.log(await res.json())
-        console.log(`File uploaded`)
+        console.log(`Files uploaded`)
     }
     else {
         console.log(res)

package/bin/commands/install.js

@@ -2,7 +2,7 @@ import fetch from 'node-fetch';
 import path from 'path';
 import { setupEnv, getAgent } from './env.js';
 import { setupUser } from './login.js';
-import { uploadFile } from './files.js';
+import { uploadFiles } from './files.js';
 
 export function installCommand() {
     return {
@@ -25,15 +25,17 @@ async function handleInstall(argv) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     let resolvedPath = path.resolve(argv.filePath)
-    await uploadFile(env, user, resolvedPath, 'System/AddIns/Local');
+    await uploadFiles(env, user, [resolvedPath], 'System/AddIns/Local');
     await installAddin(env, user, resolvedPath)
 }
 
 async function installAddin(env, user, resolvedPath) {
     console.log('Installing addin')
+    let filename = path.basename(resolvedPath);
     let data = {
-        'AddinProvider': 'Dynamicweb.Marketplace.Providers.LocalAddinProvider',
-        'Package': path.basename(resolvedPath)
+        'Ids': [
+            `${filename.substring(0, filename.lastIndexOf('.')) || filename}|${path.extname(resolvedPath)}`
+        ]
     }
     let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AddinInstall`, {
         method: 'POST',
@@ -50,6 +52,7 @@ async function installAddin(env, user, resolvedPath) {
         console.log(`Addin installed`)
     }
     else {
-        console.log(res)
+        console.log('Request failed, returned error:')
+        console.log(await res.json())
     }
 }

package/bin/commands/login.js

@@ -70,7 +70,7 @@ export async function interactiveLogin(argv, options) {
         .interactive(options)
         .then(async (result) => {
             if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
-                if (!argv.host || !argv.protocol)
+                if (!argv.host)
                     console.log(`The environment specified is missing parameters, please specify them`)
                 await interactiveEnv(argv, {
                     environment: {
@@ -78,11 +78,8 @@ export async function interactiveLogin(argv, options) {
                         default: result.environment,
                         prompt: 'never'
                     },
-                    protocol: {
-                        type: 'input',
-                        prompt: 'if-no-arg'
-                    },
                     host: {
+                        describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
                         type: 'input',
                         prompt: 'if-no-arg'
                     },
@@ -91,14 +88,16 @@ export async function interactiveLogin(argv, options) {
                     }
                 })
             }
-            await loginInteractive(result);
+            await loginInteractive(result, argv.verbose);
         });
 }
 
-async function loginInteractive(result) {
+async function loginInteractive(result, verbose) {
     var protocol = getConfig().env[result.environment].protocol;
-    var token = await login(result.username, result.password, result.environment, protocol);
-    var apiKey = await getApiKey(token, result.environment, protocol)
+    var token = await login(result.username, result.password, result.environment, protocol, verbose);
+    if (!token) return;
+    var apiKey = await getApiKey(token, result.environment, protocol, verbose)
+    if (!apiKey) return;
     getConfig().env = getConfig().env || {};
     getConfig().env[result.environment].users = getConfig().env[result.environment].users || {};
     getConfig().env[result.environment].users[result.username] = getConfig().env[result.environment].users[result.username] || {};
@@ -108,7 +107,7 @@ async function loginInteractive(result) {
     updateConfig();
 }
 
-async function login(username, password, env, protocol) {
+async function login(username, password, env, protocol, verbose) {
     let data = new URLSearchParams();
     data.append('Username', username);
     data.append('Password', password);
@@ -123,16 +122,21 @@ async function login(username, password, env, protocol) {
 
     if (res.ok) {
         let user = parseCookies(res.headers.get('set-cookie')).user;
-        return await getToken(user, env, protocol)
+        if (!user) return;
+        return await getToken(user, env, protocol, verbose)
     }
     else {
-        console.log(res)
+        if (verbose) console.info(res)
+        console.log(`Login attempt failed with username ${username}, please verify its a valid user in your Dynamicweb solution.`)
     }
 }
 
 function parseCookies (cookieHeader) {
     const list = {};
-    if (!cookieHeader) return list;
+    if (!cookieHeader) {
+        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
+        return list;
+    }
 
     cookieHeader.replace('httponly, ', '').replace('Dynamicweb.Admin', 'user').split(`;`).forEach(cookie => {
         let [ name, ...rest] = cookie.split(`=`);
@@ -143,11 +147,15 @@ function parseCookies (cookieHeader) {
         list[name] = decodeURIComponent(value);
     });
 
+    if (!list.user) {
+        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
+    }
+
     return list;
 }
 
-async function getToken(user, env, protocol) {
-    var res = await fetch(`${getConfig().env[env].protocol}://${getConfig().env[env].host}/Admin/Authentication/Token`, {
+async function getToken(user, env, protocol, verbose) {
+    var res = await fetch(`${protocol}://${getConfig().env[env].host}/Admin/Authentication/Token`, {
         method: 'GET',
         headers: {
             'cookie': `Dynamicweb.Admin=${user}`
@@ -157,12 +165,16 @@ async function getToken(user, env, protocol) {
     if (res.ok) {
         return (await res.json()).token
     }
+    else {
+        if (verbose) console.info(res)
+        console.log(`Could not fetch the token for the logged in user ${user}, please verify its a valid user in your Dynamicweb solution.`)
+    }
 }
 
-async function getApiKey(token, env, protocol) {
+async function getApiKey(token, env, protocol, verbose) {
     let data = {
-        'Name': 'addin',
-        'Prefix': 'addin',
+        'Name': 'DW CLI',
+        'Prefix': 'CLI',
         'Description': 'Auto-generated ApiKey by DW CLI'
     };
     var res = await fetch(`${protocol}://${getConfig().env[env].host}/Admin/Api/ApiKeySave`, {
@@ -179,7 +191,8 @@ async function getApiKey(token, env, protocol) {
         return (await res.json()).message
     }
     else {
-        console.log(await res.json())
+        if (verbose) console.info(res)
+        console.log(`Could not create an API Key for the logged in user, please verify its a valid user in your Dynamicweb solution.`)
     }
 }
 

package/bin/index.js

@@ -39,6 +39,10 @@ function baseCommand() {
         command: '$0',
         describe: 'Shows the current env and user being used',
         handler: () => {
+            if (Object.keys(getConfig()).length === 0) {
+                console.log('To login to a solution use `dw login`')
+                return;
+            } 
             console.log(`Environment: ${getConfig()?.current?.env}`)
             console.log(`User: ${getConfig()?.env[getConfig()?.current?.env]?.current?.user}`)
             console.log(`Protocol: ${getConfig()?.env[getConfig()?.current?.env]?.protocol}`)

package/bin/utils.js

@@ -5,7 +5,7 @@ export async function interactiveConfirm(question, func) {
         .interactive({
             confirm: {
                 type: 'confirm',
-                default: false,
+                default: true,
                 describe: question,
                 prompt: 'always'
             },

package/package.json

@@ -2,7 +2,7 @@
   "name": "@dynamicweb/cli",
   "type": "module",
   "description": "Dynamicweb CLI is a commandline tool for interacting with Dynamicweb 10 solutions.",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "bin/index.js",
   "files": [
     "bin/*"