async buildTaskItem()

in source/services/tasks/tasks.ts [717:831]
97 lines of code
22 McCabe index (conditional complexity)

    async buildTaskItem(task: TaskInfo, taskId?: string): Promise<TaskReturn | ErrorReturn> {
        try {
            let item = {
                taskId: taskId ? taskId : uuid.v4(),
                name: task.name,
                description: task.description,
                targetTag: task.targetTag,
                accounts: COMMON_UTIL.trimStringInArray(task.accounts.split(',')),
                regions: COMMON_UTIL.trimStringInArray(task.regions.split(',')),
                actionName: task.actionName,
                triggerType: task.triggerType,
                enabled: task.enabled !== undefined ? task.enabled : true
            };

            // Checks regions
            let regions = await this.getAwsRegions() as string[];
            for (let region of item['regions']) {
                if (regions.indexOf(region) < 0) {
                    return Promise.reject(
                        COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid region: ${region}`)
                    );
                }
            }

            // Checks accounts
            for (let account of item['accounts']) {
                if (!/^\d{12}$/.test(account)) {
                    return Promise.reject(
                        COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid account, account should be 12 digit number: ${account}`)
                    );
                }
            }

            // Checks and create trigger type
            if (task.triggerType === TriggerType.Schedule) {
                item['scheduledType'] = task.scheduledType;
                if (task.scheduledType === ScheduledType.CronExpression) {
                    if (task.scheduledCronExpression === undefined) {
                        return Promise.reject(
                            COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, 'Missing key/value: scheduledCronExpression')
                        );
                    }
                    item['scheduledCronExpression'] = task.scheduledCronExpression;
                } else if (task.scheduledType === ScheduledType.FixedRate) {
                    if (task.scheduledFixedRateInterval === undefined) {
                        return Promise.reject(
                            COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, 'Missing key/value: scheduledFixedRateInterval')
                        );
                    } else if (task.scheduledFixedRateType === undefined) {
                        return Promise.reject(
                            COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, 'Missing key/value: scheduledFixedRateType')
                        );
                    }

                    // Checks if the rate interval is valid
                    if (!/^[1-9]\d*$/.test(task.scheduledFixedRateInterval)) {
                        return Promise.reject(
                            COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, 'Invalid interval (1 <= interval, integer).')
                        );
                    }
                    item['scheduledFixedRateInterval'] = +task.scheduledFixedRateInterval;

                    // Checks if the rate type is valid
                    if (!Object.values(ScheduledFixedRateType).includes(task.scheduledFixedRateType)) {
                        return Promise.reject(
                            COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid rate type: ${task.scheduledFixedRateType}.`)
                        );
                    }

                    // If the interval is 1, remove 's' from the rate type if it has at the end
                    item['scheduledFixedRateType'] =
                        +task.scheduledFixedRateInterval === 1 && task.scheduledFixedRateType.endsWith('s') ?
                        task.scheduledFixedRateType.slice(0, -1) :
                        task.scheduledFixedRateType
                } else {
                    // This can happen if a user calls API directly with invalid value.
                    return Promise.reject(
                        COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid schedule type: ${task.scheduledType}`)
                    );
                }
            } else if (task.triggerType === TriggerType.Event) {
                if (task.eventPattern === undefined) {
                    return Promise.reject(
                        COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, 'Missing key/value: eventPattern')
                    )
                }

                // Checks if eventPattern is valid JSON
                try {
                    LOGGER.info(`eventPattern: ${task.eventPattern}`);
                    JSON.parse(task.eventPattern);
                } catch (error) {
                    return Promise.reject(
                        COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid eventPattern: ${error.message}`)
                    )
                }

                item['eventPattern'] = task.eventPattern;
            } else {
                // This can happen if a user calls API directly with invalid value.
                return Promise.reject(
                    COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Invalid trigger type: ${task.triggerType}`)
                );
            }
            let taskParameters = await this.checkParameterValue(task.taskParameters);
            item['taskParameters'] = taskParameters;

            return Promise.resolve(item);
        } catch (error) {
            LOGGER.error(`buildTaskItem Error: ${JSON.stringify(error)}`);
            return Promise.reject(
                COMMON_UTIL.getErrorObject('BuildTaskItemFailure', 400, `Error occurred while building a task item.`, error)
            );
        }
    }