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;