Feature/984: bulk update notification email addresses

.husky/pre-commit

@@ -1,3 +1,6 @@
-#npm run docs
-#git update-index --add docs/dist/documentation.md
+echo "[PRE-COMMIT] Re-creating documentation..."
+npm run docs
+git update-index --add docs/dist/documentation.md
+
+echo "[PRE-COMMIT] Running lint-staged..."
 npx --no lint-staged

lib/cli.js

@@ -560,6 +560,63 @@ yargs(hideBin(process.argv))
  Mcdev.fixKeys(argv.BU, argv.TYPE, csvToArray(argv.KEY));
  },
  })
+ .command({
+ command: 'updateNotifications <BU> <TYPE> [KEY]',
+ aliases: ['un'],
+ desc: 'bulk updates notification email addresses',
+ builder: (yargs) => {
+ yargs
+ .positional('BU', {
+ type: 'string',
+ describe: 'the business unit where to update notification email address',
+ })
+ .positional('TYPE', {
+ type: 'string',
+ describe: 'metadata type',
+ })
+ .positional('KEY', {
+ type: 'string',
+ describe: 'key(s) of the metadata component(s)',
+ })
+ .option('errorEmail', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe: 'email to notify that an error occured during execution',
+ })
+ .option('completionEmail', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe: 'email to notify about successfull completion',
+ })
+ .option('errorNote', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe: 'run error note',
+ })
+ .option('completionNote', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe: 'run completion note',
+ })
+ .option('clear', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe:
+ "remove notification email addresses and/or notes. Possible options: 'all', 'errorEmail', 'completionEmail', 'notes' for automation. For the rest of types any value would do (true/all/etc.)",
+ })
+ .option('like', {
+ type: 'string',
+ group: 'Options for updateNotifications:',
+ describe:
+ 'filter metadata components (can include % as wildcard or _ for a single character)',
+ });
+ },
+ handler: (argv) => {
+ Mcdev.setOptions(argv);
+ // ! do not allow multiple types to be passed in here via csvToArray
+ Mcdev.updateNotifications(argv.BU, argv.TYPE, csvToArray(argv.KEY));
+ },
+ })
  .command({
  command: 'upgrade',
  aliases: ['up'],

lib/index.js

@@ -73,6 +73,11 @@ class Mcdev {
  '_runningTest',
  'schedule',
  'skipInteraction',
+ 'errorEmail',
+ 'completionEmail',
+ 'errorNote',
+ 'completionNote',
+ 'clear',
  ];
  for (const option of knownOptions) {
  if (argv[option] !== undefined) {
@@ -798,7 +803,7 @@ class Mcdev {
  /**
  * run a method across BUs
  *
- * @param {'execute'|'pause'|'fixKeys'} methodName what to run
+ * @param {'execute'|'pause'|'fixKeys'|'updateNotifications'} methodName what to run
  * @param {string} businessUnit name of BU
  * @param {TYPE.SupportedMetadataTypes} [selectedType] limit to given metadata types
  * @param {string[]} [keys] customerkey of the metadata
@@ -834,6 +839,13 @@ class Mcdev {
  checkMetadataSupport = false;
  break;
  }
+ case 'updateNotifications': {
+ lang_past = 'updated notifications for';
+ lang_present = 'updating notifications for';
+ requireKeyOrLike = true;
+ checkMetadataSupport = false;
+ break;
+ }
  }
 
  Util.logger.info(`mcdev:: ${methodName} ${selectedType}`);
@@ -961,7 +973,7 @@ class Mcdev {
  /**
  * helper for {@link Mcdev.#runMethod}
  *
- * @param {'execute'|'pause'|'fixKeys'} methodName what to run
+ * @param {'execute'|'pause'|'fixKeys'|'updateNotifications'} methodName what to run
  * @param {string} cred name of Credential
  * @param {string} bu name of BU
  * @param {TYPE.SupportedMetadataTypes} [type] limit execution to given metadata type
@@ -999,6 +1011,21 @@ class Mcdev {
  break;
  }
  }
+ case 'updateNotifications': {
+ if (Object.prototype.hasOwnProperty.call(MetadataTypeInfo[type], methodName)) {
+ resultArr.push(...(await MetadataTypeInfo[type][methodName](keyArr)));
+ if (resultArr.length > 0) {
+ Util.logger.info(`Retrieving ${type} to have most recent changes`);
+ const retriever = new Retriever(properties, buObject);
+ await retriever.retrieve([type], resultArr, null, false);
+ }
+ } else {
+ resultArr.push(
+ ...(await this.#updateNotifications(cred, bu, type, keyArr))
+ );
+ }
+ break;
+ }
  default: {
  if (Util.OPTIONS.like && Object.keys(Util.OPTIONS.like).length) {
  keyArr = await this.#retrieveKeysWithLike(type, buObject);
@@ -1012,7 +1039,6 @@ class Mcdev {
  } catch (ex) {
  Util.logger.errorStack(ex, 'mcdev.' + methodName + ' failed');
  }
-
  return resultArr;
  }
 
@@ -1092,16 +1118,71 @@ class Mcdev {
  static async #fixKeys(cred, bu, type, keyArr) {
  const properties = await config.getProperties();
  let actuallyFixedKeys = [];
- const resultArr = [];
-
  if (
  MetadataTypeDefinitions[type].keyIsFixed === true ||
  MetadataTypeDefinitions[type].keyField === MetadataTypeDefinitions[type].idField
  ) {
  Util.logger.error(`Key cannot be updated for this type`);
- return resultArr;
+ return actuallyFixedKeys;
+ }
+ const buObject = await Cli.getCredentialObject(
+ properties,
+ cred === null ? null : cred + '/' + bu,
+ null,
+ true
+ );
+ this.setOptions({
+ changeKeyField: MetadataTypeDefinitions[type].nameField,
+ fromRetrieve: true,
+ });
+ actuallyFixedKeys = await this.#updateItems(cred, bu, type, keyArr, 'fixKeys');
+ const dependentTypes = await Util.getDependentMetadata(type);
+ if (actuallyFixedKeys && actuallyFixedKeys.length) {
+ Util.logger.info(
+ `Successfully updated ${actuallyFixedKeys.length} key${
+ actuallyFixedKeys.length === 1 ? '' : 's'
+ } of type ${type}`
+ );
+ if (dependentTypes.length) {
+ Util.logger.warn(
+ `Please re-retrieve the following types as your local copies might now be outdated: ${Util.getGrayMsg(
+ dependentTypes.join(', ')
+ )}`
+ );
+ const reRetrieve = await Cli.postFixKeysReretrieve(type, dependentTypes);
+ if (reRetrieve) {
+ Util.logger.info(
+ `Retrieving latest versions of ${dependentTypes.join(', ')} from server`
+ );
+ const retriever = new Retriever(properties, buObject);
+ await retriever.retrieve(dependentTypes, null, null, false);
+ }
+ } else {
+ Util.logger.info(
+ `No dependent types found that need to be re-retrieved after fixing keys of type ${type}.`
+ );
+ }
+ } else {
+ Util.logger.warn(`No keys of type ${type} updated.`);
  }
 
+ return actuallyFixedKeys;
+ }
+ /**
+ * A function to retrieve, update and deploy items
+ *
+ * @param {string} cred name of Credential
+ * @param {string} bu name of BU
+ * @param {TYPE.SupportedMetadataTypes} type limit execution to given metadata type
+ * @param {string[]} [keyArr] customerkey of the metadata
+ * @param {string} methodName name of the function to execute
+ * @returns {Promise.<string[]>} list of keys that were affected
+ */
+ static async #updateItems(cred, bu, type, keyArr, methodName) {
+ const properties = await config.getProperties();
+ let actuallyUpdatedItems = [];
+ const resultArr = [];
+
  const buObject = await Cli.getCredentialObject(
  properties,
  cred === null ? null : cred + '/' + bu,
@@ -1114,55 +1195,108 @@ class Mcdev {
  const retrieved = await retriever.retrieve([type], keyArr, null, false);
 
  const metadataMap = Object.values(retrieved)[0][0];
- const keysForDeploy = MetadataTypeInfo[type].getKeysForFixing(metadataMap);
+ const keysForDeploy = await this.#getKeys(type, metadataMap, methodName);
  if (keysForDeploy.length < 1) {
  Util.logger.warn(
  `No items found with a key-name mismatch that match your criteria.\n`
  );
  return resultArr;
  }
- this.setOptions({
- changeKeyField: MetadataTypeDefinitions[type].nameField,
- fromRetrieve: true,
- });
  const deployed = await Deployer.deploy(cred + '/' + bu, [type], keysForDeploy);
- actuallyFixedKeys = Object.keys(Object.values(Object.values(deployed)[0])[0]);
- resultArr.push(...actuallyFixedKeys);
- const dependentTypes = await Util.getDependentMetadata(type);
- if (actuallyFixedKeys && actuallyFixedKeys.length) {
- Util.logger.info(
- `Successfully updated ${actuallyFixedKeys.length} key${
- actuallyFixedKeys.length === 1 ? '' : 's'
- } of type ${type}`
- );
- if (dependentTypes.length) {
- Util.logger.warn(
- `Please re-retrieve the following types as your local copies might now be outdated: ${Util.getGrayMsg(
- dependentTypes.join(', ')
- )}`
- );
- const reRetrieve = await Cli.postFixKeysReretrieve(type, dependentTypes);
- if (reRetrieve) {
- Util.logger.info(
- `Retrieving latest versions of ${dependentTypes.join(', ')} from server`
- );
- const retriever = new Retriever(properties, buObject);
- await retriever.retrieve(dependentTypes, null, null, false);
- }
- } else {
- Util.logger.info(
- `No dependent types found that need to be re-retrieved after fixing keys of type ${type}.`
- );
- }
- } else {
- Util.logger.warn(`No keys of type ${type} updated.`);
- }
+ actuallyUpdatedItems = Object.keys(Object.values(Object.values(deployed)[0])[0]);
+ resultArr.push(...actuallyUpdatedItems);
  } catch (ex) {
- Util.logger.errorStack(ex, 'mcdev.fixKeys failed');
+ Util.logger.errorStack(ex, `mcdev.${methodName} failed`);
  }
- Util.logger.info(`:: Done\n`);
  return resultArr;
  }
+ /**
+ * helper function to get keys of items to update
+ *
+ * @param {TYPE.SupportedMetadataTypes} type limit execution to given metadata type
+ * @param {TYPE.MetadataTypeMap} metadataMap metadata mapped by their keyField
+ * @param {string} methodName name of the method to execute
+ * @returns {string[]} list of keys
+ */
+ static async #getKeys(type, metadataMap, methodName) {
+ const keys = [];
+ switch (methodName) {
+ case 'fixKeys': {
+ keys.push(...(await MetadataTypeInfo[type].getKeysForFixing(metadataMap)));
+ break;
+ }
+ case 'updateNotifications': {
+ keys.push(...(await MetadataTypeInfo[type].getKeysToSetNotifications(metadataMap)));
+ break;
+ }
+ }
+ return keys;
+ }
+ /**
+ * Updates notification email address field
+ *
+ * @param {string} businessUnit name of BU
+ * @param {TYPE.SupportedMetadataTypes} selectedType limit execution to given metadata type
+ * @param {string[]} [keys] customerkey of the metadata
+ * @returns {Promise.<Object.<string, string[]>>} key: business unit name, value: list of affected item keys
+ */
+ static async updateNotifications(businessUnit, selectedType, keys) {
+ if (
+ !Util.OPTIONS.completionEmail &&
+ !Util.OPTIONS.errorEmail &&
+ !Util.OPTIONS.completionNote &&
+ !Util.OPTIONS.errorNote &&
+ !Util.OPTIONS.clear
+ ) {
+ // if no options were provided there is nothing to update
+ Util.logger.error(`No email addresses, run notes or a clear option was provided`);
+ return [];
+ }
+
+ return await this.#runMethod('updateNotifications', businessUnit, selectedType, keys);
+ }
+ /**
+ * Updates notification email address field
+ *
+ * @param {string} cred name of Credential
+ * @param {string} bu name of BU
+ * @param {TYPE.SupportedMetadataTypes} type limit execution to given metadata type
+ * @param {string[]} [keyArr] customerkey of the metadata
+ * @returns {Promise.<string[]>} list of keys that were affected
+ */
+ static async #updateNotifications(cred, bu, type, keyArr) {
+ let keysUpdatedNotifications = [];
+ if (Util.OPTIONS.errorEmail || Util.OPTIONS.errorNote || Util.OPTIONS.completionNote) {
+ Util.logger.error(
+ `--errorEmail, --errorNote and --completionNote options are not available for ${type}`
+ );
+ return keysUpdatedNotifications;
+ }
+ if (!MetadataTypeDefinitions[type].fields.sendEmailNotification) {
+ Util.logger.error(`Update notifications is not supported for this type`);
+ return keysUpdatedNotifications;
+ }
+ this.setOptions({
+ fromRetrieve: true,
+ });
+ keysUpdatedNotifications = await this.#updateItems(
+ cred,
+ bu,
+ type,
+ keyArr,
+ 'updateNotifications'
+ );
+ if (keysUpdatedNotifications && keysUpdatedNotifications.length) {
+ Util.logger.info(
+ `Successfully updated notifications. Updated ${
+ keysUpdatedNotifications.length
+ } key${keysUpdatedNotifications.length === 1 ? '' : 's'} of type ${type}`
+ );
+ } else {
+ Util.logger.warn(`No keys of type ${type} updated.`);
+ }
+ return keysUpdatedNotifications;
+ }
 }
 
 export default Mcdev;