public object Validate([FromQuery] string validateArr)
{
var Parameters = JsonConvert.DeserializeObject <List <ParameterForValidate> >(validateArr);
List <object> parametersCorrect = new List <object>();
bool resultVerification;
string message;
foreach (var parameter in Parameters)
{
if (StaticData.CurrentSystems.ParametersWithEnter.TryGetValue(parameter.parameterName, out ParameterWithEnter parameterWithEnter))
{
parameterWithEnter.Value = parameter.value;
resultVerification = parameterWithEnter.Verification(out message);
if (!resultVerification)
{
QueryResponse.AddNegativeMessage(message);
}
parametersCorrect.Add(new
{
parameterName = parameter.parameterName.GetName(),
Correct = resultVerification
});
}
}
QueryResponse.Add("parametersCorrect", parametersCorrect);
return(QueryResponse.ToResult());
}
public object SaveSystemToFile([FromQuery] string fileName)
{
if (string.IsNullOrEmpty(fileName))
{
QueryResponse.AddNegativeMessage("Имя файла не указано");
return(QueryResponse.ToResult());
}
string filePath = Path.ChangeExtension(fileName, ".csv");
MemoryStream memory = new MemoryStream();
using (StreamWriter streamWriter = new StreamWriter(memory, Encoding.UTF8))
{
using (CsvWriter csvWriter = new CsvWriter(streamWriter, CultureInfo.CurrentCulture))
{
csvWriter.Configuration.Delimiter = ";";
csvWriter.WriteRecords(StaticData.CurrentSystems.ParametersWithEnter.Values);
}
}
StaticData.CurrentSystems.Name = Path.GetFileNameWithoutExtension(filePath);
return(File(memory.ToArray(), MimeTypesMap.GetMimeType(filePath), filePath));
}
public object GetParametersForAnalysis()
{
QueryResponse.Add("ParametersForAnalysis", StaticData.CurrentSystems.GetParametersForAnalysis(out List <string> message));
QueryResponse.AddNegativeMessages(message, true);
QueryResponse.Add("U", StaticData.CurrentSystems.GetParameterU(out string result));
QueryResponse.Add("result", result);
return(QueryResponse.ToResult());
}
public object ValidateRestrictionsBeforeSave()
{
if (ParameterUniversal.GetRestrictions().Count < 1)
{
QueryResponse.AddNegativeMessage("Ограничения для сохранения не добавлены");
}
return(QueryResponse.ToResult());
}
public object ValidateSystemBeforeSave()
{
if (!StaticData.CurrentSystems.U.Value.HasValue)
{
QueryResponse.AddNegativeMessage("Невозможно сохранить систему т.к. данные некорректны");
}
return(QueryResponse.ToResult());
}
public object GetParameters()
{
var ParametersWithEnter = HelperEnum.GetValuesWithoutDefault <NameParameterWithEnter>().Where(x => !StaticData.ConditionsForParameterWithEnter.ContainsKey(x)).Select(x => x.ToJson());
var ParametersWithCalculation = HelperEnum.GetValuesWithoutDefault <NameParameterWithCalculation>().Where(x => !StaticData.ConditionsForParameterWithCalculation.ContainsKey(x)).Select(x => x.ToJson());
//var ParametersForAnalysis = HelperEnum.GetValuesWithoutDefault<NameParameterForAnalysis>().Where(x => !StaticData.ConditionsForParameterForAnalysis.ContainsKey(x)).Select(x => x.ToJson());
QueryResponse.Add("Properties", ParametersWithEnter.Union(ParametersWithCalculation));
return(QueryResponse.ToResult());
}
public object AddRestriction(string parameter = null, string condition = null, string value = null)
{
ConditionType conditionValue = ConditionType.NoCorrect;
double Value = 0;
if (string.IsNullOrEmpty(value))
{
QueryResponse.AddNegativeMessage("Значение ограничения не указано");
}
else
{
if (!double.TryParse(value, out Value))
{
QueryResponse.AddNegativeMessage(String.Format("Указанное значение \"{0}\" не является числом", value));
}
else if (!(Value > 0))
{
QueryResponse.AddNegativeMessage("Значение ограничения должно быть > 0");
}
}
if (string.IsNullOrEmpty(condition))
{
QueryResponse.AddNegativeMessage("Условие для ограничения не указано");
}
else
{
HelperEnum.TryGetValue <ConditionType>(condition, out conditionValue);
if (HelperEnum.IsDefault(conditionValue))
{
QueryResponse.AddNegativeMessage(String.Format("Условие типа \"{0}\" не найдено", condition));
}
}
if (string.IsNullOrEmpty(parameter))
{
QueryResponse.AddNegativeMessage("Параметр для ограничения не указан");
}
else
{
var result = ParameterUniversal.AddToRestriction(parameter, conditionValue, Value, QueryResponse.IsSuccess, out bool correct);
if (QueryResponse.IsSuccess)
{
QueryResponse.Add(result);
}
else if (!correct)
{
QueryResponse.AddNegativeMessage(String.Format("Параметр с именем \"{0}\" не найден", parameter));
}
}
return(QueryResponse.ToResult());
}
public object LoadSystemFromFile([FromQuery] IFormFile file)
{
if ((file == null) || (string.IsNullOrEmpty(file.FileName)))
{
QueryResponse.AddNegativeMessage("Файл не выбран");
}
if (QueryResponse.IsSuccess)
{
using (StreamReader streamReader = new StreamReader(file.OpenReadStream()))
{
using (CsvReader csvReader = new CsvReader(streamReader, CultureInfo.InvariantCulture))
{
csvReader.Configuration.Delimiter = ";";
try
{
List <ParameterWithEnter> parametersWithEnter = csvReader.GetRecords <ParameterWithEnter>().ToList();
string nameSystem = Path.GetFileNameWithoutExtension(file.FileName);
if (parametersWithEnter.Count != HelperEnum.GetValuesWithoutDefault <NameParameterWithEnter>().Count)
{
QueryResponse.AddNegativeMessage(String.Format("Файл {0} не корректен, выберите файл, сохраненный системой", file.FileName));
}
else if (StaticData.Systems.Keys.Contains(nameSystem))
{
QueryResponse.AddNegativeMessage(String.Format("Система с именем {0} уже была добавлена", nameSystem));
}
else
{
SystemForAnalys systemForAnalys = new SystemForAnalys(nameSystem);
foreach (var parameterWithEnter in parametersWithEnter)
{
systemForAnalys.ParametersWithEnter[parameterWithEnter.TypeParameter].Value = parameterWithEnter.Value;
}
systemForAnalys.SetAsCorrect();
StaticData.Systems.Add(nameSystem, systemForAnalys);
}
}
catch (Exception ex)
{
QueryResponse.AddNegativeMessage(String.Format("Файл {0} не корректен, выберите файл, сохраненный системой", file.FileName));
}
}
}
}
return(QueryResponse.ToResult());
}
public object AddRestrictionsFromFile([FromQuery] IFormFile file)
{
if ((file == null) || (string.IsNullOrEmpty(file.FileName)))
{
QueryResponse.AddNegativeMessage("Файл не выбран.");
}
if (QueryResponse.IsSuccess)
{
if (!RestrictionsFromFile(file, out List <string> message))
{
QueryResponse.AddNegativeMessages(message);
}
}
return(QueryResponse.ToResult());
}
public object DeleteSystem([FromQuery] string nameSystem)
{
if (string.IsNullOrEmpty(nameSystem))
{
QueryResponse.AddNegativeMessage("Система для удаления не указана");
}
else if (!StaticData.Systems.Keys.Contains(nameSystem))
{
QueryResponse.AddNegativeMessage($"Невозможно удалить систему. Система с именем \"{nameSystem}\" не найдена");
}
else
{
StaticData.Systems.Remove(nameSystem);
}
return(QueryResponse.ToResult());
}
public object GetCalculationForDiagram([FromQuery] string queryString)
{
ParameterForCalculationDiagram parameterForCalculationDiagram = ValidateDiagram(queryString);
if (QueryResponse.IsSuccess)
{
DiagramCalculationResult diagramCalculationResult = new DiagramCalculationResult();
diagramCalculationResult.calculations = new List <DiagramCalculation>();
foreach (var nameSystem in parameterForCalculationDiagram.namesSystems)
{
diagramCalculationResult.calculations.Add(new DiagramCalculation(StaticData.Systems[nameSystem].GetParameterValue(parameterForCalculationDiagram.parameterName), nameSystem));
}
diagramCalculationResult.parameterName = StaticData.CurrentSystems.GetParameterDesignation(parameterForCalculationDiagram.parameterName);
StaticData.DiagramCalculation = diagramCalculationResult;
QueryResponse.Add("ParameterName", diagramCalculationResult.parameterName);
QueryResponse.Add("Calculations", diagramCalculationResult.calculations);
}
return(QueryResponse.ToResult());
}
public object LoadSystemFromFile([FromQuery] IFormFile file)
{
if ((file == null) || (string.IsNullOrEmpty(file.FileName)))
{
QueryResponse.AddNegativeMessage("Файл не выбран");
}
if (QueryResponse.IsSuccess)
{
//bool resultVerification;
//string message;
//List<string> messages = new List<string>();
using (StreamReader streamReader = new StreamReader(file.OpenReadStream()))
{
using (CsvReader csvReader = new CsvReader(streamReader, CultureInfo.InvariantCulture))
{
csvReader.Configuration.Delimiter = ";";
try
{
List <ParameterWithEnter> parametersWithEnter = csvReader.GetRecords <ParameterWithEnter>().ToList();
foreach (var parameterWithEnter in parametersWithEnter)
{
StaticData.CurrentSystems.ParametersWithEnter[parameterWithEnter.TypeParameter].Value = parameterWithEnter.Value;
//resultVerification = StaticData.CurrentSystems.ParametersWithEnter[parameterWithEnter.TypeParameter].Verification(out message);
//if (!resultVerification)
// messages.Add(message);
}
}
catch (Exception ex)
{
QueryResponse.AddNegativeMessage(String.Format("Файл {0} не корректен, выберите файл, сохраненный системой", file.FileName));
}
}
}
//QueryResponse.AddRangeErrorWithIfNotEmpty(messages);
}
StaticData.CurrentSystems.SetAsCorrect();
return(QueryResponse.ToResult());
}
public object DeleteRestriction([FromQuery] string restrictionName = null)
{
if (string.IsNullOrEmpty(restrictionName))
{
QueryResponse.AddNegativeMessage("Ограничение не указано");
}
else
{
bool contains = ParameterUniversal.DeleteFromRestrictions(restrictionName, out bool correct);
if (!correct)
{
QueryResponse.AddNegativeMessage(String.Format("Ограничение с именем \"{0}\" не найдено", restrictionName));
}
if (!contains)
{
QueryResponse.AddNegativeMessage("Ограничение для данного параметра не найдено");
}
}
return(QueryResponse.ToResult());
}
public object GetCalculationForChart([FromQuery] string queryString)
{
ParameterForCalculationChart parameterForCalculationChart = ValidateChart(queryString);
if (QueryResponse.IsSuccess)
{
ChartCalculationResult chartCalculationResult = new ChartCalculationResult();
chartCalculationResult.calculations = new List <ChartCalculation>();
foreach (var nameSystem in parameterForCalculationChart.namesSystems)
{
chartCalculationResult.calculations.Add(StaticData.Systems[nameSystem].GetCalculationsForChart(parameterForCalculationChart));
}
chartCalculationResult.parameterNameX = StaticData.CurrentSystems.GetParameterDesignation(parameterForCalculationChart.parameterName);
chartCalculationResult.parameterNameY = StaticData.CurrentSystems.GetParameterDesignation("U");
StaticData.ChartCalculation = chartCalculationResult;
QueryResponse.Add("ParameterNameX", chartCalculationResult.parameterNameX);
QueryResponse.Add("ParameterNameY", chartCalculationResult.parameterNameY);
QueryResponse.Add("Calculations", chartCalculationResult.calculations.Select(x => x.ToObject()));
}
return(QueryResponse.ToResult());
}
public object ValidateDiagramBeforeSave([FromQuery] string queryString)
{
ParameterForCalculationDiagram parameterForCalculationDiagram = ValidateDiagram(queryString);
return(QueryResponse.ToResult());
}
public object GetRestrictions()
{
QueryResponse.Add("Restrictions", ParameterUniversal.GetRestrictions().Select(x => x.ToResponse()));
return(QueryResponse.ToResult());
}
public object GetConditions()
{
QueryResponse.Add("Conditions", HelperEnum.GetValuesWithoutDefault <ConditionType>().Select(x => x.ToJson()));
return(QueryResponse.ToResult());
}
public object GetParametersWithEnter()
{
QueryResponse.Add("ParametersWithEnter", StaticData.CurrentSystems.GetParametersWithEnter(out List <string> message));
QueryResponse.AddWarningMessages(message, true);
return(QueryResponse.ToResult());
}
public object GetParametersWithCalculate()
{
QueryResponse.Add("ParametersWithCalculate", StaticData.CurrentSystems.GetParametersWithCalculate(out List <string> message));
QueryResponse.AddNegativeMessages(message, true);
return(QueryResponse.ToResult());
}
public object SaveDataDiagram([FromForm] string diagram)
{
StaticData.DataDiagram = diagram;
return(QueryResponse.ToResult());
}
public object DeleteAllRestriction()
{
ParameterUniversal.DeleteAllRestriction();
return(QueryResponse.ToResult());
}
public object SaveDataChart([FromForm] string chart)
{
StaticData.DataChart = chart;
return(QueryResponse.ToResult());
}
public object GetParametersForDiagram()
{
QueryResponse.Add("ParametersForDiagram", StaticData.CurrentSystems.GetParametersForDiagram());
return(QueryResponse.ToResult());
}
public object ValidateChartBeforeSave([FromQuery] string queryString)
{
ParameterForCalculationChart parameterForCalculationChart = ValidateChart(queryString);
return(QueryResponse.ToResult());
}
public object GetSystems()
{
QueryResponse.Add("Systems", StaticData.Systems.Keys.ToList());
return(QueryResponse.ToResult());
}
