public IActionResult GetUsers(FitnessType type, FilterType filter)
{
var result = new List <UserViewModel>();
var users = _context.Users
.Include(x => x.Activities).ToList();
foreach (var user in users)
{
var vmUser = Mapper.Map <UserViewModel>(user);
switch (filter)
{
case FilterType.All:
vmUser.Amount = user.Activities?.Where(x => x.Type == type).Sum(x => x.Amount) ?? 0;
break;
case FilterType.Month:
vmUser.Amount = user.Activities?.Where(x => x.Type == type && x.Date.Month == DateTime.UtcNow.Month).Sum(x => x.Amount) ?? 0;
break;
case FilterType.Week:
vmUser.Amount = user.Activities?.Where(x => x.Type == type && DateHelper.GetIso8601WeekOfYear(x.Date.Date) == DateHelper.GetIso8601WeekOfYear(DateTime.UtcNow)).Sum(x => x.Amount) ?? 0;
break;
}
//Temp patch old clients
vmUser.TotalDistance = vmUser.Amount;
vmUser.TotalSteps = vmUser.Amount;
result.Add(vmUser);
}
return(new ObjectResult(result.OrderByDescending(x => x.Amount).ToList()));
}
/// <summary>
/// Entsprechend des Netzwerkstatus wird am Server angelegt oder ein Fehler angezeigt
/// </summary>
/// <param name="username"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="passwordConfirm"></param>
/// <param name="gender"></param>
/// <param name="job"></param>
/// <param name="fitness"></param>
/// <param name="birthdate"></param>
/// <returns></returns>
public async Task <bool> SignUp(string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate)
{
if (Online)
{
try
{
User user = new User();
user.UserId = await mgnService.SignUp(username, email, password, passwordConfirm, gender, job, fitness, birthdate);
user.Username = username;
user.Password = password;
user.wasOffline = false;
db.insertUpdateUser(user);
}
catch (ServerException ex)
{
System.Console.WriteLine("Fehler beim Registrieren: " + ex.StackTrace);
throw;
}
}
else
{
//Fehler schmeissen, dass man offline ist!!!
throw (new Exception("Registrierung funktioniert nur im Online-Modus"));
}
return(true);
}
public IActionResult Activities(string userId, FitnessType type, FilterType filter)
{
var user = _context.Users
.Include(x => x.Activities)
.FirstOrDefault(x => x.UserId == userId);
if (user != null)
{
IEnumerable <Activity> userQuery;
switch (filter)
{
case FilterType.Month:
userQuery = user.Activities.Where(x => x.Type == type && x.Date.Month == DateTime.UtcNow.Month);
break;
case FilterType.Week:
userQuery = user.Activities.Where(x => x.Type == type && DateHelper.GetIso8601WeekOfYear(x.Date.Date) == DateHelper.GetIso8601WeekOfYear(DateTime.UtcNow));
break;
default:
case FilterType.All:
userQuery = user.Activities.Where(x => x.Type == type);
break;
}
var activities = userQuery.Select(Mapper.Map <ActivityViewModel>).OrderByDescending(x => x.Date).ToList();
return(new ObjectResult(activities));
}
return(NotFound());
}
private async void BtnSignUp_Click(object sender, EventArgs e)
{
//Types aus den Eingaben genrieren
GenderType geschlecht = getSelectedGender(spinGender.SelectedItem.ToString());
JobTypes job = getSelectedJob(spinJob.SelectedItem.ToString());
FitnessType fitness = getSelectedFitness(spinFitness.SelectedItem.ToString());
DateTime birthdate = getSelectedBirthdate(txtBirthdate.Text);
try
{
await ooService.SignUp(txtUsername.Text,
txtEmail.Text,
txtPassword.Text,
txtPasswordConfirm.Text,
geschlecht,
job,
fitness,
birthdate
);
//Dialog will slide to the side and will disapear
this.Dismiss();
}
catch (ServerException ex)
{
Console.WriteLine("Serverfehler: " + ex.StackTrace);
//Falsche Logindaten
//Rückmeldung an den Login-Dialog, dass die Kombination User+PW nicht passt
string fehler = "";
if (ex.StackTrace.Contains("username"))
{
fehler = "username";
}
else if (ex.StackTrace.Contains("username"))
{
fehler = "password";
}
else if (ex.StackTrace.Contains("birthdate"))
{
fehler = "birthdate";
}
SignUpFail(fehler);
}
catch (Exception ex)
{
Console.WriteLine("Fehler (Registrierung): " + ex.StackTrace);
new AlertDialog.Builder(this.Activity)
.SetMessage("Registrierung nur Online möglich")
.SetTitle("Error")
.Show();
}
}
public float GetFitnesses(FitnessType fitnessType)
{
switch (fitnessType)
{
case FitnessType.BestFitness:
return(generationFitnesses.bestFitness);
case FitnessType.WorstFitness:
return(generationFitnesses.worstFitness);
case FitnessType.AverageFitness:
return(generationFitnesses.averageFitness);
}
return(-1);
}
public ApplicationUser(
string username = "",
string email = "",
DateTime dateOfBirth = default(DateTime),
GenderType gender = GenderType.Male,
FitnessType fitness = FitnessType.NoSport,
JobTypes job = JobTypes.Middle)
: base(username)
{
this.Job = job;
DateOfBirth = dateOfBirth;
Gender = gender;
Fitness = fitness;
Email = email;
}
public ApplicationUser(
string username = "",
string email = "",
DateTime dateOfBirth = default(DateTime),
GenderType gender = GenderType.Male,
FitnessType fitness = FitnessType.NoSport,
JobTypes job = JobTypes.Middle)
: base(username)
{
this.Job = job;
DateOfBirth = dateOfBirth;
Gender = gender;
Fitness = fitness;
Email = email;
}
/// <summary>
/// Converts a value.
/// </summary>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
/// <returns>A converted value. If the method returns null, the valid null value is used.</returns>
public object?Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value is null)
{
return(null);
}
object?returnValue = null;
if (value.GetType() == typeof(FitnessType))
{
FitnessType fitnessType = (FitnessType)value;
switch (fitnessType)
{
case FitnessType.Scaled:
returnValue = EnumsViewModel.FitnessTypeScaled;
break;
case FitnessType.Raw:
returnValue = EnumsViewModel.FitnessTypeRaw;
break;
default:
returnValue = null;
break;
}
}
else if (value.GetType() == typeof(FitnessSortOption))
{
FitnessSortOption fitnessSortOption = (FitnessSortOption)value;
switch (fitnessSortOption)
{
case FitnessSortOption.Entity:
returnValue = EnumsViewModel.FitnessSortByEntity;
break;
case FitnessSortOption.Fitness:
returnValue = EnumsViewModel.FitnessSortByFitness;
break;
default:
returnValue = null;
break;
}
}
return(returnValue);
}
/// <summary>
/// Returns the appropriate fitness value of the <b>GeneticEntity</b> based on the the <paramref name="fitnessType"/>.
/// </summary>
/// <param name="fitnessType"><see cref="FitnessType"/> indicating which fitness value to
/// return.</param>
/// <returns>The appropriate fitness value of the <b>GeneticEntity</b>.</returns>
/// <exception cref="ArgumentException"><paramref name="fitnessType"/> value is undefined.</exception>
public double GetFitnessValue(FitnessType fitnessType)
{
if (!Enum.IsDefined(typeof(FitnessType), fitnessType))
{
throw EnumHelper.CreateUndefinedEnumException(typeof(FitnessType), "fitnessType");
}
if (fitnessType == FitnessType.Raw)
{
return(this.rawFitnessValue);
}
else
{
return(this.scaledFitnessValue);
}
}
private static GeneticAlgorithm GetAlgorithm(double fitnessTarget, FitnessType fitnessType)
{
GeneticAlgorithm algorithm = new MockGeneticAlgorithm
{
SelectionOperator = new MockSelectionOperator(),
FitnessEvaluator = new MockFitnessEvaluator(),
PopulationSeed = new SimplePopulation(),
GeneticEntitySeed = new MockEntity(),
Terminator = new FitnessTargetTerminator
{
FitnessTarget = fitnessTarget,
FitnessType = fitnessType
}
};
return(algorithm);
}
/// <summary>
/// Generates FitnessType out of string
/// </summary>
/// <param name="value">string fitnessValue</param>
/// <returns>FitnessType of selected value</returns>
private FitnessType getSelectedFitness(string value)
{
FitnessType fTfitness;
FitnessType fTout = FitnessType.NoSport; //Geht das auch schöner?
try
{
if (Enum.TryParse <FitnessType>(value, true, out fTfitness))
{
fTout = (FitnessType)Enum.Parse(typeof(FitnessType), value);
}
}
catch (Exception e)
{
Console.WriteLine("Falscher FitnessType wurde übermittelt");
}
return(fTout);
}
public OnSignUpEventArgs(
string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate
) : base()
{
Username = username;
Email = email;
Password = password;
PasswordConfirm = passwordConfirm;
Gender = gender;
Job = job;
Fitness = fitness;
Birthdate = birthdate;
}
/// <summary>
/// Registrierung am Server
/// </summary>
/// <param name="username"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="passwordConfirm"></param>
/// <param name="gender"></param>
/// <param name="job"></param>
/// <param name="fitness"></param>
/// <param name="birthdate"></param>
/// <returns></returns>
public async Task <string> SignUp(
string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate)
{
string userId = "";
try
{
CreateUserModel user = new CreateUserModel();
user.Username = username;
user.Password = password;
user.ConfirmPassword = passwordConfirm;
user.Email = email;
user.Gender = gender;
user.Job = job;
user.Fitness = fitness;
user.DateOfBirth = birthdate;
await service.RegisterAsync(user);
userId = (await session.Admins.GetUserByUsernameAsync(username)).Id;
}
catch (ServerException ex)
{
throw;
}
catch (Exception exc)
{
Console.WriteLine("Fehler beim Registrieren: " + exc.StackTrace);
}
return(userId);
}
/// <summary>
/// Entsprechend des Netzwerkstatus wird am Server angelegt oder ein Fehler angezeigt
/// </summary>
/// <param name="username"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="passwordConfirm"></param>
/// <param name="gender"></param>
/// <param name="job"></param>
/// <param name="fitness"></param>
/// <param name="birthdate"></param>
/// <returns></returns>
public async Task<bool> SignUp(string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate)
{
if (Online)
{
try
{
User user = new User();
user.UserId = await mgnService.SignUp(username, email, password, passwordConfirm, gender, job, fitness, birthdate);
user.Username = username;
user.Password = password;
user.wasOffline = false;
db.insertUpdateUser(user);
}
catch (ServerException ex)
{
System.Console.WriteLine("Fehler beim Registrieren: " + ex.StackTrace);
throw;
}
}
else
{
//Fehler schmeissen, dass man offline ist!!!
throw (new Exception("Registrierung funktioniert nur im Online-Modus"));
}
return true;
}
public static string PatchOld(FitnessType type)
{
return(type == FitnessType.Distance ? "getDailyDistanceSamples" : "getDailyStepCountSamples");
}
/// <summary>
/// Returns the standard deviation of the raw fitness value for the <paramref name="entities"/>.
/// </summary>
/// <param name="entities">The entities whose fitness values should be used.</param>
/// <param name="mean">Mean fitness value for the population.</param>
/// <param name="fitnessType">The type of fitness value to use.</param>
/// <returns>The standard deviation of the raw fitness value for the population.</returns>
public static double GetStandardDeviation(IEnumerable <GeneticEntity> entities, double mean, FitnessType fitnessType)
{
int count = 0;
double diffSums = entities.Sum(e =>
{
count++;
double val;
if (fitnessType == FitnessType.Scaled)
{
val = e.ScaledFitnessValue - mean;
}
else
{
val = e.RawFitnessValue - mean;
}
return(Math.Pow(val, 2));
});
return(Math.Sqrt(diffSums / count));
}
/// <summary>
/// Registrierung am Server
/// </summary>
/// <param name="username"></param>
/// <param name="email"></param>
/// <param name="password"></param>
/// <param name="passwordConfirm"></param>
/// <param name="gender"></param>
/// <param name="job"></param>
/// <param name="fitness"></param>
/// <param name="birthdate"></param>
/// <returns></returns>
public async Task<string> SignUp(
string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate)
{
string userId = "";
try
{
CreateUserModel user = new CreateUserModel();
user.Username = username;
user.Password = password;
user.ConfirmPassword = passwordConfirm;
user.Email = email;
user.Gender = gender;
user.Job = job;
user.Fitness = fitness;
user.DateOfBirth = birthdate;
await service.RegisterAsync(user);
userId = (await session.Admins.GetUserByUsernameAsync(username)).Id;
}
catch (ServerException ex)
{
throw;
}
catch (Exception exc)
{
Console.WriteLine("Fehler beim Registrieren: " + exc.StackTrace);
}
return userId;
}
/// <summary>
/// Initializes a new instance of the <see cref="FitnessValueComparer"/> class.
/// </summary>
/// <param name="sortBasis">Type of fitness value on which the comparison is based.</param>
public FitnessValueComparer(FitnessType sortBasis)
{
this.sortBasis = sortBasis;
}
private async Task TestRefreshChartScenario(FitnessType fitnessType, FitnessSortOption fitnessSortOption,
bool switchPopulations, bool createNewGeneration, bool completeAlgorithm, bool elapseTime)
{
TimeSpan elapsedTime = TimeSpan.FromSeconds(0);
Mock <IStopwatch> stopwatchMock = new Mock <IStopwatch>();
stopwatchMock
.SetupGet(o => o.Elapsed)
.Returns(() => elapsedTime);
Mock <IStopwatchFactory> stopwatchFactoryMock = new Mock <IStopwatchFactory>();
stopwatchFactoryMock
.Setup(o => o.Create())
.Returns(stopwatchMock.Object);
FitnessChart chart = new FitnessChart(stopwatchFactoryMock.Object)
{
FitnessSortOption = fitnessSortOption,
FitnessType = fitnessType
};
PlotModel model = chart.PlotModel;
CategoryAxis axis = (CategoryAxis)model.Axes[0];
axis.Labels.Add("test"); // Add test label to ensure it gets cleared
TestAlgorithm algorithm = new TestAlgorithm
{
MinimumEnvironmentSize = 2,
PopulationSeed = new TestPopulation()
{
MinimumPopulationSize = 5
},
FitnessEvaluator = new TestFitnessEvaluator(),
GeneticEntitySeed = new TestEntity(),
SelectionOperator = new TestSelectionOperator(),
Terminator = new TestTerminator()
};
await algorithm.InitializeAsync();
if (switchPopulations)
{
chart.Population = algorithm.Environment.Populations[1];
}
Population population = algorithm.Environment.Populations[0];
TestEntity[] entities = population.Entities.Cast <TestEntity>().ToArray();
entities[0].RawFitnessValue = 2;
entities[1].RawFitnessValue = 0;
entities[2].RawFitnessValue = 1;
entities[3].RawFitnessValue = 4;
entities[4].RawFitnessValue = 3;
entities[0].ScaledFitnessValue = 0;
entities[1].ScaledFitnessValue = 3;
entities[2].ScaledFitnessValue = 2;
entities[3].ScaledFitnessValue = 4;
entities[4].ScaledFitnessValue = 1;
entities[0].CompareFactor = 4;
entities[1].CompareFactor = 0;
entities[2].CompareFactor = 3;
entities[3].CompareFactor = 2;
entities[4].CompareFactor = 1;
// Set the Population which will trigger the logic to test
chart.Population = population;
stopwatchFactoryMock.Verify(o => o.Create(), Times.Once());
stopwatchMock.Verify(o => o.Start(), Times.Once());
stopwatchMock.Verify(o => o.Restart(), switchPopulations ? Times.Exactly(2) : Times.Once());
List <GeneticEntity> sortedEntities;
if (fitnessSortOption == FitnessSortOption.Entity)
{
sortedEntities = new List <GeneticEntity>
{
entities[1],
entities[4],
entities[3],
entities[2],
entities[0],
};
}
else
{
if (fitnessType == FitnessType.Raw)
{
sortedEntities = new List <GeneticEntity>
{
entities[1],
entities[2],
entities[0],
entities[4],
entities[3],
};
}
else
{
sortedEntities = new List <GeneticEntity>
{
entities[0],
entities[4],
entities[2],
entities[1],
entities[3],
};
}
}
ColumnSeries columnSeries = (ColumnSeries)model.Series[0];
if (fitnessType == FitnessType.Scaled)
{
Assert.Equal(nameof(GeneticEntity.ScaledFitnessValue), columnSeries.ValueField);
}
else
{
Assert.Equal(nameof(GeneticEntity.RawFitnessValue), columnSeries.ValueField);
}
Assert.Equal(sortedEntities, columnSeries.ItemsSource.Cast <object>().ToList());
Assert.Equal(algorithm.PopulationSeed.MinimumPopulationSize, axis.Labels.Count);
for (int i = 0; i < algorithm.PopulationSeed.MinimumPopulationSize; i++)
{
Assert.Equal("", axis.Labels[i]);
}
if (createNewGeneration)
{
if (elapseTime)
{
// Ensure that enough time has passed for refresh to occur
elapsedTime = TimeSpan.FromSeconds(5);
}
// Create next generation to cause the chart to be refresh again
await algorithm.StepAsync();
if (elapseTime)
{
Assert.NotEqual(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
}
if (completeAlgorithm)
{
if (elapseTime)
{
// Ensure that enough time has passed for refresh to occur
elapsedTime = TimeSpan.FromSeconds(5);
}
((TestTerminator)algorithm.Terminator).IsCompleteValue = true;
// Create next generation to cause the chart to be refresh again
await algorithm.StepAsync();
if (createNewGeneration && elapseTime)
{
Assert.NotEqual(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
else
{
Assert.Equal(sortedEntities,
columnSeries.ItemsSource.Cast <object>().ToList());
}
}
// Set the population to null to verify the series gets cleared
chart.Population = null;
Assert.Null(columnSeries.ItemsSource);
}
public IActionResult GetAwards(FitnessType fitnessType, FilterType filter)
{
var query = _context.Activities.Where(x => x.Type == fitnessType);
var awards = new List <AwardViewModel>();
var startDate = new DateTime(2017, 05, 18);
switch (filter)
{
case FilterType.Month:
for (DateTime date = startDate; date.Month < DateTime.UtcNow.Month; date = date.AddMonths(1))
{
var res = query
.Where(x => x.Date.Month == date.Month)
.GroupBy(x => x.UserId)
.Select(x => new { UserId = x.Key, TotalAmount = x.Sum(y => y.Amount) })
.OrderByDescending(x => x.TotalAmount)
.Take(3);
if (res != null)
{
int placement = 1;
foreach (var award in res)
{
awards.Add(new AwardViewModel
{
AwardId = Guid.NewGuid(),
UserId = award.UserId,
Description = fitnessType == FitnessType.Distance ? $"Sträcka månad: {date.Month}" : $"Steg månad: {date.Month}",
Value = award.TotalAmount.ToString(),
Date = date,
Type = fitnessType == FitnessType.Distance ? AwardType.MonthDistance : AwardType.MonthSteps,
Placement = placement++
});
}
}
}
break;
case FilterType.Week:
for (DateTime date = startDate; DateHelper.GetIso8601WeekOfYear(date) < DateHelper.GetIso8601WeekOfYear(DateTime.UtcNow); date = date.AddDays(7))
{
var week = DateHelper.GetIso8601WeekOfYear(date);
var res = query
.Where(x => DateHelper.GetIso8601WeekOfYear(x.Date.Date) == week)
.GroupBy(x => x.UserId)
.Select(x => new { UserId = x.Key, TotalAmount = x.Sum(y => y.Amount) })
.OrderByDescending(x => x.TotalAmount)
.Take(3);
if (res != null)
{
int placement = 1;
foreach (var award in res)
{
awards.Add(new AwardViewModel
{
AwardId = Guid.NewGuid(),
UserId = award.UserId,
Description = fitnessType == FitnessType.Distance ? $"Sträcka vecka: {week}" : $"Steg vecka: {week}",
Value = award.TotalAmount.ToString(),
Date = date,
Type = fitnessType == FitnessType.Distance ? AwardType.WeekDistance : AwardType.WeekSteps,
Placement = placement++
});
}
}
}
break;
case FilterType.All:
default:
break;
}
return(new ObjectResult(awards));
}
public static int CalculateFitness(int gatesPassed, float distanceTravelled, float avgSpeed, FitnessType fitnessType)
{
int result = 0;
if (gatesPassed > GlobalConst.MIN_GATES_PASSED_WHEN_DISABLED_BASED_ON_AVG_VELOCITY)
{//even when car did not pass any gate distanceTravelled will contain value grater than zero, hence this condition
switch (fitnessType)
{
case FitnessType.DIST_ADD_SPEED:
result = (int)(distanceTravelled + avgSpeed);
break;
case FitnessType.DIST_MUL_SPEED:
result = (int)(distanceTravelled * avgSpeed);
break;
case FitnessType.ONLY_DISTANCE:
result = (int)distanceTravelled;
break;
}
}
return(result);
}
public OnSignUpEventArgs(
string username,
string email,
string password,
string passwordConfirm,
GenderType gender,
JobTypes job,
FitnessType fitness,
DateTime birthdate
) : base()
{
Username = username;
Email = email;
Password = password;
PasswordConfirm = passwordConfirm;
Gender = gender;
Job = job;
Fitness = fitness;
Birthdate = birthdate;
}
/// <summary>
/// Sorts the list in the order by the fitness type indicated, from worst to best.
/// </summary>
/// <param name="entities">The entities to sort.</param>
/// <param name="sortBasis">Type of fitness value on which sorting is based.</param>
/// <param name="evaluationMode">Mode which indicates whether the sorting will be based on higher or lower fitness values.</param>
/// <exception cref="ArgumentException"><paramref name="sortBasis"/> value is undefined.</exception>
/// <exception cref="ArgumentException"><paramref name="evaluationMode"/> value is undefined.</exception>
public static IEnumerable <GeneticEntity> GetEntitiesSortedByFitness(this IEnumerable <GeneticEntity> entities, FitnessType sortBasis, FitnessEvaluationMode evaluationMode)
{
if (!Enum.IsDefined(typeof(FitnessType), sortBasis))
{
throw EnumHelper.CreateUndefinedEnumException(typeof(FitnessType), "sortBasis");
}
if (!Enum.IsDefined(typeof(FitnessEvaluationMode), evaluationMode))
{
throw EnumHelper.CreateUndefinedEnumException(typeof(FitnessEvaluationMode), "evaluationMode");
}
FitnessValueComparer comparer = new FitnessValueComparer(sortBasis);
GeneticEntity keySelector(GeneticEntity entity) => entity;
if (evaluationMode == FitnessEvaluationMode.Maximize)
{
return(entities.OrderBy(keySelector, comparer));
}
else
{
return(entities.OrderByDescending(keySelector, comparer));
}
}
