@contentstack/cli-cm-import 0.1.1-beta.7 → 1.0.0

package/src/lib/import/labels.js

@@ -9,22 +9,21 @@ const fs = require('fs');
 const path = require('path');
 const Promise = require('bluebird');
 const chalk = require('chalk');
-const _ = require('lodash')
+const {isEmpty} = require('lodash');
 
 const helper = require('../util/fs');
 const { addlogs } = require('../util/log');
-let config = require('../../config/default')
-let stack = require('../util/contentstack-management-sdk')
+let config = require('../../config/default');
+let stack = require('../util/contentstack-management-sdk');
 
 let reqConcurrency = config.concurrency;
 let labelConfig = config.modules.labels;
-let labelsFolderPath
-let labelMapperPath
-let labelUidMapperPath
-let labelSuccessPath
-let labelFailsPath
-let client
-
+let labelsFolderPath;
+let labelMapperPath;
+let labelUidMapperPath;
+let labelSuccessPath;
+let labelFailsPath;
+let client;
 
 function importLabels() {
   this.fails = [];
@@ -40,10 +39,10 @@ function importLabels() {
 importLabels.prototype = {
   start: function (credentialConfig) {
     let self = this;
-    config = credentialConfig
-    client = stack.Client(config)
-    addlogs(config, chalk.white('Migrating labels'), 'success')
-    labelsFolderPath = path.resolve(config.data, labelConfig.dirName)
+    config = credentialConfig;
+    client = stack.Client(config);
+    addlogs(config, chalk.white('Migrating labels'), 'success');
+    labelsFolderPath = path.resolve(config.data, labelConfig.dirName);
     self.labels = helper.readFile(path.resolve(labelsFolderPath, labelConfig.fileName));
     labelMapperPath = path.resolve(config.data, 'mapper', 'labels');
     labelUidMapperPath = path.resolve(config.data, 'mapper', 'labels', 'uid-mapping.json');
@@ -51,63 +50,74 @@ importLabels.prototype = {
     labelFailsPath = path.resolve(config.data, 'labels', 'fails.json');
     mkdirp.sync(labelMapperPath);
     return new Promise(function (resolve, reject) {
-      if (self.labels == undefined) {
-        addlogs(config, chalk.white('No Label Found'), 'error');
-        return resolve();
+      if (self.labels == undefined || isEmpty(self.labels)) {
+        addlogs(config, chalk.white('No Label Found'), 'success');
+        return resolve({ empty: true });
       }
       self.labelUids = Object.keys(self.labels);
-      return Promise.map(self.labelUids, function (labelUid) {
-        let label = self.labels[labelUid];
-        if (label.parent.length != 0) {
-          delete label['parent'];
-        }
+      return Promise.map(
+        self.labelUids,
+        function (labelUid) {
+          let label = self.labels[labelUid];
+          if (label.parent.length != 0) {
+            delete label['parent'];
+          }
 
-        if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
-          let requestOption = {
-            label: label
-          };
+          if (!self.labelUidMapper.hasOwnProperty(labelUid)) {
+            let requestOption = {
+              label: label,
+            };
 
-          // return self.createLabels(self.labels[labelUid]);
-          return client.stack({ api_key: config.target_stack, management_token: config.management_token }).label().create(requestOption)
-            .then(function (response) {
-              self.labelUidMapper[labelUid] = response;
-              helper.writeFile(labelUidMapperPath, self.labelUidMapper);
-              return;
-            }).catch(function (error) {
-              self.fails.push(label);
-              // addlogs(config, chalk.red('Label: \'' + label.name + '\' failed to be imported\n'), 'error');
-              if (error.errors.name) {
-                addlogs(config, chalk.red('Label: \'' + label.name + '\'  already exist'), 'error');
-              } else {
-                addlogs(config, chalk.red('Label: \'' + label.name + '\' failed to be imported\n'), 'error');
-              }
-              return;
+            return client
+              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .label()
+              .create(requestOption)
+              .then(function (response) {
+                self.labelUidMapper[labelUid] = response;
+                helper.writeFile(labelUidMapperPath, self.labelUidMapper);
+              })
+              .catch(function (error) {
+                self.fails.push(label);
+                if (error.errors.name) {
+                  addlogs(config, chalk.red("Label: '" + label.name + "'  already exist"), 'error');
+                } else {
+                  addlogs(config, chalk.red("Label: '" + label.name + "' failed to be imported\n"), 'error');
+                }
+              });
+          } else {
+            // the label has already been created
+            addlogs(
+              config,
+              chalk.white("The label: '" + label.name + "' already exists. Skipping it to avoid duplicates!"),
+              'success',
+            );
+          }
+          // import 1 labels at a time
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          // eslint-disable-next-line no-undef
+          return self
+            .updateLabels()
+            .then(function () {
+              helper.writeFile(labelSuccessPath, self.success);
+              addlogs(config, chalk.green('Labels have been imported successfully!'), 'success');
+              return resolve();
+            })
+            .catch(function (error) {
+              // eslint-disable-next-line no-console
+              return reject(error);
             });
-        } else {
-          // the label has already been created
-          addlogs(config, (chalk.white('The label: \'' + label.name +
-            '\' already exists. Skipping it to avoid duplicates!')), 'success');
-          return;
-        }
-        // import 1 labels at a time
-      }, {
-        concurrency: reqConcurrency
-      }).then(function () {
-        // eslint-disable-next-line no-undef
-        return self.updateLabels().then(function () {
-          helper.writeFile(labelSuccessPath, self.success);
-          addlogs(config, (chalk.green('Labels have been imported successfully!')), 'success');
-          return resolve();
-        }).catch(function (error) {
-          // eslint-disable-next-line no-console
+        })
+        .catch(function (error) {
+          // error while importing labels
+          helper.writeFile(labelFailsPath, self.fails);
+          addlogs(config, chalk.red('Label import failed'), 'error');
           return reject(error);
         });
-      }).catch(function (error) {
-        // error while importing labels
-        helper.writeFile(labelFailsPath, self.fails);
-        addlogs(config, chalk.red('Label import failed'), 'error');
-        return reject(error);
-      });
     });
   },
 
@@ -115,43 +125,53 @@ importLabels.prototype = {
     let self = this;
     return new Promise(function (resolve, reject) {
       let labelsObj = helper.readFile(path.resolve(labelsFolderPath, labelConfig.fileName));
-      return Promise.map(self.labelUids, function (labelUid) {
-        let label = labelsObj[labelUid];
-        if (self.labelUidMapper.hasOwnProperty(labelUid)) {
-          let newLabelUid = self.labelUidMapper[labelUid];
-          if (label.parent.length > 0) {
-            let parentUids = label.parent;
-            for (let i = 0; i < parentUids.length; i++) {
-              if (self.labelUidMapper.hasOwnProperty(parentUids[i])) {
-                label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
+      return Promise.map(
+        self.labelUids,
+        function (labelUid) {
+          let label = labelsObj[labelUid];
+          if (self.labelUidMapper.hasOwnProperty(labelUid)) {
+            let newLabelUid = self.labelUidMapper[labelUid];
+            if (label.parent.length > 0) {
+              let parentUids = label.parent;
+              for (let i = 0; i < parentUids.length; i++) {
+                if (self.labelUidMapper.hasOwnProperty(parentUids[i])) {
+                  label.parent[i] = self.labelUidMapper[parentUids[i]].uid;
+                }
               }
+              return client
+                .stack({ api_key: config.target_stack, management_token: config.management_token })
+                .label(newLabelUid.uid)
+                .fetch()
+                .then(function (response) {
+                  //Object.assign(response, _.cloneDeep(label))
+                  response.parent = label.parent;
+                  response
+                    .update()
+                    .then((result) => {
+                      self.success.push(result);
+                    })
+                    .catch((error) => {
+                      return reject(error);
+                    });
+                })
+                .catch(function (error) {
+                  return reject(error);
+                });
             }
-            return client.stack({ api_key: config.target_stack, management_token: config.management_token }).label(newLabelUid.uid).fetch()
-            .then(function (response) {
-              //Object.assign(response, _.cloneDeep(label))
-              response.parent = label.parent
-              response.update().then((result) => {
-                self.success.push(result);
-              }).catch(error => {
-                return reject(error);
-              })
-            }).catch(function (error) {
-              return reject(error);
-            });
           }
-
-          
-        }
-      }, {
-        concurrency: reqConcurrency
-      }).then(function () {
-        return resolve();
-
-      }).catch(function (error) {
-        // eslint-disable-next-line no-console
-        return reject(error);
-      });
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          return resolve();
+        })
+        .catch(function (error) {
+          // eslint-disable-next-line no-console
+          return reject(error);
+        });
     });
-  }
+  },
 };
 module.exports = new importLabels();

package/src/lib/import/locales.js

@@ -5,135 +5,148 @@
  * MIT Licensed
  */
 
-let mkdirp = require('mkdirp')
-let fs = require('fs')
-let path = require('path')
-let Promise = require('bluebird')
-let chalk = require('chalk')
+let mkdirp = require('mkdirp');
+let fs = require('fs');
+let path = require('path');
+let Promise = require('bluebird');
+let chalk = require('chalk');
 
-let helper = require('../util/fs')
-let {addlogs} = require('../util/log')
-let util = require('../util')
-let stack = require('../util/contentstack-management-sdk')
-let config = require('../../config/default')
-let _ = require('lodash')
-let reqConcurrency = config.concurrency
-let langConfig = config.modules.locales
-let langFolderPath
-let langMapperPath
-let langUidMapperPath
-let langSuccessPath
-let langFailsPath 
-let client
+let helper = require('../util/fs');
+let { addlogs } = require('../util/log');
+let stack = require('../util/contentstack-management-sdk');
+let config = require('../../config/default');
+let {isEmpty, cloneDeep} = require('lodash');
+let reqConcurrency = config.concurrency;
+let langConfig = config.modules.locales;
+let langFolderPath;
+let langMapperPath;
+let langUidMapperPath;
+let langSuccessPath;
+let langFailsPath;
+let client;
 
-let masterLanguage = config.master_locale
+let masterLanguage = config.master_locale;
 
 function importLanguages() {
-  this.fails = []
-  this.success = []
-  this.langUidMapper = {}
+  this.fails = [];
+  this.success = [];
+  this.langUidMapper = {};
 }
 
 importLanguages.prototype = {
-  start: function (credentialConfig) {  
-    addlogs(config, 'Migrating languages', 'success')
-    let self = this
-    config = credentialConfig
-    client = stack.Client(config)
-    langFolderPath = path.resolve(config.data, langConfig.dirName)
-    langMapperPath = path.resolve(config.data, 'mapper', 'languages')
-    langUidMapperPath = path.resolve(config.data, 'mapper', 'languages', 'uid-mapper.json')
-    langSuccessPath = path.resolve(config.data, 'mapper', 'languages', 'success.json')
-    langFailsPath = path.resolve(config.data, 'mapper', 'languages', 'fails.json')
-    mkdirp.sync(langMapperPath)
-    self.languages = helper.readFile(path.resolve(langFolderPath, langConfig.fileName))
+  start: function (credentialConfig) {
+    addlogs(config, 'Migrating languages', 'success');
+    let self = this;
+    config = credentialConfig;
+    client = stack.Client(config);
+    langFolderPath = path.resolve(config.data, langConfig.dirName);
+    langMapperPath = path.resolve(config.data, 'mapper', 'languages');
+    langUidMapperPath = path.resolve(config.data, 'mapper', 'languages', 'uid-mapper.json');
+    langSuccessPath = path.resolve(config.data, 'mapper', 'languages', 'success.json');
+    langFailsPath = path.resolve(config.data, 'mapper', 'languages', 'fails.json');
+    mkdirp.sync(langMapperPath);
+    self.languages = helper.readFile(path.resolve(langFolderPath, langConfig.fileName));
     if (fs.existsSync(langUidMapperPath)) {
-      self.langUidMapper = helper.readFile(langUidMapperPath)
-      self.langUidMapper = self.langUidMapper || {}
+      self.langUidMapper = helper.readFile(langUidMapperPath);
+      self.langUidMapper = self.langUidMapper || {};
     }
 
     return new Promise(function (resolve, reject) {
-      if (self.languages === undefined) {
-        addlogs(config, chalk.white('No Languages Found'), 'error')
-        return resolve()
+      if (self.languages === undefined || isEmpty(self.languages)) {
+        addlogs(config, chalk.white('No Languages Found'), 'success');
+        return resolve({ empty: true });
       }
-      let langUids = Object.keys(self.languages)
-      return Promise.map(langUids, function (langUid) {
-        let lang = self.languages[langUid]
-        if (!self.langUidMapper.hasOwnProperty(langUid) && (lang.code !== masterLanguage)) {
-          let requestOption = {
-            locale: {
-              code: lang.code,
-              name: lang.name,
-            },
+      let langUids = Object.keys(self.languages);
+      return Promise.map(
+        langUids,
+        function (langUid) {
+          let lang = self.languages[langUid];
+          if (!self.langUidMapper.hasOwnProperty(langUid) && lang.code !== masterLanguage) {
+            let requestOption = {
+              locale: {
+                code: lang.code,
+                name: lang.name,
+              },
+            };
+
+            return client
+              .stack({ api_key: config.target_stack, management_token: config.management_token })
+              .locale()
+              .create(requestOption)
+              .then((locale) => {
+                self.success.push(locale.items);
+                self.langUidMapper[langUid] = locale.uid;
+                helper.writeFile(langUidMapperPath, self.langUidMapper);
+              })
+              .catch(function (err) {
+                let error = JSON.parse(err.message);
+                if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
+                  addlogs(config, error.errors.code[0], 'success');
+                  return;
+                }
+                self.fails.push(lang);
+                addlogs(config, chalk.red("Language: '" + lang.code + "' failed to be import\n"), 'error');
+              });
+          } else {
+            // the language has already been created
+            addlogs(config, chalk.yellow("The language: '" + lang.code + "' already exists."), 'error');
           }
-          
-         return client.stack({api_key: config.target_stack, management_token: config.management_token}).locale().create(requestOption)
-          .then(locale => {                    
-            self.success.push(locale.items)
-            self.langUidMapper[langUid] = locale.uid
-            helper.writeFile(langUidMapperPath, self.langUidMapper)
-          }).catch(function (err) {
-            let error = JSON.parse(err.message)
-            if (error.hasOwnProperty('errorCode') && error.errorCode === 247) {
-              addlogs(config, error.errors.code[0], 'success')
-              return
-            }
-            self.fails.push(lang)
-            addlogs(config, chalk.red('Language: \'' + lang.code + '\' failed to be import\n'), 'error')
-          })
-        } else {
-          // the language has already been created
-          addlogs(config, chalk.yellow('The language: \'' + lang.code + '\' already exists.'), 'error')
-        }
 
-        // import 2 languages at a time
-      }, {
-        concurrency: reqConcurrency,
-      }).then(function () {
-        // languages have imported successfully
-        self.update_locales(langUids)
-        .then(() => {
-          helper.writeFile(langSuccessPath, self.success)
-          addlogs(config, chalk.green('Languages have been imported successfully!'), 'success')
-          return resolve()
-        }).catch(function (error) {
-          return reject(error)
+          // import 2 languages at a time
+        },
+        {
+          concurrency: reqConcurrency,
+        },
+      )
+        .then(function () {
+          // languages have imported successfully
+          self
+            .update_locales(langUids)
+            .then(() => {
+              helper.writeFile(langSuccessPath, self.success);
+              addlogs(config, chalk.green('Languages have been imported successfully!'), 'success');
+              return resolve();
+            })
+            .catch(function (error) {
+              return reject(error);
+            });
         })
-       
-      }).catch(function (error) {
-        // error while importing languages
-        helper.writeFile(langFailsPath, self.fails)
-        addlogs(config, chalk.red('Language import failed'), 'error')
-        return reject(error)
-      })
-    })
+        .catch(function (error) {
+          // error while importing languages
+          helper.writeFile(langFailsPath, self.fails);
+          addlogs(config, chalk.red('Language import failed'), 'error');
+          return reject(error);
+        });
+    });
   },
   update_locales: function (langUids) {
-    let self = this
+    let self = this;
     return new Promise(function (resolve, reject) {
-    Promise.all(
-      langUids.map(async langUid => {
-        let lang = {}
-          let requireKeys = config.modules.locales.requiredKeys
-          let _lang = self.languages[langUid]
-          requireKeys.forEach(e => {
-            lang[e] = _lang[e]
-          })
-        let langobj = client.stack({api_key: config.target_stack, management_token: config.management_token}).locale(lang.code)
-        Object.assign(langobj, _.cloneDeep(lang))
-        langobj.update()
-        .then(()=>{
+      Promise.all(
+        langUids.map(async (langUid) => {
+          let lang = {};
+          let requireKeys = config.modules.locales.requiredKeys;
+          let _lang = self.languages[langUid];
+          requireKeys.forEach((e) => {
+            lang[e] = _lang[e];
+          });
+          let langobj = client
+            .stack({ api_key: config.target_stack, management_token: config.management_token })
+            .locale(lang.code);
+          Object.assign(langobj, cloneDeep(lang));
+          langobj.update().then(() => {
+            // empty function
+          });
+        }),
+      )
+        .then(() => {
+          return resolve();
         })
-      })
-    )
-    .then(()=>{
-      return resolve()
-    }).catch((error) => {
-      return reject(error)
-    })
-  })
+        .catch((error) => {
+          return reject(error);
+        });
+    });
   },
-}
+};
 
-module.exports = new importLanguages()
+module.exports = new importLanguages();