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)); } }