public async Task <IActionResult> OnPost()
{
if (ModelState.IsValid)
{
var newLog = _mapper.Map <FC_MVVC.Data.Models.WeightLog>(Input);
ApplicationUser user = await GetUser();
if (user.MeasureType == MeasureType.lbs)
{
newLog = WeightConverter.ConvertToKg(newLog);
}
newLog.User = user;
await _weigtLogService.Add(newLog);
return(RedirectToPage("/Table/Index"));
}
return(Page());
}
public Objectifs_ViewModel(IDataStore dataStore, INavigation navigation)
{
DataStore = dataStore;
Navigation = navigation;
Profil = DataStore.GetSettingsAsync().First();
GlycemiaConverter = new GlycemiaConverter();
WeightConverter = new WeightConverter();
Objectifs = DataStore.GetObjectifAsync().First();
var new_max = GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Max_Glycemia, Profil.GlycemiaUnit);
var new_min = GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Min_Glycemia, Profil.GlycemiaUnit);
var new_weght = WeightConverter.DoubleWeightConvet(Objectifs.Weight_Objectif, Profil.WeightUnit);
Max_Glycemia = new_max.ToString();
Min_Glycemia = new_min.ToString();
Objectifs.Weight_Objectif = new_weght;
SaveCommand = new Command(async() =>
{
await ExecuteOnSaveObjectifs();
});
}
public void ConvertGramsToOunces_WhenCalled_ReturnsWeightInOunces(double grams, double expectedResult)
{
Assert.AreEqual(expectedResult, WeightConverter.ConvertGramsToOunces(grams), 0.00000001);
}
public void ConvertPoundsToKilograms_WhenCalled_ReturnsWeightInKilograms(double pounds, double expectedResult)
{
Assert.AreEqual(expectedResult, WeightConverter.ConvertPoundsToKilograms(pounds), 0.00000001);
}
public void ConvertKilogramsToPounds_WhenCalled_ReturnsWeightInPounds(double kilograms, double expectedResult)
{
Assert.AreEqual(expectedResult, WeightConverter.ConvertKilogramsToPounds(kilograms), 0.00000001);
}
///// <summary>
///// Configuration class for the server
///// </summary>
//public static class Config
//{
// public static int Port = 500;
// public static string Endpoint = "127.0.0.1";
//}
public void Start()
{
try
{
IPAddress ipAddress = IPAddress.Parse(serverEndpoint);
Console.WriteLine("Starting TCP listener...");
Listener = new TcpListener(ipAddress, serverPort);
Listener.Start();
while (true)
{
Console.WriteLine("Server is listening on " + Listener.LocalEndpoint);
Console.WriteLine("Waiting for a connection...");
Console.WriteLine("###########################################");
// incoming client connected
TcpClient client = Listener.AcceptTcpClient();
var sw = new Stopwatch();
sw.MeasureTimeElapsed(() =>
{
// 1. Log that we received a request
Console.WriteLine("Connection accepted.");
Console.WriteLine("Reading data...");
#region --- 2. Read Payload: ---
// Read the actual payload (posted by the connecting client)
// get the incoming data through a network stream
NetworkStream stream = client.GetStream();
byte[] buffer = new byte[client.ReceiveBufferSize];
// read incoming stream
int bytesRead = stream.Read(buffer, 0, client.ReceiveBufferSize);
Console.WriteLine("Recieved data: ");
Console.WriteLine("----------------------------------");
// convert the command data received into a string
string dataReceived = Encoding.ASCII.GetString(buffer, 0, bytesRead).TrimEnd(Environment.NewLine.ToCharArray());
Console.WriteLine("Received Command : " + dataReceived);
#endregion
#region --- 3. Parse & Evaluate payload: ---
// IMPORTANT: We expect payload to be in the format: "TOGRAM,100"
var data = dataReceived.Split(',', StringSplitOptions.RemoveEmptyEntries);
var errors = new List <string>();
double?clientValue = null;
string clientConversionType = null;
ConversionType?conversionType = null;
#region --- Parse ConversionType: ---
try
{
// try casting the clients input to the data types we expect it to be:
clientConversionType = data[0].ToUpperInvariant();
conversionType = Enum.Parse <ConversionType>(clientConversionType);
}
catch (Exception e)
{
errors.Add($"Invalid ConversionType ({clientConversionType}). Supported types are: {ConversionType.TOGRAM}, {ConversionType.TOOUNCE}!");
}
#endregion
#region --- Parse Value: ---
try
{
clientValue = double.Parse(data[1], NumberStyles.Number);
}
catch (Exception e)
{
errors.Add($"Invalid Value ({clientValue}). Value must be a valid number!");
}
#endregion
#endregion
if (errors.Any())
{
errors.ForEach(error => WriteToStream(error, stream));
WriteToStream("FOO", stream);
}
else
{
if (conversionType.HasValue && clientValue.HasValue)
{
//4.process the request
var result = WeightConverter.Convert(conversionType.Value, clientValue.Value);
var msg = $"{result.Value} {result.Unit}";
//5. return result to client
WriteToStream(msg, stream);
}
}
client.Close();
});
}
}
catch (Exception e)
{
Console.WriteLine("Error: " + e.StackTrace);
Console.ReadLine();
}
}
// Expected to pass
public void GramsToOz()
{
Assert.AreEqual(3.527396195, WeightConverter.GramsToOz(100), 0.0001);
}
private void UpdateData()
{
List <LogBook_Model> _data = new List <LogBook_Model>();
Profil = DataStore.GetSettingsAsync().First();
foreach (var item in DataStore.GetGlucosAsync())
{
var glucose = new LogBook_Model
{
Data = item,
DataValue = GlycemiaConverter.Convert(item, Profil.GlycemiaUnit).Glycemia.ToString(),
Date = item.Date,
Activity = item.Activity,
Take_Medication = item.Taking_Medication,
Type = "Glucose",
Unit = Profil.GlycemiaUnit,
PicturePath = item.PicturePathe
};
_data.Add(glucose);
}
foreach (var item in DataStore.GetHb1acAsync())
{
var drug = new LogBook_Model
{
Data = item,
DataValue = item.Hb1Ac.ToString(),
Date = item.Date,
Type = "Hb1Ac",
Unit = "%",
PicturePath = item.PicturePathe
};
_data.Add(drug);
}
foreach (var item in DataStore.GetPressionAsync())
{
var drug = new LogBook_Model
{
Data = item,
DataValue = item.Diastolique.ToString() + "/" + item.Systolique.ToString(),
Date = item.Date,
At_Home = (item.Where == "home") ? true : false,
At_Doctor = (item.Where == "clinic") ? true : false,
Type = "Pression",
Unit = "mmgH",
PicturePath = item.PicturePathe
};
_data.Add(drug);
}
foreach (var item in DataStore.GetWeightAsync())
{
var drug = new LogBook_Model
{
Data = item,
DataValue = WeightConverter.Convert(item, Profil.WeightUnit).Weight.ToString(),
Date = item.Date,
Type = "Weight",
Unit = Profil.WeightUnit,
PicturePath = item.PicturePathe
};
_data.Add(drug);
}
private_list = new ObservableCollection <LogBook_Model>(_data);
Selected_item = null;
old_selected = null;
var sorted = from data in _data
orderby data.Date descending
group data by data.DateSort into DataGroup
select new Grouping <string, LogBook_Model>(DataGroup.Key, DataGroup);
DataGrouped = new ObservableCollection <Grouping <string, LogBook_Model> >(sorted);
}
public void ParsePoundsToKilograms_WhenCalled_ReturnsFormatedWeightInKilograms(string weightInPounds, string expectedResult, int decimalPlaces)
{
Assert.AreEqual(expectedResult, WeightConverter.ParsePoundsToKilograms(weightInPounds, decimalPlaces));
}
public HomePage_ViewModel(INavigation navigation, IDataStore dataStore)
{
this.DataStore = dataStore;
Navigation = navigation;
Glucose_Data = new ObservableCollection <Glucose_Model>();
Weight_Data = new ObservableCollection <Weight_Model>();
GlycemiaConverter = new GlycemiaConverter();
WeightConverter = new WeightConverter();
Upload_Service = new Upload_Service();
UpdateData();
// DependencyService.Get<IStepCounter>().StepCountChanged += StepCounterService_StepCountChanged;
AddDataTypeCommand = new Command(async() =>
{
await ExecuteOnAddDataType();
});
GlucoseStatistiqueCommand = new Command(async() =>
{
await ExecuteOnGlucoseTapped();
});
WeightStatistiqueCommand = new Command(async() =>
{
await ExecuteOnWeightTapped();
});
Hb1acSatistiqueCommand = new Command(async() =>
{
await ExecuteOnHb1acTapped();
});
PressionStatiqtiqueCommand = new Command(async() =>
{
await ExecuteOnPressionTapped();
});
MedicationCommand = new Command(async() =>
{
await ExecuteOnMedicationTapped();
});
StepsStatistiqueCommand = new Command(async() =>
{
await ExecuteOnStepsTapped();
});
MessagingCenter.Subscribe <object, int>(Application.Current, "Steps", (sender, args) =>
{
Steps = args;
});
MessagingCenter.Subscribe <AddData_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
MessagingCenter.Subscribe <SelectedData_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
MessagingCenter.Subscribe <LogBook_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
MessagingCenter.Subscribe <Objectifs_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
MessagingCenter.Subscribe <DataTypeSelection_ViewModel>(this, "HidePopUp", async(sender) =>
{
await Navigation.PopPopupAsync(true);
});
MessagingCenter.Subscribe <Units_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
MessagingCenter.Subscribe <AddDrugs_ViewModel>(this, "DataUpdated", (sender) =>
{
IsBusy = true;
UpdateData();
IsBusy = false;
});
var startTimeSpan = TimeSpan.Zero;
var periodTimeSpan = TimeSpan.FromMinutes(1);
var timer = new System.Threading.Timer((e) =>
{
UpdateData();
Task.Run(async() =>
{
await Upload_Service.Upload();
});
}, null, startTimeSpan, periodTimeSpan);
}
private static void DoComunicate(TcpClient client)
{
NetworkStream stream = client.GetStream();
StreamReader reader = new StreamReader(stream);
StreamWriter writer = new StreamWriter(stream);
while (true)
{
ClassLibraryMandatory.WeightConverter obj = new WeightConverter();
string request = reader.ReadLine();
if (request != null)
{
Console.WriteLine("Request: " + request);
string response = null;
string[] myArray = request.Split(' ');
if (request.Split(' ').Length == 2)
{
if ((myArray[0] == "TOGRAM" || myArray[0] == "TOOUNCE") && myArray[1] != null)
{
try
{
double value = double.Parse(myArray[1]);
if (myArray[1] == "TOGRAM")
{
response = obj.OuncesToGram(value).ToString();
}
else
{
response = obj.GramToOunces(value).ToString();
}
Console.WriteLine("Responce: " + response);
writer.WriteLine(response + "\n ");
Console.WriteLine();
writer.WriteLine();
}
catch (Exception)
{
Console.WriteLine("WRONG INPUT");
writer.WriteLine("Please inseart valid number.");
Console.WriteLine();
writer.WriteLine();
writer.Flush();
continue;
}
}
else
{
Console.WriteLine("Available actions: \nTOGRAM [number]\nTOOUNCE [number]");
writer.WriteLine("No such action available");
Console.WriteLine();
writer.WriteLine();
}
}
if (request == "STOP")
{
break;
}
else
{
if (request.Split(' ').Length != 2)
{
Console.WriteLine("No such action available");
Console.WriteLine();
writer.WriteLine("No such action available");
writer.WriteLine();
}
}
writer.Flush();
}
}
client.Close();
Console.WriteLine("Client disconnected.\nWaiting...");
}
public Malt()
{
this._Converter = new WeightConverter();
}
public void EqualConvertToGram()
{
Assert.AreEqual(85.04856, WeightConverter.ConvertToGram(3), 0.001);
}
public void EqualConvertToOunce()
{
Assert.AreEqual(3.527396195, WeightConverter.ConvertToOunce(100), 0.001);
}
public void ConvertOuncesToGrams_WhenCalled_ReturnsWeightInGrams(double ounces, double expectedResult)
{
Assert.AreEqual(expectedResult, WeightConverter.ConvertOuncesToGrams(ounces), 0.00000001);
}
public void ParsePoundsToKilograms_WhenCalledWithNotParseableArgument_ThrowsFormatException(string weightInPounds)
{
Assert.Throws <FormatException>(() => WeightConverter.ParsePoundsToKilograms(weightInPounds));
}
private void UpdateData()
{
Profil = DataStore.GetSettingsAsync().First();
Objectifs = DataStore.GetObjectifAsync().First();
Glucose_Data.Clear();
Weight_Data.Clear();
Last_Glycemia = null;
Last_Hb1Ac = null;
Last_Pression = null;
Last_Weight = null;
Average = 0;
Nbr_Hight = 0;
Nbr_Low = 0;
Nbr_Normal = 0;
Min = 0;
Max = 0;
foreach (var item in DataStore.GetGlucosAsync().Where(i => i.Date >= DateTime.Now.AddDays(-7)))
{
Glucose_Data.Add(GlycemiaConverter.Convert(item, Profil.GlycemiaUnit));
}
foreach (var item in DataStore.GetWeightAsync())
{
Weight_Data.Add(WeightConverter.Convert(item, Profil.WeightUnit));
}
pression_data = new ObservableCollection <Pression_Model>(DataStore.GetPressionAsync().Where(i => i.Date.Date == DateTime.Now.Date));
Hb1Ac_Data = new ObservableCollection <Hb1Ac_Model>(DataStore.GetHb1acAsync());
if (Glucose_Data.Count > 0)
{
Last_Glycemia = Glucose_Data.OrderBy(i => i.Date).Last();
Average = (Profil.GlycemiaUnit == "mg / dL") ? Math.Round((Glucose_Data.Sum(i => i.Glycemia)) / Glucose_Data.Count, 0) : Math.Round((Glucose_Data.Sum(i => i.Glycemia)) / Glucose_Data.Count, 3);
Min = Glucose_Data.OrderBy(i => i.Glycemia).First().Glycemia;
Max = Glucose_Data.OrderBy(i => i.Glycemia).Last().Glycemia;
if (Profil.GlycemiaUnit == "mg / dL")
{
Nbr_Normal = Glucose_Data.Where(i => i.Glycemia >= Objectifs.Min_Glycemia & i.Glycemia <= Objectifs.Max_Glycemia).Count();
Nbr_Hight = Glucose_Data.Where(i => i.Glycemia > Objectifs.Max_Glycemia).Count();
Nbr_Low = Glucose_Data.Where(i => i.Glycemia < Objectifs.Min_Glycemia).Count();
if (Last_Glycemia.Glycemia < Objectifs.Min_Glycemia & Last_Glycemia.Glycemia != 0)
{
GlucoseColor = Color.FromHex("#f1c40f");
}
if (Last_Glycemia.Glycemia >= Objectifs.Min_Glycemia & Last_Glycemia.Glycemia <= Objectifs.Max_Glycemia)
{
GlucoseColor = Color.FromHex("#0AC774");
}
if (Last_Glycemia.Glycemia > Objectifs.Max_Glycemia)
{
GlucoseColor = Color.FromHex("#C72D14");
}
}
else
{
Nbr_Normal = Glucose_Data.Where(i => i.Glycemia >= GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Min_Glycemia, Profil.GlycemiaUnit) & i.Glycemia <= GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Max_Glycemia, Profil.GlycemiaUnit)).Count();
Nbr_Hight = Glucose_Data.Where(i => i.Glycemia > GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Max_Glycemia, Profil.GlycemiaUnit)).Count();
Nbr_Low = Glucose_Data.Where(i => i.Glycemia < GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Min_Glycemia, Profil.GlycemiaUnit)).Count();
if (Last_Glycemia.Glycemia < GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Min_Glycemia, Profil.GlycemiaUnit) & Average != 0)
{
GlucoseColor = Color.FromHex("#f1c40f");
}
if (Last_Glycemia.Glycemia >= GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Min_Glycemia, Profil.GlycemiaUnit) & Average <= GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Max_Glycemia, Profil.GlycemiaUnit))
{
GlucoseColor = Color.FromHex("#2ecc71");
}
if (Last_Glycemia.Glycemia > GlycemiaConverter.DoubleGlycemiaConvert(Objectifs.Max_Glycemia, Profil.GlycemiaUnit))
{
GlucoseColor = Color.FromHex("#e74c3c");
}
}
}
if (pression_data.Count > 0)
{
Last_Pression = Pression_Data.Where(i => i.Date.Date <= DateTime.Now.Date).OrderBy(i => i.Date).Last();
}
if (Hb1Ac_Data.Count > 0)
{
Last_Hb1Ac = Hb1Ac_Data.Where(i => i.Date.Date <= DateTime.Now.Date).OrderBy(i => i.Date).Last();
}
if (Weight_Data.Count > 0)
{
Last_Weight = Weight_Data.Where(i => i.Date.Date <= DateTime.Now.Date).OrderBy(i => i.Date).Last();
}
if (DataStore.GetStepsAsync().Count() > 0)
{
if (DataStore.GetStepsAsync().Where(i => i.Date.Date == DateTime.Now.Date).Count() > 0)
{
Steps = DataStore.GetStepsAsync().Single(i => i.Date.Date == DateTime.Now.Date).Steps;
}
}
NextMedication();
}
public decimal Resolve(DepotStockDto source, DepotStockViewModel destination, decimal member, ResolutionContext context)
{
return(WeightConverter.ConvertPoundsToKg(source.DrugUnitsWeight));
}
// Expected to pass
public void OzToGrams()
{
Assert.AreEqual(2834.9523125, WeightConverter.OzToGrams(100), 0.0001);
}
