private bool AreCentralVersionRequirementsSatisfied()

in src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs [1019:1173]
126 lines of code
29 McCabe index (conditional complexity)

        private bool AreCentralVersionRequirementsSatisfied(RestoreRequest restoreRequest, int httpSourcesCount)
        {
            if (restoreRequest?.Project?.RestoreMetadata == null || !restoreRequest.Project.RestoreMetadata.CentralPackageVersionsEnabled)
            {
                return true;
            }

            bool result = true;

            if (!restoreRequest.PackageSourceMapping.IsEnabled && httpSourcesCount > 1)
            {
                // Log a warning if there are more than one configured HTTP source and package source mapping is not enabled
                _logger.Log(
                    RestoreLogMessage.CreateWarning(
                        NuGetLogCode.NU1507,
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Warning_CentralPackageManagement_MultipleSourcesWithoutPackageSourceMapping,
                            httpSourcesCount,
                            string.Join(", ", restoreRequest.DependencyProviders.RemoteProviders.Where(i => i.IsHttp).Select(i => i.Source.Name)))));
            }

            List<CentralPackageVersion> packageVersionItemsWithFloatingVersion = null;
            List<LibraryDependency> implicitPackageReferenceItemsWithPackageVersion = null;
            List<LibraryDependency> packageReferenceItemsWithNoPackageVersion = null;
            List<LibraryDependency> packageReferenceItemsWithVersion = null;
            List<LibraryDependency> packageReferenceItemsWithVersionOverride = null;

            foreach (TargetFrameworkInformation targetFrameworkInformation in _request.Project.TargetFrameworks)
            {
                foreach (LibraryDependency libraryDependency in targetFrameworkInformation.Dependencies)
                {
                    if (libraryDependency.AutoReferenced)
                    {
                        // Implicitly defined packages that the user specified a version for
                        if (targetFrameworkInformation.CentralPackageVersions.ContainsKey(libraryDependency.Name))
                        {
                            implicitPackageReferenceItemsWithPackageVersion ??= new();

                            implicitPackageReferenceItemsWithPackageVersion.Add(libraryDependency);
                        }
                    }
                    else
                    {
                        // VersionOverride is specified but that functionality is disabled
                        if (restoreRequest.Project.RestoreMetadata.CentralPackageVersionOverrideDisabled && libraryDependency.VersionOverride != null)
                        {
                            packageReferenceItemsWithVersionOverride ??= new();

                            packageReferenceItemsWithVersionOverride.Add(libraryDependency);
                        }

                        // Dependencies that have a version specified
                        if (!libraryDependency.VersionCentrallyManaged && libraryDependency.LibraryRange.VersionRange != null && libraryDependency.VersionOverride == null)
                        {
                            packageReferenceItemsWithVersion ??= new();

                            packageReferenceItemsWithVersion.Add(libraryDependency);
                        }

                        // Dependencies that have no version specified
                        if (libraryDependency.LibraryRange?.VersionRange == null)
                        {
                            packageReferenceItemsWithNoPackageVersion ??= new();

                            packageReferenceItemsWithNoPackageVersion.Add(libraryDependency);
                        }
                    }
                }

                if (!restoreRequest.Project.RestoreMetadata.CentralPackageFloatingVersionsEnabled)
                {
                    foreach (KeyValuePair<string, CentralPackageVersion> centralPackageVersion in targetFrameworkInformation.CentralPackageVersions.NoAllocEnumerate())
                    {
                        // Floating version dependencies
                        if (centralPackageVersion.Value.VersionRange.IsFloating)
                        {
                            packageVersionItemsWithFloatingVersion ??= new();

                            packageVersionItemsWithFloatingVersion.Add(centralPackageVersion.Value);
                        }
                    }
                }
            }

            if (packageReferenceItemsWithVersion != null && packageReferenceItemsWithVersion.Count > 0)
            {
                result = false;

                _logger.Log(
                    RestoreLogMessage.CreateError(
                        NuGetLogCode.NU1008,
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Error_CentralPackageManagement_PackageReferenceWithVersionNotAllowed,
                            string.Join(", ", packageReferenceItemsWithVersion.Select(d => d.Name)))));
            }

            if (implicitPackageReferenceItemsWithPackageVersion != null && implicitPackageReferenceItemsWithPackageVersion.Count > 0)
            {
                result = false;

                _logger.Log(
                    RestoreLogMessage.CreateError(
                        NuGetLogCode.NU1009,
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Error_CentralPackageManagement_ImplicitPackageReferenceWithVersionNotAllowed,
                            string.Join(", ", implicitPackageReferenceItemsWithPackageVersion.Select(d => d.Name)))));
            }

            if (packageReferenceItemsWithNoPackageVersion != null && packageReferenceItemsWithNoPackageVersion.Count > 0)
            {
                result = false;

                _logger.Log(
                    RestoreLogMessage.CreateError(
                        NuGetLogCode.NU1010,
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Error_CentralPackageManagement_MissingPackageVersion,
                            string.Join(", ", packageReferenceItemsWithNoPackageVersion.Select(d => d.Name)))));
            }

            if (packageVersionItemsWithFloatingVersion != null && packageVersionItemsWithFloatingVersion.Count > 0)
            {
                result = false;

                _logger.Log(
                    RestoreLogMessage.CreateError(
                        NuGetLogCode.NU1011,
                        string.Format(
                            CultureInfo.CurrentCulture,
                            Strings.Error_CentralPackageManagement_FloatingVersionsNotAllowed,
                            string.Join(", ", packageVersionItemsWithFloatingVersion.Select(i => i.Name)))));
            }

            if (packageReferenceItemsWithVersionOverride != null && packageReferenceItemsWithVersionOverride.Count > 0)
            {
                result = false;

                foreach (var item in packageReferenceItemsWithVersionOverride)
                {
                    _logger.Log(
                        RestoreLogMessage.CreateError(
                            NuGetLogCode.NU1013,
                            string.Format(
                                CultureInfo.CurrentCulture,
                                Strings.Error_CentralPackageManagement_VersionOverrideNotAllowed,
                                item.Name)));
                }
            }

            return result;
        }