public async Task AnalyzeSolutionAsync()

in src/PortingAssistant.Client.Client/PortingAssistantClient.cs [30:102]
62 lines of code
5 McCabe index (conditional complexity)

        public async Task<SolutionAnalysisResult> AnalyzeSolutionAsync(string solutionFilePath, AnalyzerSettings settings)
        {
            try
            {
                var solution = SolutionFile.Parse(solutionFilePath);
                var failedProjects = new List<string>();

                var projects = ProjectsToAnalyze(solutionFilePath, settings);

                var targetFramework = settings.TargetFramework ?? DEFAULT_TARGET;

                Dictionary<string, ProjectAnalysisResult> projectAnalysisResultsDict;

                if (settings.ContiniousEnabled)
                    projectAnalysisResultsDict = await _analysisHandler.AnalyzeSolutionIncremental(solutionFilePath, projects, targetFramework);
                else
                    projectAnalysisResultsDict = await _analysisHandler.AnalyzeSolution(solutionFilePath, projects, targetFramework);

                var projectAnalysisResults = projects.Select(p =>
                {
                    var projectAnalysisResult = projectAnalysisResultsDict.GetValueOrDefault(p, null);
                    if (projectAnalysisResult != null)
                    {
                        if (projectAnalysisResult.IsBuildFailed)
                        {
                            failedProjects.Add(p);
                        }
                        return projectAnalysisResult;
                    }
                    return null;
                }).Where(p => p != null).ToList();

                string solutionGuid = FileParser.SolutionFileParser.getSolutionGuid(solutionFilePath);
                var solutionDetails = new SolutionDetails
                {
                    SolutionName = Path.GetFileNameWithoutExtension(solutionFilePath),
                    SolutionFilePath = solutionFilePath,
                    SolutionGuid = solutionGuid,
                    RepositoryUrl = FileParser.GitConfigFileParser.getGitRepositoryUrl(
                        FileParser.GitConfigFileParser.getGitRepositoryRootPath(solutionFilePath)),
                    ApplicationGuid = solutionGuid ?? Utils.HashUtils.GenerateGuid(
                        projectAnalysisResults.Select(p => p.ProjectGuid).ToList()),
                    Projects = projectAnalysisResults.ConvertAll(p => new ProjectDetails
                    {
                        PackageReferences = p.PackageReferences,
                        ProjectFilePath = p.ProjectFilePath,
                        ProjectGuid = p.ProjectGuid,
                        FeatureType = p.FeatureType,
                        ProjectName = p.ProjectName,
                        ProjectReferences = p.ProjectReferences,
                        ProjectType = p.ProjectType,
                        TargetFrameworks = p.TargetFrameworks,
                        IsBuildFailed = p.IsBuildFailed
                    }),

                    FailedProjects = failedProjects
                };


                return new SolutionAnalysisResult
                {
                    FailedProjects = failedProjects,
                    SolutionDetails = solutionDetails,
                    ProjectAnalysisResults = projectAnalysisResults
                };

            }
            catch (Exception ex)
            {
                throw new PortingAssistantException($"Cannot Analyze solution {solutionFilePath}", ex);
            }

        }