/// <inheritdoc />
public async Task <OutputDataModel> ProcessAsync(InputDataModel input, InsightsModel graphModel)
{
return(await Task.Run(
() =>
{
var outputDataModel = new OutputDataModel();
var intersWithIncomStreets = input.Streets.Values
.Select(street => (street.EndIntersection, street.Name))
.GroupBy(tuple => tuple.EndIntersection, tuple => tuple.Name)
.ToList();
outputDataModel.Intersections = intersWithIncomStreets
.Select(
grouping => new IntersectionOptions
{
Id = grouping.Key,
IncomingStreets = grouping
.Select(
s => new StreetOptions
{
GreenLightDuration = RandomDuration,
StreetName = s
})
.ToList()
})
.ToDictionary(options => options.Id, options => options);
return outputDataModel;
}));
}
public ComparationService(string patternPath, string loadedPath)
{
mistakes = new List <Error>();
var textfrompattern = File.ReadAllText(patternPath);
pattern = JsonConvert.DeserializeObject <InputDataModel>(textfrompattern);
}
/// <summary>
/// Расчётная функция
/// </summary>
/// <param name="input"></param>
public void CalculateResult(InputDataModel input)
{
Result = new ResultDataModel();
Result.СrossSectionalArea = Math.PI * Math.Pow(input.DeviceDiameter, 2) / 4;
Result.GasConsumption = input.GasSpeedFreeCrossSection * Result.СrossSectionalArea;
Result.FlowHeatCapacitiesRatio = input.MaterialConsumption * input.MaterialHeatCapacity / (Result.GasConsumption * input.GasAverageHeatСapacity);
Result.LayerTotalRelativeHeight = input.VolumeHeatTransferCoefficient * Result.СrossSectionalArea * input.LayerHeight / (input.GasSpeedFreeCrossSection * Result.СrossSectionalArea * input.GasAverageHeatСapacity * 1000);
Result.CorrespondingAttitude = 1 - Result.FlowHeatCapacitiesRatio * Math.Exp(-(1 - Result.FlowHeatCapacitiesRatio) * Result.LayerTotalRelativeHeight / Result.FlowHeatCapacitiesRatio);
double[] coordinates = new double[] { 0, 0.5, 1, 1.5, 2, 2.5, 3 };
Result.Coordinates = coordinates;
Result.MaterialTemperatures = new double[coordinates.Length];
Result.GasTemperatures = new double[coordinates.Length];
Result.TemperatureDifferences = new double[coordinates.Length];
for (int i = 0; i < coordinates.Length; i++)
{
double Y = input.VolumeHeatTransferCoefficient * coordinates[i] / (input.GasAverageHeatСapacity * input.GasSpeedFreeCrossSection * 1000);
double Exp = 1 - Math.Exp((Result.FlowHeatCapacitiesRatio - 1) * Y / Result.FlowHeatCapacitiesRatio);
double mExp = 1 - Result.FlowHeatCapacitiesRatio * Math.Exp((Result.FlowHeatCapacitiesRatio - 1) * Y / Result.FlowHeatCapacitiesRatio);
double uCoeff = Exp / (1 - Result.FlowHeatCapacitiesRatio * Math.Exp((Result.FlowHeatCapacitiesRatio - 1) * Result.LayerTotalRelativeHeight / Result.FlowHeatCapacitiesRatio));
double oCoeff = mExp / (1 - Result.FlowHeatCapacitiesRatio * Math.Exp((Result.FlowHeatCapacitiesRatio - 1) * Result.LayerTotalRelativeHeight / Result.FlowHeatCapacitiesRatio));
Result.MaterialTemperatures[i] = input.MaterialStartTemperature + (input.GasStartTemperature - input.MaterialStartTemperature) * uCoeff;
Result.GasTemperatures[i] = input.MaterialStartTemperature + (input.GasStartTemperature - input.MaterialStartTemperature) * oCoeff;
Result.TemperatureDifferences[i] = Result.GasTemperatures[i] - Result.MaterialTemperatures[i];
}
}
public void saveToFile(string input, string des)
{
if (des.Equals("input"))
{
var todo = dbContext.InputDataModels.SingleOrDefault();
dbContext.InputDataModels.Remove(todo);
dbContext.SaveChanges();
InputDataModel data = new InputDataModel();
data.Input = input;
dbContext.InputDataModels.Add(data);
dbContext.SaveChanges();
}
else
{
var todo = dbContext.AlphabetizedDataModels.SingleOrDefault();
dbContext.AlphabetizedDataModels.Remove(todo);
dbContext.SaveChanges();
AlphabetizedDataModel data = new AlphabetizedDataModel();
data.Alphabetized = input;
dbContext.AlphabetizedDataModels.Add(data);
dbContext.SaveChanges();
}
}
public ActionResult Demo(InputDataModel InputData)
{
DemoModel result = new DemoModel(InputData);
ViewBag.Vud = result.Vud;
ViewBag.Wud = result.Wud;
ViewBag.Ph = result.Ph;
ViewBag.Ro_h = result.Ro_h;
ViewBag.Lambda = result.Lambda;
ViewBag.W_g = result.W_g;
ViewBag.Ro_g = result.Ro_g;
ViewBag.H0 = result.H0;
ViewBag.D = result.D;
ViewBag.Vm = result.Vm;
ViewBag.d_dn = result.d_dn;
ViewBag.d_g = result.d_g;
ViewBag.V = result.V;
ViewBag.H_k = result.H_k;
ViewBag.H_c = result.H_c;
ViewBag.H_v = result.H_v;
ViewBag.t_c = result.t_c;
ViewBag.t_dn = result.t_dn;
ViewBag.t_k = result.t_k;
ViewBag.delta = result.delta;
ViewBag.D_n = result.D_n;
ViewBag.H = result.H;
ViewBag.d_otv = result.d_otv;
// ! Save input data to Session
Session["InputData"] = InputData;
return(View("RezultDemo"));
}
public ActionResult Demo(InputDataModel InputData, string NameNewVariant)
{
OxyConverterDB db = new OxyConverterDB();
double _Q = double.Parse(InputData.Q.ToString());
double _C = double.Parse(InputData.C.ToString());
double _T = double.Parse(InputData.T.ToString());
double _P = double.Parse(InputData.P.ToString());
string _NameNewVariant = NameNewVariant.ToString();
Variants var_new = new Variants
{
NameVariant = _NameNewVariant,
DateVariant = System.DateTime.Now,
Owner = _users.CurrentUser
};
_variants.InsertOrUpdate(var_new);
_variants.Save();
int _ID_Variant_new = db.Variants.Where(p => p.NameVariant == _NameNewVariant && p.Owner.ID_User == _users.CurrentUser.ID_User).First().ID_Variant;
InputDataVariants inputDataVariants_new = new InputDataVariants
{
ID_Variant = _ID_Variant_new,
Q = _Q,
C = _C,
T = _T,
P = _P,
Owner = _users.CurrentUser
};
_inputDataVariants.InsertOrUpdate(inputDataVariants_new);
_inputDataVariants.Save();
return(RedirectToAction("Demo", "Home"));
}
public void CalcTeploBalanceOnTonOfSmelt(InputDataModel input, ResultDataModel result)
{
var Gas = result.TeploBalance_Gas * 1000 / result.MaterialBalance_Smelt;
var Cocks = result.TeploBalance_Cocks * 1000 / result.MaterialBalance_Smelt;
var Air = result.TeploBalance_Air * 1000 / result.MaterialBalance_Smelt;
var SumPlus = Gas + Cocks + Air;
var MeltGeneration = result.TeploBalance_MeltGeneration * 1000 / result.MaterialBalance_Smelt;
var OutputGas = result.TeploBalance_OutputGas * 1000 / result.MaterialBalance_Smelt;
var Dust = result.TeploBalance_Dust * 1000 / result.MaterialBalance_Smelt;
var ChemistryUnderburning = result.TeploBalance_ChemistryUnderburning * 1000 / result.MaterialBalance_Smelt;
var CoolingWater = result.TeploBalance_CoolingWater * 1000 / result.MaterialBalance_Smelt;
var Endoterm_Reactions = result.TeploBalance_Endoterm_Reactions * 1000 / result.MaterialBalance_Smelt;
var SumWaste = MeltGeneration + OutputGas + Dust + ChemistryUnderburning + CoolingWater + Endoterm_Reactions;
result.TeploBalanceOnTonOfSmelt_Gas = Gas;
result.TeploBalanceOnTonOfSmelt_Cocks = Cocks;
result.TeploBalanceOnTonOfSmelt_Air = Air;
result.TeploBalanceOnTonOfSmelt_SumPlus = SumPlus;
result.TeploBalanceOnTonOfSmelt_MeltGeneration = MeltGeneration;
result.TeploBalanceOnTonOfSmelt_OutputGas = OutputGas;
result.TeploBalanceOnTonOfSmelt_Dust = Dust;
result.TeploBalanceOnTonOfSmelt_ChemistryUnderburning = ChemistryUnderburning;
result.TeploBalanceOnTonOfSmelt_Endoterm_Reactions = Endoterm_Reactions;
result.TeploBalanceOnTonOfSmelt_CoolingWater = CoolingWater;
result.TeploBalanceOnTonOfSmelt_SumWaste = SumWaste;
}
//public async Task<ActionResult<FileContentResult>> GenerateCover([FromForm] GroupingAndCoveringDataController.InputData inputData)
public async Task <IActionResult> GenerateCover([FromForm] InputDataModel inputData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Keys.First()));
}
if (_cancelTokensList.ContainsKey(inputData.CancelTokenGuid))
{
var oldToken = _cancelTokensList.First(x => x.Key.Equals(inputData.CancelTokenGuid));
_cancelTokensList.Remove(oldToken.Key);
}
var runCancelToken = new CancellationTokenSource();
var token = runCancelToken.Token;
_cancelTokensList.Add(inputData.CancelTokenGuid, runCancelToken);
var result = await _coverManagerAsync.Value.CoverTaskRunner(inputData, token);
if (result.HasErrors())
{
return(BadRequest(result.Error));
}
var file = result.Value.ToArray().Last();
Response.Headers.Add("Content-Disposition", "inline; filename=" + file.FileDownloadName);
//var fileTxt2 = result.Value.Skip(1).First().FileDownloadName;
//Response.Headers.Add("Content-Disposition", "inline; filename=" + fileTxt2);
//var excelName = result.Value.Last().FileDownloadName;
//Response.Headers.Add("Content-Disposition", "inline; filename=" + excelName);
return(file);
}
public static async Task <InputDataModel> InitAsync(string filePath)
{
Console.WriteLine($"[{filePath}]: reading..");
string line;
var model = new InputDataModel();
using (StreamReader file = new System.IO.StreamReader(@$ "Resources\Inputs\{filePath}"))
public ActionResult FormationMatrix(InputDataModel input)
{
if (ModelState.IsValid)
{
return(View(input));
}
return(View("Index"));
}
public IndexViewModel()
{
Inputs = new List <InputDataModel>()
{
InputDataModel.GetDefaultData()
};
Results = new List <ResultDataModel>();
}
public IActionResult Index(InputDataModel input)
{
var viewModel = new IndexViewModel(input);
viewModel.CalculateTemps();
return(View(viewModel));
}
public InputDataModel CreateAnswerModel(InputDataModel _model)
{
var containerInput = _converterResolver.ConvertVector(_model);
int answer = _testResolver.TestNetworkFromDataBase(_model.trainedNetworkId, containerInput);
IAnswerService answerService = _answerResolver(_model, database);
_model.answer = answerService.GetAnswer(answer);
return(_model);
}
public EncryptedDataModel EncryptDataModel(InputDataModel UserModel)
{
//Takes in a UserDataModel and Returns an EncryptedDataModel.
EncryptedDataModel EncryptedData = new EncryptedDataModel();
EncryptedData = EncryptionTools.EncryptModel(UserModel);
return(EncryptedData);
}
[Authorize] // Запрещены анонимные обращения к данной странице
public ActionResult Excel() //Заменить на OpenXML
{
ViewBag.Result = "Файл успешно сохранен!";
// ! Get input data from Session
InputDataModel _inputData = (InputDataModel)Session["InputData"];
DemoModel _rezult = new DemoModel(_inputData);
try
{
string dataTimeNow = DateTime.Now.ToString("dd MMMM yyyy HH-mm-ss");
ViewBag.Result = dataTimeNow;
Excel.Application application = new Excel.Application();
Excel.Workbook workBook = application.Workbooks.Add(System.Reflection.Missing.Value);
Excel.Worksheet worksheet = workBook.ActiveSheet;
worksheet.Cells[1, 1] = "Демонстрационный пример";
worksheet.Cells[2, 1] = "Дата расчета: " + ViewBag.Result;
worksheet.Cells[4, 1] = "Исходные данные";
worksheet.Cells[5, 1] = "Количество продуктов горения, м³/ч";
worksheet.Cells[5, 2] = _inputData.Kol_prod_gorenija.ToString();
worksheet.Cells[6, 1] = "Скорость движения дыма в рекуператоре, м/с";
worksheet.Cells[6, 2] = _inputData.W0_rek.ToString();
worksheet.Cells[7, 1] = "Расчетные показатели";
worksheet.Cells[8, 1] = "Общие потери энергии при движении продуктов горения от рабочего пространства до шибера";
worksheet.Cells[8, 2] = _rezult.H_sum_pot.ToString();
String excelFileName = Server.MapPath("~/Content") + "\\Demo.xlsx";
if (System.IO.File.Exists(excelFileName))
{
System.IO.File.Delete(excelFileName);
}
// ! Save path & filename
workBook.SaveAs(excelFileName);
workBook.Close(false, Type.Missing, Type.Missing);
Marshal.ReleaseComObject(workBook);
application.Quit();
Marshal.FinalReleaseComObject(application);
// ! Redirect to download file
Response.RedirectPermanent("/Content/Demo.xlsx");
}
catch (Exception e)
{
ViewBag.Result = "Невозможно сохранить файл (" + e.Message + ").";
}
return(View());
}
public InputDataModel GetAnswerModel(InputDataModel model)
{
var containerInput = converter.ConvertVector(model);
int answer = testService.TestNetworkFromDataBase(model.trainedNetworkId, containerInput);
IAnswerService answerService = answerBuilder(model, Database);
model.answer = answerService.GetAnswer(answer);
return(model);
}
public void CalcDevice(InputDataModel input, ResultDataModel result)
{
double _A = input.Air_Spend / (input.Cocks * L0);
double _V_Alpha = L0 * _A + DeltaV;
double _V_Waste = input.Cocks * _V_Alpha;
result.Device_A = _A;
result.Device_V_Alpha = _V_Alpha;
result.Device_V_Waste = _V_Waste;
}
//РАСЧЕТ ГАЗА И ПРИБОРА
public void CalcGas(InputDataModel input, ResultDataModel result)
{
double _A = 1f / (1f - 3.76f * (input.O2_Percentage - 0.5f * input.CO_Percentage) / input.N2_Percentage);
double _V_Alpha = L0 * _A + DeltaV;
double _V_Waste = input.Cocks * ((12d / 22.4d) * input.CO_Percentage + (12d / 22.4d) * input.CO2_Percentage);
result.Gas_A = _A;
result.Gas_V_Alpha = _V_Alpha;
result.Gas_V_Waste = _V_Waste;
}
public ResultDataModel CalculateResult(InputDataModel input)
{
var result = new ResultDataModel();
result.Gas.A = 1f / (1f - 3.76f * (input.O2_Percentage - 0.5f * input.CO_Percentage) / input.N2_Percentage);
//result.Gas.V_Alpha = result.Gas.A*
return(result);
}
//ТЕПЛОВОЙ БАЛАНС
public void CalcTeploBalance(InputDataModel input, ResultDataModel result)
{
var Gas = 33500d * input.Gas / 3600d;
var Cocks = input.Cocks * Cocks_Combustion_Temperature / 3600d;
var Air = input.Air_Spend * (0.00000009d * input.Air_Temperature * input.Air_Temperature + 0.00004d * input.Air_Temperature + 1.296d) * input.Air_Temperature / 3600d;
var SumPlus = Gas + Cocks + Air;
var MeltGeneration = result.MaterialBalance_Smelt * input.Smelt_Temperature *
(AverageSiO2 * (0.00007d * input.Smelt_Temperature + 1.1296d) +
AverageAl2O3 * (0.0002d * input.Smelt_Temperature + 1.0934d) +
AverageCaO * (0.00009d * input.Smelt_Temperature + 0.8804d) +
AverageMgO * (0.0001d * input.Smelt_Temperature + 1.2024d) +
AverageFeO * (0.0001d * input.Smelt_Temperature + 0.7232d)) / 3600d;
var OutputGas = result.Device_V_Waste * input.Smoke_Temperature * (input.CO_Percentage *
(0.0000001d * input.Smoke_Temperature * input.Smoke_Temperature + 0.00005d * input.Smoke_Temperature + 1.2979) / 100d + input.CO2_Percentage *
(0.0000005d * input.Smoke_Temperature * input.Smoke_Temperature + 0.001d * input.Smoke_Temperature + 1.6016d) / 100d + 0.0125d *
(0.00000003d * input.Smoke_Temperature * input.Smoke_Temperature + 0.0002d * input.Smoke_Temperature + 1.301d) + input.N2_Percentage *
(0.0000007d * input.Smoke_Temperature * input.Smoke_Temperature + 0.00001d * input.Smoke_Temperature + 1.2981d) / 100d) / 3600d;
var Dust = input.Limestone * input.Smoke_Temperature *
(0.4915d * (0.00007d * input.Smoke_Temperature + 1.1296d) +
0.1323d * (0.0002d * input.Smoke_Temperature + 1.0934d) +
0.2243d * (0.00009d * input.Smoke_Temperature + 0.8804d) +
0.1077d * (0.0001d * input.Smoke_Temperature + 1.2024d) +
0.0345d * (0.0001d * input.Smoke_Temperature + 0.7232d)) / 3600d;
var ChemistryUnderburning = result.Device_V_Waste * input.CO_Percentage * 127.7d / 3600d;
var CoolingWater = input.AverageWaterSteamTemperature * (input.InputWaterWaste * 4.2023d - input.OutputWaterWaste * 4.1934d) * 1000d / 3600d;
var Endoterm_Reactions = SumPlus - MeltGeneration - OutputGas - Dust - ChemistryUnderburning - CoolingWater;
var SumWaste = Endoterm_Reactions + CoolingWater + ChemistryUnderburning + Dust + OutputGas + MeltGeneration;
result.TeploBalance_Gas = Gas;
result.TeploBalance_Cocks = Cocks;
result.TeploBalance_Air = Air;
result.TeploBalance_SumPlus = SumPlus;
result.TeploBalance_MeltGeneration = MeltGeneration;
result.TeploBalance_OutputGas = OutputGas;
result.TeploBalance_Dust = Dust;
result.TeploBalance_ChemistryUnderburning = ChemistryUnderburning;
result.TeploBalance_Endoterm_Reactions = Endoterm_Reactions;
result.TeploBalance_CoolingWater = CoolingWater;
result.TeploBalance_SumWaste = SumWaste;
}
public ActionResult CreateInput(InputDataModel model)
{
if (ModelState.IsValid)
{
return(View("DataInput", controller.CreateAnswerModel(model)));
}
else
{
// there is something wrong with the data values
return(View("DataInput", model));
}
}
public ActionResult CreateInput(InputDataModel model)
{
if (ModelState.IsValid)
{
return(View("DataInput", manageNetworkService.GetAnswerModel(model)));
}
else
{
// there is something wrong with the data values
return(View("DataInput", model));
}
}
public HttpResponseMessage DoCryptography(InputDataModel model)
{
ErrorMsg status = ErrorMsg.Ok;
string resultContent = null;
string fileExtention = null;
Guid guid = Guid.NewGuid();
if (model == null)
{
status = ErrorMsg.ModelNotLoaded;
}
else //some checks in case js in frontend was abused
{
VigenereEncryptor.Operation op = model.ToEncrypt ? VigenereEncryptor.Operation.Encrypt : VigenereEncryptor.Operation.Decrypt;
if (model.FromFile)
{
if (model.InputFile == null)
{
status = ErrorMsg.FileLoadingError;
}
else
{
string fileName = System.IO.Path.GetFileName(model.InputFile.FileName);
string loadedFilePath = WebApiApplication._LoadedFilesDir + guid + '.' + fileName.Split('.').Last();
System.IO.File.WriteAllBytes(loadedFilePath, model.InputFile.Buffer);
status = TryEncryptFile(loadedFilePath, model.KeyWord, guid.ToString(), op, out resultContent, out fileExtention);
System.IO.File.Delete(loadedFilePath); //we don't need uploaded file anymore
}
}
else //from text area input
{
status = TryEncryptRawText(model.InputText, model.KeyWord, guid.ToString(), op, out resultContent);
fileExtention = "txt";
}
}
if (status != ErrorMsg.Ok)
{
return(Request.CreateResponse(HttpStatusCode.OK,
new EncryptionResultModel()
{
IsError = true, Content = status.GetDescription()
}));
}
var response = Request.CreateResponse(HttpStatusCode.OK, new EncryptionResultModel()
{
IsError = false, Content = resultContent
});
response.Headers.AddCookies(new CookieHeaderValue[] { new CookieHeaderValue(_cookieName, guid.ToString() + '.' + fileExtention) });
return(response);
}
/// <summary>
/// Uploads the inputed json and converts its data into a list of guids.
/// </summary>
/// <param name="jsonData">Stream of the uploaded file.</param>
public IList <Guid> UploadDataModel(Stream jsonData)
{
IList <Guid> uploadData = new List <Guid>();
using (StreamReader r = new StreamReader(jsonData))
{
string json = r.ReadToEnd();
InputDataModel inputDataModel = JsonConvert.DeserializeObject <InputDataModel>(json);
uploadData = inputDataModel.data;
}
return(uploadData);
}
public void CalcMaterialBalanceOnTonOfSmelt(InputDataModel input, ResultDataModel result)
{
result.MaterialBalanceOnTonOfSmelt_Cocks = input.Cocks * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Gabbro = input.Gabbro * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Limestone = input.Limestone * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_M_Limestone = input.M_Limestone * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Gas = input.Gas * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Air = result.MaterialBalance_Air * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_SumPlus = result.MaterialBalance_SumPlus * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Smelt = result.MaterialBalance_Smelt * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_OutputGas = result.MaterialBalance_OutputGas * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_Dust = result.MaterialBalance_Dust * 1000 / result.MaterialBalance_Smelt;
result.MaterialBalanceOnTonOfSmelt_WasteSum = result.MaterialBalance_WasteSum * 1000 / result.MaterialBalance_Smelt;
}
[Authorize] // Запрещены анонимные обращения к данной странице
public ActionResult RezultDemo(InputDataModel input_data)
{
SolverDemoModel sm = new SolverDemoModel();
double[] val = new double[10];
val = sm.SolverSteelMeltingMixture(input_data);
// ! Save input data to Session
Session["input_data"] = input_data;
List <double> lst = val.OfType <double>().ToList();
ViewBag.Rashet = lst;
return(View(input_data));
}
private static double[,] ListToDoubleArray(InputDataModel input, List <double> elemMatrix)
{
double[,] matrix = new double[input.numberRows, input.numberColumns];
int r = 0, c = 0;
for (int i = 0; i < elemMatrix.Count(); i++)
{
if (c == input.numberColumns)
{
r++;
c = 0;
}
matrix[r, c] = elemMatrix[i];
c++;
}
return(matrix);
}
public List <string> GetContainingLines(String input)
{
var results = new List <string>();
string [] lines;
InputDataModel res = dbContext.InputDataModels.SingleOrDefault();
lines = res.Input.Split('\n');
foreach (string line in lines)
{
if (line.ToUpper().Contains(input.ToUpper()))
{
results.Add(line);
}
}
return(results);
}
public EncryptedDataModel EncryptModel(InputDataModel userData)
{
//Takes in a UserDataModel and returns an EncryptedDataModel.
EncryptedDataModel encryptedDataModel = new EncryptedDataModel();
encryptedDataModel.Age = EncryptLong(userData.Age);
encryptedDataModel.BMI = EncryptLong(userData.BMI);
encryptedDataModel.Breaks = EncryptLong(userData.Breaks);
encryptedDataModel.Height = EncryptLong(userData.Height);
encryptedDataModel.HoursWeek = EncryptLong(userData.Hours);
encryptedDataModel.Salary = EncryptLong(userData.Salary);
encryptedDataModel.Sleep = EncryptLong(userData.Sleep);
encryptedDataModel.Water = EncryptLong(userData.WaterPerDay);
encryptedDataModel.Weight = EncryptLong(userData.Weight);
encryptedDataModel.HeightOverOne = EncryptLong((long)userData.HeightOverOne);
return(encryptedDataModel);
}
public async Task <Result <FileData> > GetFileData(InputDataModel inputData)
{
var list = new List <string>();
using (var stream = inputData.File.OpenReadStream())
{
using (var reader = new StreamReader(stream))
{
while (reader.Peek() >= 0)
{
list.Add(await reader.ReadLineAsync());
}
}
}
var fileData = _fileReaderProvider.Value.ConvertFile(inputData.File.FileName, list.ToArray());
return(fileData);
}
