public async Task <IActionResult> PostUserMetrics(User user, MetricsModel model, UserManager <User> _userManager)
{
user.Age = model.MetricAge;
user.Height = model.MetricHeight;
WeightHistory history = new WeightHistory(user.Id, model.MetricWeight, DateTime.Now.Date);
WeightHistoryManager manager = new WeightHistoryManager(_context, _userManager);
await manager.AddChange(history);
user.Goal = model.MetricGoal;
user.MaxPushUps = model.MetricPushUps;
user.MaxPullUps = model.MetricPullUps;
user.IsMetrics = true;
for (int i = 0; i < model.MetricHealth.Count; i++)
{
HealthProblem problem = new HealthProblem(user.Id, model.MetricHealth[i].Problem);
await _context.HealthProblems.AddAsync(problem);
await _context.SaveChangesAsync();
}
await _userManager.UpdateAsync(user);
return(new OkResult());
}
public static void ReportOnMetricsUpdate(string sceneId, MetricsModel current,
MetricsModel limit)
{
onMetricsUpdate.given = current;
onMetricsUpdate.limit = limit;
SendSceneEvent(sceneId, "metricsUpdate", onMetricsUpdate);
}
public async Task WatchMetrics()
{
MetriŃsProvider MetriksProvider = new MetriŃsProvider();
while (true)
{
MetricsModel metricsModel = new MetricsModel(MetriksProvider.GetMetrics(), metricServiceConfiguration.MachineName, DateTime.Now);
await sentMessages.SendMetrics(metricsModel);
Thread.Sleep(metricServiceConfiguration.MetricInterval);
}
}
public override async Task Do()
{
var metrics = new MetricsModel
{
MachineName = this.machineName,
TimeStamp = this.timeStamp,
PhysicalDisk = data["disk"],
Processor = data["cpu"],
Memory = data["ram"]
};
dbContext.Add(metrics);
await dbContext.SaveChangesAsync();
}
public async Task <IActionResult> PostMetrics(MetricsModel model)
{
if (!ModelState.IsValid)
{
return(UnprocessableEntity());
}
var user = await _jwtService.CheckUser(Request.Cookies["JWT"]);
if (user == null)
{
return(Unauthorized());
}
await _userMetricsManager.PostUserMetrics(user, model, _userManager);
return(Ok());
}
private void SetRiskMetrics()
{
lock (m_Lock)
{
ClearRiskMetrics();
MetricsModel metrics = m_Metrics;
if (metrics != null)
{
CriticalityRisk = metrics.Criticality;
FibonacciRisk = metrics.Fibonacci;
ActivityRisk = metrics.Activity;
ActivityRiskWithStdDevCorrection = metrics.ActivityStdDevCorrection;
GeometricCriticalityRisk = metrics.GeometricCriticality;
GeometricFibonacciRisk = metrics.GeometricFibonacci;
GeometricActivityRisk = metrics.GeometricActivity;
}
}
}
private void CalculateRiskMetrics()
{
lock (m_Lock)
{
ClearRiskMetrics();
IEnumerable <IDependentActivity <int, int> > dependentActivities = GraphCompilation?.DependentActivities;
if (dependentActivities != null &&
dependentActivities.Any())
{
if (HasCompilationErrors)
{
return;
}
m_Metrics = m_ProjectService.CalculateProjectMetrics(
m_Mapper.Map <IEnumerable <IActivity <int, int> >, IList <ActivityModel> >(dependentActivities.Where(x => !x.IsDummy).Select(x => (IActivity <int, int>)x)),
ArrowGraphSettings?.ActivitySeverities);
SetRiskMetrics();
}
}
}
public List <MetricsModel> ProvideVolumeMetrics()
{
var jsonStatisticsRaw = File.ReadAllText(PathToVolumeMetrics);
var jsonFormatter = new JsonFormatter();
var allFilesStatistics = jsonFormatter.ConvertJsonToPlainObjectRepresentation(jsonStatisticsRaw);
var allFilesData = new List <MetricsModel>();
foreach (var(fullFileName, details) in allFilesStatistics)
{
var fileCodeStatistics = new MetricsModel
{
Code = int.Parse(details["code"].ToString()),
Comment = int.Parse(details["comment"].ToString()),
FileFullName = fullFileName,
};
allFilesData.Add(fileCodeStatistics);
}
return(allFilesData);
}
public void Post([FromBody] MetricsModel metrics)
{
}
public MetricsViewModel(ISourcesCacheProvider cacheProvider)
{
_model = new MetricsModel
{
Caption = "Metrics",
Cache = cacheProvider.CurrentCache
};
Disposables.Add(_model);
_model.WhenAnyValue(x => x.Caption, x => x.Online)
.Subscribe(v => Title = v.Item1 + (v.Item2 ? " >" : " ||"));
var dynamicFilter = _model.SelectedSourcesChanged
.Select(_ => Filters.CreateFilterMetricBySources(_model));
var observable = _model.Cache.Metrics
.Connect()
.Filter(dynamicFilter)
.Publish();
_metricsCache = observable
.AsObservableCache()
.DisposeWith(Disposables);
observable
.Transform(x => new MetricValueItem {
Metric = x
})
.Sort(SortExpressionComparer <MetricValueItem>
.Ascending(x => x.Metric.Instance.Source.Name)
.ThenByAscending(x => x.Metric.Instance.Name)
.ThenByAscending(x => x.Metric.Name))
.ObserveOnDispatcher()
.Bind(out var metricValuesStatic)
.Subscribe()
.DisposeWith(Disposables);
observable
.Connect()
.DisposeWith(Disposables);
var metricValuesDynamicSource = new SourceList <MetricValueItem>()
.DisposeWith(Disposables);
metricValuesDynamicSource
.Connect()
.ObserveOnDispatcher()
.Bind(out var metricValuesDynamic)
.Subscribe()
.DisposeWith(Disposables);
_model.WhenAnyValue(x => x.MetricDiagramVisible)
.Subscribe(x => MetricValuesList = x ? metricValuesStatic : metricValuesDynamic);
_model.SelectedSourcesChanged.Subscribe(_ => UpdateSelectedMetrics());
UpdateSelectedMetrics();
var canStart = _model.WhenAny(x => x.Online, x => !x.Value);
StartCommand = ReactiveCommand.Create(OnStart, canStart);
var canStop = _model.WhenAny(x => x.Online, x => x.Value);
StopCommand = ReactiveCommand.Create(OnStop, canStop);
UpdateCommand = ReactiveCommand.Create(OnUpdate, canStop);
var mapper = Mappers.Xy <MetricValueItem>()
.X(item => (double)item.Interval.Ticks / TimeSpan.FromMinutes(5).Ticks)
.Y(item => item.Value);
//lets save the mapper globally.
Charting.For <MetricValueItem>(mapper);
SeriesCollection = new ChartValues <MetricValueItem>();
//lets set how to display the X Labels
DateTimeFormatter = value => new DateTime((long)value * TimeSpan.FromMinutes(5).Ticks).ToString("t");
UpdateCommand.Subscribe(results =>
{
if (_model.MetricDiagramVisible)
{
SeriesCollection.Clear();
if (results != null)
{
SeriesCollection.AddRange(results);
}
}
else
{
metricValuesDynamicSource.Edit(innerList =>
{
innerList.Clear();
innerList.AddRange(results);
});
}
});
}
