public IActionResult Duyet([FromBody] ParamDTO obj, string flagDieuChuyen, string flag, string id)
{
var _flagDieuChuyen = new Guid(flagDieuChuyen);
var _id = new Guid(id);
return(Ok(_PhanBoQuaTangService.Duyet(_flagDieuChuyen, flag, _id, obj.Comment, HttpContext.User)));
}
public void MakeParams()
{
if (_params == null)
{
ISProcedure SP_Parameter = SProcedureFactory.GetInstance(ServerKey);
SP_Parameter.SetConnectionString(ConnectionString);
IEnumerable <ParameterMetadata> PMetadata = SP_Parameter.GetParameterMetadata(SpName);
_params = new Dictionary <string, SpParameter>();
foreach (var item in PMetadata)
{
//removeing @ from the ParameterName
string ParaName = item.Name.Substring(1);
var P_DTOParam = DataHelper.ParameterFromDTO(ParamDTO);
if (P_DTOParam.ContainsKey(ParaName))
{
var Param_Meta = P_DTOParam[ParaName];
Param_Meta.IsOutParam = item.IsOut(ServerKey);
_params.Add(ParaName, Param_Meta);
}
else
{
throw new Exception(ParamDTO.GetType().Name + "Not Containg Parameter of " + ParaName + ", of Procedure " + SpName + ".");
}
}
}
}
public int ValidateParam(string user_id, ParamDTO value)
{
Users user;
user = GetUser(user_id);
if (user == null)
{
return(401);
}
else
{
Params param;
param = GetParam(value.Id);
if (param == null)
{
return(404);
}
else
{
if (user.Active == true && user.Role == 1) //Role 1 = Admin
{
return(200);
}
else
{
return(401);
}
}
}
}
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"));
}
List <ChartDataDTO> CalculateData(ParamDTO paramsDto)
{
Calculation calculation = new Calculation(paramsDto);
var data = calculation.CalculationOfPoints();
SaveData(paramsDto, data);
return(data);
}
public ParamDTO ReplaceType(ParamViewModel param)
{
ParamDTO newParam = new ParamDTO();
newParam.A = param.A;
newParam.B = param.B;
newParam.C = param.C;
newParam.Step = param.Step;
newParam.RangeFrom = param.RangeFrom;
newParam.RangeTo = param.RangeTo;
return(newParam);
}
public List <CacheDataDTO> GetData(ParamDTO paramsDto)
{
var id = GetIdIfExist(paramsDto);
if (id != 0)
{
Logic.Logic logic = new GetItemsFromDb(Database, id);
return(logic.GetItems());
}
else
{
Logic.Logic logic = new CalculateItems(Database, paramsDto);
return(logic.GetItems());
}
}
int AddParams(ParamDTO paramDto)
{
Param _param = new Param
{
CoefficientA = paramDto.CoefficientA,
CoefficientB = paramDto.CoefficientB,
CoefficientC = paramDto.CoefficientC,
RangeFrom = paramDto.RangeFrom,
RangeTo = paramDto.RangeTo,
Step = paramDto.Step
};
Database.Params.Create(_param);
Database.Save();
return(_param.ParamId);
}
void SaveData(ParamDTO paramsDto, List <ChartDataDTO> chartDto)
{
var Param = Database.Params.Get(paramsDto.ParamId);
foreach (var c in chartDto)
{
var data = new ChartData()
{
Param = Param,
PointY = c.PointY,
PointX = c.PointX
};
Database.Data.Create(data);
}
Database.Save();
}
Param SaveParams(ParamDTO paramDto)
{
Param _param = new Param
{
CoefficientA = paramDto.CoefficientA,
CoefficientB = paramDto.CoefficientB,
CoefficientC = paramDto.CoefficientC,
SizeFrom = paramDto.SizeFrom,
SizeTo = paramDto.SizeTo,
Step = paramDto.Step
};
Database.Params.Create(_param);
Database.Save();
return(_param);
}
public async Task UpdateParam(string user_id, ParamDTO value)
{
Users user;
user = GetUser(user_id);
Params param;
param = GetParam(value.Id);
param.Value = value.Value;
param.Description = value.Description;
param.StartDate = value.StartDate;
param.EndDate = value.EndDate;
param.LastModified = DateTime.UtcNow;
param.UpdatedBy = user.Id;
_context.Update(param);
await _context.SaveChangesAsync();
}
public async Task AddParamsAndCacheDataAsync(ParamDTO param, List <CacheDataDTO> cacheData)
{
await Task.Run(() =>
{
Param _param = new Param
{
A = param.A,
B = param.B,
C = param.C,
Step = param.Step,
RangeFrom = param.RangeFrom,
RangeTo = param.RangeTo,
CacheDatas = ReplaseCacheData(cacheData)
};
Database.Parameters.Add(_param);
Database.Save();
});
}
int GetIdIfExist(ParamDTO paramDto)
{
var items = Database.Params.GetAll()
.Where(p => p.CoefficientA == paramDto.CoefficientA)
.Where(p => p.CoefficientB == paramDto.CoefficientB)
.Where(p => p.CoefficientC == paramDto.CoefficientC)
.Where(p => p.RangeFrom == paramDto.RangeFrom)
.Where(p => p.RangeTo == paramDto.RangeTo)
.Where(p => p.Step == paramDto.Step);
if (items.Count() == 1)
{
var item = items.First();
return(item.ParamId);
}
return(0);
}
List <CacheDataDTO> CalculateData(ParamDTO paramsDto)
{
Function func = new Function(paramsDto);
var data = func.Calculate();
var Param = Database.Params.Get(paramsDto.ParamId);
foreach (var item in data)
{
var DataItem = new CacheData()
{
Param = Param,
PointY = item.PointY,
PointX = item.PointX
};
Database.Data.Create(DataItem);
}
Database.Save();
return(data);
}
public List <CacheDataDTO> GetCacheDatas(ParamDTO parameters)
{
List <CacheDataDTO> cordinate = new List <CacheDataDTO>();
Create create = new CreateXmin();
var xmin = create.FactoryMethod().CoordinateX(parameters.B, parameters.A, parameters.RangeFrom);
create = new CreateXmax();
var xmax = create.FactoryMethod().CoordinateX(parameters.B, parameters.A, parameters.RangeTo);
for (var x = xmin; x <= xmax; x += parameters.Step)
{
var y = CoordinateY(x, parameters.A, parameters.B, parameters.C);
cordinate.Add(new CacheDataDTO {
PointX = x, PointY = y
});
}
_cacheData = cordinate;
return(cordinate);
}
public async Task <ActionResult> UpdateParam([FromBody] ParamDTO value)
{
string user_id = Request.Headers.FirstOrDefault(header => header.Key == "user_id").Value;
var valid = _repository.ValidateParam(user_id, value);
if (valid == 200)
{
await _repository.UpdateParam(user_id, value);
return(Ok());
}
else if (valid == 401)
{
return(Unauthorized());
}
else
{
return(NotFound());
}
}
public Task <int> FindParamsIdAsync(ParamDTO param)
{
var task = Task.Run(() =>
{
var _param = Database.Parameters.Find(p =>
p.A == param.A &&
p.B == param.B &&
p.C == param.C &&
p.Step == param.Step &&
p.RangeFrom == param.RangeFrom &&
p.RangeTo == param.RangeTo).FirstOrDefault();
if (_param != null)
{
return(_param.ParamId);
}
return(-1);
});
return(task);
}
private void SetControl(ParamDTO param, int position)
{
dynamic control = new Control();
switch (param.Type)
{
case "System.Byte":
control = new ByteControl();
control.NameProperty = param.Name;
break;
case "System.Single":
control = new FloatControl();
control.NameProperty = param.Name;
break;
case "System.Drawing.Color":
control = new ColorControl();
control.NameProperty = param.Name;
break;
}
this.tableLayoutPanel3.Controls.Add(control, 0, position - 1);
}
public async Task <List <ChartDataDTO> > GetDataAsync(ParamDTO paramDto)
{
var t = await Task.Run(() =>
{
var paramsCheck = Database.Params.GetAll()
.Where(p => p.CoefficientA == paramDto.CoefficientA)
.Where(p => p.CoefficientB == paramDto.CoefficientB)
.Where(p => p.CoefficientC == paramDto.CoefficientC)
.Where(p => p.SizeFrom == paramDto.SizeFrom)
.Where(p => p.SizeTo == paramDto.SizeTo)
.Where(p => p.Step == paramDto.Step);
if (paramsCheck.Any())
{
return(FindData(paramsCheck.First().ParamId));
}
else
{
return(AddInDb(paramDto));
}
});
return(t);
}
private void SetControl(ParamDTO param, int position)
{
dynamic control = new Control();
switch (param.Type)
{
case "System.Byte":
control = new ByteControl();
control.NameProperty = param.Name;
break;
case "System.Single":
control = new FloatControl();
control.NameProperty = param.Name;
break;
case "System.Drawing.Color":
control = new ColorControl();
control.NameProperty = param.Name;
break;
}
this.tableLayoutPanel3.Controls.Add(control, 0, position - 1);
}
public PointsParabola(ParamDTO parameters)
{
_parameters = parameters;
_cacheData = null;
}
public Calculation(ParamDTO param)
{
_param = param;
_chartData = new List <ChartDataDTO>();
}
public Logic(IUnitOfWork uow, ParamDTO paramsDto)
{
Database = uow;
this.paramsDto = paramsDto;
}
public CalculateItems(IUnitOfWork uow, ParamDTO paramsDto) : base(uow, paramsDto)
{
}
public Function(ParamDTO param)
{
_param = param;
_points = new List <CacheDataDTO>();
}
public List <ChartDataDTO> AddInDb(ParamDTO paramDto)
{
paramDto.ParamId = SaveParams(paramDto).ParamId;
return(CalculateData(paramDto));
}
