static IssueStats[] GetScriptIssuesSummary(ProjectReport projectReport)
{
var statsDict = new Dictionary <int, IssueStats>();
var scriptIssues = projectReport.GetIssues(IssueCategory.Code);
var numScriptIssues = scriptIssues.Length;
for (var i = 0; i < numScriptIssues; ++i)
{
var descriptor = scriptIssues[i].descriptor;
var id = descriptor.id;
IssueStats stats;
if (!statsDict.TryGetValue(id, out stats))
{
stats = new IssueStats {
id = id
};
}
++stats.numOccurrences;
if (scriptIssues[i].isPerfCriticalContext)
{
++stats.numHotPathOccurrences;
}
statsDict[id] = stats;
}
return(statsDict.Values.OrderByDescending(x => x.numOccurrences).Take(k_MaxIssuesInAnalyzeSummary).ToArray());
}
public async Task <ActionResult> GetAsync([FromQuery] ProjectReport projectReport)
{
ResponseModel <ProjectReport> returnResponse = new ResponseModel <ProjectReport>();
if (!ModelState.IsValid)
{
returnResponse.ReturnStatus = false;
returnResponse.Errors.Add(1, ModelState);
return(BadRequest(returnResponse));
}
var spParms = new DynamicParameters();
spParms.Add("p_startdate", projectReport.startDate, DbType.Date);
spParms.Add("p_finishdate", projectReport.finishDate, DbType.Date);
try
{
var data = await _repo.GetAsync("[dbo].[Report]", spParms, commandType : CommandType.StoredProcedure);
return(await _export.Export(data));
}
catch (Exception ex)
{
returnResponse.ReturnStatus = false;
returnResponse.ReturnMessage.Add(ex.Message);
return(BadRequest(returnResponse));
}
}
//Constructor for ProjectReportViewModel
public ProjectReportViewModel(ProjectReport projectReport, EmployeeNameViewModel projectManager,
List <EmployeeNameViewModel> engineers, List <WorkPackageReportSnapshot> lowWpStatus, List <WorkPackageReportSnapshot> highWpStatus)
{
ProjectReportId = projectReport.ProjectReportId;
ProjectId = projectReport.ProjectId;
ProjectCode = projectReport.ProjectCode;
ProjectName = projectReport.ProjectName;
ReportDate = DateTime.Now;
StartDate = projectReport.StartDate;
EndDate = projectReport.EndDate;
ProjectManager = projectManager;
Engineers = engineers;
LowWpStatus = new List <LowWorkPackage>();
HighWpStatus = new List <HighWorkPackage>();
foreach (WorkPackageReportSnapshot wp in lowWpStatus)
{
LowWpStatus.Add(new LowWorkPackage(wp));
}
foreach (WorkPackageReportSnapshot wp in highWpStatus)
{
HighWpStatus.Add(new HighWorkPackage(wp));
}
//Inner class totals
totals = new Totals(LowWpStatus);
}
public AnalysisNodeVisitor(ProjectReport report, IDictionary <INode, LocalProjectService.NodeLocation> nodeMap, IEnumerable <File> poseFiles, IList <Scene> scenes)
{
_report = report;
_nodeMap = nodeMap;
_poseFiles = poseFiles;
_scenes = scenes;
}
public void FilteredReportIsExported()
{
// disabling stripEngineCode will be reported as a ProjectSettings issue
PlayerSettings.stripEngineCode = false;
var projectAuditor = new Unity.ProjectAuditor.Editor.ProjectAuditor();
var projectReport = projectAuditor.Audit();
const string path = "ProjectAuditor_Report.csv";
// let's assume we are only interested in exporting project settings
projectReport.ExportToCSV(path, issue => issue.category == IssueCategory.ProjectSettings);
Assert.True(File.Exists(path));
using (var file = new StreamReader(path))
{
var line = file.ReadLine();
Assert.True(line.Equals(ProjectReport.HeaderForCSV()));
while (file.Peek() >= 0)
{
line = file.ReadLine();
Assert.True(line.StartsWith(IssueCategory.ProjectSettings.ToString()));
}
}
}
public async Task GetProjectReport_Should_Invoke_CalculateMaxReportLevelStatus()
{
PackageVersion packageVersion = new PackageVersion
{
Id = 1
};
ProjectReport result = await projectService.GetProjectReportAsync(1);
packageVersionsRepositoryMock.Verify(packageVersionsRepository =>
packageVersionsRepository.GetLatestVersionsAsync(It.IsAny <Expression <Func <PackageVersion, bool> > >()));
projectsRepositoryMock.Verify(projectsRepository =>
projectsRepository.GetByIdWithIncludedPackageAsync(packageVersion.Id));
versionAnalyzerServiceMock.Verify(versionAnalyzerService =>
versionAnalyzerService.Compare(nUnitLatestPackageVersion, nUnitPackageVersion));
versionAnalyzerServiceMock.Verify(versionAnalyzerService =>
versionAnalyzerService.Compare(moqLatestPackageVersion, moqPackageVersion));
versionAnalyzerServiceMock.Verify(versionAnalyzerService =>
versionAnalyzerService.CalculateMaxReportLevelStatus(reports));
Assert.IsInstanceOf <ProjectReport>(result);
Assert.NotNull(result);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,ReportName,ReportConclusions,ProjectId,ReportStatusId")] ProjectReport projectReport)
{
if (id != projectReport.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(projectReport);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProjectReportExists(projectReport.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectId"] = new SelectList(_context.Project, "Id", "ProjectDescription", projectReport.ProjectId);
ViewData["ReportStatusId"] = new SelectList(_context.Set <ReportStatus>(), "Id", "ReportStatusName", projectReport.ReportStatusId);
return(View(projectReport));
}
public ActionResult insertData(ProjectReport pr, int?id)
{
int EmpId = Convert.ToInt32(Session["EmpId"]);
try
{
if (!pr.Description.Equals(null))
{
pr.EmpId = EmpId;
pr.ReportDate = DateTime.Now;
pr.ProjectId = id;
db.ProjectReports.Add(pr);
db.SaveChanges();
ViewBag.Message = "Report Submitted";
}
else
{
ViewBag.Message = "Description is required!!";
}
}
catch
{
}
return(View());
}
public async Task ReportControllerAsync()
{
var mockRepo = new Mock <IRepository <MemoryReportTable> >();
var mockExcel = new Mock <IExportToExcel>();
// mockRepo.Setup(repo => repo.GetAsync(null, null, CommandType.StoredProcedure))
// .Throws<InvalidOperationException>();
mockRepo.Setup(repo => repo.GetAsync(null, null, CommandType.StoredProcedure))
.Returns(Task.Factory.StartNew(() => GetTestMemoryReportTable()));
mockExcel.Setup(ex => ex.Export(GetTestMemoryReportTable()))
.Returns(Task.FromResult(It.IsAny <FileContentResult>()));
mockExcel.Setup(ex => ex.CalculateMode(GetTestMemoryReportTable()))
.Returns(It.IsAny <FileContentResult>());
mockExcel.Setup(ex => ex.Export(GetTestMemoryReportTable()))
.Returns(Task.FromResult(FileContentResult()));
var controller = new ReportController(mockRepo.Object, mockExcel.Object);
ProjectReport query = new ProjectReport {
startDate = "1 - 12 - 2000", finishDate = "12 - 12 - 2012"
};
var result = await controller.GetAsync(query);
Assert.IsNotNull(result);
Assert.IsInstanceOf <Task <ActionResult> >(result);
Assert.IsAssignableFrom <Task <ActionResult> >(result);
Assert.IsInstanceOf <Task <FileContentResult> >(Task.FromResult(FileContentResult()), "Expected a FileResult");
}
public IActionResult Word(string userId)
{
string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "template.docx");
string templatePath = AppDomain.CurrentDomain.BaseDirectory + "temp.docx";
System.IO.File.Copy(path, templatePath, true);
List <ProjectReport> projectReports = new List <ProjectReport>();
var user = _context.ApplicationUsers.FirstOrDefault(e => e.Id == userId);
var listEmployees = _context.ListEmployees
.Include(e => e.Project)
.Where(e => e.ApplicationUserId == userId)
.ToList();
List <Project> project = new List <Project>();
foreach (var listempl in listEmployees)
{
var tempProject = listempl.Project;
project.Add(tempProject);
}
user.Position = _context.Positions.FirstOrDefault(e => e.Id == user.PositionId);
user.QualificationLevel = _context.QualificationLevels.FirstOrDefault(e => e.Id == user.QualificationLevelId);
foreach (var tempProject in project)
{
var module = _context.Modules.Where(e => e.ProjectId == tempProject.Id).ToList();
List <ModuleReport> moduleReports = new List <ModuleReport>();
foreach (var tempModule in tempProject.Module)
{
var task = _context.Tasks.Where(e => e.ModuleId == tempModule.Id && e.ApplicationUserId == userId).ToList();
ModuleReport moduleReport = new ModuleReport();
moduleReport.Module = tempModule;
moduleReport.Tasks = task;
moduleReports.Add(moduleReport);
}
ProjectReport projectReport = new ProjectReport();
projectReport.Modules = moduleReports;
projectReport.Project = tempProject;
projectReports.Add(projectReport);
}
DateTime dateTime = DateTime.Now;
var valuesToFill = GetContent(projectReports, user, dateTime, dateTime);
using (var outputDocument = new TemplateProcessor(templatePath)
.SetRemoveContentControls(true))
{
outputDocument.FillContent(valuesToFill);
outputDocument.SaveChanges();
}
var bytes = System.IO.File.ReadAllBytes(templatePath);
string file_name = "department.docx";
System.IO.File.Delete(templatePath);
return(File(bytes, DOCX_FILE_MIME_TYPE, file_name));
}
public ModuleInterpreter(Scene scene, ConcurrentDictionary <Scene, Module> modules, Module parent, ProjectReport report)
{
_scene = scene;
_parent = parent;
_modules = modules;
_projectService = SimpleIoc.Default.GetInstance <IProjectService>();
Report = report;
}
public void UninitializedTestPasses()
{
var uninitialised = new ProjectReport();
Assert.Zero(uninitialised.NumTotalIssues);
Assert.Zero(uninitialised.GetNumIssues(IssueCategory.ApiCalls));
Assert.Zero(uninitialised.GetNumIssues(IssueCategory.ProjectSettings));
}
public void NewReportIsValid()
{
var projectReport = new ProjectReport();
Assert.Zero(projectReport.NumTotalIssues);
Assert.Zero(projectReport.GetNumIssues(IssueCategory.Code));
Assert.Zero(projectReport.GetNumIssues(IssueCategory.ProjectSettings));
}
public static void GetSummaryReport(Projekt obj, MethodReturnEventArgs <System.Object> e, string title, Zetbox.App.Base.DateTimeRange range)
{
using (var rpt = _rptFactory())
{
ProjectReport.Call(rpt);
rpt.Open("ProjectReport.pdf");
}
}
/// <summary>
/// Retrieve project report for given jobcode id's over a date range.
/// </summary>
private ProjectReport GetProjectReport(List <long> jobcodeId, DateTimeOffset startDate, DateTimeOffset endDate)
{
var filter = new ProjectReportFilter {
StartDate = startDate, EndDate = endDate, JobcodeIds = jobcodeId
};
ProjectReport projectReport = this.apiClient.GetProjectReport(filter).Item1;
return(projectReport);
}
void AnalyzeShaderVariants()
{
if (m_ProjectReport == null)
{
m_ProjectReport = new ProjectReport();
}
var newIssues = Audit <ShadersAuditor>();
UpdateShaderVariantsView(newIssues.ToArray(), false);
}
public async Task <IActionResult> Report(int id)
{
ProjectReport model = await projectService.GetProjectReportAsync(id);
if (model == null)
{
return(BadRequest());
}
return(View(model));
}
public void CanSaveAndLoadReport()
{
var projectAuditor = new Unity.ProjectAuditor.Editor.ProjectAuditor();
var projectReport = projectAuditor.Audit();
projectReport.Save(k_ReportPath);
var loadedReport = ProjectReport.Load(k_ReportPath);
Assert.AreEqual(projectReport.NumTotalIssues, loadedReport.NumTotalIssues);
}
public async Task <IActionResult> Create([Bind("Id,ReportName,ReportConclusions,ProjectId,ReportStatusId")] ProjectReport projectReport)
{
if (ModelState.IsValid)
{
_context.Add(projectReport);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ProjectId"] = new SelectList(_context.Project, "Id", "ProjectDescription", projectReport.ProjectId);
ViewData["ReportStatusId"] = new SelectList(_context.Set <ReportStatus>(), "Id", "ReportStatusName", projectReport.ReportStatusId);
return(View(projectReport));
}
public void ReportIsExportedAndFormatted()
{
// disabling stripEngineCode will be reported as a ProjectSettings issue
PlayerSettings.stripEngineCode = false;
var config = ScriptableObject.CreateInstance <ProjectAuditorConfig>();
config.AnalyzeEditorCode = false;
var projectAuditor = new Unity.ProjectAuditor.Editor.ProjectAuditor(config);
var projectReport = projectAuditor.Audit();
const string path = "ProjectAuditor_Report.csv";
projectReport.ExportToCSV(path);
Assert.True(File.Exists(path));
var settingsIssue = projectReport.GetIssues(IssueCategory.ProjectSettings)
.First(i => i.descriptor.method.Equals("stripEngineCode"));
var scriptIssue = projectReport.GetIssues(IssueCategory.Code)
.First(i => i.relativePath.Equals(m_TempAsset.relativePath));
var settingsIssueFound = false;
var scriptIssueFound = false;
using (var file = new StreamReader(path))
{
var line = file.ReadLine();
Assert.True(line.Equals(ProjectReport.HeaderForCSV()));
var expectedSettingsIssueLine = ProjectReport.FormatIssueForCSV(settingsIssue);
var expectedScriptIssueLine = ProjectReport.FormatIssueForCSV(scriptIssue);
while (file.Peek() >= 0)
{
line = file.ReadLine();
if (line.Equals(expectedSettingsIssueLine))
{
settingsIssueFound = true;
}
if (line.Equals(expectedScriptIssueLine))
{
scriptIssueFound = true;
}
}
}
Assert.True(settingsIssueFound);
Assert.True(scriptIssueFound);
}
public void IssueIsAddedToReport()
{
var projectReport = new ProjectReport();
projectReport.AddIssue(new ProjectIssue
(
new ProblemDescriptor(),
"dummy issue",
IssueCategory.ApiCalls
)
);
Assert.AreEqual(1, projectReport.NumTotalIssues);
Assert.AreEqual(1, projectReport.GetNumIssues(IssueCategory.ApiCalls));
Assert.AreEqual(0, projectReport.GetNumIssues(IssueCategory.ProjectSettings));
}
void Analyze()
{
m_AnalyzeButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ShouldRefresh = true;
m_AnalysisState = AnalysisState.InProgress;
m_ProjectReport = new ProjectReport();
foreach (var view in m_Views)
{
if (view != null)
{
view.Clear();
}
}
AnalysisView.SetReport(m_ProjectReport);
var newIssues = new List <ProjectIssue>();
m_ProjectAuditor.Audit(projectIssue =>
{
newIssues.Add(projectIssue);
m_ProjectReport.AddIssue(projectIssue);
},
completed =>
{
// add batch of issues
foreach (var view in m_Views)
{
if (view != null)
{
view.AddIssues(newIssues);
}
}
newIssues.Clear();
if (completed)
{
m_AnalysisState = AnalysisState.Completed;
}
m_ShouldRefresh = true;
},
new ProgressBarDisplay()
);
}
public async Task <ProjectReport> GetProjectReportAsync(int projectId)
{
Project project = await ProjectRepository.GetByIdWithIncludedPackageAsync(projectId);
if (project == null)
{
return(null);
}
IEnumerable <PackageVersion> currentPackageVersions = project
.ProjectPackageVersions
.Select(projectPackageVersion => projectPackageVersion.PackageVersion);
IReadOnlyCollection <PackageVersion> latestPackageVersions = await PackageVersionsRepository
.GetLatestVersionsAsync(x => currentPackageVersions
.Select(p => p.PackageId)
.Contains(x.PackageId));
List <PackageReport> packageReports = new List <PackageReport>();
foreach (PackageVersion packageVersion in currentPackageVersions)
{
PackageVersion latestVersion = latestPackageVersions.FirstOrDefault(p => p.PackageId == packageVersion.PackageId);
PackageReport packageVersionReport = new PackageReport
{
Id = packageVersion.PackageId,
LastUpdateTime = packageVersion.Package.LastUpdateTime,
Name = packageVersion.Package.Name,
CurrentPackageVersion = PackageVersionConverter.PackageVersionToPackageVersionDto(packageVersion),
LatestPackageVersion = PackageVersionConverter.PackageVersionToPackageVersionDto(latestVersion),
Report = versionsAnalyzerService.Compare(latestVersion, packageVersion)
};
packageReports.Add(packageVersionReport);
}
ProjectReport projectReport = new ProjectReport
{
Name = project.Name,
Id = project.Id,
Packages = packageReports,
Report = versionsAnalyzerService
.CalculateMaxReportLevelStatus(packageReports.Select(p => p.Report).ToList())
};
return(projectReport);
}
void Analyze()
{
m_AnalyzeButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ShouldRefresh = true;
m_AnalysisState = AnalysisState.InProgress;
m_ProjectReport = new ProjectReport();
foreach (var view in m_AnalysisViews)
{
view.Clear();
}
var newIssues = new List <ProjectIssue>();
try
{
m_ProjectAuditor.Audit(projectIssue =>
{
newIssues.Add(projectIssue);
m_ProjectReport.AddIssue(projectIssue);
},
completed =>
{
// add batch of issues
foreach (var view in m_AnalysisViews)
{
view.AddIssues(newIssues);
}
newIssues.Clear();
if (completed)
{
m_AnalysisState = AnalysisState.Completed;
}
m_ShouldRefresh = true;
},
new ProgressBarDisplay());
}
catch (AssemblyCompilationException e)
{
m_AnalysisState = AnalysisState.NotStarted;
Debug.LogError(e);
}
}
public void CanExportReport()
{
var projectReport = new ProjectReport();
projectReport.AddIssue(new ProjectIssue
(
new ProblemDescriptor
{
area = "CPU",
type = "SomeType",
method = "SomeMethod",
problem = "",
solution = ""
},
"dummy issue",
IssueCategory.ApiCalls
));
projectReport.AddIssue(new ProjectIssue
(
new ProblemDescriptor
{
area = "CPU",
type = "SomeType",
method = "SomeMethod",
problem = "",
solution = ""
},
"dummy issue #2",
IssueCategory.ProjectSettings
));
const string path = "ProjectAuditor_Report.csv";
projectReport.Export(path);
Assert.True(File.Exists(path));
string line;
System.IO.StreamReader file = new System.IO.StreamReader(path);
line = file.ReadLine();
Assert.True(line.Equals("Issue,Area,Path,Line"));
file.Close();
}
void Load()
{
var path = EditorUtility.OpenFilePanel("Load from json file", m_SaveLoadDirectory, "json");
if (path.Length != 0)
{
m_LoadButtonAnalytic = ProjectAuditorAnalytics.BeginAnalytic();
m_ProjectReport = ProjectReport.Load(path);
m_AnalysisState = AnalysisState.Valid;
m_SaveLoadDirectory = Path.GetDirectoryName(path);
}
OnEnable();
UpdateAssemblyNames();
UpdateAssemblySelection();
// switch to summary view after loading
SelectView(IssueCategory.MetaData);
}
private async Task <IActionResult> GetProjectReport(Project project, string fromDate = "", string toDate = "")
{
if (project == null)
{
return(NotFound("Project not found."));
}
DateTime startDate;
bool fromDateCheck = ValidateStartDate(fromDate, out startDate);
DateTime endDate;
bool toDateCheck = ValidateEndDate(toDate, out endDate);
if (fromDateCheck == false || toDateCheck == false)
{
return(BadRequest("Invalid date format. Acceptable formats are yyyy-MM-dd and dd-MM-yyyy."));
}
if (startDate > endDate)
{
return(BadRequest("Invalid date range."));
}
ProjectReport resultReport = await reportService.GetProjectReport(project, startDate, endDate);
return(Ok(resultReport));
}
public void IssueIsAddedToReport()
{
var projectReport = new ProjectReport();
var p = new ProblemDescriptor
(
102001,
"test",
Area.CPU,
"this is not actually a problem",
"do nothing"
);
projectReport.AddIssue(new ProjectIssue
(
p,
"dummy issue",
IssueCategory.Code
)
);
Assert.AreEqual(1, projectReport.NumTotalIssues);
Assert.AreEqual(1, projectReport.GetNumIssues(IssueCategory.Code));
Assert.AreEqual(0, projectReport.GetNumIssues(IssueCategory.ProjectSettings));
}
public async Task <IActionResult> GetProjectReport(int id)
{
ProjectReport pr = await _projectReportRepository.Get(id);
IEnumerable <WorkPackageReportSnapshot> allWPRS = await _workPackageReportSnapshotRepository.GetAll();
IEnumerable <WorkPackageReportSnapshot> lowWPRS = allWPRS.Where(x => x.ProjectReportId == id && !x.IsHighWorkPackage); //lowWorkPackage
IEnumerable <WorkPackageReportSnapshot> highWPRS = allWPRS.Where(x => x.ProjectReportId == id && x.IsHighWorkPackage); //highWP
IEnumerable <EmployeeProjectAssignment> allEmpProjectAssignments = await _employeeProjectAssignmentRepository.GetAll();
IEnumerable <EmployeeProjectAssignment> projectAssignments = allEmpProjectAssignments.Where(x => x.ProjectId == pr.ProjectId);
IEnumerable <Employee> employees = await _employeeRepository.GetAll();
List <EmployeeNameViewModel> engineers = new List <EmployeeNameViewModel>();
EmployeeNameViewModel pm = null;
foreach (EmployeeProjectAssignment e in projectAssignments)
{
if (e.IsProjectManager)
{
pm = new EmployeeNameViewModel(employees.Where(x => x.EmployeeId == e.EmployeeId).FirstOrDefault());
}
else
{
engineers.Add(new EmployeeNameViewModel(employees.Where(x => x.EmployeeId == e.EmployeeId).FirstOrDefault()));
}
}
ProjectReportViewModel projectReportView = new ProjectReportViewModel(pr, pm, engineers, lowWPRS.ToList(), highWPRS.ToList());
return(Ok(projectReportView));
}
public void InterpretScene(Scene scene, ProjectReport report)
{
_interpreters[0].Interpreter.Report = report;
while (_interpreters.Count(i => i.Running) != 0)
{
var newStates = new List <InterpreterState>();
foreach (var interpreter in _interpreters)
{
if (!interpreter.Running)
{
continue;
}
if (scene.Nodes.Count == interpreter.Position)
{
interpreter.Running = false;
continue;
}
var node = scene.Nodes[interpreter.Position++];
node.Accept(interpreter.Interpreter);
if (node is NodeJump nj)
{
if (nj.Target == null)
{
continue;
}
var targetIndexJ = scene.Nodes.IndexOf(nj.Target);
if (targetIndexJ == -1)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump outside of current scope, aborting analysis of this branch.", nj);
interpreter.Running = false;
}
else if (targetIndexJ < interpreter.Position)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump backwards (potential loop), aborting analysis of this branch.", nj);
interpreter.Running = false;
}
interpreter.Position = targetIndexJ;
}
else if (node is NodeVariableJump nvj)
{
if (nvj.Target == null)
{
continue;
}
bool interpreterState = interpreter.Interpreter.SetVariables.Contains(nvj.Variable);
bool requiredState = nvj.Value;
if (interpreterState != requiredState)
{
continue;
}
var targetIndexVJ = scene.Nodes.IndexOf(nvj.Target);
if (targetIndexVJ == -1)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump outside of current scope, aborting analysis of this branch.", nvj);
interpreter.Running = false;
}
else if (targetIndexVJ < interpreter.Position)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump backwards (potential loop), aborting analysis of this branch.", nvj);
interpreter.Running = false;
}
interpreter.Position = targetIndexVJ;
}
else if (node is NodeCall nc)
{
var targetIndexC = scene.Nodes.IndexOf(nc.Target);
if (targetIndexC != -1)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Local call detected, aborting analysis of this branch.", nc);
}
else
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Intermodular call detected, aborting analysis of this branch.", nc);
}
}
else if (node is NodeRet)
{
interpreter.Running = false;
}
else if (node is NodeResponseDialogue nrd)
{
var targetIndex = scene.Nodes.IndexOf(nrd.ResponseMap[0].Target);
if (targetIndex == -1)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump outside of current scope, aborting analysis of this branch.", nrd);
interpreter.Running = false;
}
interpreter.Position = targetIndex;
foreach (var response in nrd.ResponseMap.Skip(1))
{
var newState = new InterpreterState
{
Interpreter = (BranchingInterpreterVisitor)interpreter.Interpreter.Clone(),
Position = scene.Nodes.IndexOf(response.Target),
Running = true
};
if (newState.Position == -1)
{
report.AddMessage(ProjectReportMessage.MessageSeverity.Info, "Detected jump outside of current scope, aborting analysis of this branch.", nrd);
}
else
{
newStates.Add(newState);
}
}
}
}
_interpreters.AddRange(newStates);
}
}
public Report(DateTime from, DateTime until)
{
Project = new ProjectReport()
{
Summary = new ProjectSummary()
{
Total = 1,
TotalCorrected = 2,
From = from,
Until = until
},
Costs = new ProjectCosts()
{
TotalEURO = 1000,
TotalEUROCorrected = 2000,
From = from,
Until = until
},
Months = {
new MonthEntry() { Month = "01", Year = "2012", Total = 1, TotalCorrected = 10 },
new MonthEntry() { Month = "02", Year = "2012", Total = 2, TotalCorrected = 10 },
new MonthEntry() { Month = "03", Year = "2012", Total = 3, TotalCorrected = 10 },
new MonthEntry() { Month = "04", Year = "2012", Total = 4, TotalCorrected = 10 },
new MonthEntry() { Month = "05", Year = "2012", Total = 5, TotalCorrected = 10 },
new MonthEntry() { Month = "06", Year = "2012", Total = 6, TotalCorrected = 10 },
new MonthEntry() { Month = "07", Year = "2012", Total = 7, TotalCorrected = 10 },
new MonthEntry() { Month = "08", Year = "2012", Total = 8, TotalCorrected = 10 },
new MonthEntry() { Month = "09", Year = "2012", Total = 9, TotalCorrected = 10 },
new MonthEntry() { Month = "00", Year = "2012", Total = 10, TotalCorrected = 10 },
new MonthEntry() { Month = "11", Year = "2012", Total = 11, TotalCorrected = 10 },
new MonthEntry() { Month = "12", Year = "2012", Total = 12, TotalCorrected = 10 },
}
};
Task = new TaskReport()
{
Total = 11,
TotalCorrected = 12,
From = from,
Until = until,
Months = {
new MonthEntry() { Month = "01", Year = "2012", Total = 11, TotalCorrected = 110 },
new MonthEntry() { Month = "02", Year = "2012", Total = 12, TotalCorrected = 110 },
new MonthEntry() { Month = "03", Year = "2012", Total = 13, TotalCorrected = 110 },
new MonthEntry() { Month = "04", Year = "2012", Total = 14, TotalCorrected = 110 },
new MonthEntry() { Month = "05", Year = "2012", Total = 15, TotalCorrected = 110 },
new MonthEntry() { Month = "06", Year = "2012", Total = 16, TotalCorrected = 110 },
new MonthEntry() { Month = "07", Year = "2012", Total = 17, TotalCorrected = 110 },
new MonthEntry() { Month = "08", Year = "2012", Total = 18, TotalCorrected = 110 },
new MonthEntry() { Month = "09", Year = "2012", Total = 19, TotalCorrected = 110 },
new MonthEntry() { Month = "00", Year = "2012", Total = 110, TotalCorrected = 110 },
new MonthEntry() { Month = "11", Year = "2012", Total = 111, TotalCorrected = 110 },
new MonthEntry() { Month = "12", Year = "2012", Total = 112, TotalCorrected = 110 },
}
};
}
