public PropertiesForm(ProfilerProjectMode mode) { // // Required for Windows Form Designer support // InitializeComponent(); // // TODO: Add any constructor code after InitializeComponent call // projectMode = ProfilerProjectMode.CreateProject; project = new ProjectInfo( ProjectType.File ); this.Mode = mode; if (mode == ProfilerProjectMode.CreateProject) { List<string> files=SerializationHandler.GetRecentlyUsed(); foreach (string file in files.GetRange(0,Math.Min(files.Count,5))) { LinkLabel label=new LinkLabel(); label.AutoSize = true; label.Text=file; label.Click += delegate { ProfilerForm.form.Project = SerializationHandler.OpenProjectInfo(label.Text); Close(); }; recentProjects.Controls.Add(label); } } }
public ProjectMetadata(ProjectInfo projectInfo) { if (projectInfo == null) throw new ArgumentNullException("projectInfo"); m_projectInfo = projectInfo; Init(); }
public ProjectInfo GetProjectInfo() { var referenceProjectItems = from item in m_project.Items where item is ReferenceProjectItem select item as ReferenceProjectItem; var references = new List<ProjectReference>(referenceProjectItems.Count()); referenceProjectItems. ForEach(item => references.Add( new ProjectReference { Aliases = item.Aliases, Name = item.Name, Location = item.FileName, Version = item.Version, Culture = item.Culture, PublicKeyToken = item.PublicKeyToken })); var projectInfo = new ProjectInfo { Name = m_project.Name, Configuration = m_project.ActiveConfiguration, Platform = m_project.ActivePlatform, OutputAssemblyPath = m_project.OutputAssemblyFullPath, Type = Guid.Parse(m_project.TypeGuid), References = references }; return projectInfo; }
private IList<ProjectReference> CreateUnusedReferencesList(ProjectInfo projectInfo) { var references = from item in projectInfo.References where !item.Name.Equals(MsCorLib, StringComparison.InvariantCultureIgnoreCase) && !item.Name.Equals(SystemCore, StringComparison.InvariantCultureIgnoreCase) select item; return references.ToList(); }
public ProjectProvider (ProjectInfo pinfo) : base (null) { AddTarget ("name", pinfo.Name); AddTarget ("version", pinfo.Version); AddTarget ("compat_code", pinfo.CompatCode); // Alias to line up better with how it's declared // in the buildfile. (Need the underscore version so // we can reference it in .bundles) AddTarget ("compat-code", pinfo.CompatCode); }
public static ProjectAssemblyResolver Create(ProjectInfo projectInfo) { if (projectInfo == null) throw new ArgumentNullException("projectInfo"); var assemblyResolver = new ProjectAssemblyResolver(projectInfo); assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(projectInfo.OutputAssemblyPath)); //assemblyResolver.AddSearchDirectory(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)); foreach (var path in GetLocations(projectInfo.References)) { assemblyResolver.AddSearchDirectory(path); } return assemblyResolver; }
public void ProjectInfo_Serialization_InvalidFileName() { // 0. Setup ProjectInfo pi = new ProjectInfo(); // 1a. Missing file name - save AssertException.Expects<ArgumentNullException>(() => pi.Save(null)); AssertException.Expects<ArgumentNullException>(() => pi.Save(string.Empty)); AssertException.Expects<ArgumentNullException>(() => pi.Save("\r\t ")); // 1b. Missing file name - load AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(null)); AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(string.Empty)); AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load("\r\t ")); }
public static List<ProjectInfo> getValue(string sql) { List<ProjectInfo> list = new List<ProjectInfo>(); OleDbDataReader odr = DBHelper.GetReader(sql); while (odr.Read()) { ProjectInfo pi = new ProjectInfo(); pi.ProjectID = Convert.ToInt32(odr["ProjectID"]); pi.ProjectName = odr["ProjectName"].ToString(); pi.Province = odr["Province"].ToString(); pi.Remarks = odr["remarks"].ToString(); list.Add(pi); } odr.Close(); return list; }
public static UnusedReferencesAudit Create(ProjectInfo projectInfo) { if (projectInfo == null) throw new ArgumentNullException("projectInfo"); switch (projectInfo.Type.ToString("D")) { case CSharpProjectTypeString: return new CSharpProjectAudit(projectInfo); case VBasicProjectTypeString: return new VBasicProjectAudit(projectInfo); case CppCliProjectTypeString: return new CppCliProjectAudit(projectInfo); default: throw new NotImplementedException(); } }
public NemerleContainedLanguage(IVsTextBufferCoordinator bufferCoordinator, NemerleIntellisenseProvider intellisenseProject, uint itemId, IVsHierarchy pHierarchy) { if (null == bufferCoordinator) { throw new ArgumentNullException("bufferCoordinator"); } if (null == intellisenseProject) { throw new ArgumentNullException("intellisenseProject"); } _hierarchy = pHierarchy; object projectItem = null; pHierarchy.GetProperty(itemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out projectItem); _projectItem = projectItem as EnvDTE.ProjectItem; EnvDTE.Property prop = _projectItem.Properties.Item("FullPath"); if (prop != null) _filePath = prop.Value as string; var project = _projectItem.ContainingProject as NemerleOAProject; if(project != null) { _projectInfo = ((NemerleProjectNode)project.Project).ProjectInfo; } _typeResolutionService = null; DynamicTypeService typeService = LanguageService.GetService(typeof(DynamicTypeService)) as DynamicTypeService; if (typeService != null) _typeResolutionService = typeService.GetTypeResolutionService(this._hierarchy); this.bufferCoordinator = bufferCoordinator; this.intellisenseProject = intellisenseProject; this.itemId = itemId; // Make sure that the secondary buffer uses the IronPython language service. IVsTextLines buffer; ErrorHandler.ThrowOnFailure(bufferCoordinator.GetSecondaryBuffer(out buffer)); Guid languageGuid; this.GetLanguageServiceID(out languageGuid); ErrorHandler.ThrowOnFailure(buffer.SetLanguageServiceID(ref languageGuid)); _documentClosingEventHandler = new _dispDocumentEvents_DocumentClosingEventHandler(OnDocumentClosing); }
public void ProjectInfo_Serialization_SaveAndReload() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); Guid projectGuid = Guid.NewGuid(); ProjectInfo originalProjectInfo = new ProjectInfo(); originalProjectInfo.FullPath = "c:\\fullPath\\project.proj"; originalProjectInfo.ProjectLanguage = "a language"; originalProjectInfo.ProjectType = ProjectType.Product; originalProjectInfo.ProjectGuid = projectGuid; originalProjectInfo.ProjectName = "MyProject"; string fileName = Path.Combine(testFolder, "ProjectInfo1.xml"); SaveAndReloadProjectInfo(originalProjectInfo, fileName); }
public static void Open(ProjectInfo project) { foreach (var view in IdeApp.Workbench.Documents) { var sourceDoc = view.GetContent<SourceControlExplorerView>(); if (sourceDoc != null) { sourceDoc.Load(project.Collection); sourceDoc.ExpandPath(VersionControlPath.RootFolder + project.Name); view.Window.SelectWindow(); return; } } var sourceControlExplorerView = new SourceControlExplorerView(); sourceControlExplorerView.Load(project.Collection); sourceControlExplorerView.ExpandPath(VersionControlPath.RootFolder + project.Name); IdeApp.Workbench.OpenDocument(sourceControlExplorerView, true); }
public override object GetResult(out int level) { level = 1; ProjectInfo project = new ProjectInfo(); NProf.form.Project = project; Profiler profiler = new Profiler(); //project.ApplicationName = @"D:\Meta\0.2\bin\Debug\Meta.exe"; //project.Arguments = "-test"; project.ApplicationName = Path.Combine(NProfDirectory, @"TestProfilee\bin\Debug\TestProfilee.exe"); run = project.CreateRun(profiler); run.profiler.Completed += new EventHandler(profiler_Completed); run.Start(); while (result == null) { Thread.Sleep(100); } return result; }
public ActionResult AddProject( [DataSourceRequest] DataSourceRequest request,ProjectInfoModel model) { ProjectInfo project = new ProjectInfo(); var getSatusId = _projects.GetstatusName(model.StatusName); if(ModelState.IsValid) { project.Id = model.Id; project.PM = model.PM; project.Project = model.Project; project.ProjectComment = model.ProjectComment; project.statusId = getSatusId.Id; project.percentage = model.percentage; _projects.CreateProjects(project); TempData["success"] = "Edited Succefully"; } else { TempData["fail"] = " Not Edited Succefully"; } return RedirectToAction("ProjectOnDisplay", "AdminProject"); }
public NemerleErrorTask(ProjectInfo projectInfo, CompilerMessage compilerMessage) { ErrorHelper.ThrowIsNull(projectInfo, "projectInfo"); ErrorHelper.ThrowIsNull(compilerMessage, "compilerMessage"); ProjectInfo = projectInfo; CompilerMessage = compilerMessage; var loc = compilerMessage.Location; if (loc.FileIndex != 0) { var span = Utils.SpanFromLocation(loc); Document = loc.File; Line = span.iStartLine; Column = span.iStartIndex; } Text = compilerMessage.Msg; switch (compilerMessage.Kind) { case MessageKind.Error: Priority = TaskPriority.High; ErrorCategory = TaskErrorCategory.Error; break; case MessageKind.Warning: Priority = TaskPriority.Normal; ErrorCategory = TaskErrorCategory.Warning; break; default: Priority = TaskPriority.Low; ErrorCategory = TaskErrorCategory.Message; break; } Category = TaskCategory.BuildCompile; HierarchyItem = projectInfo.ProjectNode.InteropSafeHierarchy; }
public void ProjectInfo_Serialization_AnalysisResults() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); Guid projectGuid = Guid.NewGuid(); ProjectInfo originalProjectInfo = new ProjectInfo(); originalProjectInfo.ProjectGuid = projectGuid; // 1. Null list SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults1.xml")); // 2. Empty list originalProjectInfo.AnalysisResults = new List<AnalysisResult>(); SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults2.xml")); // 3. Non-empty list originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = string.Empty, Location = string.Empty }); // empty item originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = "Id1", Location = "location1" }); originalProjectInfo.AnalysisResults.Add(new AnalysisResult() { Id = "Id2", Location = "location2" }); SaveAndReloadProjectInfo(originalProjectInfo, Path.Combine(testFolder, "ProjectInfo_AnalysisResults3.xml")); }
private ContextMenu CreateFilterButtonContextMenu() { var filterContextMenu = new ContextMenu(); filterContextMenu.Placement = PlacementMode.Bottom; filterContextMenu.PlacementTarget = _buttonFilter; _buttonFilter.ContextMenu = filterContextMenu; var filterContextMenuItemAll = new MenuItem() { Header = "Show All" }; filterContextMenuItemAll.Click += (sender, eventArgs) => { foreach (TreeViewItem projectTreeViewItem in _treeViewProjects.Items) { PerformActionOnTreeViewItems(projectTreeViewItem, (treeViewItem) => { treeViewItem.Visibility = Visibility.Visible; }); } filterContextMenu.IsOpen = false; }; filterContextMenu.Items.Add(filterContextMenuItemAll); var filterContextMenuItemOnlyExcluded = new MenuItem() { Header = "Show Only Excluded Files" }; filterContextMenuItemOnlyExcluded.Click += (sender, eventArgs) => { foreach (TreeViewItem projectTreeViewItem in _treeViewProjects.Items) { ProjectInfo projectInfo = (ProjectInfo)projectTreeViewItem.DataContext; PerformActionOnTreeViewItems(projectTreeViewItem, (treeViewItem) => { treeViewItem.Visibility = Visibility.Visible; }); PerformActionOnTreeViewItems(projectTreeViewItem, (treeViewItem) => { SolutionHierarchy.Item item = treeViewItem.DataContext as SolutionHierarchy.Item; if (null != item && item.Type == SolutionHierarchy.Item.ItemType.CppFile) { treeViewItem.Visibility = _solutionSettings.IsExcludedCppFileNameForProject(projectInfo, item.Name) ? Visibility.Visible : Visibility.Collapsed; } else { CollapseTreeViewItemIfAllChildrenCollapsed(treeViewItem); } }); } filterContextMenu.IsOpen = false; }; filterContextMenu.Items.Add(filterContextMenuItemOnlyExcluded); var filterContextMenuItemOnlyIncluded = new MenuItem() { Header = "Show Only Included Files" }; filterContextMenuItemOnlyIncluded.Click += (sender, eventArgs) => { foreach (TreeViewItem projectTreeViewItem in _treeViewProjects.Items) { ProjectInfo projectInfo = (ProjectInfo)projectTreeViewItem.DataContext; PerformActionOnTreeViewItems(projectTreeViewItem, (treeViewItem) => { treeViewItem.Visibility = Visibility.Visible; }); PerformActionOnTreeViewItems(projectTreeViewItem, (treeViewItem) => { SolutionHierarchy.Item item = treeViewItem.DataContext as SolutionHierarchy.Item; if (null != item && item.Type == SolutionHierarchy.Item.ItemType.CppFile) { treeViewItem.Visibility = !_solutionSettings.IsExcludedCppFileNameForProject(projectInfo, item.Name) ? Visibility.Visible : Visibility.Collapsed; } else { CollapseTreeViewItemIfAllChildrenCollapsed(treeViewItem); } }); } filterContextMenu.IsOpen = false; }; filterContextMenu.Items.Add(filterContextMenuItemOnlyIncluded); return(filterContextMenu); }
public async Task TestUpdatedDocumentHasTextVersionAsync() { var pid = ProjectId.CreateNewId(); var text = SourceText.From("public class C { }"); var version = VersionStamp.Create(); var docInfo = DocumentInfo.Create(DocumentId.CreateNewId(pid), "c.cs", loader: TextLoader.From(TextAndVersion.Create(text, version))); var projInfo = ProjectInfo.Create( pid, version: VersionStamp.Default, name: "TestProject", assemblyName: "TestProject.dll", language: LanguageNames.CSharp, documents: new[] { docInfo }); using var ws = new AdhocWorkspace(); ws.AddProject(projInfo); var doc = ws.CurrentSolution.GetDocument(docInfo.Id); Assert.False(doc.TryGetText(out var currentText)); Assert.False(doc.TryGetTextVersion(out var currentVersion)); // cause text to load and show that TryGet now works for text and version currentText = await doc.GetTextAsync(); Assert.True(doc.TryGetText(out currentText)); Assert.True(doc.TryGetTextVersion(out currentVersion)); Assert.Equal(version, currentVersion); // change document var root = await doc.GetSyntaxRootAsync(); var newRoot = root.WithAdditionalAnnotations(new SyntaxAnnotation()); Assert.NotSame(root, newRoot); var newDoc = doc.WithSyntaxRoot(newRoot); Assert.NotSame(doc, newDoc); // text is now unavailable since it must be constructed from tree Assert.False(newDoc.TryGetText(out currentText)); // version is available because it is cached Assert.True(newDoc.TryGetTextVersion(out currentVersion)); // access it the hard way var actualVersion = await newDoc.GetTextVersionAsync(); // version is the same Assert.Equal(currentVersion, actualVersion); // accessing text version did not cause text to be constructed. Assert.False(newDoc.TryGetText(out currentText)); // now access text directly (force it to be constructed) var actualText = await newDoc.GetTextAsync(); actualVersion = await newDoc.GetTextVersionAsync(); // prove constructing text did not introduce a new version Assert.Equal(currentVersion, actualVersion); }
public void WriteSettingsForProject(ProjectInfo project, IEnumerable <string> files, string fxCopReportFilePath, string codeCoverageFilePath) { if (this.FinishedWriting) { throw new InvalidOperationException(); } if (project == null) { throw new ArgumentNullException("project"); } if (files == null) { throw new ArgumentNullException("files"); } Debug.Assert(files.Any(), "Expecting a project to have files to analyze"); Debug.Assert(files.All(f => File.Exists(f)), "Expecting all of the specified files to exist"); this.projects.Add(project); string guid = project.GetProjectGuidAsString(); AppendKeyValue(sb, guid, SonarProperties.ProjectKey, this.config.SonarProjectKey + ":" + guid); AppendKeyValue(sb, guid, SonarProperties.ProjectName, project.ProjectName); AppendKeyValue(sb, guid, SonarProperties.ProjectBaseDir, project.GetProjectDirectory()); if (fxCopReportFilePath != null) { string property = null; if (ProjectLanguages.IsCSharpProject(project.ProjectLanguage)) { property = "sonar.cs.fxcop.reportPath"; } else if (ProjectLanguages.IsVbProject(project.ProjectLanguage)) { property = "sonar.vbnet.fxcop.reportPath"; } if (property != null) { AppendKeyValue(sb, guid, property, fxCopReportFilePath); } else { Debug.Fail("FxCopReportFilePath is set but the language is unrecognised. Language: " + project.ProjectLanguage); } } if (codeCoverageFilePath != null) { AppendKeyValue(sb, guid, "sonar.cs.vscoveragexml.reportsPaths", codeCoverageFilePath); } if (project.ProjectType == ProjectType.Product) { sb.AppendLine(guid + @".sonar.sources=\"); } else { AppendKeyValue(sb, guid, "sonar.sources", ""); sb.AppendLine(guid + @".sonar.tests=\"); } IEnumerable <string> escapedFiles = files.Select(f => Escape(f)); sb.AppendLine(string.Join(@",\" + Environment.NewLine, escapedFiles)); sb.AppendLine(); if (project.AnalysisSettings != null && project.AnalysisSettings.Any()) { foreach (Property setting in project.AnalysisSettings) { sb.AppendFormat("{0}.{1}={2}", guid, setting.Id, Escape(setting.Value)); sb.AppendLine(); } sb.AppendLine(); } }
/// <summary> /// Saves control with actual data. /// </summary> public bool Save() { if (!CheckPermissions("CMS.ProjectManagement", PERMISSION_MANAGE)) { return false; } // Validate the form if (Validate()) { // Indicates whether project is new bool isNew = false; int progress = 0; // Ensure the info object if (ProjectObj == null) { // New project ProjectInfo pi = new ProjectInfo(); // First initialization of the Access property - allow authenticated users pi.ProjectAccess = 1222; pi.ProjectCreatedByID = CMSContext.CurrentUser.UserID; pi.ProjectOwner = 0; if (CommunityGroupID != 0) { pi.ProjectGroupID = CommunityGroupID; // Set default access to the group pi.ProjectAccess = 3333; } mProjectObj = pi; isNew = true; } else { // Existing project // Reset ProjectOrder if checkbox was unchecked if ((ProjectObj.ProjectAllowOrdering) && (!chkProjectAllowOrdering.Checked)) { ProjectInfoProvider.ResetProjectOrder(ProjectObj.ProjectID); } // Clear the hashtables if the codename has been changed if ((ProjectObj.ProjectGroupID > 0) && ProjectObj.ProjectName != txtProjectName.Text) { ProjectInfoProvider.Clear(true); } progress = ProjectInfoProvider.GetProjectProgress(ProjectObj.ProjectID); } ltrProjectProgress.Text = ProjectTaskInfoProvider.GenerateProgressHtml(progress, true); // Initialize object ProjectObj.ProjectSiteID = CMSContext.CurrentSiteID; if (DisplayMode == ControlDisplayModeEnum.Simple) { if (isNew) { ProjectObj.ProjectName = ValidationHelper.GetCodeName(txtProjectDisplayName.Text, 50) + ((CommunityGroupID > 0) ? "_group_" : "_general_") + CodenameGUID; } } else { ProjectObj.ProjectName = txtProjectName.Text.Trim(); } ProjectObj.ProjectDisplayName = txtProjectDisplayName.Text.Trim(); ProjectObj.ProjectDescription = txtProjectDescription.Text.Trim(); ProjectObj.ProjectStartDate = dtpProjectStartDate.SelectedDateTime; ProjectObj.ProjectDeadline = dtpProjectDeadline.SelectedDateTime; ProjectObj.ProjectOwner = ValidationHelper.GetInteger(userSelector.UniSelector.Value, 0); ProjectObj.ProjectStatusID = ValidationHelper.GetInteger(drpProjectStatus.SelectedValue, 0); ProjectObj.ProjectAllowOrdering = chkProjectAllowOrdering.Checked; // Set ProjectNodeID if (!ShowPageSelector) { // Set current node id for new project if (isNew && (CMSContext.CurrentDocument != null)) { ProjectObj.ProjectNodeID = CMSContext.CurrentDocument.NodeID; } } else { TreeProvider treeProvider = new TreeProvider(); TreeNode node = treeProvider.SelectSingleNode(ValidationHelper.GetGuid(pageSelector.Value, Guid.Empty), TreeProvider.ALL_CULTURES, CMSContext.CurrentSiteName); if (node != null) { ProjectObj.ProjectNodeID = node.NodeID; } else { ProjectObj.ProjectNodeID = 0; } } // Use try/catch due to license check try { // Save object data to database ProjectInfoProvider.SetProjectInfo(ProjectObj); ProjectID = ProjectObj.ProjectID; ItemID = ProjectObj.ProjectID; RaiseOnSaved(); // Set the info message ShowChangesSaved(); return true; } catch (Exception ex) { ShowError(ex.Message); } } return false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Handle the OK button. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> /// ------------------------------------------------------------------------------------ private void btnOK_Click(object sender, System.EventArgs e) { Enabled = false; DialogResult = DialogResult.OK; Logger.WriteEvent(string.Format( "Creating new language project: name: {0}, vernacular ws: {1}, anal ws: {2}", ProjectName, m_cbVernWrtSys.Text, m_cbAnalWrtSys.Text)); m_projInfo = GetProjectInfoByName(ProjectName); // Project with this name already exists? if (m_projInfo != null) { // Bring up a dialog giving the user the option to open this existing project, // create a new project or cancel (return to New Project dialog). using (DuplicateProjectFoundDlg dlg = new DuplicateProjectFoundDlg()) { dlg.ShowDialog(); switch (dlg.DialogResult) { case DialogResult.OK: m_fCreateNew = false; break; case DialogResult.Cancel: // Return to New FieldWorks Project dialog Enabled = true; DialogResult = DialogResult.None; break; } } } else { // The project does not exist yet. Bring up the new project dialog box. CreateNewLangProjWithProgress(); } }
private String WriteEmployerBasicInfo(ProjectInfo projectmodels) { m_wordApp.Selection.ParagraphFormat.Alignment = WdParagraphAlignment.wdAlignParagraphCenter; m_wordApp.Selection.Font.Size = 14; m_wordApp.Selection.Font.Bold = 2; m_wordApp.Selection.TypeText("水 质 检 测 报 告 "); m_wordApp.Selection.TypeParagraph(); Word.Table basicInfo = m_doc.Tables.Add(m_wordApp.Selection.Range, 14, 4); basicInfo.Borders.Enable = 1; basicInfo.Borders.OutsideLineStyle = WdLineStyle.wdLineStyleNone; basicInfo.Borders[WdBorderType.wdBorderTop].LineStyle = WdLineStyle.wdLineStyleSingle; basicInfo.Borders[WdBorderType.wdBorderBottom].LineStyle = WdLineStyle.wdLineStyleSingle; basicInfo.Columns[1].Width = 100; basicInfo.Rows[1].Height = 10; ///单位名称 basicInfo.Cell(1, 1).Select(); SetCellHeaderText("委托单位:"); basicInfo.Cell(1, 2).Merge(basicInfo.Cell(1, 4)); basicInfo.Cell(1, 2).Select(); SetCellText(0, 12, projectmodels.CompaneName, WdParagraphAlignment.wdAlignParagraphLeft, WdCellVerticalAlignment.wdCellAlignVerticalCenter); basicInfo.Rows[2].Height = 10; ///单位名称 basicInfo.Cell(2, 1).Select(); SetCellHeaderText("受检单位:"); basicInfo.Cell(2, 2).Merge(basicInfo.Cell(2, 4)); basicInfo.Cell(2, 2).Select(); SetCellText(0, 12, projectmodels.CompaneName, WdParagraphAlignment.wdAlignParagraphLeft, WdCellVerticalAlignment.wdCellAlignVerticalCenter); basicInfo.Rows[3].Height = 10; ///项目名称 basicInfo.Cell(3, 1).Select(); SetCellHeaderText("受检单位地址:"); basicInfo.Cell(3, 2).Merge(basicInfo.Cell(3, 4)); basicInfo.Cell(3, 2).Select(); SetCellText(0, 12, projectmodels.CompanyAddress, WdParagraphAlignment.wdAlignParagraphLeft, WdCellVerticalAlignment.wdCellAlignVerticalCenter); basicInfo.Rows[4].Height = 10; ///项目名称 basicInfo.Cell(4, 1).Select(); SetCellHeaderText("检测类别:"); basicInfo.Cell(4, 2).Select(); SetCellHeaderText(" "); basicInfo.Cell(4, 3).Select(); SetCellHeaderText("受理日期:"); basicInfo.Cell(4, 4).Select(); basicInfo.Rows[5].Height = 10; ///项目名称 basicInfo.Cell(5, 1).Select(); SetCellHeaderText("样品来源:"); basicInfo.Cell(5, 2).Select(); SetCellHeaderText("采样"); basicInfo.Cell(5, 3).Select(); SetCellHeaderText("采样日期:"); basicInfo.Cell(5, 4).Select(); basicInfo.Rows[6].Height = 10; ///项目名称 basicInfo.Cell(6, 1).Select(); SetCellHeaderText("样品数量:"); basicInfo.Cell(6, 2).Select(); SetCellHeaderText(" "); basicInfo.Cell(6, 3).Select(); SetCellHeaderText("检测日期:"); basicInfo.Cell(6, 4).Select(); basicInfo.Cell(7, 1).Merge(basicInfo.Cell(8, 1)); basicInfo.Cell(7, 1).Select(); SetCellHeaderText("主要仪器设备:"); basicInfo.Cell(7, 2).Merge(basicInfo.Cell(8, 4)); basicInfo.Cell(7, 2).Select(); SetCellHeaderText(" "); basicInfo.Cell(8, 1).Merge(basicInfo.Cell(14, 1)); basicInfo.Cell(8, 1).Select(); SetCellHeaderText("检测依据:"); basicInfo.Cell(8, 2).Merge(basicInfo.Cell(14, 4)); basicInfo.Cell(8, 2).Select(); SetCellHeaderText(" "); m_wordApp.Selection.MoveDown();//光标下移,光标移出表格 m_wordApp.Selection.TypeText("\r\n"); return("0"); }
public void AddProject(ProjectInfo projectInfo) { OnProjectAdded(projectInfo); }
public async Task <FileBasedProject> CreateBackTranslationProject(FileBasedProject project, string localProjectFolder, string targetLanguage, string iconPath, List <SourceFile> sourceFiles, string projectNameSuffix) { if (string.IsNullOrEmpty(projectNameSuffix)) { throw new Exception(PluginResources.Warning_Message_ProjectNameSuffixCannotBeNull); } var projectInfo = project.GetProjectInfo(); var newSourceLanguage = projectInfo.TargetLanguages.FirstOrDefault(a => string.Compare(a.CultureInfo.Name, targetLanguage, StringComparison.CurrentCultureIgnoreCase) == 0); var newTargetLanguage = projectInfo.SourceLanguage; if (Directory.Exists(localProjectFolder)) { Directory.Delete(localProjectFolder, true); } var projectReference = new ProjectReference(project.FilePath); var newProjectInfo = new ProjectInfo { Name = projectInfo.Name + "-" + projectNameSuffix + "-" + targetLanguage, Description = projectInfo.Description, LocalProjectFolder = localProjectFolder, SourceLanguage = newSourceLanguage, TargetLanguages = new Language[] { newTargetLanguage }, DueDate = projectInfo.DueDate, ProjectOrigin = Constants.ProjectOrigin_BackTranslationProject, IconPath = iconPath }; var newProject = new FileBasedProject(newProjectInfo, projectReference); foreach (var sourceFile in sourceFiles) { if (!string.IsNullOrEmpty(sourceFile.FilePath) && File.Exists(sourceFile.FilePath)) { newProject.AddFiles(new[] { sourceFile.FilePath }, sourceFile.FolderPathInProject); } } newProject.Save(); UpdateProjectSettingsBundle(newProject, null, null, null); // Remove any TMs that don't correspond to the language directions of the project UpdateTmConfiguration(newProject); var languageFileIds = newProject.GetSourceLanguageFiles().GetIds(); newProject.RunAutomaticTask( languageFileIds, AutomaticTaskTemplateIds.Scan); var sourceGuids = GetProjectFileGuids(newProject.GetSourceLanguageFiles()); if (sourceGuids.Count > 0) { newProject.RunAutomaticTask( sourceGuids.ToArray(), AutomaticTaskTemplateIds.ConvertToTranslatableFormat); newProject.RunAutomaticTask( sourceGuids.ToArray(), AutomaticTaskTemplateIds.CopyToTargetLanguages); } newProject.Save(); return(await System.Threading.Tasks.Task.FromResult(newProject)); }
private Task <ProjectInfo> CreateProjectInfoAsync(ProjectFileInfo projectFileInfo, ProjectId projectId, bool addDiscriminator, CancellationToken cancellationToken) { var language = projectFileInfo.Language; var projectPath = projectFileInfo.FilePath; var projectName = Path.GetFileNameWithoutExtension(projectPath); if (addDiscriminator && !string.IsNullOrWhiteSpace(projectFileInfo.TargetFramework)) { projectName += "(" + projectFileInfo.TargetFramework + ")"; } var version = VersionStamp.Create( FileUtilities.GetFileTimeStamp(projectPath)); if (projectFileInfo.IsEmpty) { var assemblyName = GetAssemblyNameFromProjectPath(projectPath); var parseOptions = GetLanguageService <ISyntaxTreeFactoryService>(language) .GetDefaultParseOptions(); var compilationOptions = GetLanguageService <ICompilationFactoryService>(language) .GetDefaultCompilationOptions(); return(Task.FromResult( ProjectInfo.Create( projectId, version, projectName, assemblyName: assemblyName, language: language, filePath: projectPath, outputFilePath: string.Empty, outputRefFilePath: string.Empty, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), projectReferences: SpecializedCollections.EmptyEnumerable <ProjectReference>(), metadataReferences: SpecializedCollections.EmptyEnumerable <MetadataReference>(), analyzerReferences: SpecializedCollections.EmptyEnumerable <AnalyzerReference>(), additionalDocuments: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), isSubmission: false, hostObjectType: null))); } return(DoOperationAndReportProgressAsync(ProjectLoadOperation.Resolve, projectPath, projectFileInfo.TargetFramework, async() => { var projectDirectory = Path.GetDirectoryName(projectPath); // parse command line arguments var commandLineParser = GetLanguageService <ICommandLineParserService>(projectFileInfo.Language); var commandLineArgs = commandLineParser.Parse( arguments: projectFileInfo.CommandLineArgs, baseDirectory: projectDirectory, isInteractive: false, sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory()); var assemblyName = commandLineArgs.CompilationName; if (string.IsNullOrWhiteSpace(assemblyName)) { // if there isn't an assembly name, make one from the file path. // Note: This may not be necessary any longer if the commmand line args // always produce a valid compilation name. assemblyName = GetAssemblyNameFromProjectPath(projectPath); } // Ensure sure that doc-comments are parsed var parseOptions = commandLineArgs.ParseOptions; if (parseOptions.DocumentationMode == DocumentationMode.None) { parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Parse); } // add all the extra options that are really behavior overrides var metadataService = GetWorkspaceService <IMetadataService>(); var compilationOptions = commandLineArgs.CompilationOptions .WithXmlReferenceResolver(new XmlFileResolver(projectDirectory)) .WithSourceReferenceResolver(new SourceFileResolver(ImmutableArray <string> .Empty, projectDirectory)) // TODO: https://github.com/dotnet/roslyn/issues/4967 .WithMetadataReferenceResolver(new WorkspaceMetadataFileReferenceResolver(metadataService, new RelativePathResolver(ImmutableArray <string> .Empty, projectDirectory))) .WithStrongNameProvider(new DesktopStrongNameProvider(commandLineArgs.KeyFileSearchPaths)) .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); var documents = CreateDocumentInfos(projectFileInfo.Documents, projectId, commandLineArgs.Encoding); var additionalDocuments = CreateDocumentInfos(projectFileInfo.AdditionalDocuments, projectId, commandLineArgs.Encoding); CheckForDuplicateDocuments(documents, additionalDocuments, projectPath, projectId); var analyzerReferences = ResolveAnalyzerReferences(commandLineArgs); var resolvedReferences = await ResolveReferencesAsync(projectId, projectFileInfo, commandLineArgs, cancellationToken).ConfigureAwait(false); return ProjectInfo.Create( projectId, version, projectName, assemblyName, language, projectPath, outputFilePath: projectFileInfo.OutputFilePath, outputRefFilePath: projectFileInfo.OutputRefFilePath, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: documents, projectReferences: resolvedReferences.ProjectReferences, metadataReferences: resolvedReferences.MetadataReferences, analyzerReferences: analyzerReferences, additionalDocuments: additionalDocuments, isSubmission: false, hostObjectType: null) .WithDefaultNamespace(projectFileInfo.DefaultNamespace); })); }
Project AddProject(IBuildEngine buildEngine, string projectPath, CancellationToken cancellation) { // NOTE: we use a different workspace for each project added // because we need to set the current configuration/platform // as a global property for each, according to the current // solution configuration as detected by the current global // properties. This is automatically done by the workspace // factory, which looks up the project by ID and determines // the configuration/platform to load. using (var loader = loaderFactory.Create(buildEngine)) { cancellation.ThrowIfCancellationRequested(); var xml = loader.LoadXml(projectPath); var msbuildProject = xml.ToDynamic(); var msbuildProjectFile = (string)msbuildProject["FilePath"]; // Use the msbuild project to add a new project to the current solution of the workspace OnProjectAdded( ProjectInfo.Create( ProjectId.CreateFromSerialized(new Guid((string)msbuildProject["Id"])), VersionStamp.Default, (string)msbuildProject["Name"], (string)msbuildProject["AssemblyName"], (string)msbuildProject["Language"], msbuildProjectFile, outputFilePath: (string)msbuildProject["OutputFilePath"], metadataReferences: ((XElement)msbuildProject.MetadataReferences) .Elements("MetadataReference") .Select(e => MetadataReference.CreateFromFile(e.Attribute("FilePath").Value)), compilationOptions: new CSharpCompilationOptions( (OutputKind)(Enum.Parse(typeof(OutputKind), (string)msbuildProject.CompilationOptions["OutputKind"])), platform: (Platform)(Enum.Parse(typeof(Platform), (string)msbuildProject.CompilationOptions["Platform"]))))); cancellation.ThrowIfCancellationRequested(); // Add the documents to the workspace foreach (XElement document in ((XElement)msbuildProject.Documents).Elements("Document")) { AddDocument(msbuildProjectFile, document, false); cancellation.ThrowIfCancellationRequested(); } foreach (XElement document in ((XElement)msbuildProject.AdditionalDocuments).Elements("Document")) { AddDocument(msbuildProjectFile, document, true); cancellation.ThrowIfCancellationRequested(); } // Fix references // Iterate the references of the msbuild project var referencesToAdd = new List <ProjectReference>(); foreach (var referencePath in ((XElement)msbuildProject.ProjectReferences).Elements("ProjectReference").Select(e => e.Attribute("FilePath").Value)) { var referencedProject = GetOrAddProject(buildEngine, referencePath, cancellation); referencesToAdd.Add(new ProjectReference(referencedProject.Id)); } cancellation.ThrowIfCancellationRequested(); if (referencesToAdd.Count > 0) { var addedProject = FindProjectByPath(msbuildProjectFile); TryApplyChanges(CurrentSolution.WithProjectReferences(addedProject.Id, referencesToAdd)); } return(FindProjectByPath(projectPath)); } }
public MessageModel CreateProject(PackageModel package) { var penaltiesTmsList = new List <StarTranslationMemoryMetadata>(); var target = GetTargetLanguages(package.LanguagePairs); var projectInfo = new ProjectInfo { Name = package.Name, LocalProjectFolder = package.Location, SourceLanguage = new Language(package.LanguagePairs[0].SourceLanguage), TargetLanguages = target, DueDate = package.DueDate }; var newProject = new FileBasedProject(projectInfo, new ProjectTemplateReference(package.ProjectTemplate.Uri)); if (package.Customer != null) { newProject.SetCustomer(package.Customer); } //Add StarTransit package source files. The same on all language pairs ProjectFile[] sourceProjectFiles = newProject.AddFiles(package.LanguagePairs[0].SourceFile.ToArray()); //set the file role(user to display project details in Studio view) var sourceFilesIds = newProject.GetSourceLanguageFiles().GetIds(); newProject.SetFileRole(sourceFilesIds, FileRole.Translatable); var tmConfig = newProject.GetTranslationProviderConfiguration(); var fileTypeManager = DefaultFileTypeManager.CreateInstance(true); List <ProjectFile> targetProjectFiles = new List <ProjectFile>(); foreach (var pair in package.LanguagePairs) { // Separate all items from package.TMPenalties(files that are having penalties set) // which are found in pair.StarTranslationMemoryMetadatas foreach (var starTMMetadata in pair.StarTranslationMemoryMetadatas) { if (package.TMPenalties != null) { if (package.TMPenalties.Any(t => t.Key.Equals(starTMMetadata.TargetFile))) { starTMMetadata.TMPenalty = package.TMPenalties.FirstOrDefault(t => t.Key.Equals(starTMMetadata.TargetFile)).Value; penaltiesTmsList.Add(starTMMetadata); } } } // Remove found items from pair.StarTranslationMemoryMetadatas (the remained ones are those which does not have penalties set on them) foreach (var item in penaltiesTmsList) { pair.StarTranslationMemoryMetadatas.Remove(item); } // Create one TM (that has the name equals with the project name) // with the TM files from pair.StarTranslationMemoryMetadatas (the onew without penalties set by the user) targetProjectFiles.Clear(); // Import language pair TM if any if (pair.HasTm) { if (pair.StarTranslationMemoryMetadatas.Count > 0) { var importer = new TransitTmImporter(pair.SourceLanguage, pair.TargetLanguage, pair.CreateNewTm, fileTypeManager, Path.Combine(Path.GetDirectoryName(newProject.FilePath), Path.GetFileName(pair.TmPath))); foreach (var tm in pair.StarTranslationMemoryMetadatas) { importer.ImportStarTransitTm(tm.TargetFile); } tmConfig.Entries.Add(new TranslationProviderCascadeEntry(importer.GetTranslationProviderReference(), true, true, true)); } // Create separate TM for each TM file on which user set penalty // (the name of the new TM will be the same with the one from StarTransit package) foreach (var item in penaltiesTmsList) { var tmWithPenaltyImporter = new TransitTmImporter( Path.GetDirectoryName(newProject.FilePath), pair.SourceLanguage, pair.TargetLanguage, Path.GetFileName(item.TargetFile), fileTypeManager); tmWithPenaltyImporter.ImportStarTransitTm(item.TargetFile); tmConfig.Entries.Add(new TranslationProviderCascadeEntry( new TranslationProviderReference(tmWithPenaltyImporter.TMFilePath), true, true, true, item.TMPenalty)); } } if (!pair.TargetFile.Any() || pair.TargetFile.Count == 0) { var messageModel = new MessageModel() { IsProjectCreated = false, Message = "Project was not created correctly because no target files were found in the package!", Title = "Informative message" }; return(messageModel); } else { targetProjectFiles.AddRange(newProject.AddFiles(pair.TargetFile.ToArray())); newProject.RunAutomaticTask(targetProjectFiles.GetIds(), AutomaticTaskTemplateIds.Scan); var taskSequence = newProject.RunAutomaticTasks(targetProjectFiles.GetIds(), new string[] { AutomaticTaskTemplateIds.ConvertToTranslatableFormat, AutomaticTaskTemplateIds.CopyToTargetLanguages, AutomaticTaskTemplateIds.PerfectMatch, AutomaticTaskTemplateIds.PreTranslateFiles, AutomaticTaskTemplateIds.AnalyzeFiles, }); if (taskSequence.Status.Equals(TaskStatus.Failed)) { var messageModel = new MessageModel() { IsProjectCreated = false, Message = "Project could not be created.Error occured while running automatic tasks!", Title = "Informative message" }; return(messageModel); } else { newProject.UpdateTranslationProviderConfiguration(tmConfig); newProject.Save(); } } } if (Directory.Exists(Path.GetDirectoryName(newProject.FilePath))) { CreateMetadataFolder(package.Location, package.PathToPrjFile); Controller.RefreshProjects(); } return(null); }
/// <summary> /// Handles the Load event of the Page control. /// </summary> protected void Page_Load(object sender, EventArgs e) { gridMatrix.OnItemChanged += gridMatrix_OnItemChanged; gridMatrix.StopProcessing = true; gridMatrix.ColumnsPreferedOrder = string.Join(",", mAllowedPermissions); if (ProjectID > 0) { mProject = ProjectInfoProvider.GetProjectInfo(ProjectID); // Check whether the project still exists EditedObject = mProject; } // Handle page chnaged event gridMatrix.OnPageChanged += gridMatrix_OnPageChanged; // Disable permission matrix if user has no MANAGE rights if (!ProjectInfoProvider.IsAuthorizedPerProject(ProjectID, PERMISSION_MANAGE, MembershipContext.AuthenticatedUser)) { Enable = false; gridMatrix.Enabled = false; lblError.Text = String.Format(GetString("general.accessdeniedonpermissionname"), "Manage"); lblError.Visible = true; } }
private void AddToRecentProjects(Project project) { if (project == null) return; ProjectInfo alreadyThere = RecentProjects.SingleOrDefault(p => p.ProjectUId == project.ProjectUId); if (alreadyThere != null) { int idx = RecentProjects.IndexOf(alreadyThere); RecentProjects.Remove(alreadyThere); if(idx >=0 && idx < jumpList.JumpItems.Count) jumpList.JumpItems.RemoveAt(idx); } ProjectInfo pInfo = new ProjectInfo(project); jumpList.JumpItems.Insert(0, CreateProjectJumpItem(pInfo)); RecentProjects.Insert(0, pInfo); if (RecentProjects.Count > 10) { int toBeRemoved = RecentProjects.Count - 10; RecentProjects.RemoveRange(10, toBeRemoved); } if (jumpList.JumpItems.Count > 10) { int toBeRemoved = jumpList.JumpItems.Count - 10; jumpList.JumpItems.RemoveRange(10, toBeRemoved); } aggregator.Publish<ICollection<ProjectInfo>>(ScrumFactoryEvent.RecentProjectChanged, RecentProjects); jumpList.Apply(); }
public CreatWaterTestDoc(ProjectInfo projectinfo) { // start word and turn off msg boxes this.Header = projectinfo.ProjectNumber + " DKL/QB-33-03 ";; }
static void DumpNetModule(ProjectInfo info, List<ProjectInfo> projectFiles) { var fileName = info.AssemblyFileName; if (string.IsNullOrEmpty(fileName)) throw new Exception(".NET module filename is empty or null"); var asmList = new AssemblyList("dnspc.exe", false); asmList.UseGAC = !noGac; asmList.AddSearchPath(Path.GetDirectoryName(fileName)); foreach (var path in asmPaths) asmList.AddSearchPath(path); var lasm = new LoadedAssembly(asmList, fileName); var opts = new DecompilationOptions { FullDecompilation = true, CancellationToken = new CancellationToken(), }; TextWriter writer = null; try { var lang = GetLanguage(); if (useStdout) writer = System.Console.Out; else { var baseDir = GetProjectDir(lang, fileName); Directory.CreateDirectory(baseDir); writer = new StreamWriter(info.ProjectFileName, false, Encoding.UTF8); opts.SaveAsProjectDirectory = baseDir; opts.DontReferenceStdLib = noCorlibRef; opts.ProjectFiles = projectFiles; opts.ProjectGuid = info.ProjectGuid; opts.DontShowCreateMethodBodyExceptions = dontMaskErr; Console.WriteLine("Saving {0} to {1}", fileName, baseDir); } lang.DecompileAssembly(lasm, new PlainTextOutput(writer), opts); } finally { if (!useStdout && writer != null) writer.Dispose(); } }
public abstract bool IsApplicable(ProjectInfo projectInfo);
public void Initalize(IConfiguration configuration) { _logger.LogInformation($"Detecting CSX files in '{_env.Path}'."); var allCsxFiles = Directory.GetFiles(_env.Path, "*.csx", SearchOption.TopDirectoryOnly); if (allCsxFiles.Length == 0) { _logger.LogInformation("Could not find any CSX files"); return; } _scriptCsContext.Path = _env.Path; _logger.LogInformation($"Found {allCsxFiles.Length} CSX files."); //script name is added here as a fake one (dir path not even a real file); this is OK though -> it forces MEF initialization var scriptServicesBuilder = new ScriptServicesBuilder(new ScriptConsole(), LogManager.GetCurrentClassLogger()). LogLevel(LogLevel.Info).Cache(false).Repl(false).ScriptName(_env.Path).ScriptEngine <NullScriptEngine>(); _scriptServices = scriptServicesBuilder.Build(); var mscorlib = MetadataReference.CreateFromFile(typeof(object).GetTypeInfo().Assembly.Location); var systemCore = MetadataReference.CreateFromFile(typeof(Enumerable).GetTypeInfo().Assembly.Location); var scriptcsContracts = MetadataReference.CreateFromFile(typeof(IScriptHost).Assembly.Location); var parseOptions = new CSharpParseOptions(LanguageVersion.CSharp6, DocumentationMode.Parse, SourceCodeKind.Script); var scriptPacks = _scriptServices.ScriptPackResolver.GetPacks().ToList(); var assemblyPaths = _scriptServices.AssemblyResolver.GetAssemblyPaths(_env.Path); foreach (var csxPath in allCsxFiles) { try { _scriptCsContext.CsxFiles.Add(csxPath); var processResult = _scriptServices.FilePreProcessor.ProcessFile(csxPath); var references = new List <MetadataReference> { mscorlib, systemCore, scriptcsContracts }; var usings = new List <string>(ScriptExecutor.DefaultNamespaces); //default references ImportReferences(references, ScriptExecutor.DefaultReferences); //file usings usings.AddRange(processResult.Namespaces); //#r references ImportReferences(references, processResult.References); //nuget references ImportReferences(references, assemblyPaths); //script packs if (scriptPacks != null && scriptPacks.Any()) { var scriptPackSession = new ScriptPackSession(scriptPacks, new string[0]); scriptPackSession.InitializePacks(); //script pack references ImportReferences(references, scriptPackSession.References); //script pack usings usings.AddRange(scriptPackSession.Namespaces); _scriptCsContext.ScriptPacks.UnionWith(scriptPackSession.Contexts.Select(pack => pack.GetType().ToString())); } _scriptCsContext.References.UnionWith(references.Select(x => x.Display)); _scriptCsContext.Usings.UnionWith(usings); var compilationOptions = new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, usings: usings.Distinct()); var fileName = Path.GetFileName(csxPath); var projectId = ProjectId.CreateNewId(Guid.NewGuid().ToString()); var project = ProjectInfo.Create(projectId, VersionStamp.Create(), fileName, $"{fileName}.dll", LanguageNames.CSharp, null, null, compilationOptions, parseOptions, null, null, references, null, null, true, typeof(IScriptHost)); _workspace.AddProject(project); AddFile(csxPath, projectId); foreach (var filePath in processResult.LoadedScripts.Distinct().Except(new[] { csxPath })) { _scriptCsContext.CsxFiles.Add(filePath); var loadedFileName = Path.GetFileName(filePath); var loadedFileProjectId = ProjectId.CreateNewId(Guid.NewGuid().ToString()); var loadedFileSubmissionProject = ProjectInfo.Create(loadedFileProjectId, VersionStamp.Create(), $"{loadedFileName}-LoadedFrom-{fileName}", $"{loadedFileName}-LoadedFrom-{fileName}.dll", LanguageNames.CSharp, null, null, compilationOptions, parseOptions, null, null, references, null, null, true, typeof(IScriptHost)); _workspace.AddProject(loadedFileSubmissionProject); AddFile(filePath, loadedFileProjectId); _workspace.AddProjectReference(projectId, new ProjectReference(loadedFileProjectId)); } } catch (Exception ex) { _logger.LogError($"{csxPath} will be ignored due to the following error:", ex); } } }
public abstract IEnumerable <ITask> Create(ProjectInfo projectInfo);
internal async Task <(Compilation compilation, List <MetadataReference> metadata)> CreateCompilationAsync(IEnumerable <string> paths, IEnumerable <string> assemblies, IEnumerable <string> preprocessors = null, Regex[] filters = null) { Console.WriteLine("Creating workspace..."); var ws = new AdhocWorkspace(); var solutionInfo = SolutionInfo.Create(SolutionId.CreateNewId(), VersionStamp.Default); ws.AddSolution(solutionInfo); var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(), VersionStamp.Default, "CSharpExample", "CSharpExample", "C#"); ws.AddProject(projectInfo); if (paths != null) { foreach (var path in paths) { if (path.StartsWith("http://") || path.StartsWith("https://")) { await DownloadDocumentsAsync(path, ws, projectInfo.Id, filters).ConfigureAwait(false); } else if (path.EndsWith(".zip")) { LoadCompressedDocuments(path, ws, projectInfo.Id, filters); } else { LoadFolderDocuments(path, ws, projectInfo.Id, filters); } } } Console.WriteLine("Compiling..."); var project = ws.CurrentSolution.Projects.Single(); List <MetadataReference> metadata = new List <MetadataReference>(); if (assemblies != null) { foreach (var assm in assemblies) { IEnumerable <FileInfo> files = Enumerable.Empty <FileInfo>(); if (File.Exists(assm)) { files = new FileInfo[] { new FileInfo(assm) }; } else { string recursive = Path.DirectorySeparatorChar + "**" + Path.DirectorySeparatorChar; bool isRecursive = false; var d = assm; var fn = Path.GetFileName(assm); if (d.Contains(recursive)) { d = d.Substring(0, d.IndexOf(recursive)); isRecursive = true; } else if (Directory.Exists(d)) { fn = null; } else { d = Path.GetDirectoryName(d); } var dir = new DirectoryInfo(d); if (!dir.Exists) { throw new DirectoryNotFoundException(d); } if (string.IsNullOrEmpty(fn)) { files = dir.GetFiles("*.dll", isRecursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly); } else { var di = new DirectoryInfo(d); files = dir.GetFiles(fn, isRecursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly); } } foreach (var item in files) { var metaref = MetadataReference.CreateFromFile(item.FullName); project = project.AddMetadataReference(metaref); metadata.Add(metaref); } } } //Ensure mscorlib is referenced string mscorlib = typeof(System.Enum).Assembly.Location; if (File.Exists(mscorlib)) { project = project.WithParseOptions(new Microsoft.CodeAnalysis.CSharp.CSharpParseOptions(Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest, DocumentationMode.Parse, SourceCodeKind.Regular, preprocessors)); var metaref = MetadataReference.CreateFromFile(mscorlib); project = project.AddMetadataReference(metaref); } var comp = await project.GetCompilationAsync().ConfigureAwait(false); return(comp, metadata); }
public static ProjectInfo CreateProjectInfo(string language, string assemblyName, bool includeStuntApi = true, bool includeMockApi = false) { var suffix = language == LanguageNames.CSharp ? "CS" : "VB"; var options = language == LanguageNames.CSharp ? (CompilationOptions) new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default) : (CompilationOptions) new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary, optionStrict: OptionStrict.On, assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default); var parse = language == LanguageNames.CSharp ? (ParseOptions) new CSharpParseOptions(Microsoft.CodeAnalysis.CSharp.LanguageVersion.Latest) : (ParseOptions) new VisualBasicParseOptions(Microsoft.CodeAnalysis.VisualBasic.LanguageVersion.Latest); //The location of the .NET assemblies var frameworkPath = Path.GetDirectoryName(typeof(object).Assembly.Location); var netstandardPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), @".nuget\packages\NETStandard.Library\2.0.0\build\netstandard2.0\ref"); if (!Directory.Exists(netstandardPath)) { netstandardPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles), @"dotnet\sdk\NuGetFallbackFolder\netstandard.library\2.0.0\build\netstandard2.0\ref"); } if (!Directory.Exists(netstandardPath)) { netstandardPath = @"C:\Program Files\dotnet\sdk\NuGetFallbackFolder\netstandard.library\2.0.0\build\netstandard2.0\ref"; } if (!Directory.Exists(netstandardPath)) { throw new InvalidOperationException("Failed to find location of .NETStandard 2.0 reference assemblies"); } var referencePaths = //new[] //{ // typeof(object).Assembly.Location, // typeof(Enumerable).Assembly.Location, // typeof(CSharpCompilation).Assembly.Location, // typeof(Compilation).Assembly.Location, //} Directory.EnumerateFiles(netstandardPath, "*.dll") .Concat(ReferencePaths.Paths) //ReferencePaths.Paths //.Concat(Directory.EnumerateFiles(netstandardPath, "*.dll")) .Where(path => !string.IsNullOrEmpty(path) && File.Exists(path)) .Distinct(FileNameEqualityComparer.Default); var projectId = ProjectId.CreateNewId(); var documents = new List <DocumentInfo>(); if (includeStuntApi) { var stuntApi = language == LanguageNames.CSharp ? new FileInfo(@"contentFiles\cs\netstandard1.3\Stunt.cs").FullName : new FileInfo(@"contentFiles\vb\netstandard1.3\Stunt.vb").FullName; Assert.True(File.Exists(stuntApi)); documents.Add(DocumentInfo.Create( DocumentId.CreateNewId(projectId, Path.GetFileName(stuntApi)), Path.GetFileName(stuntApi), loader: new FileTextLoader(stuntApi, Encoding.Default), filePath: stuntApi)); } if (includeMockApi) { var mockApi = language == LanguageNames.CSharp ? new FileInfo(@"contentFiles\cs\netstandard2.0\Mock.cs").FullName : new FileInfo(@"contentFiles\vb\netstandard2.0\Mock.vb").FullName; var mockApiOverloads = Path.ChangeExtension(mockApi, ".Overloads") + Path.GetExtension(mockApi); Assert.True(File.Exists(mockApi)); documents.Add(DocumentInfo.Create( DocumentId.CreateNewId(projectId, Path.GetFileName(mockApi)), Path.GetFileName(mockApi), loader: new FileTextLoader(mockApi, Encoding.Default), filePath: mockApi)); documents.Add(DocumentInfo.Create( DocumentId.CreateNewId(projectId, Path.GetFileName(mockApiOverloads)), Path.GetFileName(mockApiOverloads), loader: new FileTextLoader(mockApiOverloads, Encoding.Default), filePath: mockApiOverloads)); } var projectDir = Path.Combine(Path.GetTempPath(), "Mock", projectId.Id.ToString()); return(ProjectInfo.Create( projectId, VersionStamp.Create(), assemblyName + "." + suffix, assemblyName + "." + suffix, language, filePath: language == LanguageNames.CSharp ? Path.Combine(projectDir, "code.csproj") : Path.Combine(projectDir, "code.vbproj"), compilationOptions: options, parseOptions: parse, metadataReferences: referencePaths .Select(path => MetadataReference.CreateFromFile(path)), documents: documents.ToArray())); }
public static void AssertNoAnalysisResultsExist(ProjectInfo projectInfo) { Assert.IsTrue(projectInfo.AnalysisResults == null || projectInfo.AnalysisResults.Count == 0, "Not expecting analysis results to exist. Count: {0}", projectInfo.AnalysisResults.Count); }
protected void MoveProjectData(string projectNumber) { var infomodel = new ProjectInfo(); infomodel = this.IDKLManagerService.GetProjectInfo(projectNumber); if (infomodel != null) { ProjectInfoHistory history = ProjectInfoHistory.Clone(infomodel); history.ProjectRealClosingDate = DateTime.Now; this.IDKLManagerService.AddProjectInfoHistory(history); } this.IDKLManagerService.DeleteProjectInfo(projectNumber); var valueInfo = new ValueBasicInfo(); valueInfo = this.IDKLManagerService.GetVlaueProjectBasicInfo(projectNumber); if (valueInfo != null) { ValueBasicInfoHistory history = ValueBasicInfoHistory.Clone(valueInfo); this.IDKLManagerService.AddVlaueProjectBasicInfoHistory(history); } this.IDKLManagerService.DeleteVlaueProjectBasicInfo(projectNumber); var testChemical = new TestChemicalReport(); testChemical = this.IDKLManagerService.GetTestTestChemicalReport(projectNumber); if (testChemical != null) { TestChemicalReportListHistory chemicalHistory = TestChemicalReportListHistory.Clone(testChemical); this.IDKLManagerService.AddTestChemicalReportListHistory(chemicalHistory); } this.IDKLManagerService.DeleteTestChemicalReport(projectNumber); var testInfo = new TestBasicInfo(); testInfo = this.IDKLManagerService.GetProjectTestBasicInfo(projectNumber); if (testInfo != null) { TestBasicInfoHistory history = TestBasicInfoHistory.Clone(testInfo); this.IDKLManagerService.AddProjectTestBasicInfoHistory(history); } this.IDKLManagerService.DeleteProjectTestBasicInfo(projectNumber); var consultInfo = new ConsultBasicInfo(); consultInfo = this.IDKLManagerService.GetConsultBasicInfo(projectNumber); if (consultInfo != null) { ConsultBasicInfoHistory history = ConsultBasicInfoHistory.Clone(consultInfo); this.IDKLManagerService.AddConsultBasicInfoHistory(history); } this.IDKLManagerService.DeleteConsultBasicInfo(projectNumber); var fileInfo = new ProjectFile(); fileInfo = this.IDKLManagerService.GetProjectFile(projectNumber); if (fileInfo != null) { ProjectFileHistory history = ProjectFileHistory.Clone(fileInfo); this.IDKLManagerService.AddProjectFileHistory(history); } this.IDKLManagerService.DeleteProjectFile(projectNumber); var docList = this.IDKLManagerService.GetProjectDocFileList(projectNumber); ProjectDocFileHistory docHistory = new ProjectDocFileHistory(); foreach (var doc in docList) { docHistory = ProjectDocFileHistory.Clone(doc); this.IDKLManagerService.AddProjectDocFileHistory(docHistory); } this.IDKLManagerService.DeleteProjectDocFile(projectNumber); }
/// <summary> /// Gets cached project wrapper. /// </summary> /// <param name="projectInfo">The project information. If null then gets active project.</param> /// <returns>Returns the project wrapper.</returns> /// <exception cref="System.InvalidOperationException"/> private BaseProjectWrapper GetProjectWrapper(ProjectInfo projectInfo) { return(GetProjectWrapperByName(projectInfo != null ? projectInfo.Name : null)); }
private static bool HasInvalidGuid(ProjectInfo project) { return(project.ProjectGuid == Guid.Empty); }
private void AddCppFileTreeViewItem(ProjectInfo projectInfo, TreeViewItem parentTreeViewItem, SolutionHierarchy.Item item) { const string kExcludeFromUnityBuild = "Exclude from Unity Build"; const string kIncludeInUnityBuild = "Include in Unity Build"; string cppFileName = item.Name; var treeViewItem = new TreeViewItem() { FontWeight = FontWeights.Normal }; treeViewItem.DataContext = item; treeViewItem.ContextMenu = new ContextMenu(); var checkBox = new CheckBox() { IsChecked = !_solutionSettings.IsExcludedCppFileNameForProject(projectInfo, cppFileName), VerticalAlignment = VerticalAlignment.Center }; var contextMenuItemExclude = new MenuItem() { Header = checkBox.IsChecked.Value ? kExcludeFromUnityBuild : kIncludeInUnityBuild, }; contextMenuItemExclude.Click += (sender, eventArgs) => { checkBox.IsChecked = !checkBox.IsChecked.Value; }; treeViewItem.ContextMenu.Items.Add(contextMenuItemExclude); checkBox.Checked += (sender, eventArgs) => { _solutionSettings.RemoveExcludedCppFileNameForProject(projectInfo, cppFileName); contextMenuItemExclude.Header = kExcludeFromUnityBuild; }; checkBox.Unchecked += (sender, eventArgs) => { _solutionSettings.ExcludeCppFileNameForProject(projectInfo, cppFileName); contextMenuItemExclude.Header = kIncludeInUnityBuild; }; var image = new Image() { Source = _solutionHierarchy.GetIcon(SolutionHierarchy.IconType.CppFile) }; var label = new Label() { Content = System.IO.Path.GetFileName(cppFileName) }; var stack = new StackPanel() { Orientation = Orientation.Horizontal, Margin = new Thickness(0, -2, 0, -2) }; stack.Children.Add(checkBox); stack.Children.Add(image); stack.Children.Add(label); treeViewItem.Header = stack; parentTreeViewItem.Items.Add(treeViewItem); }
protected void Page_Load(object sender, EventArgs e) { // Keep current user object CurrentUserInfo currentUser = CMSContext.CurrentUser; // Title element settings titleElem.TitleImage = GetImageUrl("Objects/PM_ProjectTask/object.png"); titleElem.TitleText = GetString("pm.projecttask.edit"); #region "Header actions" if (CMSContext.CurrentUser.IsAuthenticated()) { // New task link string[,] actions = new string[1, 7]; actions[0, 0] = HeaderActions.TYPE_LINKBUTTON; actions[0, 1] = GetString("pm.projecttask.newpersonal"); actions[0, 2] = null; actions[0, 4] = null; actions[0, 5] = GetImageUrl("Objects/PM_Project/add.png"); actions[0, 6] = "new_task"; HeaderActions.Actions = actions; HeaderActions.ActionPerformed += new CommandEventHandler(actionsElem_ActionPerformed); HeaderActions.ReloadData(); } #endregion // Switch by display type and set correct list grid name switch (this.TasksDisplayType) { // Project tasks case TasksDisplayTypeEnum.ProjectTasks: ucTaskList.OrderByType = ProjectTaskOrderByEnum.NotSpecified; ucTaskList.Grid.OrderBy = "TaskPriorityOrder ASC,ProjectTaskDeadline DESC"; ucTaskList.Grid.GridName = "~/CMSModules/ProjectManagement/Controls/LiveControls/ProjectTasks.xml"; pnlListActions.Visible = false; break; // Tasks owned by me case TasksDisplayTypeEnum.TasksOwnedByMe: ucTaskList.OrderByType = ProjectTaskOrderByEnum.NotSpecified; ucTaskList.Grid.OrderBy = "TaskPriorityOrder ASC,ProjectTaskDeadline DESC"; ucTaskList.Grid.GridName = "~/CMSModules/ProjectManagement/Controls/LiveControls/TasksOwnedByMe.xml"; break; // Tasks assigned to me case TasksDisplayTypeEnum.TasksAssignedToMe: // Set not specified order by default ucTaskList.OrderByType = ProjectTaskOrderByEnum.NotSpecified; // If sitename is not defined => display task from all sites => use user order if (String.IsNullOrEmpty(this.SiteName)) { ucTaskList.OrderByType = ProjectTaskOrderByEnum.UserOrder; } ucTaskList.Grid.OrderBy = "TaskPriorityOrder ASC,ProjectTaskDeadline DESC"; ucTaskList.Grid.GridName = "~/CMSModules/ProjectManagement/Controls/LiveControls/TasksAssignedToMe.xml"; break; } #region "Force edit by TaskID in querystring" // Check whether is not postback if (!RequestHelper.IsPostBack()) { // Try get value from request stroage which indicates whether force dialog is displayed bool isDisplayed = ValidationHelper.GetBoolean(RequestStockHelper.GetItem("cmspmforceitemdisplayed", true), false); // Try get task id from querystring int forceTaskId = QueryHelper.GetInteger("taskid", 0); if ((forceTaskId > 0) && (!isDisplayed)) { ProjectTaskInfo pti = ProjectTaskInfoProvider.GetProjectTaskInfo(forceTaskId); ProjectInfo pi = ProjectInfoProvider.GetProjectInfo(pti.ProjectTaskProjectID); // Check whether task is defined // and if is assigned to some project, this project is assigned to current site if ((pti != null) && ((pi == null) || (pi.ProjectSiteID == CMSContext.CurrentSiteID))) { bool taskIdValid = false; // Switch by display type switch (this.TasksDisplayType) { // Tasks created by me case TasksDisplayTypeEnum.TasksOwnedByMe: if (pti.ProjectTaskOwnerID == currentUser.UserID) { taskIdValid = true; } break; // Tasks assigned to me case TasksDisplayTypeEnum.TasksAssignedToMe: if (pti.ProjectTaskAssignedToUserID == currentUser.UserID) { taskIdValid = true; } break; // Project task case TasksDisplayTypeEnum.ProjectTasks: if (!String.IsNullOrEmpty(ProjectNames) && (pi != null)) { string projectNames = ";" + ProjectNames.ToLower() + ";"; if (projectNames.Contains(";" + pi.ProjectName.ToLower() + ";")) { // Check whether user can see private task if (!pti.ProjectTaskIsPrivate || ((pti.ProjectTaskOwnerID == currentUser.UserID) || (pti.ProjectTaskAssignedToUserID == currentUser.UserID)) || ((pi.ProjectGroupID > 0) && currentUser.IsGroupAdministrator(pi.ProjectGroupID)) || ((pi.ProjectGroupID == 0) && (currentUser.IsAuthorizedPerResource("CMS.ProjectManagement", CMSAdminControl.PERMISSION_MANAGE)))) { taskIdValid = true; } } } break; } bool displayValid = true; // Check whether do not display finished tasks is required if (!this.ShowFinishedTasks) { ProjectTaskStatusInfo ptsi = ProjectTaskStatusInfoProvider.GetProjectTaskStatusInfo(pti.ProjectTaskStatusID); if ((ptsi != null) && (ptsi.TaskStatusIsFinished)) { displayValid = false; } } // Check whether private task should be edited if (!this.ShowPrivateTasks) { if (pti.ProjectTaskProjectID == 0) { displayValid = false; } } // Check whether ontime task should be edited if (!this.ShowOnTimeTasks) { if ((pti.ProjectTaskDeadline != DateTimeHelper.ZERO_TIME) && (pti.ProjectTaskDeadline < DateTime.Now)) { displayValid = false; } } // Check whether overdue task should be edited if (!this.ShowOverdueTasks) { if ((pti.ProjectTaskDeadline != DateTimeHelper.ZERO_TIME) && (pti.ProjectTaskDeadline > DateTime.Now)) { displayValid = false; } } // Check whether user is allowed to see project if ((pi != null) && (ProjectInfoProvider.IsAuthorizedPerProject(pi.ProjectID, ProjectManagementPermissionType.READ, CMSContext.CurrentUser))) { displayValid = false; } // If task is valid and user has permissions to see this task display edit task dialog if (displayValid && taskIdValid && ProjectTaskInfoProvider.IsAuthorizedPerTask(forceTaskId, ProjectManagementPermissionType.READ, CMSContext.CurrentUser, CMSContext.CurrentSiteID)) { this.ucTaskEdit.ItemID = forceTaskId; this.ucTaskEdit.ReloadData(); // Render dialog this.ucPopupDialog.Visible = true; this.ucPopupDialog.Show(); // Set "force dialog displayed" flag RequestStockHelper.Add("cmspmforceitemdisplayed", true, true); } } } } #endregion #region "Event handlers registration" // Register list action handler ucTaskList.OnAction += new CommandEventHandler(ucTaskList_OnAction); #endregion #region "Pager settings" // Paging if (!EnablePaging) { ucTaskList.Grid.PageSize = "##ALL##"; ucTaskList.Grid.Pager.DefaultPageSize = -1; } else { ucTaskList.Grid.Pager.DefaultPageSize = PageSize; ucTaskList.Grid.PageSize = this.PageSize.ToString(); ucTaskList.Grid.FilterLimit = PageSize; } #endregion // Use postbacks on list actions ucTaskList.UsePostbackOnEdit = true; // Check delete permission ucTaskList.OnCheckPermissionsExtended += new CheckPermissionsExtendedEventHandler(ucTaskList_OnCheckPermissionsExtended); // Dont register JS edit script ucTaskList.RegisterEditScript = false; // Hide default ok button on edit ucTaskEdit.ShowOKButton = false; // Disable on site validators ucTaskEdit.DisableOnSiteValidators = true; // Check modify permission ucTaskEdit.OnCheckPermissionsExtended += new CheckPermissionsExtendedEventHandler(ucTaskEdit_OnCheckPermissionsExtended); // Build condition event ucTaskList.BuildCondition += new CMSModules_ProjectManagement_Controls_UI_ProjectTask_List.BuildConditionEvent(ucTaskList_BuildCondition); }
/// <summary> /// Handles the Load event of the Page control. /// </summary> protected void Page_Load(object sender, EventArgs e) { gridMatrix.OnItemChanged += new UniMatrix.ItemChangedEventHandler(gridMatrix_OnItemChanged); gridMatrix.StopProcessing = true; gridMatrix.ColumnsPreferedOrder = string.Join(",", allowedPermissions); if (ProjectID > 0) { project = ProjectInfoProvider.GetProjectInfo(ProjectID); // Check whether the project still exists EditedObject = project; } // Handle page chnaged event gridMatrix.OnPageChanged += new EventHandler<EventArgs>(gridMatrix_OnPageChanged); // Disable permission matrix if user has no MANAGE rights if (!ProjectInfoProvider.IsAuthorizedPerProject(ProjectID, PERMISSION_MANAGE, CMSContext.CurrentUser)) { Enable = false; gridMatrix.Enabled = false; lblError.Text = String.Format(GetString("CMSSiteManager.AccessDeniedOnPermissionName"), "Manage"); lblError.Visible = true; } }
public void Add(ProjectInfo info) { _projectIdToProjectInfoMap.Add(info.Id, info); //Memoized results of ProjectAlreadyReferencesProject may no longer be correct; //reset the cache. _projectAlreadyReferencesProjectResultCache.Clear(); }
/// <summary> /// Generates the permission matrix for the cutrrent project. /// </summary> private void CreateMatrix() { // Get project resource info if (mResProjects == null) { mResProjects = ResourceInfoProvider.GetResourceInfo("CMS.ProjectManagement"); } // Get project object if ((mProject == null) && (ProjectID > 0)) { mProject = ProjectInfoProvider.GetProjectInfo(ProjectID); } if ((mResProjects != null) && (mProject != null)) { // Get permissions for the current project resource DataSet permissions = PermissionNameInfoProvider.GetResourcePermissions(mResProjects.ResourceId); if (DataHelper.DataSourceIsEmpty(permissions)) { lblInfo.Text = GetString("general.emptymatrix"); lblInfo.Visible = true; } else { TableRow headerRow = new TableRow(); headerRow.TableSection = TableRowSection.TableHeader; headerRow.CssClass = "unigrid-head"; TableHeaderCell newHeaderCell = new TableHeaderCell(); newHeaderCell.CssClass = "first-column"; headerRow.Cells.Add(newHeaderCell); foreach (string permission in mAllowedPermissions) { DataRow[] drArray = permissions.Tables[0].DefaultView.Table.Select("PermissionName = '" + permission + "'"); if (drArray.Length > 0) { DataRow dr = drArray[0]; newHeaderCell = new TableHeaderCell(); newHeaderCell.Text = dr["PermissionDisplayName"].ToString(); newHeaderCell.ToolTip = dr["PermissionDescription"].ToString(); headerRow.Cells.Add(newHeaderCell); } else { throw new Exception("[Security matrix] Column '" + permission + "' cannot be found."); } } tblMatrix.Rows.Add(headerRow); // Render project access permissions object[,] accessNames = new object[5, 2]; accessNames[0, 0] = GetString("security.nobody"); accessNames[0, 1] = SecurityAccessEnum.Nobody; accessNames[1, 0] = GetString("security.allusers"); accessNames[1, 1] = SecurityAccessEnum.AllUsers; accessNames[2, 0] = GetString("security.authenticated"); accessNames[2, 1] = SecurityAccessEnum.AuthenticatedUsers; accessNames[3, 0] = GetString("security.groupmembers"); accessNames[3, 1] = SecurityAccessEnum.GroupMembers; accessNames[4, 0] = GetString("security.authorizedroles"); accessNames[4, 1] = SecurityAccessEnum.AuthorizedRoles; TableRow newRow; int rowIndex = 0; for (int access = 0; access <= accessNames.GetUpperBound(0); access++) { SecurityAccessEnum currentAccess = ((SecurityAccessEnum)accessNames[access, 1]); // If the security isn't displayed as part of group section if ((currentAccess == SecurityAccessEnum.GroupMembers) && (mProject.ProjectGroupID == 0)) { // Do not render this access item } else { // Generate cell holding access item name newRow = new TableRow(); TableCell newCell = new TableCell(); newCell.Text = accessNames[access, 0].ToString(); newCell.CssClass = "matrix-header"; newRow.Cells.Add(newCell); rowIndex++; // Render the permissions access items int permissionIndex = 0; for (int permission = 0; permission < (tblMatrix.Rows[0].Cells.Count - 1); permission++) { newCell = new TableCell(); // Check if the currently processed access is applied for permission bool isAllowed = CheckPermissionAccess(currentAccess, permission, tblMatrix.Rows[0].Cells[permission + 1].Text); // Disable column in roles grid if needed if ((currentAccess == SecurityAccessEnum.AuthorizedRoles) && !isAllowed) { gridMatrix.DisableColumn(permissionIndex); } // Insert the radio button for the current permission var radio = new CMSRadioButton { Checked = isAllowed, Enabled = Enable, }; radio.Attributes.Add("onclick", ControlsHelper.GetPostBackEventReference(this, permission + ";" + Convert.ToInt32(currentAccess))); newCell.Controls.Add(radio); newRow.Cells.Add(newCell); permissionIndex++; } // Add the access row to the table tblMatrix.Rows.Add(newRow); } } // Check if project has some roles assigned headTitle.Visible = gridMatrix.HasData; } } }
public VisualStudioProject CreateAndAddToWorkspace(string projectSystemName, string language, VisualStudioProjectCreationInfo creationInfo) { // HACK: Fetch this service to ensure it's still created on the UI thread; once this is moved off we'll need to fix up it's constructor to be free-threaded. _visualStudioWorkspaceImpl.Services.GetRequiredService <VisualStudioMetadataReferenceManager>(); // HACK: since we're on the UI thread, ensure we initialize our options provider which depends on a UI-affinitized experimentation service _visualStudioWorkspaceImpl.EnsureDocumentOptionProvidersInitialized(); var id = ProjectId.CreateNewId(projectSystemName); var directoryNameOpt = creationInfo.FilePath != null?Path.GetDirectoryName(creationInfo.FilePath) : null; // We will use the project system name as the default display name of the project var project = new VisualStudioProject(_visualStudioWorkspaceImpl, _dynamicFileInfoProviders, _hostDiagnosticUpdateSource, id, displayName: projectSystemName, language, directoryNameOpt); var versionStamp = creationInfo.FilePath != null?VersionStamp.Create(File.GetLastWriteTimeUtc(creationInfo.FilePath)) : VersionStamp.Create(); var assemblyName = creationInfo.AssemblyName ?? projectSystemName; _visualStudioWorkspaceImpl.AddProjectToInternalMaps(project, creationInfo.Hierarchy, creationInfo.ProjectGuid, projectSystemName); _visualStudioWorkspaceImpl.ApplyChangeToWorkspace(w => { var projectInfo = ProjectInfo.Create( id, versionStamp, name: projectSystemName, assemblyName: assemblyName, language: language, filePath: creationInfo.FilePath, compilationOptions: creationInfo.CompilationOptions, parseOptions: creationInfo.ParseOptions); // If we don't have any projects and this is our first project being added, then we'll create a new SolutionId if (w.CurrentSolution.ProjectIds.Count == 0) { // Fetch the current solution path. Since we're on the UI thread right now, we can do that. string solutionFilePath = null; var solution = (IVsSolution)Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsSolution)); if (solution != null) { if (ErrorHandler.Failed(solution.GetSolutionInfo(out _, out solutionFilePath, out _))) { // Paranoia: if the call failed, we definitely don't want to use any stuff that was set solutionFilePath = null; } } w.OnSolutionAdded( SolutionInfo.Create( SolutionId.CreateNewId(solutionFilePath), VersionStamp.Create(), solutionFilePath, projects: new[] { projectInfo })); } else { w.OnProjectAdded(projectInfo); } _visualStudioWorkspaceImpl.RefreshProjectExistsUIContextForLanguage(language); }); // We do all these sets after the w.OnProjectAdded, as the setting of these properties is going to try to modify the workspace // again. Those modifications will all implicitly do nothing, since the workspace already has the values from above. // We could pass these all through the constructor (but that gets verbose), or have some other control to ignore these, // but that seems like overkill. project.AssemblyName = assemblyName; project.CompilationOptions = creationInfo.CompilationOptions; project.FilePath = creationInfo.FilePath; project.ParseOptions = creationInfo.ParseOptions; return(project); }
private JumpTask CreateProjectJumpItem(ProjectInfo pInfo) { JumpTask goToProject = new JumpTask(); goToProject.CustomCategory = ScrumFactory.Windows.Properties.Resources.Recent_projects; goToProject.Title = pInfo.ProjectName + " - " + pInfo.ClientName + " [" + pInfo.ProjectNumber + "]"; goToProject.Description = String.Format(ScrumFactory.Windows.Properties.Resources.Go_to_project_N, pInfo.ProjectNumber); goToProject.ApplicationPath = Assembly.GetEntryAssembly().Location; goToProject.IconResourcePath = goToProject.ApplicationPath; goToProject.Arguments = "projectNumber=" + pInfo.ProjectNumber; return goToProject; }
public MyTfsProject(ProjectInfo projectInfo, IBuildServer buildServer, MyTfsProjectCollection projectCollection) { _projectInfo = projectInfo; _buildServer = buildServer; _projectCollection = projectCollection; }
/// <summary> /// Creates COBIESpaceClassifications. /// </summary> /// <param name="exporterIFC">The ExporterIFC.</param> /// <param name="file">The file.</param> /// <param name="spaceHnd">The space handle.</param> /// <param name="projectInfo">The project info.</param> /// <param name="spatialElement">The spatial element.</param> private static void CreateCOBIESpaceClassifications(ExporterIFC exporterIFC, IFCFile file, IFCAnyHandle spaceHnd, ProjectInfo projectInfo, SpatialElement spatialElement) { HashSet<IFCAnyHandle> spaceHnds = new HashSet<IFCAnyHandle>(); spaceHnds.Add(spaceHnd); string bimStandardsLocation = null; if (projectInfo != null) ParameterUtil.GetStringValueFromElement(projectInfo.Id, "BIM Standards URL", out bimStandardsLocation); // OCCS - Space by Function. string itemReference = ""; if (ParameterUtil.GetStringValueFromElement(spatialElement.Id, "OmniClass Number", out itemReference) != null) { string itemName; ParameterUtil.GetStringValueFromElement(spatialElement.Id, "OmniClass Title", out itemName); IFCAnyHandle classification; if (!ExporterCacheManager.ClassificationCache.ClassificationHandles.TryGetValue("OmniClass", out classification)) { classification = IFCInstanceExporter.CreateClassification(file, "http://www.omniclass.org", "v 1.0", null, "OmniClass"); ExporterCacheManager.ClassificationCache.ClassificationHandles.Add("OmniClass", classification); } IFCAnyHandle classificationReference = IFCInstanceExporter.CreateClassificationReference(file, "http://www.omniclass.org/tables/OmniClass_13_2006-03-28.pdf", itemReference, itemName, classification); IFCAnyHandle relAssociates = IFCInstanceExporter.CreateRelAssociatesClassification(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle, "OmniClass", null, spaceHnds, classificationReference); } // Space Type (Owner) itemReference = ""; if (ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Type (Owner) Reference", out itemReference) != null) { string itemName; ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Type (Owner) Name", out itemName); IFCAnyHandle classificationReference = IFCInstanceExporter.CreateClassificationReference(file, bimStandardsLocation, itemReference, itemName, null); IFCAnyHandle relAssociates = IFCInstanceExporter.CreateRelAssociatesClassification(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle, "Space Type (Owner)", null, spaceHnds, classificationReference); } // Space Category (Owner) itemReference = ""; if (ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Category (Owner) Reference", out itemReference) != null) { string itemName; ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Category (Owner) Name", out itemName); IFCAnyHandle classificationReference = IFCInstanceExporter.CreateClassificationReference(file, bimStandardsLocation, itemReference, itemName, null); IFCAnyHandle relAssociates = IFCInstanceExporter.CreateRelAssociatesClassification(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle, "Space Category (Owner)", null, spaceHnds, classificationReference); } // Space Category (BOMA) itemReference = ""; if (ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Category (BOMA) Reference", out itemReference) != null) { string itemName; ParameterUtil.GetStringValueFromElement(spatialElement.Id, "Space Category (BOMA) Name", out itemName); IFCAnyHandle classificationReference = IFCInstanceExporter.CreateClassificationReference(file, "http://www.BOMA.org", itemReference, itemName, null); IFCAnyHandle relAssociates = IFCInstanceExporter.CreateRelAssociatesClassification(file, GUIDUtil.CreateGUID(), ExporterCacheManager.OwnerHistoryHandle, "Space Category (BOMA)", "", spaceHnds, classificationReference); } }
public override void Start(int delay, int left, int top, int width, int height, double scale, ProjectInfo project) { base.Start(delay, left, top, width, height, scale, project); _infoHeader = new Native.BitmapInfoHeader(); _infoHeader.biSize = (uint)Marshal.SizeOf(_infoHeader); _infoHeader.biBitCount = 24; //Without alpha channel. _infoHeader.biClrUsed = 0; _infoHeader.biClrImportant = 0; _infoHeader.biCompression = 0; _infoHeader.biHeight = -StartHeight; //Negative, so the Y-axis will be positioned correctly. _infoHeader.biWidth = StartWidth; _infoHeader.biPlanes = 1; //This was working with 32 bits: 3L * Width * Height; _byteLength = (StartWidth * _infoHeader.biBitCount + 31) / 32 * 4 * StartHeight; //Due to a strange behavior with the GetDiBits method while the cursor is IBeam, it's best to use 24 bits, to ignore the alpha values. //This capture mode ignores the alpha value. project.BitDepth = 24; _fileStream = new FileStream(project.CachePath, FileMode.Create, FileAccess.Write, FileShare.None); _bufferedStream = new BufferedStream(_fileStream, UserSettings.All.MemoryCacheSize * 1048576); //Each 1 MB has 1_048_576 bytes. _compressStream = new DeflateStream(_bufferedStream, UserSettings.All.CaptureCompression, true); }
/// <summary> /// Creates the IfcPostalAddress, and assigns it to the file. /// </summary> /// <param name="file">The IFC file.</param> /// <param name="address">The address string.</param> /// <param name="town">The town string.</param> /// <returns>The handle of IFC file.</returns> private IFCAnyHandle CreateIFCAddress(IFCFile file, Document document, ProjectInfo projInfo) { IFCAnyHandle postalAddress = null; postalAddress = CreateIFCAddressFromExtStorage(file, document); if (postalAddress != null) return postalAddress; string projectAddress = projInfo != null ? projInfo.Address : String.Empty; SiteLocation siteLoc = document.ActiveProjectLocation.SiteLocation; string location = siteLoc != null ? siteLoc.PlaceName : String.Empty; if (projectAddress == null) projectAddress = String.Empty; if (location == null) location = String.Empty; List<string> parsedAddress = new List<string>(); string city = String.Empty; string state = String.Empty; string postCode = String.Empty; string country = String.Empty; string parsedTown = location; int commaLoc = -1; do { commaLoc = parsedTown.IndexOf(','); if (commaLoc >= 0) { if (commaLoc > 0) parsedAddress.Add(parsedTown.Substring(0, commaLoc)); parsedTown = parsedTown.Substring(commaLoc + 1).TrimStart(' '); } else if (!String.IsNullOrEmpty(parsedTown)) parsedAddress.Add(parsedTown); } while (commaLoc >= 0); int numLines = parsedAddress.Count; if (numLines > 0) { country = parsedAddress[numLines - 1]; numLines--; } if (numLines > 0) { int spaceLoc = parsedAddress[numLines - 1].IndexOf(' '); if (spaceLoc > 0) { state = parsedAddress[numLines - 1].Substring(0, spaceLoc); postCode = parsedAddress[numLines - 1].Substring(spaceLoc + 1); } else state = parsedAddress[numLines - 1]; numLines--; } if (numLines > 0) { city = parsedAddress[numLines - 1]; numLines--; } List<string> addressLines = new List<string>(); if (!String.IsNullOrEmpty(projectAddress)) addressLines.Add(projectAddress); for (int ii = 0; ii < numLines; ii++) { addressLines.Add(parsedAddress[ii]); } postalAddress = IFCInstanceExporter.CreatePostalAddress(file, null, null, null, null, addressLines, null, city, state, postCode, country); return postalAddress; }
public static async Task GenerateAndVerifyMocksUsingEmbeddedResources( Type fixtureType, string testName, Language language, IEnumerable <MetadataReference> metadataReferences = default, IPlugin[] plugins = default, // Should only be enabled temporarily to overwrite expected output with the actual output, making it easy to update // expected output files when code changes necessitate. bool overwriteExpectedOutput = false) { var resourceBaseName = $"{fixtureType.FullName}Resources."; var inputResourceName = $"{resourceBaseName}{testName}Input_{language}.txt"; var outputResourceName = $"{resourceBaseName}{testName}Output_{language}.txt"; var platformPath = Path.GetDirectoryName(typeof(object).Assembly.Location); // Manually add some references that are always required. var supplementedMetadataReferences = (metadataReferences ?? Enumerable.Empty <MetadataReference>()) .Concat( new[] { MetadataReference.CreateFromFile(Path.Combine(platformPath, "System.Runtime.dll")), MetadataReference.CreateFromFile(typeof(System.Linq.Expressions.Expression).Assembly.Location), MetadataReference.CreateFromFile(typeof(object).Assembly.Location), MetadataReference.CreateFromFile(typeof(MockBase <>).Assembly.Location), }); using (var inputStream = typeof(Helpers).Assembly.GetManifestResourceStream(inputResourceName)) { var projectInfo = ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Create(), "AdhocProject", "AdhocProject", language.ToSyntaxGeneratorLanguageName(), compilationOptions: language == Language.CSharp ? (CompilationOptions) new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary) : new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary), metadataReferences: supplementedMetadataReferences); // Create an adhoc workspace and project containing the input source. var workspace = new AdhocWorkspace(); var project = workspace .AddProject(projectInfo) .AddDocument("Source.cs", SourceText.From(inputStream)) .Project; var compilation = await project.GetCompilationAsync(); var diagnostics = compilation.GetDiagnostics(); // Ensure there are no issues with the input project, otherwise it might be confusing to understand issues with the generated mocks. Assert.Empty(diagnostics); var logSink = new StringLogSink() .WithMinimumLevel(LogLevel.Warn); var generatedMocks = Generator.GenerateMocks( logSink, language, ImmutableList.Create(compilation), (plugins ?? Enumerable.Empty <IPlugin>()).ToImmutableList(), x => true, x => "The.Namespace", x => $"{x.Name}Mock"); var log = logSink.ToString(); // There shouldn't be any errors or warnings in the log or something has gone wrong generating mocks. Assert.Equal("", log); var generatedMocksAggregated = generatedMocks .Aggregate( new StringBuilder(), (acc, next) => { if (next != null) { acc.AppendLine(next.ToFullString()); } return(acc); }, acc => acc.ToString()) .NormalizeLineEndings(); using (var outputStream = typeof(Helpers).Assembly.GetManifestResourceStream(outputResourceName)) using (var outputStreamReader = new StreamReader(outputStream)) { var expectedCode = outputStreamReader.ReadToEnd(); // make sure version changes don't break the tests expectedCode = expectedCode .Replace("$VERSION$", typeof(MockBase <>).Assembly.GetName().Version.ToString()) .NormalizeLineEndings(); // useful when converting generated code to something that can be pasted into an expectation file var sanitisedResult = generatedMocksAggregated.Replace(typeof(MockBase <>).Assembly.GetName().Version.ToString(), "$VERSION$"); if (overwriteExpectedOutput) { var currentDirectory = Path.GetDirectoryName(typeof(Helpers).Assembly.Location); var outputDirectory = Path.Combine(currentDirectory, @"..\..\..\", "CodeGeneration", "Plugins", $"{fixtureType.Name}Resources"); var outputFileName = Path.Combine(outputDirectory, $"{testName}Output_{language}.txt"); if (!File.Exists(outputFileName)) { throw new InvalidOperationException(@"Asked to overwrite output, but cannot determine output path."); } File.WriteAllText(outputFileName, sanitisedResult); Assert.True(false, "Output successfully overwritten - now disable the overwriteExpectedOutput flag."); } Assert.Equal(expectedCode, generatedMocksAggregated); } // Now combine the original code with the generated code and make sure there are no problems. var workspaceWithGeneratedCode = new AdhocWorkspace(); var projectWithGeneratedCode = workspaceWithGeneratedCode .AddProject(projectInfo) .AddDocument("Source.cs", SourceText.From(inputStream)) .Project .AddDocument("GeneratedSource.cs", SourceText.From(generatedMocksAggregated)) .Project; var compilationWithGeneratedCode = await projectWithGeneratedCode.GetCompilationAsync(); var diagnosticsToIgnore = new HashSet <string>( new [] { // Don't require assembly identities to match exactly because PCLMock is built against netstandard whereas we're running // tests against a specific platform. This means, e.g. System.Linq.Expressions won't be the exact same assembly. "CS1701", }); var diagnosticsWithGeneratedCode = compilationWithGeneratedCode .GetDiagnostics() .Where(diagnostic => !diagnosticsToIgnore.Contains(diagnostic.Id)) .ToImmutableArray(); // Ensure there are no issues with the input project, otherwise it might be confusing to understand issues with the generated mocks. Assert.Empty(diagnostics); } }
private async Task <bool> TryLoadAndAddReferenceAsync(ProjectId id, string projectReferencePath, ImmutableArray <string> aliases, ResolvedReferencesBuilder builder, CancellationToken cancellationToken) { var projectReferenceInfos = await LoadProjectInfosFromPathAsync(projectReferencePath, _discoveredProjectOptions, cancellationToken).ConfigureAwait(false); if (projectReferenceInfos.IsEmpty) { return(false); } // Find the project reference info whose output we have a metadata reference for. ProjectInfo projectReferenceInfo = null; foreach (var info in projectReferenceInfos) { if (builder.Contains(info.OutputFilePath) || builder.Contains(info.OutputRefFilePath)) { projectReferenceInfo = info; break; } } if (projectReferenceInfo == null) { // We didn't find the project reference info that matches any of our metadata references. // In this case, we'll go ahead and use the first project reference info that was found, // but report a warning because this likely means that either a metadata reference path // or a project output path is incorrect. projectReferenceInfo = projectReferenceInfos[0]; _diagnosticReporter.Report(new ProjectDiagnostic( WorkspaceDiagnosticKind.Warning, string.Format(WorkspaceMSBuildResources.Found_project_reference_without_a_matching_metadata_reference_0, projectReferencePath), id)); } if (!ProjectReferenceExists(to: id, from: projectReferenceInfo)) { var newProjectReference = CreateProjectReference(from: id, to: projectReferenceInfo.Id, aliases); builder.SwapMetadataReferenceForProjectReference(newProjectReference, projectReferenceInfo.OutputRefFilePath, projectReferenceInfo.OutputFilePath); } else { // This project already has a reference on us. Don't introduce a circularity by referencing it. // However, if the project's output doesn't exist on disk, we need to remove from our list of // metadata references to avoid failures later. Essentially, the concern here is that the metadata // reference is an UnresolvedMetadataReference, which will throw when we try to create a // Compilation with it. if (!File.Exists(projectReferenceInfo.OutputRefFilePath)) { builder.Remove(projectReferenceInfo.OutputRefFilePath); } if (!File.Exists(projectReferenceInfo.OutputFilePath)) { builder.Remove(projectReferenceInfo.OutputFilePath); } } // Note that we return true even if we don't actually add a reference due to a circularity because, // in that case, we've still handled everything. return(true); }
/// <summary> /// Create a <see cref="Solution"/> for <paramref name="code"/> /// Each unique namespace in <paramref name="code"/> is added as a project. /// </summary> /// <param name="code">The code to create the solution from.</param> /// <param name="compilationOptions">The <see cref="CSharpCompilationOptions"/>.</param> /// <param name="metadataReferences">The metadata references.</param> /// <param name="languageVersion">The <see cref="LanguageVersion"/>.</param> /// <returns>A <see cref="Solution"/>.</returns> public static Solution CreateSolution(IEnumerable <string> code, CSharpCompilationOptions compilationOptions, IEnumerable <MetadataReference>?metadataReferences = null, LanguageVersion languageVersion = LanguageVersion.Latest) { var solutionInfo = SolutionInfo.Create( SolutionId.CreateNewId("Test.sln"), VersionStamp.Default, projects: GetProjectInfos()); var solution = EmptySolution; foreach (var projectInfo in solutionInfo.Projects) { solution = solution.AddProject(projectInfo.WithProjectReferences(FindReferences(projectInfo))); } return(solution); IEnumerable <ProjectInfo> GetProjectInfos() { var byNamespace = new SortedDictionary <string, List <string> >(); foreach (var document in code) { var ns = CodeReader.Namespace(document); if (byNamespace.TryGetValue(ns, out var doc)) { doc.Add(document); } else { byNamespace[ns] = new List <string> { document }; } } var byProject = new SortedDictionary <string, List <KeyValuePair <string, List <string> > > >(); foreach (var kvp in byNamespace) { var last = byProject.Keys.LastOrDefault(); var ns = kvp.Key; if (last != null && ns.Contains(last)) { byProject[last].Add(kvp); } else { byProject.Add(ns, new List <KeyValuePair <string, List <string> > > { kvp }); } } foreach (var kvp in byProject) { var assemblyName = kvp.Key; var projectId = ProjectId.CreateNewId(assemblyName); yield return(ProjectInfo.Create( projectId, VersionStamp.Default, assemblyName, assemblyName, LanguageNames.CSharp, compilationOptions: compilationOptions, metadataReferences: metadataReferences, documents: kvp.Value.SelectMany(x => x.Value) .Select( x => { var documentName = CodeReader.FileName(x); return DocumentInfo.Create( DocumentId.CreateNewId(projectId, documentName), documentName, sourceCodeKind: SourceCodeKind.Regular, loader: new StringLoader(x)); })) .WithParseOptions(CSharpParseOptions.Default.WithLanguageVersion(languageVersion))); } } IEnumerable <ProjectReference> FindReferences(ProjectInfo projectInfo) { var references = new List <ProjectReference>(); foreach (var other in solutionInfo.Projects.Where(x => x.Id != projectInfo.Id)) { if (projectInfo.Documents.Any(x => x.TextLoader is StringLoader stringLoader && (stringLoader.Code.Contains($"using {other.Name};") || stringLoader.Code.Contains($"{other.Name}.")))) { references.Add(new ProjectReference(other.Id)); } } return(references); } }
/// <summary> /// Load data. /// </summary> public void LoadData() { process = true; if (!Visible || StopProcessing) { EnableViewState = false; process = false; } IsLiveSite = false; if (ProjectID > 0) { // Get information on current project project = ProjectInfoProvider.GetProjectInfo(ProjectID); } // Get project resource resProjects = ResourceInfoProvider.GetResourceInfo("CMS.ProjectManagement"); if ((resProjects != null) && (project != null)) { QueryDataParameters parameters = new QueryDataParameters(); parameters.Add("@ID", resProjects.ResourceId); parameters.Add("@ProjectID", project.ProjectID); parameters.Add("@SiteID", CMSContext.CurrentSiteID); string where = ""; int groupId = project.ProjectGroupID; // Build where condition if (groupId > 0) { where = "RoleGroupID=" + groupId.ToString() + " AND PermissionDisplayInMatrix = 0"; } else { where = "RoleGroupID IS NULL AND PermissionDisplayInMatrix = 0"; } // Setup matrix control gridMatrix.IsLiveSite = IsLiveSite; gridMatrix.QueryParameters = parameters; gridMatrix.WhereCondition = where; gridMatrix.ContentBefore = "<table class=\"PermissionMatrix\" cellspacing=\"0\" cellpadding=\"0\" rules=\"rows\" border=\"1\" style=\"border-collapse:collapse;\">"; gridMatrix.ContentAfter = "</table>"; } }
private bool ProjectReferenceExists(ProjectId to, ProjectInfo from) => from.ProjectReferences.Any(pr => pr.ProjectId == to);
/// <summary> /// Generates the permission matrix for the cutrrent project. /// </summary> private void CreateMatrix() { // Get project resource info if (resProjects == null) { resProjects = ResourceInfoProvider.GetResourceInfo("CMS.ProjectManagement"); } // Get project object if ((project == null) && (ProjectID > 0)) { project = ProjectInfoProvider.GetProjectInfo(ProjectID); } if ((resProjects != null) && (project != null)) { // Get permissions for the current project resource DataSet permissions = PermissionNameInfoProvider.GetResourcePermissions(resProjects.ResourceId); if (DataHelper.DataSourceIsEmpty(permissions)) { lblInfo.Text = GetString("general.emptymatrix"); } else { TableRow headerRow = new TableRow(); headerRow.CssClass = "UniGridHead"; TableCell newCell = new TableCell(); TableHeaderCell newHeaderCell = new TableHeaderCell(); newHeaderCell.Text = " "; newHeaderCell.Attributes["style"] = "width:200px;"; headerRow.Cells.Add(newHeaderCell); foreach (string permission in allowedPermissions) { DataRow[] drArray = permissions.Tables[0].DefaultView.Table.Select("PermissionName = '" + permission + "'"); if ((drArray != null) && (drArray.Length > 0)) { DataRow dr = drArray[0]; newHeaderCell = new TableHeaderCell(); newHeaderCell.Attributes["style"] = "text-align:center;white-space:nowrap;"; newHeaderCell.Text = dr["PermissionDisplayName"].ToString(); newHeaderCell.ToolTip = dr["PermissionDescription"].ToString(); newHeaderCell.HorizontalAlign = HorizontalAlign.Center; headerRow.Cells.Add(newHeaderCell); } else { throw new Exception("[Security matrix] Column '" + permission + "' cannot be found."); } } newHeaderCell = new TableHeaderCell(); newHeaderCell.Text = " "; headerRow.Cells.Add(newHeaderCell); tblMatrix.Rows.Add(headerRow); // Render project access permissions object[,] accessNames = new object[5,2]; accessNames[0, 0] = GetString("security.nobody"); accessNames[0, 1] = SecurityAccessEnum.Nobody; accessNames[1, 0] = GetString("security.allusers"); accessNames[1, 1] = SecurityAccessEnum.AllUsers; accessNames[2, 0] = GetString("security.authenticated"); accessNames[2, 1] = SecurityAccessEnum.AuthenticatedUsers; accessNames[3, 0] = GetString("security.groupmembers"); accessNames[3, 1] = SecurityAccessEnum.GroupMembers; accessNames[4, 0] = GetString("security.authorizedroles"); accessNames[4, 1] = SecurityAccessEnum.AuthorizedRoles; TableRow newRow = null; int rowIndex = 0; for (int access = 0; access <= accessNames.GetUpperBound(0); access++) { SecurityAccessEnum currentAccess = ((SecurityAccessEnum)accessNames[access, 1]); // If the security isn't displayed as part of group section if ((currentAccess == SecurityAccessEnum.GroupMembers) && (project.ProjectGroupID == 0)) { // Do not render this access item } else { // Generate cell holding access item name newRow = new TableRow(); newRow.CssClass = ((rowIndex % 2 == 0) ? "EvenRow" : "OddRow"); newCell = new TableCell(); newCell.Text = accessNames[access, 0].ToString(); newCell.Wrap = false; newCell.CssClass = "MatrixHeader"; newCell.Width = new Unit(28, UnitType.Percentage); newRow.Cells.Add(newCell); rowIndex++; // Render the permissions access items bool isAllowed = false; bool isDisabled = (!Enable); int permissionIndex = 0; for (int permission = 0; permission < (tblMatrix.Rows[0].Cells.Count - 2); permission++) { newCell = new TableCell(); // Check if the currently processed access is applied for permission isAllowed = CheckPermissionAccess(currentAccess, permission, tblMatrix.Rows[0].Cells[permission + 1].Text); // Disable column in roles grid if needed if ((currentAccess == SecurityAccessEnum.AuthorizedRoles) && !isAllowed) { gridMatrix.DisableColumn(permissionIndex); } // Insert the radio button for the current permission string permissionText = tblMatrix.Rows[0].Cells[permission + 1].Text; string elemId = ClientID + "_" + permission + "_" + access; newCell.Text = "<label style=\"display:none;\" for=\"" + elemId + "\">" + permissionText + "</label><input type=\"radio\" id=\"" + elemId + "\" name=\"" + permissionText + "\" onclick=\"" + ControlsHelper.GetPostBackEventReference(this, permission.ToString() + ";" + Convert.ToInt32(currentAccess).ToString()) + "\" " + ((isAllowed) ? "checked = \"checked\"" : "") + ((isDisabled) ? " disabled=\"disabled\"" : "") + "/>"; newCell.Wrap = false; newCell.Width = new Unit(12, UnitType.Percentage); newCell.HorizontalAlign = HorizontalAlign.Center; newRow.Cells.Add(newCell); permissionIndex++; } newCell = new TableCell(); newCell.Text = " "; newRow.Cells.Add(newCell); // Add the access row to the table tblMatrix.Rows.Add(newRow); } } // Check if project has some roles assigned mNoRolesAvailable = !gridMatrix.HasData; // Get permission matrix for current project resource if (!mNoRolesAvailable) { // Security - Role separator newRow = new TableRow(); newCell = new TableCell(); newCell.Text = " "; newCell.Attributes.Add("colspan", Convert.ToString(tblMatrix.Rows[0].Cells.Count)); newRow.Controls.Add(newCell); tblMatrix.Rows.Add(newRow); // Security - Role separator text newRow = new TableRow(); newCell = new TableCell(); newCell.CssClass = "MatrixLabel"; newCell.Text = GetString("SecurityMatrix.RolesAvailability"); newCell.Attributes.Add("colspan", Convert.ToString(tblMatrix.Rows[0].Cells.Count)); newRow.Controls.Add(newCell); tblMatrix.Rows.Add(newRow); } } } }
public void Initalize() { var solutionFilePath = _env.SolutionFilePath; if (string.IsNullOrEmpty(solutionFilePath)) { var solutions = Directory.GetFiles(_env.Path, "*.sln"); var result = SolutionPicker.ChooseSolution(_env.Path, solutions); if (result.Message != null) { _logger.LogInformation(result.Message); } if (result.Solution == null) { return; } solutionFilePath = result.Solution; } SolutionFile solutionFile = null; _context.SolutionPath = solutionFilePath; using (var stream = File.OpenRead(solutionFilePath)) { using (var reader = new StreamReader(stream)) { solutionFile = SolutionFile.Parse(reader); } } _logger.LogInformation($"Detecting projects in '{solutionFilePath}'."); foreach (var block in solutionFile.ProjectBlocks) { if (!_supportsProjectTypes.Contains(block.ProjectTypeGuid)) { if (UnityTypeGuid(block.ProjectName) != block.ProjectTypeGuid) { _logger.LogWarning("Skipped unsupported project type '{0}'", block.ProjectPath); continue; } } if (_context.ProjectGuidToWorkspaceMapping.ContainsKey(block.ProjectGuid)) { continue; } var projectFilePath = Path.GetFullPath(Path.GetFullPath(Path.Combine(_env.Path, block.ProjectPath.Replace('\\', Path.DirectorySeparatorChar)))); _logger.LogInformation($"Loading project from '{projectFilePath}'."); var projectFileInfo = CreateProject(projectFilePath); if (projectFileInfo == null) { continue; } var projectInfo = ProjectInfo.Create(ProjectId.CreateNewId(projectFileInfo.Name), VersionStamp.Create(), projectFileInfo.Name, projectFileInfo.AssemblyName, LanguageNames.CSharp, projectFileInfo.ProjectFilePath); _workspace.AddProject(projectInfo); projectFileInfo.WorkspaceId = projectInfo.Id; _context.Projects[projectFileInfo.ProjectFilePath] = projectFileInfo; _context.ProjectGuidToWorkspaceMapping[block.ProjectGuid] = projectInfo.Id; _watcher.Watch(projectFilePath, OnProjectChanged); } foreach (var projectFileInfo in _context.Projects.Values) { UpdateProject(projectFileInfo); } }
private async Task UpdateSymbolTreeInfoAsync(Project project, CancellationToken cancellationToken) { if (!project.SupportsCompilation) { return; } // Check the semantic version of this project. The semantic version will change // if any of the source files changed, or if the project version itself changed. // (The latter happens when something happens to the project like metadata // changing on disk). var version = await project.GetSemanticVersionAsync(cancellationToken).ConfigureAwait(false); ProjectInfo projectInfo; if (!_projectToInfo.TryGetValue(project.Id, out projectInfo) || projectInfo.VersionStamp != version) { var compilation = await project.GetCompilationAsync(cancellationToken).ConfigureAwait(false); // Update the symbol tree infos for metadata and source in parallel. var referencesTask = UpdateReferencesAync(project, compilation, cancellationToken); var projectTask = SymbolTreeInfo.GetInfoForSourceAssemblyAsync(project, cancellationToken); await Task.WhenAll(referencesTask, projectTask).ConfigureAwait(false); // Mark that we're up to date with this project. Future calls with the same // semantic version can bail out immediately. projectInfo = new ProjectInfo(version, await projectTask.ConfigureAwait(false)); _projectToInfo.AddOrUpdate(project.Id, projectInfo, (_1, _2) => projectInfo); } }
/// <summary> /// Event when OK button is pressed /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private void buttonOK_Click(object sender, RoutedEventArgs args) { // Saved changes to both Address Tab items and File Header Tab items if they have changed if (m_newAddressItem.isUnchanged(m_savedAddressItem) == false) { m_newAddress.UpdateAddress(IFCCommandOverrideApplication.TheDocument, m_newAddressItem); } if (m_newFileHeaderItem.isUnchanged(m_savedFileHeaderItem) == false) { m_newFileHeader.UpdateFileHeader(IFCCommandOverrideApplication.TheDocument, m_newFileHeaderItem); } if (m_newAddressItem.UpdateProjectInformation == true) { // Format IFC address and update it into Project Information: Project Address String address = null; String geographicMapLocation = null; bool addNewLine = false; if (String.IsNullOrEmpty(m_newAddressItem.AddressLine1) == false) { address += string.Format("{0}\r\n", m_newAddressItem.AddressLine1); } if (String.IsNullOrEmpty(m_newAddressItem.AddressLine2) == false) { address += string.Format("{0}\r\n", m_newAddressItem.AddressLine2); } if (String.IsNullOrEmpty(m_newAddressItem.POBox) == false) { address += string.Format("{0}\r\n", m_newAddressItem.POBox); } if (String.IsNullOrEmpty(m_newAddressItem.TownOrCity) == false) { address += string.Format("{0}", m_newAddressItem.TownOrCity); addNewLine = true; } if (String.IsNullOrEmpty(m_newAddressItem.RegionOrState) == false) { address += string.Format(", {0}", m_newAddressItem.RegionOrState); addNewLine = true; } if (String.IsNullOrEmpty(m_newAddressItem.PostalCode) == false) { address += string.Format(" {0}", m_newAddressItem.PostalCode); addNewLine = true; } if (addNewLine == true) { address += string.Format("\r\n"); addNewLine = false; } if (String.IsNullOrEmpty(m_newAddressItem.Country) == false) { address += string.Format("{0}\r\n", m_newAddressItem.Country); } if (String.IsNullOrEmpty(m_newAddressItem.InternalLocation) == false) { address += string.Format("\r\n{0}: {1}\r\n", Properties.Resources.InternalAddress, m_newAddressItem.InternalLocation); } if (String.IsNullOrEmpty(m_newAddressItem.TownOrCity) == false) { geographicMapLocation = m_newAddressItem.TownOrCity; } if (String.IsNullOrEmpty(m_newAddressItem.RegionOrState) == false) { if (String.IsNullOrEmpty(geographicMapLocation) == false) { geographicMapLocation = geographicMapLocation + ", " + m_newAddressItem.RegionOrState; } else { geographicMapLocation = m_newAddressItem.RegionOrState; } } if (String.IsNullOrEmpty(m_newAddressItem.Country) == false) { if (String.IsNullOrEmpty(geographicMapLocation) == false) { geographicMapLocation = geographicMapLocation + ", " + m_newAddressItem.Country; } else { geographicMapLocation = m_newAddressItem.Country; } } ; Transaction transaction = new Transaction(IFCCommandOverrideApplication.TheDocument, Properties.Resources.UpdateProjectAddress); transaction.Start(); ProjectInfo projectInfo = IFCCommandOverrideApplication.TheDocument.ProjectInformation; projectInfo.Address = address; // set project address information using the IFC Address Information when requested if (String.IsNullOrEmpty(geographicMapLocation) == false) { IFCCommandOverrideApplication.TheDocument.ActiveProjectLocation.SiteLocation.PlaceName = geographicMapLocation; // Update also Revit Site location on the Map using City, State and Country when they are not null } transaction.Commit(); } // Update Classification if it has changed or the mandatory fields are filled. If mandatory fields are not filled we will ignore the classification. if (!m_newClassification.IsUnchanged(m_savedClassification)) { if (m_newClassification.AreMandatoryFieldsFilled()) { IFCClassificationMgr.UpdateClassification(IFCCommandOverrideApplication.TheDocument, m_newClassification); } else if (!m_newClassification.IsClassificationEmpty()) { m_newClassification.ClassificationTabMsg = Properties.Resources.ManditoryFieldsNotEmpty; return; } } m_newClassification.ClassificationTabMsg = null; Close(); }