Plugin will display an error message when no valid projects are found in the open solution (AST-116483) (#291)

* Improve Visual Studio Plugin Behavior When No Projects Are Detected in Solution (AST-AST-116483)

* fix bug #AST-120978

---------

Co-authored-by: cx-Margarita-LevitM <cx-margarita-levitm>

Author: cx-margarita-levitm

ast-visual-studio-extension/CxExtension/Toolbar/CxToolbar.cs

@@ -50,6 +50,61 @@ internal class CxToolbar
         public Func<List<State>, Dictionary<MenuItem, State>> CreateStateMenuItems { get; set; }
 
         private static bool initPolling = false;
+
+        public static bool IsValidSourceProject(string sourcePath)
+        {
+            if (string.IsNullOrEmpty(sourcePath))
+            {
+                return false;
+            }
+
+            try
+            {
+                string searchPath;
+                if (System.IO.File.Exists(sourcePath))
+                {
+                    searchPath = System.IO.Path.GetDirectoryName(sourcePath);
+                }
+                else if (System.IO.Directory.Exists(sourcePath))
+                {
+                    searchPath = sourcePath;
+                }
+                else
+                {
+                    return false;
+                }
+
+                string[] projectExtensions = { "*.sln", "*.csproj" };
+
+                foreach (string extension in projectExtensions)
+                {
+                    var files = System.IO.Directory.GetFiles(searchPath, extension, System.IO.SearchOption.AllDirectories);
+                    if (files.Any(file => IsValidProjectFile(file)))
+                        return true;
+                }
+
+                return false;
+            }
+            catch (Exception ex)
+            {
+                UpdateStatusBar("Checkmarx: Error validating project directory" + ex.Message);
+                return false;
+            }
+        }
+
+
+        private static bool IsValidProjectFile(string filePath)
+        {
+            try
+            {
+                var fileInfo = new System.IO.FileInfo(filePath);
+                return fileInfo.Exists && fileInfo.Length > 0;
+            }
+            catch
+            {
+                return false;
+            }
+        }
         private const string DevOrTestFilterName = "SCA Dev & Test Dependencies";
 
 
@@ -286,6 +341,13 @@ public async Task ScanStart_ClickAsync()
                 return;
             }
 
+            if (!IsValidSourceProject(dte.Solution.FullName))
+            {
+                CxUtils.DisplayMessageInInfoWithLinkBar(Package, CxConstants.NOT_A_VALID_PROJECT, KnownMonikers.StatusError, "Project Error", "", false);
+                ScanStartButton.IsEnabled = true;
+                return;
+            }
+
             var currentGitBranch = await GetCurrentGitBranchAsync(dte);
             var checkmarxBranch = SettingsUtils.GetToolbarValue(Package, SettingsUtils.branchProperty);
             var matchProject = await ASTProjectMatchesWorkspaceProjectAsync(dte);
@@ -322,6 +384,9 @@ private static async Task<string> GetCurrentGitBranchAsync(EnvDTE.DTE dte)
             try
             {
                 string workingDir = System.IO.Path.GetDirectoryName(dte.Solution.FullName);
+                if (string.IsNullOrEmpty(workingDir) || !System.IO.Directory.Exists(workingDir))
+                    return null;
+
                 RepositoryInformation repository = RepositoryInformation.GetRepositoryInformation(workingDir);
 
                 if (repository == null)
@@ -341,9 +406,9 @@ private static async Task<string> GetCurrentGitBranchAsync(EnvDTE.DTE dte)
 
         private static async Task<bool> ASTProjectMatchesWorkspaceProjectAsync(EnvDTE.DTE dte)
         {
-            if (ResultsTreePanel.currentResults == null || !ResultsTreePanel.currentResults.results.Any())
+            if (ResultsTreePanel.currentResults == null | ResultsTreePanel.currentResults.results == null || ResultsTreePanel.currentResults.results.Any())
             {
-                return true;
+                return false;
             }
 
             List<Result> astResults = ResultsTreePanel.currentResults.results;
@@ -434,6 +499,13 @@ private async Task StartScanAsync()
 
             string currentPath = await GetCurrentWorkingDirAsync();
 
+            // Check if a valid project/solution was found
+            if (string.IsNullOrEmpty(currentPath))
+            {
+                UpdateStatusBar(CxConstants.NOT_A_VALID_PROJECT);
+                return;
+            }
+
             Dictionary<string, string> parameters = new Dictionary<string, string>
             {
                 { CxCLI.CxConstants.FLAG_SOURCE, currentPath },
@@ -462,14 +534,91 @@ private static async Task<string> GetCurrentWorkingDirAsync()
             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
 
             DTE2 dte = (DTE2)ServiceProvider.GlobalProvider.GetService(typeof(DTE));
+            var solutionExplorer = dte?.ToolWindows?.SolutionExplorer;
+
+            // Try to get directory from solution or active projects
+            string directory = null;
+            
+            if (!string.IsNullOrEmpty(dte?.Solution?.FullName))
+            {
+                // Solution is loaded - get its directory or use the path itself if it's a directory
+                if (System.IO.File.Exists(dte.Solution.FullName))
+                {
+                    directory = System.IO.Path.GetDirectoryName(dte.Solution.FullName);
+                }
+                else if (System.IO.Directory.Exists(dte.Solution.FullName))
+                {
+                    directory = dte.Solution.FullName;
+                }
+            }
+            else if (solutionExplorer?.DTE?.ActiveSolutionProjects is Array projects && projects.Length > 0)
+            {
+                // Try to get directory from first active project
+                var firstProject = projects.GetValue(0) as EnvDTE.Project;
+                if (firstProject != null && !string.IsNullOrEmpty(firstProject.FullName))
+                {
+                    directory = System.IO.Path.GetDirectoryName(firstProject.FullName);
+                }
+            }
+
+            // If we still don't have a directory, try current directory
+            if (string.IsNullOrEmpty(directory))
+            {
+                try
+                {
+                    directory = System.IO.Directory.GetCurrentDirectory();
+                }
+                catch
+                {
+                    return null;
+                }
+            }
 
-            var solutionExplorer = dte.ToolWindows.SolutionExplorer;
+            // Now search for .sln or .csproj in the directory
+            if (!string.IsNullOrEmpty(directory) && System.IO.Directory.Exists(directory))
+            {
+                 return FindSolutionFileOrDirectory(directory);
+            }
+
+            return null;
+        }
+
+        private static string FindSolutionFileOrDirectory(string directory)
+        {
+            if (string.IsNullOrEmpty(directory) || !System.IO.Directory.Exists(directory))
+            {
+                return null;
+            }
+
+            // Look for .sln file in the directory
+            var slnFiles = System.IO.Directory.GetFiles(directory, "*.sln", System.IO.SearchOption.TopDirectoryOnly);
+            if (slnFiles.Length > 0)
+            {
+                // Return the first valid .sln file
+                foreach (var slnFile in slnFiles)
+                {
+                    if (IsValidProjectFile(slnFile))
+                    {
+                        return directory;
+                    }
+                }
+            }
 
-            if ((solutionExplorer.DTE.ActiveSolutionProjects as Array)?.Length > 0)
+            // If no .sln found, look for .csproj files
+            var csprojFiles = System.IO.Directory.GetFiles(directory, "*.csproj", System.IO.SearchOption.TopDirectoryOnly);
+            if (csprojFiles.Length > 0)
             {
-                return System.IO.Path.GetDirectoryName(dte.Solution.FullName);
+                foreach (var csprojFile in csprojFiles)
+                {
+                    if (IsValidProjectFile(csprojFile))
+                    {
+                        return directory;
+                    }
+                }
             }
-            return ".";
+
+            // No valid .sln or .csproj found - return null to trigger error
+            return null;
         }
 
         private async Task PollScanStartedAsync()

ast-visual-studio-extension/CxExtension/Utils/CxConstants.cs

@@ -93,6 +93,8 @@ internal class CxConstants
         public static string PROJECT_AND_BRANCH_DO_NOT_MATCH => "The Git branch and files open in your workspace don't match the branch and project that were previously scanned in this Checkmarx project. Do you want to scan anyway?";
         public static string RUN_SCAN => "Run scan";
         public static string RUN_SCAN_ACTION => "RUN_SCAN_ACTION";
+        public static string NOT_A_VALID_PROJECT => "No .NET project files were found in the source directory.";
+
 
         /** LEARN MORE AND REMEDIATION **/
         public static string CODE_SAMPLE_TITLE => "{0} using {1}";

ast-visual-studio-extension/CxExtension/Utils/SolutionExplorerUtils.cs

@@ -100,20 +100,22 @@ internal static Task<List<string>> SearchAllFilesAsync(string partialFileLocatio
 
                 List<string> allFiles = new List<string>();
 
-                allFiles.AddRange(await
-                    GetAllProjectFilesAsync(Path.GetDirectoryName(dte.Solution.FullName), partialFileLocation, new string[] { "bin", "obj", "packages", "node_modules", ".git", ".vs" }));
+                if (!string.IsNullOrEmpty(dte.Solution.FullName))
+                {
+                    allFiles.AddRange(await
+                        GetAllProjectFilesAsync(dte.Solution.FullName, partialFileLocation, new string[] { "bin", "obj", "packages", "node_modules", ".git", ".vs" }));
+                }
 
                 if (allFiles.Count == 0) { 
                     foreach (EnvDTE.Project project in dte.Solution.Projects)
                     {
                         if (!await IsProjectLoadedAsync(project)) continue;
 
-                        FileInfo projectFileInfo = new FileInfo(project.FullName);
-                        string projectPath = Directory.GetParent(projectFileInfo.Directory.FullName).FullName;
-
-                        string[] files = await GetAllProjectFilesAsync(projectPath, partialFileLocation, new string[] { "bin", "obj", "packages", "node_modules", ".git", ".vs" });
-
-                        allFiles.AddRange(files);
+                        if (!string.IsNullOrEmpty(dte.Solution.FullName))
+                        {
+                            string[] files = await GetAllProjectFilesAsync(dte.Solution.FullName, partialFileLocation, new string[] { "bin", "obj", "packages", "node_modules", ".git", ".vs" });
+                            allFiles.AddRange(files);
+                        }
                     }
                 }
 
@@ -151,15 +153,25 @@ static async Task<string[]> GetAllProjectFilesAsync(string path, string pathStri
         {
             List<string> files = new List<string>();
 
+            // Validate the input path
+            if (string.IsNullOrEmpty(path) || !Directory.Exists(path))
+            {
+                return Array.Empty<string>();
+            }
+
             string[] topLevelFiles = await Task.Run(() => Directory.GetFiles(path, "*.*", SearchOption.TopDirectoryOnly));
             files.AddRange(topLevelFiles.Where(file => file.EndsWith(pathString)));
 
             foreach (string directory in Directory.GetDirectories(path))
             {
                 if (!excludedDirectories.Contains(Path.GetFileName(directory)))
                 {
-                    string[] subdirectoryFiles = await GetAllProjectFilesAsync(directory, pathString, excludedDirectories);
-                    files.AddRange(subdirectoryFiles);
+                    // Validate subdirectory exists before recursive call
+                    if (Directory.Exists(directory))
+                    {
+                        string[] subdirectoryFiles = await GetAllProjectFilesAsync(directory, pathString, excludedDirectories);
+                        files.AddRange(subdirectoryFiles);
+                    }
                 }
             }