public ActionResult Create(Workouts model)
{
if (!ModelState.IsValid)
{
return(View("WorkoutForm", model));
}
if (model.Id == 0)
{
Workouts workout = new Workouts();
workout = model;
_context.Workoutss.Add(workout);
}
else
{
var workoutInDb = _context.Workoutss.Single(c => c.Id == model.Id);
workoutInDb.Name = model.Name;
workoutInDb.Author = model.Author;
workoutInDb.Description = model.Description;
workoutInDb.Equipment = model.Equipment;
workoutInDb.Targets = model.Targets;
}
_context.SaveChanges();
return(RedirectToAction("Library", "Workouts"));
}
private void lvExerciseClicked(object sender, ItemClickEventArgs e)
{
Workouts selected = (Workouts)e.ClickedItem;
session.setWorkouts(selected);
this.Frame.Navigate(typeof(WorkoutsPageDetail));
}
private void DeleteItem(int ind)
{
var progressList = new List <WorkoutData>();
for (int i = 0; i < progress.Length; i++)
{
if (i != ind)
{
progressList.Add(progress[i]);
}
}
Workouts.Remove(Workouts[ind]);
progress = progressList.ToArray();
foreach (var workout in Workouts)
{
foreach (var item in workout.ExerciseDetails)
{
if (planDict.ContainsKey(item.Id))
{
if (planDict[item.Id].Item1 == ind)
{
planDict.Remove(item.Id);
}
if (planDict[item.Id].Item1 > ind)
{
planDict[item.Id] = new Tuple <int, int>(planDict[item.Id].Item1 - 1, planDict[item.Id].Item2);
}
}
}
}
UpdateProgress();
DataManager.SaveProgress(progress);
}
public bool GuardaMyWork(Workouts workout)
{
Usuario usuario = (Usuario)Session["infoUsuario"];
string id = DateTime.Now.ToString().Replace("/", "").Replace(" ", "").Replace(":", "");
id += "0000000000";
workout._id = id;
try
{
var collection = _dbContext.GetDatabase().GetCollection <Usuario>("usuarios");
var usuCollection = collection.AsQueryable().Where(x => x._id == usuario._id).FirstOrDefault();
usuCollection.CustomWorkouts.Add(DateTime.Now.ToString(), workout);
collection.Save(usuCollection);
return(true);
}
catch (Exception e)
{
string exc = e.ToString();
return(false);
}
}
public void AddWorkout()
{
if (SelectedBodyPartItem == null || string.IsNullOrEmpty(WorkoutTitle))
{
return;
}
var workout = new Models.Workout.Workout()
{
AddedDate = DateTime.Now,
TargetBodyPart = SelectedBodyPartItem.BodyPart,
WorkoutTitle = WorkoutTitle,
WorkoutDescription = WorkoutDescription,
Image = Image,
VideoLink = VideoLink
};
using var db = new AppDbContext();
db.Workouts.Add(workout);
db.SaveChanges();
Workouts.Insert(0, workout);
WorkoutTitle = "";
WorkoutDescription = "";
VideoLink = "";
Image = null;
}
public void WorkoutAchievementsCheck(Workout WorkoutViewModel)
{
var user = Users.GetUser(WorkoutViewModel.UserId);
var AchievementsList = Achievements.GetAllAchievement(WorkoutViewModel.UserId);
var WorkoutList = Workouts.GetAllWorkouts(WorkoutViewModel.UserId);
var Achievement = AchievementsList.First(a => a.Name == "Pierwszy trenig siłowy");
if (WorkoutList.Any() && !Achievement.Acquired)
{
AcceptAchievement(Achievement, WorkoutViewModel.Date, user);
}
Achievement = AchievementsList.FirstOrDefault(a => a.Name == "10 trenigów siłowych");
if (WorkoutList.Count() >= 10 && !Achievement.Acquired)
{
AcceptAchievement(Achievement, WorkoutViewModel.Date, user);
}
Achievement = AchievementsList.FirstOrDefault(a => a.Name == "20 trenigów siłowych");
if (WorkoutList.Count() >= 20 && !Achievement.Acquired)
{
AcceptAchievement(Achievement, WorkoutViewModel.Date, user);
}
Achievement = AchievementsList.FirstOrDefault(a => a.Name == "50 trenigów siłowych");
if (WorkoutList.Count() >= 50 && !Achievement.Acquired)
{
AcceptAchievement(Achievement, WorkoutViewModel.Date, user);
}
Achievement = AchievementsList.FirstOrDefault(a => a.Name == "100 trenigów siłowych");
if (WorkoutList.Count() >= 100 && !Achievement.Acquired)
{
AcceptAchievement(Achievement, WorkoutViewModel.Date, user);
}
}
async Task ExecuteLoadItemsCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Workouts.Clear();
var workouts = await DataStore.GetWorkoutAsync(true);
foreach (var workout in workouts)
{
Workouts.Add(workout);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
private async Task AddWorkout()
{
if (_workout.Workout_Name is null)
{
await Application.Current.MainPage.DisplayAlert("Error", "Please Enter the Workout Name", "OK");
return;
}
else
{
_workoutRepository = new WorkoutRepository();
_workoutDaysRepository = new WorkoutDaysRepository();
_exerciseRepository = new ExerciseRepository();
_workoutWeeksrepository = new WorkoutWeeksRepository();
Workouts oLastWorkout = await _workoutRepository.AddWorkout(_workout);
foreach (var item in _weeksList)
{
var weekId = await _workoutWeeksrepository.AddWorkoutWeek(new WorkoutWeeks { Week = item.Week, Workout_Id = oLastWorkout.Workout_id });
foreach (var item2 in item.Days)
{
var dayId = await _workoutDaysRepository.AddWorkoutDay(new WorkoutDays { Day = item2.Day.ToString(), Workout_Week_Id = weekId.Id, Workout_Id = oLastWorkout.Workout_id });
foreach (var item3 in item2.exercisesOnDays)
{
await _exerciseRepository.AddExercise(new Exercises { Day_Id = dayId.Id, Exercise_Name = item3.ExerciseId, Sets = item3.Reps, Reps = item3.Reps, Workout_Id = oLastWorkout.Workout_id });
}
}
}
await _navigation.PopAsync();
}
}
public async Task LoadAsync()
{
var lookup = await _clientLookupService.GetClientLookupAsync();
Clients.Clear();
foreach (var item in lookup)
{
Clients.Add(new NavigationItemViewModel(item.Id, item.DisplayMember, _eventAggregator, nameof(ClientDetailViewModel)));
}
lookup = await _workoutLookupService.GetWorkoutLookupAsync();
Workouts.Clear();
foreach (var item in lookup)
{
Workouts.Add(new NavigationItemViewModel(item.Id, item.DisplayMember, _eventAggregator, nameof(WorkoutDetailViewModel)));
}
lookup = await _exerciseLookupDataService.GetExerciseLookupAsync();
Exercises.Clear();
foreach (var item in lookup)
{
Exercises.Add(new NavigationItemViewModel(item.Id, item.DisplayMember, _eventAggregator, nameof(ExerciseDetailViewModel)));
}
}
public bool GuardaMyWork(Workouts workout)
{
string id = DateTime.Now.ToString().Replace("/", "").Replace(" ", "").Replace(":", "");
for (int i = id.Length; i < 24; i++)
{
id += "0";
}
workout._id = id;
try
{
var usuCollection = _dbContext.Usuarios.Find <Usuario>(x => x._id == usuario._id).FirstOrDefault();
usuCollection.CustomWorkouts.Add(DateTime.Now.ToString(), workout);
_dbContext.Usuarios.UpdateOne <Usuario>(x => x._id == usuario._id, Builders <Usuario> .Update.Set(x => x.CustomWorkouts, usuCollection.CustomWorkouts));
var usuCollection2 = _dbContext.Usuarios.Find <Usuario>(x => x._id == usuario._id).FirstOrDefault();
return(true);
}
catch (Exception e)
{
string exc = e.ToString();
return(false);
}
}
public WorkoutManagerViewModel()
{
Add = new Command(async() =>
{
await navigation_.PushAsync(new WorkoutCreation());
await RefreshList();
});
Edit = new Command <object>(async w =>
{
var workout = Workouts.First(e => e == w);
await workout.Edit(database_);
Workouts.Remove(workout);
Workouts.Add(await database_.GetWorkout(workout.Id, workout.WorkoutType));
});
Delete = new Command <object>(async w =>
{
var workout = (IWorkout)w;
if (await AskQuestion("Delete " + workout.Title + " is permament"))
{
Workouts.Remove(workout);
await workout.RemoveFrom(database_);
}
});
}
public Workouts Post([FromBody] Workouts workout)
{
workout.UserId = HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
_context.Workouts.Add(workout);
_context.SaveChanges();
return(workout);
}
// retrieve workout sets
public async Task OnGet()
{
WorkoutSets = await _db.WorkoutSets.ToListAsync();
Workouts = await _db.Workout.ToListAsync();
WorkoutSetsDisplay = new List <WorkoutSetsDisplay>();
//Workouts = await _db.Workout.ToListAsync();
// we need to also get the page count for each
// pull into a new data holder that can handle that?
int count = 0;
foreach (var wrk in WorkoutSets)
{
count = Workouts.Where(x => x.WorkoutSets.Id == wrk.Id).Count();
if (count > 0)
{
WorkoutSetsDisplay.Add(new WorkoutSetsDisplay(wrk.Id, wrk.Name, count));
}
else
{
WorkoutSetsDisplay.Add(new WorkoutSetsDisplay(wrk.Id, wrk.Name, 0));
}
}
}
public ActionResult Edit(Workouts workouts, HttpPostedFileBase Pic)
{
if (ModelState.IsValid)
{
string fileName = null;
if (Pic != null)
{
fileName = Path.GetFileName(Pic.FileName);
string extensionImage = getFileExtension(fileName);
fileName = Guid.NewGuid() + "." + extensionImage;
var path = Path.Combine(Server.MapPath("~/Content/Images/WorkoutImages"), fileName);
//var path = Path.Combine("https://disk.yandex.ru/d/DXlvv0vSsvgswQ?w=1", fileName);
Pic.SaveAs(path);
workouts.PicturePath = fileName;
}
else
{
using (SmartWorkouts_newEntities bd = new SmartWorkouts_newEntities())
{
workouts.PicturePath = bd.Workouts.Where(p => p.ID_Workout == workouts.ID_Workout).FirstOrDefault().PicturePath;
}
}
db.Entry(workouts).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Number_Premium_Workout = new SelectList(db.Premium_Works, "Number_Premium_Work", "Name_Premium_Work", workouts.Number_Premium_Workout);
ViewBag.Type_Workout = new SelectList(db.Types_Workout, "Number_Type", "Name_Type", workouts.Type_Workout);
return(View(workouts));
}
public async Task TestEditWorkoutSuccessfully()
{
using (var context = new FitTracContext(options))
{
string updateWorkoutName = "Update name of workout";
Workouts workouts1 = context.Workouts.Where(x => x.WorkoutName == workouts[0].WorkoutName).Single();
workouts1.WorkoutName = updateWorkoutName;
string updateExerciseName = "Update name of exercise";
ICollection <Exercises> tempExercises = new List <Exercises>
{
new Exercises()
{
ExerciseId = 1,
ExerciseName = updateExerciseName,
ExerciseReps = 5,
ExerciseSets = 5,
}
};
workouts1.Exercises = tempExercises;
ExercisesController exercisesController = new ExercisesController(context);
WorkoutsController workoutsController = new WorkoutsController(context, exercisesController);
IActionResult result = await workoutsController.EditWorkouts(workouts1.WorkoutId, workouts1) as IActionResult;
Assert.IsNotNull(result);
Assert.IsInstanceOfType(result, typeof(NoContentResult));
}
}
async Task ExecuteLoadItemsCommand()
{
IsBusy = true;
try
{
Workouts.Clear();
var workouts = await DataStore.GetItemsAsync(true);
foreach (var item in workouts)
{
Workouts.Add(item);
}
var exercises = await exerciseStore.GetItemsAsync(true);
foreach (var item in exercises)
{
Exercises.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
public ActionResult DeleteConfirmed(int id)
{
Workouts workouts = db.Workouts.Find(id);
db.Workouts.Remove(workouts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult TablaDatosWorkout(Workouts workout, Tracks[] tracks)
{
WorkoutTracksTablaDatosVM datosVM = new WorkoutTracksTablaDatosVM();
datosVM.workoutVM = workout;
datosVM.tracksVM = tracks;
return(View(datosVM));
}
//Populate the script lists here. Follow the example on how to add to a list
#region Populate Lists
/// <summary>
/// Use this method to populate the lists. They are already set to be selected from the
/// CycleScripts method and no other work is required.
/// </summary>
public override void PopulateLists()
{
SignIn.Clear();
AccountCreation.Clear();
Activities.Clear();
ActivityDetail.Clear();
Workouts.Clear();
Courses.Clear();
Dashboard.Clear();
Navigation.Clear();
Explore.Clear();
Reports.Clear();
Health.Clear();
Goals.Clear();
Upload.Clear();
Settings.Clear();
CheckFirmware.Clear();
ManualActivity.Clear();
Troubleshoot.Clear();
base.PopulateLists();
//MyCategory.Add(new TestCase(base.baseURL, base.webdriver, base.verificationErrors));
SignIn.Add(new Connect_SignIn(base.baseURL, base.webdriver, base.verificationErrors));
SignIn.Add(new Connect_SignInValidation(base.baseURL, base.webdriver, base.verificationErrors));
Settings.Add(new Connect_MeasurementSettings(base.baseURL, base.webdriver, base.verificationErrors));
Navigation.Add(new Connect_GeneralNavigation(base.baseURL, base.webdriver, base.verificationErrors));
Navigation.Add(new Connect_Navigation_Unauthenticated(base.baseURL, base.webdriver, base.verificationErrors));
Upload.Add(new Connect_UploadFile(base.baseURL, base.webdriver, base.verificationErrors));
Activities.Add(new Connect_ActivitiesSort(base.baseURL, base.webdriver, base.verificationErrors));
ActivityDetail.Add(new Connect_ActivityDetail_Validation(base.baseURL, base.webdriver, base.verificationErrors));
//CheckFirmware.Add(new Connect_CheckFirmware_Edge800(base.baseURL, base.webdriver, base.verificationErrors)); // Jira opened
CheckFirmware.Add(new Connect_CheckFirmware_Edge705(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_Edge605(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_FR60(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_FR405CX(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_Edge305(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_FR201(base.baseURL, base.webdriver, base.verificationErrors));
//CheckFirmware.Add(new Connect_CheckFirmware_FR210(base.baseURL, base.webdriver, base.verificationErrors)); //Test Failing
CheckFirmware.Add(new Connect_CheckFirmware_Edge500(base.baseURL, base.webdriver, base.verificationErrors));
//CheckFirmware.Add(new Connect_CheckFirmware_FR110(base.baseURL, base.webdriver, base.verificationErrors)); //Test Failing
//CheckFirmware.Add(new Connect_CheckFirmware_FR910(base.baseURL, base.webdriver, base.verificationErrors));
CheckFirmware.Add(new Connect_CheckFirmware_FR610(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_CreateGoal(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_NoGoal(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_PercentComplete(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_NoUploads(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_FiveItems(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_ActivityNameTabs(base.baseURL, base.webdriver, base.verificationErrors));
Dashboard.Add(new Connect_Dashboard_ActivityType(base.baseURL, base.webdriver, base.verificationErrors));
//Dashboard.Add(new Connect_Dashboard_FiveItems(base.baseURL, base.webdriver, base.verificationErrors)); //jira 10209
ManualActivity.Add(new Connect_ManualActivity_NameCharLimit(base.baseURL, base.webdriver, base.verificationErrors));
ManualActivity.Add(new Connect_ManualActivity_NoName(base.baseURL, base.webdriver, base.verificationErrors));
ManualActivity.Add(new Connect_ManualActivity_ActivityType(base.baseURL, base.webdriver, base.verificationErrors));
ManualActivity.Add(new Connect_ManualActivity_DescriptionLimit(base.baseURL, base.webdriver, base.verificationErrors)); //Related to Jira 10309
ManualActivity.Add(new Connect_ManualActivity_PaceCalc(base.baseURL, base.webdriver, base.verificationErrors));
}
public ActionResult Edit([Bind(Include = "WorkoutID,WorkoutName,Description,YouTubeLink")] Workouts workouts)
{
if (ModelState.IsValid)
{
db.Entry(workouts).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workouts));
}
private void LoadWorkouts()
{
Workouts.Clear();
foreach (var workout in RepoWorkout.Instance.FindAll())
{
Workouts.Add(new WorkoutVM(workout, this));
}
NotifyPropertyChanged("IsWorkoutsEmpty");
}
public ActionResult Edit([Bind(Include = "Id,WorkoutType")] Workouts workouts)
{
if (ModelState.IsValid)
{
db.Entry(workouts).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workouts));
}
private string GetCurrentWeight(Exercise exercise)
{
var lastWorkout = Workouts.Where(x => x.ExerciseId == exercise.ExerciseId).OrderBy(x => x.Created).LastOrDefault();
if (lastWorkout == null)
{
return(string.Empty);
}
return($"{WeightMetricToImperialConverter.GetWeight(lastWorkout.Weight)} {L10n.GetWeightUnit()}");
}
public ActionResult Create([Bind(Include = "WorkoutID,WorkoutName,Description,YouTubeLink")] Workouts workouts)
{
if (ModelState.IsValid)
{
db.Workouts.Add(workouts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workouts));
}
public ActionResult Create([Bind(Include = "Id,WorkoutType")] Workouts workouts)
{
if (ModelState.IsValid)
{
db.Workouts.Add(workouts);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(workouts));
}
private string GetStarted(Exercise exercise)
{
var workout = Workouts.Where(x => x.ExerciseId == exercise.ExerciseId).OrderBy(x => x.Created).FirstOrDefault();
if (workout == null)
{
return(string.Empty);
}
return
($"{workout.Created:d}, {workout.Reps} Reps {WeightMetricToImperialConverter.GetWeight(workout.Weight)} {L10n.GetWeightUnit()}");
}
public AddWorkoutViewModel(INavigation navigation)
{
_navigation = navigation;
_workout = new Workouts();
_weeksList = new ObservableRangeCollection <WeeksList>();
AddWorkoutCommand = new Command(async() => await AddWorkout());
AddCommand = new Command(async() => await Add());
AddDayCommand = new Command <WeeksList>((model) => AddDay(model));
AddExerciseCommand = new Command <DaysInWeek>((model) => AddExercise(model));
bEnableWorkoutEdit = true;
}
// receives the changed workout and updates current listview and sendable object
void ChangedWorkoutCell(WorkoutModel watchObject)
{
for (int i = 0; i < Workouts.Count; i++)
{
if (Workouts[i].Name == watchObject.Name)
{
Workouts.RemoveAt(i);
Workouts.Insert(i, watchObject);
CollectionToNewWatchModel(Workouts, globalWatchModelHold);
return;
}
}
}
private async Task DeleteWorkout()
{
if (_selectedWorkout == null)
{
return;
}
if (await _pageService.DisplayAlert("Delete workout", "You are about to permamently delete a workout!", "Delete", "Cancel"))
{
await _workoutStore.DeleteWorkout(_selectedWorkout);
Workouts.Remove(_selectedWorkout);
_selectedWorkout = null;
}
}
// GET: Workouts/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Workouts workouts = db.Workouts.Find(id);
if (workouts == null)
{
return(HttpNotFound());
}
return(View(workouts));
}
