@contentstack/cli-cm-import 0.1.1-beta.1 → 0.1.1-beta.12

package/src/lib/util/import-flags.js

@@ -6,93 +6,153 @@
 let defaultConfig = require('../../config/default')
 let { initial } = require('../../app')
 let _ = require('lodash')
-const {cli} = require('cli-ux')
+const { cli } = require('cli-ux')
 let message = require('../../../messages/index.json')
 
-exports.configWithMToken = function (config, managementTokens, moduleName, host) {
-  let externalConfig = require(config)
-  defaultConfig.management_token = managementTokens.token
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, externalConfig)
-  initial(defaultConfig)
+exports.configWithMToken = function (config, managementTokens, moduleName, host, _authToken, backupdir, branchName) {
+  return new Promise(async function (resolve, reject) {
+    let externalConfig = require(config)
+    defaultConfig.management_token = managementTokens.token
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    defaultConfig.auth_token = _authToken
+    defaultConfig = _.merge(defaultConfig, externalConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }
 
-exports.parameterWithMToken = function (masterLang, managementTokens, data, moduleName, host) {
-  var masterloc = {master_locale: {code: masterLang}}
-  defaultConfig.management_token = managementTokens.token  
-  defaultConfig.target_stack = managementTokens.apiKey
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = data
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.parameterWithMToken = function (managementTokens, data, moduleName, host, _authToken, backupdir, branchName) {
+  return new Promise(async function (resolve, reject) {
+    defaultConfig.management_token = managementTokens.token
+    defaultConfig.target_stack = managementTokens.apiKey
+    defaultConfig.auth_token = _authToken
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.data = data
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }
 
 // using ManagemetToken
-exports.withoutParameterMToken = async (managementTokens, moduleName, host) => {
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
-  // const stackUid = managementTokens.apiKey
-  const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
-  var masterloc = {master_locale: {code: masterLocale}}
-  defaultConfig.management_token = managementTokens.token
-  defaultConfig.target_stack = managementTokens.apiKey
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = exporteddata
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.withoutParameterMToken = async (managementTokens, moduleName, host, _authToken, backupdir, branchName) => {
+  return new Promise(async function (resolve, reject) {
+    const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
+    defaultConfig.management_token = managementTokens.token
+    defaultConfig.target_stack = managementTokens.apiKey
+    defaultConfig.auth_token = _authToken
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.data = exporteddata
+    defaultConfig.host = host
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }
 
-exports.configWithAuthToken = function (config, _authToken, moduleName, host) {
-  let externalConfig = require(config)
-  defaultConfig.auth_token = _authToken
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, externalConfig)
-  initial(defaultConfig)
+exports.configWithAuthToken = function (config, _authToken, moduleName, host, backupdir, branchName) {
+  return new Promise(async function (resolve, reject) {
+    let externalConfig = require(config)
+    defaultConfig.auth_token = _authToken
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined) {
+      defaultConfig.moduleName = moduleName
+    }
+    defaultConfig.host = host
+
+    if (externalConfig.modules) {
+      defaultConfig.modules.types = externalConfig.modules
+      delete externalConfig.modules
+    }
+
+    if (backupdir) {
+      defaultConfig.useBackedupDir = backupdir;
+    }
+    defaultConfig = _.merge(defaultConfig, externalConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }
 
-exports.parametersWithAuthToken = function (masterLang, _authToken, targetStack, data, moduleName, host) {
-  var masterloc = {master_locale: {code: masterLang}}
-  defaultConfig.auth_token = _authToken
-  defaultConfig.target_stack = targetStack
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.data = data
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+exports.parametersWithAuthToken = function (_authToken, targetStack, data, moduleName, host, backupdir, branchName) {
+  return new Promise(async function (resolve, reject) {
+    defaultConfig.auth_token = _authToken
+    defaultConfig.target_stack = targetStack
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined && backupdir === undefined) {
+      defaultConfig.moduleName = moduleName
+    } else if (moduleName && moduleName !== undefined && backupdir !== undefined) {
+      defaultConfig.moduleName = moduleName
+      defaultConfig.useBackedupDir = backupdir
+    }
+    defaultConfig.data = data
+    defaultConfig.host = host
+
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }
 
-exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host) => {
+exports.withoutParametersWithAuthToken = async (_authToken, moduleName, host, backupdir, branchName) => {
+  return new Promise(async function (resolve, reject) {
+    const stackUid = await cli.prompt(message.promptMessageList.promptTargetStack)
+    const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
+    defaultConfig.auth_token = _authToken
+    defaultConfig.target_stack = stackUid
+    defaultConfig.data = exporteddata
+    defaultConfig.branchName = branchName
+    if (moduleName && moduleName !== undefined && backupdir === undefined) {
+      defaultConfig.moduleName = moduleName
+    } else if (moduleName && moduleName !== undefined && backupdir !== undefined) {
+      defaultConfig.moduleName = moduleName
+      defaultConfig.useBackedupDir = backupdir
+    }
+
+    defaultConfig.host = host
 
-  const masterLocale = await cli.prompt(message.promptMessageList.promptMasterLocale)
-  const stackUid = await cli.prompt(message.promptMessageList.promptTargetStack)
-  const exporteddata = await cli.prompt(message.promptMessageList.promptPathStoredData)
-  var masterloc = {master_locale: {code: masterLocale}}
-  defaultConfig.auth_token = _authToken
-  defaultConfig.target_stack = stackUid
-  defaultConfig.data = exporteddata
-  if (moduleName && moduleName !== undefined) {
-    defaultConfig.moduleName = moduleName
-  }
-  defaultConfig.host = host.cma
-  defaultConfig.cdn = host.cda  
-  defaultConfig = _.merge(defaultConfig, masterloc)
-  initial(defaultConfig)
+    initial(defaultConfig)
+      .then(() => {
+        return resolve()
+      }).catch((error) => {
+        return reject(error)
+      })
+  })
 }

package/src/lib/util/index.js

@@ -11,9 +11,10 @@ var path = require('path')
 var chalk = require('chalk')
 var {addlogs} = require('./log')
 var request = require('./request')
-// var config = require('../../config/');
 var defaultConfig = require('../../config/default')
+const stack = require('./contentstack-management-sdk')
 var config 
+
 exports.initialization = function(configData) {
   config = this.buildAppConfig(configData)
   var res = this.validateConfig(config)
@@ -23,40 +24,40 @@ exports.initialization = function(configData) {
   }
 }
 
-exports.validateConfig = function (config) {
-  if (config.email && config.password && !config.target_stack) {
-    addlogs(config, chalk.red('Kindly provide api_token'), 'error')
+exports.validateConfig = function (importConfig) {
+  if (importConfig.email && importConfig.password && !importConfig.target_stack) {
+    addlogs(importConfig, chalk.red('Kindly provide api_token'), 'error')
     return 'error' 
-  } if(!config.email && !config.password && !config.management_token && config.target_stack && !config.auth_token) {
-    addlogs(config, chalk.red('Kindly provide management_token or email and password'), 'error')
-    return 'error'
-  } else if(!config.email && !config.password && config.preserveStackVersion) {
-    addlogs(config, chalk.red('Kindly provide Email and password for old version stack'), 'error')
+  } else if(!importConfig.email && !importConfig.password && !importConfig.management_token && importConfig.target_stack && !importConfig.auth_token) {
+    addlogs(importConfig, chalk.red('Kindly provide management_token or email and password'), 'error')
     return 'error'
-  } else if(config.email && !config.password || !config.email && config.password) {
-    addlogs(config, chalk.red('Kindly provide Email and password'), 'error')
+  } else if(!importConfig.email && !importConfig.password && importConfig.preserveStackVersion) {
+    addlogs(importConfig, chalk.red('Kindly provide Email and password for old version stack'), 'error')
     return 'error'
-  }
-   if(!config.languagesCode.includes(config.master_locale.code)) {
-    addlogs(config, chalk.red('Kindly provide valid master_locale code'), 'error')
+  } else if(importConfig.email && !importConfig.password || !importConfig.email && importConfig.password) {
+    addlogs(importConfig, chalk.red('Kindly provide Email and password'), 'error')
     return 'error'
   }
+  //  if(!importConfig.languagesCode.includes(importConfig.master_locale.code)) {
+  //   addlogs(importConfig, chalk.red('Kindly provide valid master_locale code'), 'error')
+  //   return 'error'
+  // }
 }
 
-exports.buildAppConfig = function (config) {
-  config = _.merge(defaultConfig, config)
-  return config
+exports.buildAppConfig = function (importConfig) {
+  importConfig = _.merge(defaultConfig, importConfig)
+  return importConfig
 };
 
-exports.sanitizeStack = function (config) {
-  if (typeof config.preserveStackVersion !== 'boolean' || !config.preserveStackVersion) {
+exports.sanitizeStack = function (importConfig) {
+  if (typeof importConfig.preserveStackVersion !== 'boolean' || !importConfig.preserveStackVersion) {
     return Promise.resolve()
   }
-  addlogs(config, 'Running script to maintain stack version.', 'success')
+  addlogs(importConfig, 'Running script to maintain stack version.', 'success')
   var getStackOptions = {
-    url: config.host + config.apis.stacks,
+    url: importConfig.host + importConfig.apis.stacks,
     method: 'GET',
-    headers: config.headers,
+    headers: importConfig.headers,
     json: true
   }
 
@@ -66,7 +67,7 @@ exports.sanitizeStack = function (config) {
         if (stackDetails.body && stackDetails.body.stack && stackDetails.body.stack.settings) {
           const newStackVersion = stackDetails.body.stack.settings.version
           const newStackDate = new Date(newStackVersion).toString()
-          const stackFilePath = path.join(config.data, config.modules.stack.dirName, config.modules.stack.fileName)
+          const stackFilePath = path.join(importConfig.data, importConfig.modules.stack.dirName, importConfig.modules.stack.fileName)
 
           const oldStackDetails = fs.readFile(stackFilePath)
           if (!oldStackDetails || !oldStackDetails.settings || !oldStackDetails.settings.hasOwnProperty('version')) {
@@ -77,15 +78,15 @@ exports.sanitizeStack = function (config) {
           if (oldStackDate > newStackDate) {
             throw new Error('Migration Error. You cannot migrate data from new stack onto old. Kindly contact support@contentstack.com for more details.')
           } else if (oldStackDate === newStackDate) {
-            addlogs(config, 'The version of both the stacks are same.', 'success')
+            addlogs(importConfig, 'The version of both the stacks are same.', 'success')
             return Promise.resolve()
           }
-          addlogs(config, 'Updating stack version.', 'success')
+          addlogs(importConfig, 'Updating stack version.', 'success')
           // Update the new stack
           var updateStackOptions = {
-            url: config.host + config.apis.stacks + 'settings/set-version',
+            url: importConfig.host + importConfig.apis.stacks + 'settings/set-version',
             method: 'PUT',
-            headers: config.headers,
+            headers: importConfig.headers,
             body: {
               stack_settings: {
                 version: '2017-10-14' // This can be used as a variable
@@ -95,7 +96,7 @@ exports.sanitizeStack = function (config) {
 
           return request(updateStackOptions)
             .then((response) => {
-              addlogs(config, `Stack version preserved successfully!\n${JSON.stringify(response.body)}`, 'success')
+              addlogs(importConfig, `Stack version preserved successfully!\n${JSON.stringify(response.body)}`, 'success')
               return;
             })
         } 
@@ -106,6 +107,77 @@ exports.sanitizeStack = function (config) {
   }
 }
 
+exports.masterLocalDetails = function(credentialConfig) {
+  let client = stack.Client(credentialConfig)
+  return new Promise((resolve, reject) => {
+    var result =  client.stack({ api_key: credentialConfig.target_stack, management_token: credentialConfig.management_token }).locale().query()
+      result.find()
+      .then(response => {
+        var masterLocalObj = response.items.filter(obj => {
+            if (obj.fallback_locale === null) {
+              return obj
+            }
+            });
+        return resolve(masterLocalObj[0])
+      }).catch(error => {
+        return reject(error)
+      })
+  })
+};
+
+exports.field_rules_update = function(importConfig, ctPath) {
+  return new Promise(function (resolve, reject) {
+    let client = stack.Client(importConfig)
+    
+    fs.readFile(path.join(ctPath + '/field_rules_uid.json'), async (err, data) => {
+      if (err) {
+        throw err;
+      }
+      var ct_field_visibility_uid = JSON.parse(data)
+      let ct_files = fs.readdirSync(ctPath)
+      if (ct_field_visibility_uid && ct_field_visibility_uid != 'undefined') {
+        for (let index = 0; index < ct_field_visibility_uid.length; index++) {
+          if (ct_files.indexOf(ct_field_visibility_uid[index] + '.json') > -1) {
+            let schema = require(path.resolve(ctPath, ct_field_visibility_uid[index]))
+            // await field_rules_update(schema)
+            let fieldRuleLength = schema.field_rules.length
+            for (let k = 0; k < fieldRuleLength; k++) {
+              let fieldRuleConditionLength = schema.field_rules[k].conditions.length
+              for (let i = 0; i < fieldRuleConditionLength; i++) {
+                if (schema.field_rules[k].conditions[i].operand_field === 'reference') {
+                  let entryMapperPath = path.resolve(importConfig.data, 'mapper', 'entries')
+                  let entryUidMapperPath = path.join(entryMapperPath, 'uid-mapping.json')
+                  let fieldRulesValue = schema.field_rules[k].conditions[i].value
+                  let fieldRulesArray = fieldRulesValue.split('.')
+                  let updatedValue = []
+                  for (let j = 0; j < fieldRulesArray.length; j++) {
+                    let splitedFieldRulesValue = fieldRulesArray[j]
+                    let oldUid = helper.readFile(path.join(entryUidMapperPath))
+                    if (oldUid.hasOwnProperty(splitedFieldRulesValue)) {
+                      updatedValue.push(oldUid[splitedFieldRulesValue])
+                    } else {
+                      updatedValue.push(fieldRulesArray[j])
+                    }
+                  }
+                  schema.field_rules[k].conditions[i].value = updatedValue.join('.')
+                }
+              }
+            }
+            let ctObj = client.stack({ api_key: importConfig.target_stack, management_token: importConfig.management_token }).contentType(schema.uid)
+            Object.assign(ctObj, _.cloneDeep(schema))
+            ctObj.update()
+              .then(() => {
+                return resolve()
+              }).catch(function (error) {
+                return reject(error)
+              })
+          }
+        }
+      }
+    })
+  })
+}
+
 exports.getConfig = function() {
   return config
 };

package/src/lib/util/log.js

@@ -91,9 +91,11 @@ function init (_logPath, logfileName) {
 }
 
 exports.addlogs = async (config, message, type) => {
+  var configLogPath
+  config.source_stack && config.target_stack ? configLogPath = config.data : configLogPath = config.oldPath
   if (type !== 'error') {
-    init(config.oldPath, type).log(message)
+    init(configLogPath, type).log(message)
   } else {
-    init(config.oldPath, type).error(message)
+    init(configLogPath, type).error(message)
   }
 }

package/src/lib/util/login.js

@@ -34,9 +34,9 @@ module.exports = function (config) {
       }).catch(reject);
     } else if (config.management_token) {
       return resolve()
-    } else if (config.auth_token) {                  
+    } else if (config.auth_token) {                 
       //  return resolve()
-      client.stack({api_key: config.target_stack, management_token: config.management_token}).users()
+      client.stack({api_key: config.target_stack, management_token: config.management_token}).fetch()
       .then(function () {
           return resolve()
       })
@@ -44,10 +44,10 @@ module.exports = function (config) {
         let errorstack_key = error.errors.api_key       
         if(error.errors.api_key) {
           addlogs(config, chalk.red("Stack Api key " + errorstack_key[0], "Please enter valid Key"), 'error')
-          return reject()
+          return reject(error)
         }
         addlogs(config, error.errorMessage, 'error')
-        return reject()
+        return reject(error)
       })
     }
   });