internal static void ValidateUserSelection()

in code/src/CoreTemplateStudio/CoreTemplateStudio.Core/Gen/GenController.cs [118:183]
54 lines of code
12 McCabe index (conditional complexity)

        internal static void ValidateUserSelection(UserSelection userSelection, bool isNewProject)
        {
            if (isNewProject)
            {
                var rootDir = Directory.GetParent(Directory.GetParent(GenContext.Current.DestinationPath).FullName).FullName;

                var projectNameService = new ProjectNameService(GenContext.ToolBox.Repo.ProjectNameValidationConfig, () => Fs.GetExistingFolderNames(rootDir));

                var result = projectNameService.Validate(GenContext.Current.ProjectName);
                {
                    if (!result.IsValid)
                    {
                        var errors = string.Join(Environment.NewLine, result.Errors.Select(e => $"Error: {e.ErrorType}; Validator: {e.ValidatorName}."));
                        throw new InvalidDataException(string.Format(StringRes.ErrorProjectNameValidationFailed, GenContext.Current.ProjectName, Environment.NewLine + errors));
                    }
                }
            }

            foreach (var item in userSelection.Items)
            {
                var template = GenContext.ToolBox.Repo.Find(t => t.Identity == item.TemplateId);

                if (template.GetItemNameEditable())
                {
                    Func<IEnumerable<string>> existingNames = () => userSelection.Items.Where(t => t.TemplateId != template.Identity).Select(n => n.Name);

                    var itemNameService = new ItemNameService(GenContext.ToolBox.Repo.ItemNameValidationConfig, existingNames);

                    var validationResult = itemNameService.Validate(item.Name);
                    {
                        if (!validationResult.IsValid)
                        {
                            var errors = string.Join(Environment.NewLine, validationResult.Errors.Select(e => $"Error: {e.ErrorType}; Validator: {e.ValidatorName}."));
                            throw new InvalidDataException(string.Format(StringRes.ErrorNamingValidationFailed, item.Name, Environment.NewLine + errors));
                        }
                    }
                }

                var dependencies = GenContext.ToolBox.Repo.GetDependencies(template, userSelection.Context, new List<ITemplateInfo>());

                foreach (var dependency in dependencies)
                {
                    if (!userSelection.Items.Any(i => i.TemplateId == dependency.Identity))
                    {
                        throw new InvalidDataException(string.Format(StringRes.ErrorDependencyMissing, dependency));
                    }
                }

                var requirements = GenContext.ToolBox.Repo.GetRequirements(template, userSelection.Context);

                if (requirements.Count() > 0 && !userSelection.Items.Any(i => requirements.Select(r => r.Identity).Contains(i.TemplateId)))
                {
                    throw new InvalidDataException(string.Format(StringRes.ErrorRequirementMissing, requirements.Select(r => r.Name).Aggregate((i, j) => $"{i},{j}")));
                }

                var exclusionTemplates = GenContext.ToolBox.Repo.GetExclusions(template, userSelection.Context);

                foreach (var exclusion in exclusionTemplates)
                {
                    if (userSelection.Items.Any(i => i.TemplateId == exclusion.Identity))
                    {
                        throw new InvalidDataException(string.Format(StringRes.ErrorExcludedTemplatesFound, exclusion.Name));
                    }
                }
            }
        }