public validatePipeline()

in app/scripts/modules/core/pipeline/config/validation/pipelineConfig.validator.ts [90:165]
74 lines of code
19 McCabe index (conditional complexity)

  public validatePipeline(pipeline: IPipeline): ng.IPromise<IPipelineValidationResults> {
    const stages: IStage[] = pipeline.stages || [],
          triggers: ITrigger[] = pipeline.triggers || [],
          validations: ng.IPromise<string>[] = [],
          pipelineValidations: string[] = this.getPipelineLevelValidations(pipeline),
          stageValidations: Map<IStage, string[]> = new Map();
    let preventSave = false;

    triggers.forEach((trigger, index) => {
      const config: ITriggerTypeConfig = this.pipelineConfig.getTriggerConfig(trigger.type);
      if (config && config.validators) {
        config.validators.forEach((validator) => {
          const typedValidator = this.getValidator(validator);
          if (!typedValidator) {
            this.$log.warn(`No validator of type "${validator.type}" found, ignoring validation on trigger "${(index + 1)}" (${trigger.type})`);
          } else {
            validations.push(
              this.$q.resolve<string>(typedValidator.validate(pipeline, trigger, validator, config))
                .then(message => {
                  if (message && !pipelineValidations.includes(message)) {
                    pipelineValidations.push(message);
                    if (validator.preventSave) {
                      preventSave = true;
                    }
                  }
                  return message;
                })
            );
          }
        });
      }
    });
    stages.forEach((stage) => {
      const config: IStageTypeConfig = this.pipelineConfig.getStageConfig(stage);
      if (config && config.validators) {
        config.validators.forEach((validator) => {
          if (validator.skipValidation && validator.skipValidation(pipeline, stage)) {
            return;
          }
          const typedValidator = this.getValidator(validator);
          if (!typedValidator) {
            this.$log.warn(`No validator of type "${validator.type}" found, ignoring validation on stage "${stage.name}" (${stage.type})`);
          } else {
            validations.push(
              this.$q.resolve<string>(typedValidator.validate(pipeline, stage, validator, config)).then((message: string) => {
                if (message) {
                  if (!stageValidations.has(stage)) {
                    stageValidations.set(stage, [] as string[]);
                  }
                  if (!stageValidations.get(stage).includes(message)) {
                    stageValidations.get(stage).push(message);
                    if (validator.preventSave) {
                      preventSave = true;
                    }
                  }
                }
                return message;
              })
            );
          }
        });
      }
    });

    return this.$q.all(validations).then(() => {
      const results = {
        stages: Array.from(stageValidations).map(([stage, messages]) => ({ stage, messages })),
        pipeline: pipelineValidations,
        hasWarnings: false,
        preventSave,
      };
      results.hasWarnings = results.pipeline.length > 0 || results.stages.length > 0;
      this.validationStream.next(results);
      return results;
    });
  }