public async Task <ActionResult> Index(ParamViewModel coefficient)
{
if (ModelState.IsValid)
{
ParamDTO _coefficient = coefficient.ReplaceType(coefficient);
PointsParabola pointPar = new PointsParabola(coefficient.ReplaceType(coefficient));
int paramId = await service.FindParamsIdAsync(_coefficient);
List <CacheDataDTO> cacheData = new List <CacheDataDTO>();
List <PointsViewModel> points = new List <PointsViewModel>();
if (paramId == -1)
{
cacheData = pointPar.GetCacheDatas(_coefficient);
await service.AddParamsAndCacheDataAsync(_coefficient, cacheData);
}
else
{
cacheData = await service.GetCacheDataAsync(paramId);
}
foreach (var c in cacheData)
{
points.Add(new PointsViewModel(c.PointX, c.PointY));
}
ViewBag.Result = points;
ViewBag.IsRotated = coefficient.A < 0;
return(View("Index"));
}
return(View("Index"));
}
public void Changing_the_value_of_param_will_trigger_callback()
{
var p = new ParamViewModel(GetParam());
bool triggered = false;
p.PropertyChanged += (s, arg) => { triggered = true; };
p.Value = "val";
Assert.That(triggered);
}
private void SliderChanged(object sender, ValueChangedEventArgs e)
{
ParamViewModel from = (ParamViewModel)sender;
for (int q = 0; q < 5; q++)
{
if (entries[q].Label == from.Name)
{
int val = Convert.ToInt32(e);
entries[q] = new Entry(val)
{
Label = entries[q].Label,
ValueLabel = entries[q].ValueLabel.ToString(),
Color = entries[q].Color
};
}
}
}
public async Task <ActionResult> UpdateValue([FromBody] ParamViewModel newParam)
{
Param param = _dbContext.Params?.FirstOrDefault();
if (param != null)
{
//TODO: se puede mejorar usando automapper
param.Color = newParam.Color;
param.Diameter = newParam.Diameter;
_dbContext.Update(param);
_dbContext.SaveChanges();
}
await _hubContext.Clients.All.SendCoreAsync("circleUpdated", new object[] { newParam });
return(Ok());
}
public ActionResult GetData(ParamViewModel model)
{
if (ModelState.IsValid)
{
ICollection <CacheDataView> data = null;
if (ParabolicFunctionService.CheckIfStored(model, out data))
{
return(Json(new { data, IsError = false }));
}
data = ParabolicFunctionService.CalculateChartParallel(model);
return(Json(new { data, IsError = false }));
}
else
{
var errors = ModelState.Values.Select(v => v.Errors.Select(e => e.ErrorMessage));
return(Json(new { errors, IsError = true }));
}
}
public ICollection <CacheDataView> CalculateChartParallel(ParamViewModel paramModel)
{
if (paramModel == null)
{
throw new ArgumentNullException("param");
}
//TODO: add automapper
Param param = new Param
{
CoefficientA = paramModel.CoefficientA,
CoefficientB = paramModel.CoefficientB,
CoefficientC = paramModel.CoefficientC,
Step = paramModel.Step,
RangeFrom = paramModel.RangeFrom,
RangeTo = paramModel.RangeTo
};
int elementsCount = (int)((param.RangeTo - param.RangeFrom) / param.Step) + 1;
var elements = new CacheData[elementsCount];
Parallel.For(0, elementsCount, i => {
var x = param.RangeFrom + param.Step * i;
var y = CalculatePointY(param.CoefficientA, param.CoefficientB, param.CoefficientC, x);
elements[i] = new CacheData {
PointX = x, PointY = y
};
});
using (var paramRepository = Factory.GetParamRepository())
{
param.Points = elements;
paramRepository.AddOrUpdate(param);
paramRepository.SaveChanges();
}
return(elements.Select(cd => new CacheDataView {
x = cd.PointX, y = cd.PointY
})?.ToList());
}
public ICollection <CacheDataView> CalculateChart(ParamViewModel paramModel)
{
if (paramModel == null)
{
throw new ArgumentNullException("param");
}
//TODO: add automapper
Param param = new Param
{
CoefficientA = paramModel.CoefficientA,
CoefficientB = paramModel.CoefficientB,
CoefficientC = paramModel.CoefficientC,
Step = paramModel.Step,
RangeFrom = paramModel.RangeFrom,
RangeTo = paramModel.RangeTo
};
using (var paramRepository = Factory.GetParamRepository())
{
param.Points = new List <CacheData>();
for (double i = param.RangeFrom; i <= param.RangeTo; i += param.Step)
{
param.Points.Add(new CacheData
{
PointX = i,
PointY = CalculatePointY(param.CoefficientA, param.CoefficientB, param.CoefficientC, i)
});
}
paramRepository.AddOrUpdate(param);
paramRepository.SaveChanges();
}
return(param.Points?.Select(cd => new CacheDataView {
x = cd.PointX, y = cd.PointY
})?.ToList());
}
public bool CheckIfStored(ParamViewModel paramModel, out ICollection <CacheDataView> data)
{
if (paramModel == null)
{
throw new ArgumentNullException("param");
}
using (var paramRepository = Factory.GetParamRepository())
{
var storedParam = paramRepository.GetAll(p =>
p.CoefficientA == paramModel.CoefficientA &&
p.CoefficientB == paramModel.CoefficientB &&
p.CoefficientC == paramModel.CoefficientC &&
p.Step == paramModel.Step &&
p.RangeFrom == paramModel.RangeFrom &&
p.RangeTo == paramModel.RangeTo
)
.FirstOrDefault();
if (storedParam == null)
{
data = null;
return(false);
}
else
{
using (var cacheDataRepository = Factory.GetCacheDataRepository())
{
data = cacheDataRepository.GetAll(cd => cd.ParamId == storedParam.Id)?.Select(cd => new CacheDataView {
x = cd.PointX, y = cd.PointY
})?.ToList();
}
return(true);
}
}
}
public void Changing_the_value_of_param_without_callback()
{
var p = new ParamViewModel(GetParam());
p.Value = "val";
}
