/// <summary> /// Given existing template Program.cs Syntax Tree, Add configurations and generate new Syntax Tree. /// </summary> /// <param name="programTree">Syntax Tree for existing Program.cs Template</param> /// <returns>New root with updated Program.cs</returns> public SyntaxNode ReplaceProgramFile(SyntaxTree programTree) { Dictionary <string, int> transportPort = new Dictionary <string, int>(); Dictionary <string, BindingConfiguration> bindingModeMap = new Dictionary <string, BindingConfiguration>(); if (_projectType == ProjectType.WCFConfigBasedService) { string projectDir = _analyzerResult.ProjectResult.ProjectRootPath; bindingModeMap = GetBindingsTransportMap(projectDir); AddBinding(bindingModeMap, transportPort); } else { ProjectWorkspace project = _analyzerResult.ProjectResult; bindingModeMap = GetBindingsTransportMap(project); AddBinding(bindingModeMap, transportPort); } if (transportPort.IsNullOrEmpty()) { return(programTree.GetRoot()); } var containsTransportRelatedMode = bindingModeMap.Any(b => b.Value.Mode.ToLower() == Constants.TransportMessageCredentialsMode.ToLower() || b.Value.Mode.ToLower() == Constants.TransportMode.ToLower()); var newRoot = ReplaceProgramNode(transportPort, programTree, containsTransportRelatedMode); return(newRoot); }
private ISyntax CreateAbnfSyntax() { var syntax = new Syntax(); syntax.DefaultConverter.Add(CommonConverters.GuidConverter); syntax.DefaultConverter.Add(CommonConverters.Int32Converter); HostExtenderRef.Setup(syntax); HostExtenders.Setup(syntax); //LibidReference.Setup(syntax); ProjectId.Setup(syntax); ProjectDocModule.Setup(syntax); ProjectStdModule.Setup(syntax); ProjectClassModule.Setup(syntax); ProjectDesignerModule.Setup(syntax); ProjectPackage.Setup(syntax); ProjectProperties.Setup(syntax); ProjectReference.Setup(syntax); ProjectWindow.Setup(syntax); ProjectWindowState.Setup(syntax); ProjectWindowRecord.Setup(syntax); ProjectWorkspace.Setup(syntax); VBAPROJECTText.Setup(syntax); return(syntax); }
private ProjectWorkspace AnalyzeProject(ProjectBuildResult projectResult) { Logger.LogDebug("Analyzing the project: " + projectResult.ProjectPath); ProjectWorkspace workspace = new ProjectWorkspace(projectResult.ProjectPath) { SourceFiles = new UstList <string>(projectResult.SourceFiles), BuildErrors = projectResult.BuildErrors, BuildErrorsCount = projectResult.BuildErrors.Count }; if (AnalyzerConfiguration.MetaDataSettings.ReferenceData) { workspace.ExternalReferences = projectResult.ExternalReferences; } workspace.TargetFramework = projectResult.TargetFramework; workspace.TargetFrameworks = projectResult.TargetFrameworks; foreach (var fileBuildResult in projectResult.SourceFileBuildResults) { var fileAnalysis = AnalyzeFile(fileBuildResult, workspace.ProjectRootPath); workspace.SourceFileResults.Add(fileAnalysis); } return(workspace); }
private void toolStripMenuItemNewProject_Click(object sender, EventArgs e) { _logger.Trace("FormMain.toolStripMenuItemNewProject_Click()"); try { SaveAndCloseProject(false); FormNewProject form = new FormNewProject(); form.LoadLocalVariables(); if (form.ShowDialog() == DialogResult.OK) { _activeProject = form.Project; _activeControl = new ProjectWorkspace(); _activeControl.Dock = DockStyle.Fill; _activeControl.Project = _activeProject; _activeControl.OnProjectChange += activeControl_OnProjectChange; _activeControl.LoadLocalVariables(); UpdateWindowTitle(); UpdateMenuControls(); panelMain.Visible = true; panelMain.Controls.Add(_activeControl); } } catch (Exception ex) { _logger.Error(ex, ex.Message); MessageBoxHelper.ProcessException(ex); } }
/// <summary> /// Determines if the project contains a file with the given extension. /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="extension">Extension name to search for without '.'</param> /// <param name="searchSubdirectories">Whether or not to search recursively through directories</param> /// <returns>Whether or not a file with extesnion exists in the project directory</returns> /// <returns></returns> public static bool ContainsFileWithExtension(this ProjectWorkspace project, string extension, bool searchSubdirectories = true) { var projectDirectory = project.ProjectRootPath; var searchOption = searchSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; var searchPattern = string.Join(".", "*", extension); return(Directory.EnumerateFiles(projectDirectory, searchPattern, searchOption).Any()); }
protected override bool OnSaveCanExecute() { var result = ProjectWorkspace != null && !Project.HasErrors && ProjectWorkspace.All(pc => !pc.HasErrors) && HasChanges; return(result); }
/// <summary> /// Determines if a specified directory exists in the project directory and is non-empty /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="directoryName">Name of directory to search for</param> /// <param name="searchSubdirectories">Whether or not to search recursively through directories</param> /// <returns>Whether or not the specified directory exists in the project directory and is not empty</returns> public static bool ContainsNonEmptyDirectory(this ProjectWorkspace project, string directoryName, bool searchSubdirectories = true) { var projectDirectory = project.ProjectRootPath; var searchOption = searchSubdirectories ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly; var directories = Directory.EnumerateDirectories(projectDirectory, directoryName, searchOption); return(directories.Any(d => Directory.EnumerateFiles(d, "*", searchOption).Any())); }
private void OnRemoveWorkspaceExecute() { SelectedProjectWorkspace.PropertyChanged -= ProjectWorkspaceWrapper_PropertyChanged; _projectRepository.RemoveProjectWorkspace(SelectedProjectWorkspace.Model); ProjectWorkspace.Remove(SelectedProjectWorkspace); SelectedProjectWorkspace = null; HasChanges = _projectRepository.HasChanges(); ((DelegateCommand)SaveCommand).RaiseCanExecuteChanged(); }
private void InitializeProjetWrappers(int projectId) { var projectWorkspace = _projectRepository.GetProjectWorkspacesForProject(projectId); foreach (var wrapper in ProjectWorkspace) { wrapper.PropertyChanged -= ProjectWorkspaceWrapper_PropertyChanged; } ProjectWorkspace.Clear(); foreach (var item in projectWorkspace) { var wrapper = new ProjectWorkspaceWrapper(item); ProjectWorkspace.Add(wrapper); wrapper.PropertyChanged += ProjectWorkspaceWrapper_PropertyChanged; } }
public void Setup() { SolutionPath = "temp/solutionPath"; ProjectPath = "temp/solutionPath"; var projectResult = new ProjectWorkspace(ProjectPath) { ProjectGuid = "1234-5678" }; var analyzerResult = new AnalyzerResult { ProjectResult = projectResult }; var analyzerResults = new List <AnalyzerResult> { analyzerResult }; Context = new MetricsContext(SolutionPath, analyzerResults); }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { JObject jObject = JObject.Load(reader); var type = jObject["type"]; if (type != null) { string ustType = type.ToString(); UstNode item = ModelFactory.GetObject(ustType); serializer.Populate(jObject.CreateReader(), item); return(item); } else { ProjectWorkspace item = new ProjectWorkspace(""); serializer.Populate(jObject.CreateReader(), item); return(item); } }
private void SavePathInProject(string selectedPath) { var existingWorkspacesForProject = _projectRepository.GetProjectWorkspacesForProject(Project.Id); if (existingWorkspacesForProject.Where(p => p.WorkspacePath == selectedPath).Count() == 0) { var newWorkspace = new ProjectWorkspaceWrapper(new ProjectWorkspace()); newWorkspace.WorkspacePath = selectedPath; Project.Model.ProjectWorkspaces.Add(newWorkspace.Model); //TODO - Integrate with whole model validations OnSaveExecute(); ProjectWorkspace.Add(newWorkspace); } else { //TODO: Implement info for user, that path already exists } }
protected FilesFolderCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) { Project = project; Messaging = messaging; Socket = socket; messaging.Listen <ProjectFileSelected>(payload => { SelectedFile = payload.File.FullPath; SelectedFolder = string.Empty; SetProjectData(); }); messaging.Listen <ProjectFolderSelected>(payload => { SelectedFolder = payload.Folder.FullPath; SelectedFile = string.Empty; SetProjectData(); }); }
private void OpenProject(string projectLocation) { _logger.Trace("FormMain.OpenProject()"); _activeProject = ProjectsController.OpenProjectFromLocation(projectLocation, Resources.EncriptionKey); if (!_activeProject.IsValid) { return; } _activeControl = new ProjectWorkspace(); _activeControl.Dock = DockStyle.Fill; _activeControl.Project = _activeProject; _activeControl.OnProjectChange += activeControl_OnProjectChange; _activeControl.LoadLocalVariables(); UpdateWindowTitle(); UpdateMenuControls(); panelMain.Visible = true; panelMain.Controls.Add(_activeControl); }
private ProjectWorkspace AnalyzeProject(ProjectBuildResult projectResult) { Logger.LogDebug("Analyzing the project: " + projectResult.ProjectPath); ProjectWorkspace workspace = new ProjectWorkspace(projectResult.ProjectPath) { SourceFiles = new UstList <string>(projectResult.SourceFiles), BuildErrors = projectResult.BuildErrors, BuildErrorsCount = projectResult.BuildErrors.Count }; if (AnalyzerConfiguration.MetaDataSettings.ReferenceData) { workspace.ExternalReferences = projectResult.ExternalReferences; } workspace.TargetFramework = projectResult.TargetFramework; workspace.TargetFrameworks = projectResult.TargetFrameworks; foreach (var fileBuildResult in projectResult.SourceFileBuildResults) { CodeContext codeContext = new CodeContext(fileBuildResult.SemanticModel, fileBuildResult.SyntaxTree, workspace.ProjectRootPath, fileBuildResult.SourceFilePath, AnalyzerConfiguration, Logger); Logger.LogDebug("Analyzing: " + fileBuildResult.SourceFileFullPath); using (CSharpRoslynProcessor processor = new CSharpRoslynProcessor(codeContext)) { var result = processor.Visit(codeContext.SyntaxTree.GetRoot()); workspace.SourceFileResults.Add((RootUstNode)result); } } return(workspace); }
public OpenXamlCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) : base(project, messaging, socket) { MenuText = "Open XAML"; ToolTip = "Open for editing."; }
public OpenVisualStudioCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) : base(project, messaging, socket) { MenuText = "Open in Visual Studio"; }
/// <summary> /// Determines if a ProjectWorkspace has a specified Nuget Dependency /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="nugetReferenceIdentifier">Nuget reference to search for</param> /// <returns>Whether or not the nuget reference exists in the project</returns> public static bool ContainsNugetDependency(this ProjectWorkspace project, string nugetReferenceIdentifier) => project.ExternalReferences?.NugetReferences .Any(r => r.Identity == nugetReferenceIdentifier) == true;
/// <summary> /// Determines if a ProjectWorkspace has a specified Dependency /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="referenceIdentifier">Reference to search for</param> /// <returns>Whether or not the reference exists in the project</returns> public static bool ContainsDependency(this ProjectWorkspace project, string referenceIdentifier) => project.ExternalReferences?.NugetReferences .Union(project.ExternalReferences?.NugetDependencies) .Union(project.ExternalReferences?.SdkReferences) .Any(r => r.Identity == referenceIdentifier) == true;
/// <summary> /// Get all object creation expressions in project with the given Semantic Class Type /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="semanticClassType">Semantic Class Type to search for</param> /// <returns></returns> public static IEnumerable <ObjectCreationExpression> GetObjectCreationExpressionBySemanticClassType(this ProjectWorkspace project, string semanticClassType) => project.SourceFileResults.SelectMany(r => r.AllObjectCreationExpressions().Where(o => o.SemanticClassType == semanticClassType));
/// <summary> /// Handles the process of building the core components /// </summary> private void BuildApplicationCore(bool fullBuild) { ServiceCollection services = ApplicationContext.Current.Services; var cm = services.Get<Sage.Platform.Configuration.ConfigurationManager>(true); cm.RegisterConfigurationType(typeof(BuildSettings)); var settings = cm.GetConfiguration<BuildSettings>(); settings.SolutionFolder = Manifest.OutputPath; settings.AcceptChanges(); cm.WriteConfiguration(settings); var modelTypes = new ModelTypeCollection(); RegisterRequiredModels(modelTypes); string vfsPath = string.Empty; if (string.IsNullOrEmpty(Manifest.VFSPath)) vfsPath = ProjectWorkspace.VFS_MODEL_PATH; else vfsPath = Manifest.VFSPath; var workspace = new ProjectWorkspace(vfsPath) { Name = "TEMP_VFS" }; using (IProject project = new Project(workspace, modelTypes)) { RegisterNeededServices(services, project); var service = (Platforms)ExtensionManager.Default.GetService(typeof(Platforms)); if (fullBuild) { log.Info(Resources.log_building_core); try { VFSQuery.UpgradeToBatchMode(); var files = new List<string>(); // Build Interfaces string[] interfaceFiles = BuildPlatform(project, service, PlatformGuids.CommonGuid); files.AddRange(interfaceFiles); OnBuildComplete(files.ToArray()); files.AddRange(BuildPlatform(project, service, PlatformGuids.WebGuid)); GenerateCodeSnippetLibraries(project); GenerateRulesConfiguration(project); } catch (Exception ex) { } finally { VFSQuery.DowngradeFromBatchMode(); } } } }
public static Dictionary <string, BindingConfiguration> GetBindingsTransportMap(ProjectWorkspace project) { Dictionary <string, BindingConfiguration> bindingsTransportMap = new Dictionary <string, BindingConfiguration>(); WCFBindingAndTransportUtil.CodeBasedCheck(project, bindingsTransportMap); return(bindingsTransportMap); }
/// <summary> /// Given existing Startup.cs template file, generate new Startup.cs based on configuration. /// </summary> /// <param name="startupFilePath">Path to existing Startup.cs template</param> /// <returns>New Startup.cs contents</returns> public string ReplaceStartupFile(string startupFilePath) { var startupFileContents = File.ReadAllText(startupFilePath); if (_projectType == ProjectType.WCFConfigBasedService) { string configPath = Path.Combine(_projectPath, Constants.PortedConfigFileName); if (HasBehavioursTag()) { startupFileContents = HandleBehaviorsTag(startupFilePath); } return(startupFileContents.Replace(Constants.XMLPathPlaceholder, "@\"" + configPath + "\"")); } else { string addService = Constants.AddServiceFormat; string endpointConfigTemplate = Constants.AddServiceEndpointFormat; string endpointConfigs = ""; ProjectWorkspace project = _analyzerResult.ProjectResult; Dictionary <string, BindingConfiguration> bindingTransportMap = GetBindingsTransportMap(project); Tuple <string, string> serviceInterfaceAndClass = WCFBindingAndTransportUtil.GetServiceInterfaceAndClass(project); var serviceInterfaceName = serviceInterfaceAndClass.Item1 ?? Constants.DefaultServiceInterface; var serviceClassName = serviceInterfaceAndClass.Item2 ?? Constants.DefaultServiceClass; endpointConfigs += String.Format(addService, serviceClassName); foreach (KeyValuePair <string, BindingConfiguration> keyValuePair in bindingTransportMap) { var binding = keyValuePair.Key; var mode = keyValuePair.Value.Mode; var endpointAddress = keyValuePair.Value.EndpointAddress ?? String.Join("", "\"", "/", binding.ToLower(), "\""); if (mode.ToLower() == Constants.TransportMode.ToLower()) { mode = Constants.TransportMode; } else if (mode.ToLower() == Constants.TransportMessageCredentialsMode.ToLower()) { mode = Constants.TransportMessageCredentialsMode; } if (binding == Constants.HttpProtocol) { endpointConfigs += String.Format(endpointConfigTemplate, serviceClassName, serviceInterfaceName, mode == Constants.NoneMode ? "new BasicHttpBinding()" : "new BasicHttpBinding(BasicHttpSecurityMode." + mode + ")", endpointAddress); } else if (binding == Constants.NettcpProtocol) { endpointConfigs += String.Format(endpointConfigTemplate, serviceClassName, serviceInterfaceName, mode == Constants.NoneMode ? "new NetTcpBinding()" : "new NetTcpBinding(SecurityMode." + mode + ")", endpointAddress); } else if (binding == Constants.WSHttpProtocol) { endpointConfigs += String.Format(endpointConfigTemplate, serviceClassName, serviceInterfaceName, mode == Constants.NoneMode ? "new WSHttpBinding()" : "new WSHttpBinding(SecurityMode." + mode + ")", endpointAddress); } else if (binding == Constants.HttpsProtocol) { endpointConfigs += String.Format(endpointConfigTemplate, serviceClassName, serviceInterfaceName, "new BasicHttpBinding(BasicHttpSecurityMode.Transport)", endpointAddress); } else if (binding == Constants.NethttpProtocol) { endpointConfigs += String.Format(endpointConfigTemplate, serviceClassName, serviceInterfaceName, mode == Constants.NoneMode ? "new NetHttpBinding()" : "new NetHttpBinding(BasicHttpSecurityMode." + mode + ")", endpointAddress); } } return(startupFileContents.Replace(Constants.EndpointPlaceholder, endpointConfigs)); } }
/// <summary> /// Gets all Invocation Expressions with the given method name. /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="methodName">Method name to search for</param> /// <returns>Collection of invocation expressions with given method name</returns> public static IEnumerable <InvocationExpression> GetInvocationExpressionsByMethodName(this ProjectWorkspace project, string methodName) => project.SourceFileResults.SelectMany(r => r.AllInvocationExpressions().Where(i => i.MethodName == methodName));
/// <summary> /// Determines if a ProjectWorkspace declares a class with a specified base type /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="typeOriginalDefinition">Original Definition of the base type being searched for</param> /// <returns>Whether or not a class with the specified base type is declared in the project</returns> public static bool DeclaresClassWithBaseType(this ProjectWorkspace project, string typeOriginalDefinition) => project.SourceFileResults .SelectMany(n => n.AllClasses()) .Any(c => c.BaseTypeOriginalDefinition == typeOriginalDefinition);
/// <summary> /// Gets all class declaration nodes in a ProjectWorkspace /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <returns>Collection of class declaration nodes in the project with the specified base type</returns> public static IEnumerable <ClassDeclaration> GetAllClassDeclarations(this ProjectWorkspace project) => project.SourceFileResults.SelectMany(r => r.AllClasses());
/// <summary> /// Gets all class declaration nodes in a ProjectWorkspace derived from a specified base type /// </summary> /// <param name="project">ProjectWorkspace to search</param> /// <param name="baseTypeOriginalDefinition">ProjectWorkspace to search</param> /// <returns>Collection of class declaration nodes in the project with the specified base type</returns> public static IEnumerable <ClassDeclaration> GetClassDeclarationsByBaseType(this ProjectWorkspace project, string baseTypeOriginalDefinition) => project.GetAllClassDeclarations().Where(c => c.HasBaseType(baseTypeOriginalDefinition));
public void Dispose() { ProjectResult = null; ProjectBuildResult?.Dispose(); ProjectBuildResult = null; }
public OpenNotepadCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) : base(project, messaging, socket) { MenuText = "Open in Notepad"; }
public OpenFolderCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) : base(project, messaging, socket) { MenuText = "Open in File Explorer"; }
public WatchXamlCommand(ProjectWorkspace project, IMessageBus messaging, ToolboxSocket socket) : base(project, messaging, socket) { MenuText = "Watch for Changes"; ToolTip = "Continually send external changes made to the XAML file to the designer."; }
public bool BuildBaseProject(ProjectInstallInfo installedProjectInfo, IDirectoryInfo projectBackupDir, string baseProjectPath) { if (!projectBackupDir.Exists) throw new ArgumentException("Path does not exist.", "projectBackupPath"); if (string.IsNullOrEmpty(installedProjectInfo.ProjectVersionInfo.BackupFileName)) throw new ArgumentException("BackupFileName is not set.", "projectInfo"); IFileInfo backupFile = projectBackupDir.GetFiles(installedProjectInfo.ProjectVersionInfo.BackupFileName).FirstOrDefault(); if (backupFile == null) { throw new ApplicationException(string.Format("Project backup file {0} does not exist.", Path.Combine(projectBackupDir.FullName, installedProjectInfo.ProjectVersionInfo.BackupFileName))); } IDirectoryInfo baseDir = FileSystem.FileSystem.GetDirectoryInfo(baseProjectPath); if (!baseDir.Exists) baseDir.Create(); var bundlesToInstall = installedProjectInfo.BundlesApplied .OrderBy(b => b.Version.Major) .ThenBy(b => b.Version.Minor) .ThenBy(b => b.Version.Build) .ThenBy(b => b.Version.Revision); //ensure we can find all the bundle files foreach (BundleInfo bundleInfo in bundlesToInstall) { if (!BundleExistsInRepository(projectBackupDir, bundleInfo.FileName)) { _log.Error(string.Format("The bundle file \"{0}\" could not be found.", bundleInfo.FileName)); Environment.Exit(-1); } } var backup = new ProjectBackup(backupFile.FullName); var workspace = new ProjectWorkspace(baseProjectPath); workspace.RestoreProjectFromBackup(backup); IProject project = new Project(workspace); var pcs = new SimpleProjectContextService(project); ApplicationContext.Current.Services.Add(typeof(IProjectContextService), pcs); var installResults = bundlesToInstall.Select(bundleInfo => InstallBundle(projectBackupDir.FullName, bundleInfo.FileName, project)); return installResults.All(result => result); }