public void ImperialToMetricWeightTests()
{
Assert.AreEqual(6.577, MeasurementConverter.ConvertWeight(14.5, MeasurementSystem.Imperial, MeasurementSystem.Metric), .01);
Assert.AreEqual(8.164, MeasurementConverter.ConvertWeight(18, MeasurementSystem.Imperial, MeasurementSystem.Metric), .01);
Assert.AreEqual(44.724, MeasurementConverter.ConvertWeight(98.6, MeasurementSystem.Imperial, MeasurementSystem.Metric), .01);
}
public void MetricToImperialWeightTests()
{
Assert.AreEqual(14.5, MeasurementConverter.ConvertWeight(6.577, MeasurementSystem.Metric, MeasurementSystem.Imperial), .01);
Assert.AreEqual(18, MeasurementConverter.ConvertWeight(8.164, MeasurementSystem.Metric, MeasurementSystem.Imperial), .01);
Assert.AreEqual(98.6, MeasurementConverter.ConvertWeight(44.724, MeasurementSystem.Metric, MeasurementSystem.Imperial), .01);
}
public void MetricToImperialLengthTests()
{
Assert.AreEqual(5, MeasurementConverter.ConvertLength(12.7, MeasurementSystem.Metric, MeasurementSystem.Imperial), .001);
Assert.AreEqual(3.5, MeasurementConverter.ConvertLength(8.89, MeasurementSystem.Metric, MeasurementSystem.Imperial), .001);
Assert.AreEqual(4, MeasurementConverter.ConvertLength(10.16, MeasurementSystem.Metric, MeasurementSystem.Imperial), .001);
}
public void ImperialToMetricLengthTests()
{
Assert.AreEqual(12.7, MeasurementConverter.ConvertLength(5, MeasurementSystem.Imperial, MeasurementSystem.Metric), .001);
Assert.AreEqual(8.89, MeasurementConverter.ConvertLength(3.5, MeasurementSystem.Imperial, MeasurementSystem.Metric), .001);
Assert.AreEqual(10.16, MeasurementConverter.ConvertLength(4, MeasurementSystem.Imperial, MeasurementSystem.Metric), .001);
}
public void ConversionBetweenSameSourceAndDestinationTests()
{
Assert.AreEqual(18, MeasurementConverter.ConvertWeight(18, MeasurementSystem.Imperial, MeasurementSystem.Imperial), .01);
Assert.AreEqual(6.577, MeasurementConverter.ConvertWeight(6.577, MeasurementSystem.Metric, MeasurementSystem.Metric), .01);
Assert.AreEqual(14, MeasurementConverter.ConvertLength(14, MeasurementSystem.Imperial, MeasurementSystem.Imperial), .001);
Assert.AreEqual(10.16, MeasurementConverter.ConvertLength(10.16, MeasurementSystem.Metric, MeasurementSystem.Metric), .001);
}
public AppUserDTO Handle()
{
int currentUserId = _userAccessor.GetCurrentUserId();
AppUser appUser = _bodyFitTrackerContext.AppUsers.Where(x => x.AppUserId == currentUserId).First();
AppUserDTO appUserDto = _mapper.Map <AppUser, AppUserDTO>(appUser);
appUserDto.MeasurementPreference = new MeasurementSystemDTO(appUser.MeasurementSystemPreference);
appUserDto.Height = MeasurementConverter.ConvertLength(appUser.Height, MeasurementSystem.Imperial, appUser.MeasurementSystemPreference);
return(appUserDto);
}
public void Handle(ChangeProfileSettingsRequest changeProfileSettingsRequest)
{
int currentUserId = _userAccessor.GetCurrentUserId();
AppUser appUser = _bodyFitTrackerContext.AppUsers.Where(x => x.AppUserId == currentUserId).First();
appUser.Email = changeProfileSettingsRequest.Email;
// all units must be in imperial in the database
appUser.Height = MeasurementConverter.ConvertLength(changeProfileSettingsRequest.Height, changeProfileSettingsRequest.UnitsOfMeasure, MeasurementSystem.Imperial);
appUser.MeasurementSystemPreference = changeProfileSettingsRequest.UnitsOfMeasure;
_bodyFitTrackerContext.SaveChanges();
}
public async Task <IActionResult> Get([FromQuery] string sensorId, [FromQuery] DateTime start, [FromQuery] DateTime end,
[FromQuery] double?longitude, [FromQuery] double?latitude, [FromQuery] int?radius,
[FromQuery] int skip = -1, [FromQuery] int limit = -1, [FromQuery] string order = "")
{
var sensor = await this.m_sensors.GetAsync(sensorId).AwaitBackground();
var orderDirection = order switch {
"asc" => OrderDirection.Ascending,
"desc" => OrderDirection.Descending,
_ => OrderDirection.None,
};
if (sensor == null)
{
return(this.NotFound());
}
var linked = await this.IsLinkedSensor(sensorId).AwaitBackground();
if (!await this.AuthenticateUserForSensor(sensor, false).AwaitBackground() && !linked)
{
return(this.Unauthorized());
}
if (end == DateTime.MinValue)
{
end = DateTime.MaxValue;
}
IEnumerable <MeasurementsQueryResult> data;
if (longitude != null && latitude != null)
{
var maxDist = radius ?? 100;
var coords = new GeoJsonPoint {
Latitude = latitude.Value,
Longitude = longitude.Value
};
data = await this.m_measurements
.GetMeasurementsNearAsync(sensor, start, end, coords, maxDist, skip, limit, orderDirection)
.AwaitBackground();
}
else
{
data = await this.m_measurements.GetBetweenAsync(sensor, start, end,
skip, limit, orderDirection).AwaitBackground();
}
return(this.Ok(MeasurementConverter.Convert(data)));
}
private void TryEditingMeasurement(CreateOrEditBodyMeasurementRequest request)
{
int currentUserId = _userAccessor.GetCurrentUserId();
Dictionary <string, string> errors = new Dictionary <string, string>();
AppUser appUser = _bodyFitTrackerContext.AppUsers.Where(x => x.AppUserId == currentUserId).First();
BodyMeasurement bodyMeasurementToEdit = appUser.BodyMeasurements.Where(x => x.BodyMeasurementId ==
request.IdOfBodyMeasurementToEdit).FirstOrDefault();
if (bodyMeasurementToEdit == null)
{
errors.Add("", $"The bodymeasurement with id {request.IdOfBodyMeasurementToEdit} was not found");
throw new RestException(HttpStatusCode.NotFound, errors);
}
// all measurements in the database should be in imperial units
MeasurementSystem sourceUnits = appUser.MeasurementSystemPreference;
MeasurementSystem destinationUnits = MeasurementSystem.Imperial;
bodyMeasurementToEdit.NeckCircumference =
MeasurementConverter.ConvertLength(request.NeckCircumference, sourceUnits, destinationUnits);
bodyMeasurementToEdit.WaistCircumference =
MeasurementConverter.ConvertLength(request.WaistCircumference,
sourceUnits, destinationUnits);
if (request.HipCircumference.HasValue)
{
bodyMeasurementToEdit.HipCircumference =
MeasurementConverter.ConvertLength((double)request.HipCircumference, sourceUnits, destinationUnits);
}
bodyMeasurementToEdit.Height =
MeasurementConverter.ConvertLength(request.Height, sourceUnits, destinationUnits);
bodyMeasurementToEdit.Weight =
MeasurementConverter.ConvertWeight(request.Weight, sourceUnits, destinationUnits);
bodyMeasurementToEdit.DateAdded = request.DateAdded;
bodyMeasurementToEdit.BodyFatPercentage = BodyFatPercentageCalculator.CalculateBodyFatPercentage(bodyMeasurementToEdit);
_bodyFitTrackerContext.SaveChanges();
}
void Awake()
{
#if UNITY_EDITOR
if (_criticalCaloryLevel > _hungryCaloryLevel)
{
Debug.LogError("The Critical Calory Level must be lower than the Hungry Calory Level");
}
if (_hungryCaloryLevel > _satisfiedCaloryLevel)
{
Debug.LogError("The Hungry Calory Level must be lower than the Satisfied Calory Level");
}
if (_satisfiedCaloryLevel > _fullCaloryLevel)
{
Debug.LogError("The Satisfied Calory Level must be lower than the Full Calory Level");
}
#endif
_criticalEnergyLevel = (uint)MeasurementConverter.ConvertCaloriesToKiloJoules(_criticalCaloryLevel);
_hungryEnergyLevel = (uint)MeasurementConverter.ConvertCaloriesToKiloJoules(_hungryCaloryLevel);
_satisfiedEnergyLevel = (uint)MeasurementConverter.ConvertCaloriesToKiloJoules(_satisfiedCaloryLevel);
_fullEnergyLevel = (uint)MeasurementConverter.ConvertCaloriesToKiloJoules(_fullCaloryLevel);
}
public void ProcessBlock(List <string> block)
{
var firstLine = block.First();
if (firstLine.StartsWith("K0100"))
{
var values = firstLine.Split(' ');
int numberOfCharacteristics;
if (!int.TryParse(values[1], out numberOfCharacteristics))
{
throw new Exception("Value of field K0100 is invalid.");
}
while (numberOfCharacteristics > Characteristics.Count)
{
Characteristics.Add(new Characteristic());
}
firstLine = block[1];
}
if (firstLine.StartsWith("K0999"))
{
//todo finish
}
if (firstLine.StartsWith("K1"))
{
//process part data
var part = PartConverter.Convert(block);
if (part != null)
{
Parts.Add(part);
_currentPart = part;
}
}
else if (firstLine.StartsWith("K2"))
{
//process characteristic data
CharacteristicConverter.Convert(block, Characteristics.ToArray());
}
else if (firstLine.StartsWith("K00") || char.IsNumber(firstLine[0]))
{
if (_currentPart == null)
{
throw new Exception("Invalid key structure. Part information should be processed before any measurements.");
}
//process value portion
//part and characteristic sections are considered finished now so make sure we got all processed characteristics assigned to current part
if (_currentPart.Characteristics == null)
{
//assign characteristics to _current part
_currentPart.Characteristics = Characteristics.Where(p => string.IsNullOrEmpty(p.PartNumber) && !string.IsNullOrEmpty(p.Number)).ToArray();
foreach (var currentPartCharacteristic in _currentPart.Characteristics)
{
currentPartCharacteristic.PartNumber = _currentPart.Number;
}
}
MeasurementConverter.Convert(block, _currentPart.Characteristics);
}
}
private async Task <IEnumerable <MeasurementsQueryResult> > GetMeasurementsAsync(Filter filter)
{
var status = new Status();
IEnumerable <Common.Data.Models.MeasurementsQueryResult> result;
if (filter.SensorIds == null || filter.SensorIds.Count <= 0)
{
status.ErrorCode = ReplyCode.BadInput;
status.Message = "Sensor ID list cannot be empty!";
return(null);
}
filter.Skip ??= -1;
filter.Limit ??= -1;
var sensors = await this.m_sensorService.GetSensorsAsync(this.CurrentUser).AwaitBackground();
var filtered = sensors.Values.Where(x => filter.SensorIds.Contains(x.InternalId.ToString())).ToList();
if (filtered.Count <= 0)
{
status.Message = "No sensors available!";
status.ErrorCode = ReplyCode.NotAllowed;
return(null);
}
OrderDirection direction;
if (string.IsNullOrEmpty(filter.OrderDirection))
{
filter.OrderDirection = "";
}
if (filter.End == DateTime.MinValue)
{
filter.End = DateTime.MaxValue;
}
direction = filter.OrderDirection switch {
"asc" => OrderDirection.Ascending,
"desc" => OrderDirection.Descending,
_ => OrderDirection.None,
};
if (filter.Latitude != null & filter.Longitude != null && filter.Radius != null && filter.Radius.Value > 0)
{
var coords = new GeoJsonPoint {
Latitude = filter.Latitude.Value,
Longitude = filter.Longitude.Value
};
result = await this.m_measurements
.GetMeasurementsNearAsync(filtered, filter.Start, filter.End, coords, filter.Radius.Value,
filter.Skip.Value, filter.Limit.Value, direction).AwaitBackground();
}
else
{
result = await this.m_measurements
.GetMeasurementsBetweenAsync(filtered, filter.Start, filter.End, filter.Skip.Value,
filter.Limit.Value, direction).AwaitBackground();
}
return(MeasurementConverter.Convert(result));
}
