public void CanCreateProjectAndGetDeviceVersion() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Name = "Test" }; var device = new Device { IpAddress = "192.168.1.1", Name = "MyTestDevice" }; project = ProjectActions.CreateProject(project).Function(conn); var projectDevice = DeviceActions.AddDeviceToProject(project.Id, device).Function(conn); var projectDeviceVersion = ProjectDeviceActions.GetLatestProjectDeviceVersion(projectDevice.Id).Function(conn); projectDeviceVersion = ProjectDeviceActions.SetLatestProjectDeviceVersion(new ProjectDeviceVersion { ProjectDeviceId = projectDevice.Id, HorizontalPercentage = 100, VerticalPercentage = 100, NumberOfHorizontalPixels = 50, NumberOfVerticalPixels = 50, StartAtHorizontalPercentage = 0, StartAtVerticalPercentage = 0 }).Function(conn); projectDeviceVersion = ProjectDeviceActions.GetLatestProjectDeviceVersion(projectDevice.Id).Function(conn); Assert.NotNull(projectDeviceVersion); } }
public ProjectActions AnalyzeFiles(ProjectActions projectActions, List <string> updatedFiles) { var options = new ParallelOptions() { MaxDegreeOfParallelism = Constants.ThreadCount }; var selectedSourceFileResults = _sourceFileResults.Where(s => updatedFiles.Contains(s.FileFullPath)); Parallel.ForEach(selectedSourceFileResults, options, result => { var fileAction = new FileActions() { FilePath = result.FileFullPath }; if (AnalyzeChildren(fileAction, result.Children, 0)) { var existingFileAction = _projectActions.FileActions.FirstOrDefault(f => f.FilePath == fileAction.FilePath); if (existingFileAction != null) { existingFileAction = fileAction; } else { _projectActions.FileActions.Add(fileAction); } } }); return(_projectActions); }
public void CanDistinguishBetweenProjectDevicesAndNonProjectDevices() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Name = "Test" }; var anotherProject = new Project { Name = "Test2" }; var device = new Device { IpAddress = "192.168.1.1", Name = "MyTestDevice" }; var anotherDevice = new Device { IpAddress = "192.168.1.2", Name = "MyOtherTestDevice" }; project = ProjectActions.CreateProject(project).Function(conn); anotherProject = ProjectActions.CreateProject(anotherProject).Function(conn); var projectDevice = DeviceActions.AddDeviceToProject(project.Id, device).Function(conn); var anotherProjectDevice = DeviceActions.AddDeviceToProject(anotherProject.Id, anotherDevice).Function(conn); var devices = DeviceActions.GetProjectDevices(project.Id).Function(conn); Assert.Equal(1, devices.Count()); var retrievedDevice = devices.Single(); Assert.Equal(device.IpAddress, retrievedDevice.IpAddress); Assert.Equal(device.Name, retrievedDevice.Name); } }
/// <summary> /// Initializes a RulesAnalysis instance /// </summary> /// <param name="sourceFileResults">List of analyzed code files</param> /// <param name="rootNodes">List of rules to be applied to the code files</param> /// <param name="projectType">Type of project</param> public RulesAnalysis(List <RootUstNode> sourceFileResults, RootNodes rootNodes, ProjectType projectType = ProjectType.ClassLibrary) { _projectActions = new ProjectActions(); _sourceFileResults = sourceFileResults; _rootNodes = rootNodes; _projectType = projectType; }
public GlobalJsonResult <Project> GetWorkingProject() { var projectId = store.GetWorkingProjectId(); var result = dispatcher.Dispatch(ProjectActions.GetProject(projectId)); return(GlobalJsonResult <Project> .Success(System.Net.HttpStatusCode.OK, result)); }
public void CanSetProjectDeviceMappingsTwice() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Name = "Test" }; var device = new Device { IpAddress = "192.168.1.1", Name = "MyTestDevice" }; project = ProjectActions.CreateProject(project).Function(conn); var projectDevice = DeviceActions.AddDeviceToProject(project.Id, device).Function(conn); var projectDeviceVersion = ProjectDeviceActions.SetLatestProjectDeviceVersion(new ProjectDeviceVersion { ProjectDeviceId = projectDevice.Id, HorizontalPercentage = 100, VerticalPercentage = 100, NumberOfHorizontalPixels = 50, NumberOfVerticalPixels = 50, StartAtHorizontalPercentage = 0, StartAtVerticalPercentage = 0 }).Function(conn); var firstMappings = new List <ProjectDeviceVersionMapping> { new ProjectDeviceVersionMapping { HorizontalPosition = 1, VerticalPosition = 1, MappingOrder = 1 } }; var secondMappings = new List <ProjectDeviceVersionMapping> { new ProjectDeviceVersionMapping { HorizontalPosition = 1, VerticalPosition = 1, MappingOrder = 1, }, new ProjectDeviceVersionMapping { HorizontalPosition = 2, VerticalPosition = 1, MappingOrder = 2 } }; ProjectDeviceActions.SetProjectDeviceMappings(projectDeviceVersion.Id, firstMappings).Function(conn); ProjectDeviceActions.SetProjectDeviceMappings(projectDeviceVersion.Id, secondMappings).Function(conn); var result = ProjectDeviceActions.GetProjectDeviceMappings(projectDeviceVersion.Id).Function(conn); Assert.Equal(2, result.Count()); } }
/// <summary> /// Runs the project rewriter using a previously initialized analysis /// </summary> /// <param name="projectActions"></param> public ProjectResult Run(ProjectActions projectActions) { _projectResult.ProjectActions = projectActions; CodeReplacer baseReplacer = new CodeReplacer(_sourceFileBuildResults, RulesEngineConfiguration, _metaReferences); _projectResult.ExecutedActions = baseReplacer.Run(projectActions, RulesEngineConfiguration.ProjectType); return(_projectResult); }
/// <summary> /// Runs the project rewriter using a previously initialized analysis /// </summary> /// <param name="projectActions"></param> public virtual ProjectResult Run(ProjectActions projectActions) { _projectResult.ProjectActions = projectActions; CodeReplacer baseReplacer = new CodeReplacer(_sourceFileBuildResults, ProjectConfiguration, _metaReferences, _analyzerResult, projectResult: _projectResult); _projectResult.ExecutedActions = baseReplacer.Run(projectActions, ProjectConfiguration.ProjectType); return(_projectResult); }
public PluginUI(PluginMain plugin, FDMenus menus, FileActions fileActions, ProjectActions projectActions) { this.plugin = plugin; this.menus = menus; this.Tag = "Project"; this.Text = "Project Explorer"; #region Build TreeView menu = new ProjectContextMenu(menus); menu.Rename.Click += new EventHandler(RenameNode); treeBar = new TreeBar(menus, menu); treeBar.Dock = DockStyle.Top; treeBar.Visible = false; tree = new ProjectTreeView(); tree.Visible = false; tree.Dock = DockStyle.Fill; tree.ImageIndex = 0; tree.ImageList = Icons.ImageList; tree.LabelEdit = true; tree.SelectedImageIndex = 0; tree.ShowRootLines = false; tree.HideSelection = false; tree.ContextMenu = menu; tree.DoubleClick += new EventHandler(tree_DoubleClick); tree.AfterLabelEdit += new NodeLabelEditEventHandler(tree_AfterLabelEdit); tree.BeforeLabelEdit += new NodeLabelEditEventHandler(tree_BeforeLabelEdit); tree.AfterSelect += new TreeViewEventHandler(tree_AfterSelect); this.Controls.Add(tree); this.Controls.Add(treeBar); #endregion #region Instructions LinkLabel link = new LinkLabel(); link.Text = "Create a new project\nor\nOpen an existing project"; link.Links.Add(0, 20, "create"); link.Links.Add(24, 24, "open"); link.LinkClicked += new LinkLabelLinkClickedEventHandler(link_LinkClicked); link.TextAlign = ContentAlignment.MiddleCenter; link.Dock = DockStyle.Fill; link.ContextMenu = new ContextMenu(); this.Controls.Add(link); #endregion // we care about some of these events fileActions.FileCreated += new FileNameHandler(NewFileCreated); fileActions.ProjectModified += new ProjectModifiedHandler(ProjectModified); projectActions.ProjectModified += new ProjectModifiedHandler(ProjectModified); }
protected virtual List <GenericActionExecution> ApplyProjectActions(ProjectActions projectActions, ProjectType projectType) { var projectRunActions = new List <GenericActionExecution>(); //Project Level Actions foreach (var projectLevelAction in projectActions.ProjectLevelActions) { var projectActionExecution = new GenericActionExecution(projectLevelAction, _projectConfiguration.ProjectPath) { TimesRun = 1 }; var runResult = string.Empty; if (!_projectConfiguration.IsMockRun) { if (projectLevelAction.ProjectLevelActionFunc != null) { try { runResult = projectLevelAction.ProjectLevelActionFunc(_projectConfiguration.ProjectPath, projectType); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } else if (projectLevelAction.ProjectFileActionFunc != null) { try { runResult = projectLevelAction.ProjectFileActionFunc(_projectConfiguration.ProjectPath, projectType, _projectConfiguration.TargetVersions, projectActions.PackageActions.GroupBy(g => g.Name).Select(g => g.FirstOrDefault()).ToDictionary(p => p.Name, p => p.Version), projectActions.ProjectReferenceActions.ToList(), _metadataReferences); } catch (Exception ex) { var actionExecutionException = new ActionExecutionException(projectLevelAction.Name, projectLevelAction.Key, ex); projectActionExecution.InvalidExecutions = 1; LogHelper.LogError(actionExecutionException); } } } if (!string.IsNullOrEmpty(runResult)) { projectActionExecution.Description = string.Concat(projectActionExecution.Description, ": ", runResult); projectRunActions.Add(projectActionExecution); LogHelper.LogInformation(projectLevelAction.Description); } } return(projectRunActions); }
public Dictionary <string, List <GenericActionExecution> > Run(ProjectActions projectActions, ProjectType projectType) { IEnumerable <FileActions> fileActions = projectActions.FileActions; ConcurrentDictionary <string, List <GenericActionExecution> > actionsPerProject = new ConcurrentDictionary <string, List <GenericActionExecution> >(); var parallelOptions = new ParallelOptions() { MaxDegreeOfParallelism = Constants.ThreadCount }; var fileActionsCount = fileActions.Count(); Parallel.ForEach(_sourceFileBuildResults, parallelOptions, sourceFileBuildResult => { try { var currentFileActions = fileActions.Where(f => f.FilePath == sourceFileBuildResult.SourceFileFullPath).FirstOrDefault(); var root = sourceFileBuildResult.SyntaxTree.GetRoot(); if (currentFileActions != null) { LogHelper.LogInformation("---------------------------------------------------------------------------"); LogHelper.LogInformation("Processing file " + sourceFileBuildResult.SourceFilePath); if (_projectConfiguration.PortCode) { RunCodeChanges(root, sourceFileBuildResult, currentFileActions, actionsPerProject); } else { GenerateCodeChanges(root, sourceFileBuildResult, currentFileActions, fileActionsCount, actionsPerProject); } } } catch (Exception ex) { var filePortingException = new FilePortingException(sourceFileBuildResult.SourceFilePath, ex); LogHelper.LogError(filePortingException); } }); var projectRunActions = new List <GenericActionExecution>(); if (_projectConfiguration.PortProject) { projectRunActions = ApplyProjectActions(projectActions, projectType); if (!actionsPerProject.TryAdd(Constants.Project, projectRunActions)) { LogHelper.LogError(new FilePortingException(Constants.Project, new Exception("Error adding project to actions collection"))); } } return(actionsPerProject.ToDictionary(a => a.Key, a => a.Value)); }
/// <summary> /// Runs the project rewriter using a previously initialized analysis /// </summary> /// <param name="projectActions"></param> public override ProjectResult Run(ProjectActions projectActions) { base.Run(projectActions); // After running all other actions, run WCF-specific changes if (ProjectConfiguration.PortCode) { RunWCFChanges(); } return(_projectResult); }
public void CanCreateProject() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { ProjectActions .CreateProject(new Project { Id = 1, Name = "Test" }) .Function(conn); } }
/// <summary> /// Initializes the project rewriter by getting a list of actions that will be run /// </summary> /// <returns>A list of project actions to be run</returns> public ProjectResult Initialize() { ProjectActions projectActions = new ProjectActions(); try { var allReferences = _sourceFileResults?.SelectMany(s => s.References) .Union(_sourceFileResults.SelectMany(s => s.Children.OfType <UsingDirective>())?.Select(u => new Reference() { Namespace = u.Identifier, Assembly = u.Identifier }).Distinct()) .Union(ProjectConfiguration.AdditionalReferences.Select(r => new Reference { Assembly = r, Namespace = r })); RulesFileLoader rulesFileLoader = new RulesFileLoader(allReferences, ProjectConfiguration.RulesDir, ProjectConfiguration.TargetVersions, string.Empty, ProjectConfiguration.AssemblyDir); var projectRules = rulesFileLoader.Load(); RulesAnalysis walker = new RulesAnalysis(_sourceFileResults, projectRules, ProjectConfiguration.ProjectType); projectActions = walker.Analyze(); _projectReferences.ForEach(p => { projectActions.ProjectReferenceActions.Add(Config.Utils.GetRelativePath(ProjectConfiguration.ProjectPath, p)); }); _projectResult.ActionPackages = projectActions.PackageActions.Distinct().ToList(); _projectResult.MetaReferences = _metaReferences; foreach (var p in ProjectConfiguration.PackageReferences) { projectActions.PackageActions.Add(new PackageAction() { Name = p.Key, OriginalVersion = p.Value.Item1, Version = p.Value.Item2 }); } MergePackages(projectActions.PackageActions); projectActions.ProjectLevelActions = projectRules.ProjectTokens.SelectMany(p => p.ProjectLevelActions).Distinct().ToList(); projectActions.ProjectLevelActions.AddRange(projectRules.ProjectTokens.SelectMany(p => p.ProjectFileActions)); projectActions.ProjectRules = projectRules; _projectResult.ProjectActions = projectActions; _projectResult.FeatureType = ProjectConfiguration.ProjectType; } catch (Exception ex) { LogHelper.LogError(ex, "Error while initializing project {0}", ProjectConfiguration.ProjectPath); } return(_projectResult); }
public void CanAddDeviceToProject() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Name = "Test" }; var device = new Device { IpAddress = "192.168.1.1", Name = "MyTestDevice" }; project = ProjectActions.CreateProject(project).Function(conn); DeviceActions.AddDeviceToProject(project.Id, device).Function(conn); } }
/// <summary> /// Runs the project rewriter using a previously initialized analysis /// </summary> /// <param name="projectActions"></param> public override ProjectResult Run(ProjectActions projectActions) { // NOTE: project actions are not used, but are still used for telemetry _projectResult.ProjectActions = projectActions; if (ProjectConfiguration.PortCode) { var result = RunWebFormsChanges(); if (result != null) { _projectResult.WebFormsMetricResults = result.Metrics; } } return(_projectResult); }
public void CanGetAllProjects() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Id = 1, Name = "Test" }; ProjectActions .CreateProject(project) .Function(conn); ProjectActions .GetAllProjects() .Function(conn); } }
public void CanUndoProjectDeviceVersion() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Name = "Test" }; var device = new Device { IpAddress = "192.168.1.1", Name = "MyTestDevice" }; project = ProjectActions.CreateProject(project).Function(conn); var projectDevice = DeviceActions.AddDeviceToProject(project.Id, device).Function(conn); var projectDeviceVersion = ProjectDeviceActions.SetLatestProjectDeviceVersion(new ProjectDeviceVersion { ProjectDeviceId = projectDevice.Id, HorizontalPercentage = 100, VerticalPercentage = 100, NumberOfHorizontalPixels = 50, NumberOfVerticalPixels = 50, StartAtHorizontalPercentage = 0, StartAtVerticalPercentage = 0 }).Function(conn); var updatedProjectDeviceVersion = ProjectDeviceActions.SetLatestProjectDeviceVersion(new ProjectDeviceVersion { ProjectDeviceId = projectDevice.Id, HorizontalPercentage = 99, VerticalPercentage = 99, NumberOfHorizontalPixels = 30, NumberOfVerticalPixels = 30, StartAtHorizontalPercentage = 1, StartAtVerticalPercentage = 1 }).Function(conn); var undoneProjectDeviceVersion = ProjectDeviceActions.UndoLatestProjectDeviceVersion(projectDevice.Id).Function(conn); var undoEqualsOriginalProjectDeviceVersion = projectDeviceVersion.PropertiesAreEqual(undoneProjectDeviceVersion); Assert.True(undoEqualsOriginalProjectDeviceVersion); } }
public static Dictionary <string, List <RecommendedAction> > Convert(ProjectActions projectActions) { return(projectActions.FileActions.Select(fileAction => { var RecommendedActions = fileAction.NodeTokens.ConvertAll(t => new RecommendedAction { TargetCPU = t.TargetCPU, TextSpan = new TextSpan { EndCharPosition = t.TextSpan.EndCharPosition, EndLinePosition = t.TextSpan.EndLinePosition, StartCharPosition = t.TextSpan.StartCharPosition, StartLinePosition = t.TextSpan.StartLinePosition }, Description = t.Description, RecommendedActionType = RecommendedActionType.ReplaceNamespace }).ToHashSet(); return new Tuple <string, List <RecommendedAction> >(fileAction.FilePath, RecommendedActions.ToList()); }).ToDictionary(t => t.Item1, t => t.Item2)); }
/// <summary> /// Initializes the project rewriter by getting a list of actions that will be run /// </summary> /// <returns>A list of project actions to be run</returns> public ProjectResult Initialize() { ProjectActions projectActions = new ProjectActions(); try { var allReferences = _sourceFileResults?.SelectMany(s => s.References).Distinct(); RulesFileLoader rulesFileLoader = new RulesFileLoader(allReferences, RulesEngineConfiguration.RulesDir, RulesEngineConfiguration.TargetVersions, string.Empty, RulesEngineConfiguration.AssemblyDir); var projectRules = rulesFileLoader.Load(); RulesAnalysis walker = new RulesAnalysis(_sourceFileResults, projectRules); projectActions = walker.Analyze(); _projectReferences.ForEach(p => { projectActions.ProjectReferenceActions.Add(Config.Utils.GetRelativePath(RulesEngineConfiguration.ProjectPath, p)); }); _projectResult.ActionPackages = projectActions.PackageActions.Distinct().ToList(); _projectResult.MetaReferences = _metaReferences; foreach (var p in RulesEngineConfiguration.PackageReferences) { projectActions.PackageActions.Add(new PackageAction() { Name = p.Key, OriginalVersion = p.Value.Item1, Version = p.Value.Item2 }); } MergePackages(projectActions.PackageActions); projectActions.ProjectLevelActions = projectRules.ProjectTokens.SelectMany(p => p.ProjectLevelActions).Distinct().ToList(); projectActions.ProjectLevelActions.AddRange(projectRules.ProjectTokens.SelectMany(p => p.ProjectFileActions)); projectActions.ProjectRules = projectRules; _projectResult.ProjectActions = projectActions; } catch (Exception ex) { LogHelper.LogError(ex, "Error while initializing project {0}", RulesEngineConfiguration.ProjectPath); } return(_projectResult); }
public VideoMetadata StartReadingVideo(int projectId, int projectDeviceId) { var project = dispatcher.Dispatch(ProjectActions.GetProject(projectId)); Guard.This(project).AgainstDefaultValue(string.Format("Could not find project with project id '{0}'", projectId)); var video = dispatcher.Dispatch(VideoActions.GetVideoForProject(projectId)); Guard.This(video).AgainstDefaultValue(string.Format("Could not find video for project '{0}' (id '{1}')", project.Name, project.Id)); var projectDeviceVersion = dispatcher.Dispatch(ProjectDeviceActions.GetLatestProjectDeviceVersion(projectDeviceId)); Guard.This(projectDeviceVersion).AgainstDefaultValue(string.Format("Could not get latest project device version for project '{0}' (id '{1}')", project.Name, project.Id)); reader = videoFileReader(); reader.Open(video.FilePath); framesRead = 0; framesToRead = reader.FrameCount; this.videoReference = video; this.projectDeviceVersion = projectDeviceVersion; return(new VideoMetadata(reader.FrameCount, reader.FrameRate)); }
public void CanDeleteProject() { using (var dbFactory = new TestDbConnectionFactory()) using (var conn = dbFactory.Database()) { var project = new Project { Id = 1, Name = "Test" }; ProjectActions .CreateProject(project) .Function(conn); ProjectActions .DeleteProject(project.Id) .Action(conn); var get = ProjectActions .GetProject(project.Id) .Function(conn); Assert.Null(get); } }
public GlobalJsonResult <Project> Get(int id) { var project = dispatcher.Dispatch(ProjectActions.GetProject(id)); return(GlobalJsonResult <Project> .Success(System.Net.HttpStatusCode.OK, project)); }
public GlobalJsonResult <IEnumerable <Project> > GetAll() { var projects = dispatcher.Dispatch(ProjectActions.GetAllProjects()); return(GlobalJsonResult <IEnumerable <Project> > .Success(System.Net.HttpStatusCode.OK, projects)); }
/// <summary> /// Initializes an RulesAnalysis instance /// </summary> /// <param name="sourceFileResults">List of analyzed code files</param> /// <param name="rootNodes">List of rules to be applied to the code files</param> public RulesAnalysis(List <RootUstNode> sourceFileResults, RootNodes rootNodes) { _projectActions = new ProjectActions(); _sourceFileResults = sourceFileResults; _rootNodes = rootNodes; }
public void ProcessProjectDeviceVersion(BackgroundJob job) { var projectDeviceVersion = dispatcher.Dispatch(ProjectDeviceActions.GetProjectDeviceVersion(job.ProjectDeviceVersionId)); Guard.This(projectDeviceVersion).AgainstDefaultValue(string.Format("Could not find project device version '{0}'", job.ProjectDeviceVersionId)); var device = dispatcher.Dispatch(DeviceActions.GetProjectDevice(projectDeviceVersion.ProjectDeviceId)); Guard.This(device).AgainstDefaultValue(string.Format("Could not find project device with project device Id '{0}'", projectDeviceVersion.ProjectDeviceId)); Guard.This(device).WithRule(d => deviceStatusService.IsOnline(device), string.Format("Device {0} (with IP Address {1}) is not online", device.Name, device.IpAddress)); var project = dispatcher.Dispatch(ProjectActions.GetProjectFromProjectDevice(projectDeviceVersion.ProjectDeviceId)); Guard.This(project).AgainstDefaultValue(string.Format("Could not find project from project device with id '{0}'", projectDeviceVersion.ProjectDeviceId)); var video = dispatcher.Dispatch(VideoActions.GetVideoForProject(project.Id)); Guard.This(video).AgainstDefaultValue(string.Format("Could not find video for project '{0}'", project.Name)); using (var videoProcessor = videoProcessorInstantiator()) { var videoMetadata = videoProcessor.StartReadingVideo(project.Id, projectDeviceVersion.ProjectDeviceId); var client = piClientFactory.ForDevice(device); // Update video metadata (use project device id instead of video id with client (could have the same video in multiple configurations) var existingVideosOnPi = client.GetAllVideoMetadata(); var existingVideoOnPi = existingVideosOnPi.SingleOrDefault(v => v.Id == projectDeviceVersion.ProjectDeviceId); if (existingVideoOnPi == null) { client.CreateVideoMetadata(new VideoMetadataCreateRequest { Id = projectDeviceVersion.ProjectDeviceId, FileName = video.FilePath, FrameRate = videoMetadata.FrameRate }); } else { client.UpdateVideoMetadata(new VideoMetadataPutRequest { Id = projectDeviceVersion.ProjectDeviceId, FileName = video.FilePath, FrameRate = videoMetadata.FrameRate, }); } // Clear, then send frames to Pi client.ClearFrames(projectDeviceVersion.ProjectDeviceId); int framePosition = 1; while (true) { var read = videoProcessor.ReadNext1000Frames(); client.SendFrames(projectDeviceVersion.ProjectDeviceId, new AppendFramesRequest { AppendFrameRequests = read.Frames .Select(f => new AppendFrameRequest { BinaryData = f, Position = framePosition }) .ToArray() }); dispatcher.Dispatch(BackgroundJobActions.MarkPercentageCompletion(job.Id, read.PercentageComplete)); if (!read.MoreFrames) { break; } framePosition++; } } }
public GlobalJsonResult <Project> CopyProject(Project project) { var newProject = dispatcher.Dispatch(ProjectActions.CopyProject(project)); return(GlobalJsonResult <Project> .Success(System.Net.HttpStatusCode.Created, newProject)); }
public GlobalJsonResult <Project> Update([FromBody] Project project) { dispatcher.Dispatch(ProjectActions.UpdateProject(project)); return(GlobalJsonResult <Project> .Success(System.Net.HttpStatusCode.OK, project)); }
public GlobalJsonResult <EmptyResult> Delete(int id) { dispatcher.Dispatch(ProjectActions.DeleteProject(id)); return(GlobalJsonResult <EmptyResult> .Success(System.Net.HttpStatusCode.NoContent)); }
private ProjectAnalysisResult AnalyzeProject( string project, List <AnalyzerResult> analyzers, Dictionary <string, ProjectActions> analysisActions, string targetFramework = "netcoreapp3.1") { try { using var analyzer = analyzers.Find((a) => a.ProjectResult?.ProjectFilePath != null && a.ProjectResult.ProjectFilePath.Equals(project)); var projectActions = new ProjectActions(); analysisActions.TryGetValue(project, out projectActions); if (analyzer == null || analyzer.ProjectResult == null) { _logger.LogError("Unable to build {0}.", project); return(null); } var sourceFileToInvocations = analyzer.ProjectResult.SourceFileResults.Select((sourceFile) => { var invocationsInSourceFile = sourceFile.AllInvocationExpressions(); _logger.LogInformation("API: SourceFile {0} has {1} invocations pre-filter", sourceFile.FileFullPath, invocationsInSourceFile.Count()); return(KeyValuePair.Create(sourceFile.FileFullPath, invocationsInSourceFile)); }).ToDictionary(p => p.Key, p => p.Value); var sourceFileToCodeEntityDetails = InvocationExpressionModelToInvocations.Convert(sourceFileToInvocations, analyzer); var namespaces = sourceFileToCodeEntityDetails.Aggregate(new HashSet <string>(), (agg, cur) => { agg.UnionWith(cur.Value.Select(i => i.Namespace).Where(i => i != null)); return(agg); }); var targetframeworks = analyzer.ProjectResult.TargetFrameworks.Count == 0 ? new List <string> { analyzer.ProjectResult.TargetFramework } : analyzer.ProjectResult.TargetFrameworks; var nugetPackages = analyzer.ProjectResult.ExternalReferences.NugetReferences .Select(r => InvocationExpressionModelToInvocations.ReferenceToPackageVersionPair(r)) .ToHashSet(); var subDependencies = analyzer.ProjectResult.ExternalReferences.NugetDependencies .Select(r => InvocationExpressionModelToInvocations.ReferenceToPackageVersionPair(r)) .ToHashSet(); var sdkPackages = namespaces.Select(n => new PackageVersionPair { PackageId = n, Version = "0.0.0", PackageSourceType = PackageSourceType.SDK }); var allPackages = nugetPackages .Union(subDependencies) .Union(sdkPackages) .ToList(); var packageResults = _handler.GetNugetPackages(allPackages, null); var recommendationResults = _recommendationHandler.GetApiRecommendation(namespaces.ToList()); var packageAnalysisResults = nugetPackages.Select(package => { var result = PackageCompatibility.IsCompatibleAsync(packageResults.GetValueOrDefault(package, null), package, _logger, targetFramework); var packageAnalysisResult = PackageCompatibility.GetPackageAnalysisResult(result, package, targetFramework); return(new Tuple <PackageVersionPair, Task <PackageAnalysisResult> >(package, packageAnalysisResult)); }).ToDictionary(t => t.Item1, t => t.Item2); var portingActionResults = ProjectActionsToRecommendedActions.Convert(projectActions); var SourceFileAnalysisResults = InvocationExpressionModelToInvocations.AnalyzeResults( sourceFileToCodeEntityDetails, packageResults, recommendationResults, portingActionResults, targetFramework); return(new ProjectAnalysisResult { ProjectName = analyzer.ProjectResult.ProjectName, ProjectFilePath = analyzer.ProjectResult.ProjectFilePath, TargetFrameworks = targetframeworks, PackageReferences = nugetPackages.ToList(), ProjectReferences = analyzer.ProjectResult.ExternalReferences.ProjectReferences.ConvertAll(p => new ProjectReference { ReferencePath = p.AssemblyLocation }), PackageAnalysisResults = packageAnalysisResults, IsBuildFailed = analyzer.ProjectResult.IsBuildFailed(), Errors = analyzer.ProjectResult.BuildErrors, ProjectGuid = analyzer.ProjectResult.ProjectGuid, ProjectType = analyzer.ProjectResult.ProjectType, SourceFileAnalysisResults = SourceFileAnalysisResults }); } catch (Exception ex) { _logger.LogError("Error while analyzing {0}, {1}", project, ex); return(new ProjectAnalysisResult { ProjectName = Path.GetFileNameWithoutExtension(project), ProjectFilePath = project, TargetFrameworks = new List <string>(), PackageReferences = new List <PackageVersionPair>(), ProjectReferences = new List <ProjectReference>(), PackageAnalysisResults = new Dictionary <PackageVersionPair, Task <PackageAnalysisResult> >(), IsBuildFailed = true, Errors = new List <string> { string.Format("Error while analyzing {0}, {1}", project, ex) }, ProjectGuid = null, ProjectType = null, SourceFileAnalysisResults = new List <SourceFileAnalysisResult>() }); } }