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>()
});
}
}
