private TUnitType GetExerciseUnit()
{
TUnitType unit = TUnitType.Metric;
if (_trainingExercise != null)
{
var trainingDayKey = new TrainingDayKey()
{
UserId = _trainingExercise.UserId,
Year = _trainingExercise.Year,
WeekOfYear = _trainingExercise.WeekOfYear,
DayOfWeek = _trainingExercise.DayOfWeek,
TrainingDayId = _trainingExercise.TrainingDayId
};
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = false
};
var trainingDay = _trainingDayService.GetTrainingDay(trainingDayKey, trainingDayScenario);
if (trainingDay != null)
{
unit = trainingDay.Unit;
}
}
return(unit);
}
internal TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
{
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Update(trainingDay, AppUtils.GetUserUnit(_userInfosService, trainingDay.UserId));
SynchroManager.TrainingDayChange(DbContext, trainingDayResult);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise)
{
var trainingExerciseCriteria = new TrainingExerciseCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
TrainingDayId = new IntegerCriteria()
{
Equal = trainingDay.TrainingDayId
}
};
var trainingExercisesDb = _trainingExercisesService.FindTrainingExercise(trainingExerciseCriteria);
if (trainingExercisesDb != null && trainingExercisesDb.Count > 0)
{
foreach (var trainingExerciseDb in trainingExercisesDb)
{
//remove only training exercises who do not present (for keep exercise tempos: retrocompatibility)
if (trainingDay.TrainingExercises == null || !trainingDay.TrainingExercises.Any(te => te.Id == trainingExerciseDb.Id))
{
_trainingExercisesService.DeleteTrainingExercise(trainingExerciseDb);
}
}
}
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List <TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(_trainingExercisesService.UpdateTrainingExercise(trainingExercise, true));
}
}
}
return(trainingDayResult);
}
public void SwitchDayOnTrainingDay(string userId, int year, int weekOfYear, int dayOfWeek, int switchDayOfWeek)
{
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
var userUnit = AppUtils.GetUserUnit(_userInfosService, userId);
//Search current training day
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria()
{
Equal = userId
},
Year = new IntegerCriteria()
{
Equal = year
},
WeekOfYear = new IntegerCriteria()
{
Equal = weekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = dayOfWeek
}
};
var currentTrainingDayList = FindTrainingDay(userUnit, trainingDayCriteria, trainingDayScenario);
trainingDayCriteria.DayOfWeek.Equal = switchDayOfWeek;
var switchTrainingDayList = FindTrainingDay(userUnit, trainingDayCriteria, trainingDayScenario);
DeleteTrainingDays(currentTrainingDayList);
DeleteTrainingDays(switchTrainingDayList);
if (currentTrainingDayList != null)
{
foreach (var trainingDay in currentTrainingDayList)
{
ChangeDayOnTrainingDay(trainingDay, switchDayOfWeek);
UpdateTrainingDay(trainingDay, trainingDayScenario);
}
}
if (switchTrainingDayList != null)
{
foreach (var trainingDay in switchTrainingDayList)
{
ChangeDayOnTrainingDay(trainingDay, dayOfWeek);
UpdateTrainingDay(trainingDay, trainingDayScenario);
}
}
}
internal TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario trainingDayScenario)
{
var trainingDay = _trainingDayModule.Get(key, AppUtils.GetUserUnit(_userInfosService, key.UserId));
if (trainingDayScenario.ManageExercise && trainingDay != null)
{
var trainingExerciseCriteria = CreateTrainingExerciseCriteria(trainingDay);
trainingDay.TrainingExercises = _trainingExercisesService.FindTrainingExercise(trainingExerciseCriteria);
}
return(trainingDay);
}
internal TrainingDay CreateTrainingDay(TrainingDay trainingDay)
{
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria()
{
Equal = trainingDay.UserId
},
Year = new IntegerCriteria()
{
Equal = trainingDay.Year
},
WeekOfYear = new IntegerCriteria()
{
Equal = trainingDay.WeekOfYear
},
DayOfWeek = new IntegerCriteria()
{
Equal = trainingDay.DayOfWeek
},
};
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = false
};
var trainingDayList = FindTrainingDay(AppUtils.GetUserUnit(_userInfosService, trainingDay.UserId), trainingDayCriteria, trainingDayScenario);
int trainingDayId = 1;
if (trainingDayList != null && trainingDayList.Count > 0)
{
trainingDayId = trainingDayList.Max(td => td.TrainingDayId) + 1;
}
trainingDay.TrainingDayId = trainingDayId;
// no need transaction, only header
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Create(trainingDay, AppUtils.GetUserUnit(_userInfosService, trainingDay.UserId));
SynchroManager.TrainingDayChange(DbContext, trainingDayResult);
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List <TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(_trainingExercisesService.CreateTrainingExercise(trainingExercise));
}
}
return(trainingDayResult);
}
private static void UpdateTrainingDayModificationDate(ApplicationDbContext dbContext, DateTime modificationDate, TrainingDayKey trainingDayKey)
{
var trainingDaysService = WebAppConfiguration.ServiceProvider.GetService<ITrainingDaysService>();
((BodyReportService)trainingDaysService).SetDbContext(dbContext);
var scenario = new TrainingDayScenario() { ManageExercise = false };
var trainingDay = trainingDaysService.GetTrainingDay(trainingDayKey, scenario);
if(trainingDay != null && trainingDay.ModificationDate != null && modificationDate != null &&
(modificationDate - trainingDay.ModificationDate).TotalSeconds > 2) // don't spam database
{
trainingDaysService.UpdateTrainingDay(trainingDay, scenario);
}
}
public IActionResult Get(TrainingDayKey trainingDayKey, TrainingDayScenario trainingDayScenario)
{
try
{
if (trainingDayKey == null || trainingDayScenario == null)
{
return(BadRequest());
}
var trainingday = _trainingDaysService.GetTrainingDay(trainingDayKey, trainingDayScenario);
return(new OkObjectResult(trainingday));
}
catch (Exception exception)
{
return(BadRequest(new WebApiException("Error", exception)));
}
}
private async Task EditActionAsync(BindingTrainingExercise bindingTrainingExercise)
{
if (bindingTrainingExercise == null || bindingTrainingExercise.TrainingExercise == null)
{
return;
}
try
{
var trainingExercise = bindingTrainingExercise.TrainingExercise;
var editTrainingExerciseViewModelResult = await EditTrainingExerciseViewModel.ShowAsync(trainingExercise, this);
if (editTrainingExerciseViewModelResult != null && editTrainingExerciseViewModelResult.Result)
{
var trainingDayKey = new TrainingDayKey()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear,
DayOfWeek = trainingExercise.DayOfWeek,
TrainingDayId = trainingExercise.TrainingDayId
};
var trainingDay = _trainingDays.Where(t => TrainingDayKey.IsEqualByKey(t, trainingDayKey)).FirstOrDefault();
if (trainingDay != null)
{
var indexOfTrainingDay = _trainingDays.IndexOf(trainingDay);
//Reload local data
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
trainingDay = _trainingDayService.GetTrainingDay(trainingDayKey, trainingDayScenario);
//Update trainingDay in list
_trainingDays[indexOfTrainingDay] = trainingDay;
//Update UI
CreateOrReplaceBindingTrainingDay(trainingDay);
}
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to edit training exercise set", except);
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
public void DeleteTrainingDay(TrainingDayKey key)
{
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
var trainingDay = GetTrainingDay(key, trainingDayScenario);
if (trainingDay != null)
{
_trainingDayModule.Delete(trainingDay);
SynchroManager.TrainingDayChange(DbContext, trainingDay, true);
if (trainingDay.TrainingExercises != null)
{
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
_trainingWeeksService.DeleteTrainingExercise(trainingExercise);
}
}
}
}
private void DeleteTrainingDays(List <TrainingDay> trainingDays)
{
TrainingDay trainingDay;
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
if (trainingDays == null)
{
return;
}
foreach (var trainingDayKey in trainingDays)
{
trainingDay = GetTrainingDay(trainingDayKey, trainingDayScenario);
if (trainingDay != null)
{
DeleteTrainingDay(trainingDay);
}
}
}
public void DeleteTrainingDay(TrainingDayKey key)
{
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
var trainingDay = GetTrainingDay(key, trainingDayScenario);
if (trainingDay != null)
{
_trainingDayModule.Delete(trainingDay);
SynchroManager.TrainingDayChange(DbContext, trainingDay, true);
if (trainingDay.TrainingExercises != null)
{
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
_trainingExercisesService.DeleteTrainingExercise(trainingExercise);
}
}
}
}
public void SwitchDayOnTrainingDay(string userId, int year, int weekOfYear, int dayOfWeek, int switchDayOfWeek)
{
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
//Search current training day
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria() { Equal = userId },
Year = new IntegerCriteria() { Equal = year },
WeekOfYear = new IntegerCriteria() { Equal = weekOfYear },
DayOfWeek = new IntegerCriteria() { Equal = dayOfWeek }
};
var currentTrainingDayList = FindTrainingDay(trainingDayCriteria, trainingDayScenario);
trainingDayCriteria.DayOfWeek.Equal = switchDayOfWeek;
var switchTrainingDayList = FindTrainingDay(trainingDayCriteria, trainingDayScenario);
DeleteTrainingDays(currentTrainingDayList);
DeleteTrainingDays(switchTrainingDayList);
if (currentTrainingDayList != null)
{
foreach (var trainingDay in currentTrainingDayList)
{
ChangeDayOnTrainingDay(trainingDay, switchDayOfWeek);
UpdateTrainingDay(trainingDay, trainingDayScenario);
}
}
if (switchTrainingDayList != null)
{
foreach (var trainingDay in switchTrainingDayList)
{
ChangeDayOnTrainingDay(trainingDay, dayOfWeek);
UpdateTrainingDay(trainingDay, trainingDayScenario);
}
}
}
private void CompleteTrainingWeekWithTrainingDay(TrainingWeek trainingWeek, TrainingDayScenario trainingDayScenario)
{
if (trainingWeek != null)
{
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria() { Equal = trainingWeek.UserId },
Year = new IntegerCriteria() { Equal = trainingWeek.Year },
WeekOfYear = new IntegerCriteria() { Equal = trainingWeek.WeekOfYear },
};
trainingWeek.TrainingDays = _trainingDaysService.FindTrainingDay(trainingDayCriteria, trainingDayScenario);
}
}
internal TrainingWeek UpdateTrainingWeek(TrainingWeek trainingWeek, TrainingWeekScenario trainingWeekScenario)
{
TrainingWeek trainingWeekResult = null;
trainingWeekResult = _trainingWeekModule.Update(trainingWeek);
if (trainingWeekScenario != null && trainingWeekScenario.ManageTrainingDay)
{
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria() { Equal = trainingWeek.UserId },
Year = new IntegerCriteria() { Equal = trainingWeek.Year },
WeekOfYear = new IntegerCriteria() { Equal = trainingWeek.WeekOfYear }
};
var trainingDaysDb = _trainingDaysService.FindTrainingDay(trainingDayCriteria, trainingDayScenario);
if (trainingDaysDb != null && trainingDaysDb.Count > 0)
{
foreach (var trainingDayDb in trainingDaysDb)
_trainingDaysService.DeleteTrainingDay(trainingDayDb);
}
if (trainingWeek.TrainingDays != null)
{
trainingWeekResult.TrainingDays = new List<TrainingDay>();
foreach (var trainingDay in trainingWeek.TrainingDays)
{
trainingWeekResult.TrainingDays.Add(_trainingDaysService.UpdateTrainingDay(trainingDay, trainingWeekScenario.TrainingDayScenario));
}
}
}
return trainingWeekResult;
}
public List<TrainingDay> FindTrainingDay(TrainingDayCriteria trainingDayCriteria, TrainingDayScenario trainingDayScenario)
{
return GetTrainingDayManager().FindTrainingDay(trainingDayCriteria, trainingDayScenario);
}
private void DeleteTrainingDays(List<TrainingDay> trainingDays)
{
TrainingDay trainingDay;
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
if (trainingDays == null)
return;
foreach (var trainingDayKey in trainingDays)
{
trainingDay = GetTrainingDay(trainingDayKey, trainingDayScenario);
if (trainingDay != null)
DeleteTrainingDay(trainingDay);
}
}
internal TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
{
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Update(trainingDay);
SynchroManager.TrainingDayChange(DbContext, trainingDayResult);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise)
{
var trainingExerciseCriteria = new TrainingExerciseCriteria()
{
UserId = new StringCriteria() { Equal = trainingDay.UserId },
Year = new IntegerCriteria() { Equal = trainingDay.Year },
WeekOfYear = new IntegerCriteria() { Equal = trainingDay.WeekOfYear },
DayOfWeek = new IntegerCriteria() { Equal = trainingDay.DayOfWeek },
TrainingDayId = new IntegerCriteria() { Equal = trainingDay.TrainingDayId }
};
var trainingExercisesDb = _trainingWeeksService.FindTrainingExercise(trainingExerciseCriteria);
if (trainingExercisesDb != null && trainingExercisesDb.Count > 0)
{
foreach(var trainingExerciseDb in trainingExercisesDb)
{
//remove only training exercises who do not present (for keep exercise tempos: retrocompatibility)
if (trainingDay.TrainingExercises == null || !trainingDay.TrainingExercises.Any(te => te.Id == trainingExerciseDb.Id))
_trainingWeeksService.DeleteTrainingExercise(trainingExerciseDb);
}
}
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List<TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(_trainingWeeksService.UpdateTrainingExercise(trainingExercise, true));
}
}
}
return trainingDayResult;
}
public IActionResult AddTrainingExercises(TrainingExercisesViewModel viewModel, string buttonType)
{
if (IncorrectHttpData(viewModel.UserId, viewModel.Year, viewModel.WeekOfYear, viewModel.DayOfWeek, viewModel.TrainingDayId))
return View(viewModel);
bool displayMessage = buttonType == "submit";
int currentMuscularGroupId = 0, currentMuscleId = 0;
if (viewModel != null)
{
currentMuscularGroupId = viewModel.MuscularGroupId;
currentMuscleId = viewModel.MuscleId;
}
List<BodyExercise> bodyExerciseList;
InsertViewBagOnEditTrainingExercise(out bodyExerciseList, currentMuscularGroupId, currentMuscleId);
ModelState.Clear();
if (ModelState.IsValid)
{
if(viewModel.BodyExerciseList != null)
{ // filter selected data with existing exercise
if (bodyExerciseList == null)
viewModel.BodyExerciseList = null;
else
{
var deleteList = new List<SelectBodyExercise>();
foreach(var selectBodyExercise in viewModel.BodyExerciseList)
{
if(bodyExerciseList.FirstOrDefault(c => c.Id == selectBodyExercise.Id) == null)
{
deleteList.Add(selectBodyExercise);
}
}
foreach (var selectBodyExercise in deleteList)
{
viewModel.BodyExerciseList.Remove(selectBodyExercise);
}
}
}
if (viewModel.BodyExerciseList == null || viewModel.BodyExerciseList.Count(b => b.Selected == true) == 0)
{
CopyViewBagBodyExerciseToViewModel(viewModel, bodyExerciseList);
if (displayMessage)
ModelState.AddModelError(string.Empty, string.Format(Translation.THE_P0_FIELD_IS_REQUIRED, Translation.BODY_EXERCISES));
return View(viewModel);
}
var trainingDayKey = new TrainingDayKey() { UserId = viewModel.UserId, Year = viewModel.Year, WeekOfYear = viewModel.WeekOfYear, DayOfWeek = viewModel.DayOfWeek, TrainingDayId = viewModel.TrainingDayId };
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
var trainingDay = _trainingDaysService.GetTrainingDay(trainingDayKey, trainingDayScenario);
if(trainingDay == null)
{
CopyViewBagBodyExerciseToViewModel(viewModel, bodyExerciseList);
ModelState.AddModelError(string.Empty, string.Format(Translation.P0_NOT_EXIST, Translation.TRAINING_DAY));
return View(viewModel);
}
if (trainingDay.TrainingExercises == null)
trainingDay.TrainingExercises = new List<TrainingExercise>();
int bodyExerciseCount = trainingDay.TrainingExercises.Count;
int maxId = 1;
if (bodyExerciseCount > 0)
maxId = trainingDay.TrainingExercises.Max(t => t.Id) + 1;
TrainingExercise trainingExercise;
var bodyExerciseSelectedList = viewModel.BodyExerciseList.Where(b => b.Selected == true);
foreach (var bodyExercise in bodyExerciseSelectedList)
{
//Only manage add in this page
trainingExercise = new TrainingExercise()
{
UserId = viewModel.UserId,
Year = viewModel.Year,
WeekOfYear = viewModel.WeekOfYear,
DayOfWeek = viewModel.DayOfWeek,
TrainingDayId = viewModel.TrainingDayId,
Id = maxId,
BodyExerciseId = bodyExercise.Id,
RestTime = 0,
EccentricContractionTempo = 1,
StretchPositionTempo = 0,
ConcentricContractionTempo = 1,
ContractedPositionTempo = 0
};
trainingDay.TrainingExercises.Add(trainingExercise);
maxId++;
}
if(bodyExerciseCount != trainingDay.TrainingExercises.Count)
{ //data changed
_trainingDaysService.UpdateTrainingDay(trainingDay, trainingDayScenario);
}
return GetViewActionResult(viewModel.UserId, viewModel.Year, viewModel.WeekOfYear, viewModel.DayOfWeek);
}
CopyViewBagBodyExerciseToViewModel(viewModel, bodyExerciseList);
return View(viewModel);
}
public IActionResult EditTrainingDay(TrainingDayViewModel viewModel)
{
if (ModelState.IsValid)
{
if (string.IsNullOrWhiteSpace(viewModel.UserId) || viewModel.Year == 0 || viewModel.WeekOfYear == 0 ||
viewModel.DayOfWeek < 0 || viewModel.DayOfWeek > 6 || viewModel.TrainingDayId == 0 || SessionUserId != viewModel.UserId)
return View(viewModel);
//Verify valide week of year
if (viewModel.WeekOfYear > 0 && viewModel.WeekOfYear <= 52)
{
var trainingDay = ControllerUtils.TransformViewModelToTrainingDay(viewModel);
var key = new TrainingDayKey()
{
UserId = trainingDay.UserId,
Year = trainingDay.Year,
WeekOfYear = trainingDay.WeekOfYear,
DayOfWeek = trainingDay.DayOfWeek,
TrainingDayId = trainingDay.TrainingDayId
};
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = false };
var foundTrainingDay = _trainingDaysService.GetTrainingDay(key, trainingDayScenario);
if (foundTrainingDay == null) // no data found
{
ModelState.AddModelError(string.Empty, string.Format(Translation.P0_NOT_EXIST, Translation.TRAINING_DAY));
return View(viewModel);
}
trainingDay = _trainingDaysService.UpdateTrainingDay(trainingDay, trainingDayScenario);
if (trainingDay != null)
{
return RedirectToAction("View", new { userId = trainingDay.UserId, year = trainingDay.Year, weekOfYear = trainingDay.WeekOfYear, dayOfWeekSelected = trainingDay.DayOfWeek });
}
}
}
return View(viewModel);
}
private async Task TrainingDayOrderActionAsync(BindingTrainingExercise bindingTrainingExercise, bool up)
{
if (bindingTrainingExercise == null || bindingTrainingExercise.TrainingExercise == null)
{
return;
}
try
{
var trainingExercise = bindingTrainingExercise.TrainingExercise;
var trainingDayKey = new TrainingDayKey()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear,
DayOfWeek = trainingExercise.DayOfWeek,
TrainingDayId = trainingExercise.TrainingDayId
};
var trainingDay = _trainingDays.Where(t => TrainingDayKey.IsEqualByKey(t, trainingDayKey)).FirstOrDefault();
var indexOfTrainingDay = _trainingDays.IndexOf(trainingDay);
if (trainingDay != null)
{
var indexOf = trainingDay.TrainingExercises.IndexOf(trainingExercise);
if (up && indexOf > 0)
{ //up
trainingDay.TrainingExercises.Remove(trainingExercise);
trainingDay.TrainingExercises.Insert(indexOf - 1, trainingExercise);
}
if (!up && indexOf < (trainingDay.TrainingExercises.Count - 1))
{ //down
trainingDay.TrainingExercises.Remove(trainingExercise);
trainingDay.TrainingExercises.Insert(indexOf + 1, trainingExercise);
}
indexOf = 1;
foreach (var trainingExerciseTmp in trainingDay.TrainingExercises)
{
trainingExerciseTmp.Id = indexOf;
indexOf++;
}
//Save in server
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
trainingDay = await TrainingDayWebService.UpdateTrainingDayAsync(trainingDay, trainingDayScenario);
//Save in local database
_trainingDayService.UpdateTrainingDay(trainingDay, trainingDayScenario);
//Update trainingDay in list
_trainingDays[indexOfTrainingDay] = trainingDay;
//Update UI
CreateOrReplaceBindingTrainingDay(trainingDay);
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to order exercise", except);
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
public IActionResult Get(TrainingDayKey trainingDayKey, TrainingDayScenario trainingDayScenario)
{
try
{
if (trainingDayKey == null || trainingDayScenario == null)
return BadRequest();
var trainingday = _trainingDaysService.GetTrainingDay(trainingDayKey, trainingDayScenario);
return new OkObjectResult(trainingday);
}
catch (Exception exception)
{
return BadRequest(new WebApiException("Error", exception));
}
}
public IActionResult DeleteTrainingDay(string userId, int year, int weekOfYear, int dayOfWeek, int trainingDayId, bool confirmation = false)
{
if (string.IsNullOrWhiteSpace(userId) || year == 0 || weekOfYear == 0 || dayOfWeek < 0 || dayOfWeek > 6 || trainingDayId == 0 || SessionUserId != userId)
return RedirectToAction("Index");
if (confirmation)
{
var actionResult = RedirectToAction("View", "TrainingJournal", new { Area = "User", userId = userId, year = year, weekOfYear = weekOfYear, dayOfWeekSelected = dayOfWeek });
var key = new TrainingDayKey()
{
UserId = userId,
Year = year,
WeekOfYear = weekOfYear,
DayOfWeek = dayOfWeek,
TrainingDayId = trainingDayId
};
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
var trainingDay = _trainingDaysService.GetTrainingDay(key, trainingDayScenario);
if (trainingDay == null)
return actionResult;
_trainingDaysService.DeleteTrainingDay(trainingDay);
return actionResult;
}
else
{
string title = Translation.TRAINING_DAY;
string message = Translation.ARE_YOU_SURE_YOU_WANNA_DELETE_THIS_ELEMENT_PI;
string returnUrlYes = Url.Action("DeleteTrainingDay", "TrainingJournal", new { Area = "User", userId = userId, year = year, weekOfYear = weekOfYear, dayOfWeek = dayOfWeek, trainingDayId = trainingDayId, confirmation = true });
string returnUrlNo = Url.Action("View", "TrainingJournal", new { Area = "User", userId = userId, year = year, weekOfYear = weekOfYear, dayOfWeekSelected = dayOfWeek });
return RedirectToAction("Confirm", "Message", new { Area = "Site", title = title, message = message, returnUrlYes = returnUrlYes, returnUrlNo = returnUrlNo });
}
}
public IActionResult CreateTrainingDay(string userId, int year, int weekOfYear, int dayOfWeek)
{
if (string.IsNullOrWhiteSpace(userId) || year == 0 || weekOfYear == 0 || dayOfWeek < 0 || dayOfWeek > 6 || SessionUserId != userId)
return RedirectToAction("Index");
var userInfo = _userInfosService.GetUserInfo(new UserInfoKey() { UserId = SessionUserId });
if (userInfo == null)
return RedirectToAction("View", new { userId = userId, year = year, weekOfYear = weekOfYear, dayOfWeek = dayOfWeek });
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria() { Equal = userId },
Year = new IntegerCriteria() { Equal = year },
WeekOfYear = new IntegerCriteria() { Equal = weekOfYear }
};
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = false
};
var trainingDayList = _trainingDaysService.FindTrainingDay(trainingDayCriteria, trainingDayScenario);
int trainingDayId = 0;
if (trainingDayList != null && trainingDayList.Count > 0)
trainingDayId = trainingDayList.Max(td => td.TrainingDayId) + 1;
var trainingDay = new TrainingDay()
{
UserId = userId,
Year = year,
WeekOfYear = weekOfYear,
DayOfWeek = dayOfWeek,
TrainingDayId = trainingDayId
};
ViewBag.UserUnit = userInfo.Unit;
return View(TrainingViewModelTransformer.TrainingDayToViewModel(trainingDay, userInfo));
}
public TrainingDay UpdateTrainingDay(TrainingDay trainingDay, TrainingDayScenario trainingDayScenario)
{
TrainingDay result = null;
BeginTransaction();
try
{
result = GetTrainingDayManager().UpdateTrainingDay(trainingDay, trainingDayScenario);
CommitTransaction();
}
catch (Exception exception)
{
_logger.LogCritical("Unable to update training day", exception);
RollbackTransaction();
throw exception;
}
finally
{
EndTransaction();
}
return result;
}
internal TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario trainingDayScenario)
{
var trainingDay = _trainingDayModule.Get(key);
if (trainingDayScenario.ManageExercise && trainingDay != null)
{
CompleteTrainingDayWithExercise(trainingDay);
}
return trainingDay;
}
internal TrainingDay CreateTrainingDay(TrainingDay trainingDay)
{
var trainingDayCriteria = new TrainingDayCriteria()
{
UserId = new StringCriteria() { Equal = trainingDay.UserId },
Year = new IntegerCriteria() { Equal = trainingDay.Year },
WeekOfYear = new IntegerCriteria() { Equal = trainingDay.WeekOfYear },
DayOfWeek = new IntegerCriteria() { Equal = trainingDay.DayOfWeek },
};
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = false
};
var trainingDayList = FindTrainingDay(trainingDayCriteria, trainingDayScenario);
int trainingDayId = 1;
if (trainingDayList != null && trainingDayList.Count > 0)
{
trainingDayId = trainingDayList.Max(td => td.TrainingDayId) + 1;
}
trainingDay.TrainingDayId = trainingDayId;
// no need transaction, only header
TrainingDay trainingDayResult = null;
trainingDayResult = _trainingDayModule.Create(trainingDay);
SynchroManager.TrainingDayChange(DbContext, trainingDayResult);
if (trainingDay.TrainingExercises != null)
{
trainingDayResult.TrainingExercises = new List<TrainingExercise>();
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingDayResult.TrainingExercises.Add(_trainingWeeksService.CreateTrainingExercise(trainingExercise));
}
}
return trainingDayResult;
}
public TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario trainingDayScenario)
{
return GetTrainingDayManager().GetTrainingDay(key, trainingDayScenario);
}
public IActionResult EditTrainingDay(string userId, int year, int weekOfYear, int dayOfWeek, int trainingDayId)
{
if (string.IsNullOrWhiteSpace(userId) || year == 0 || weekOfYear == 0 || dayOfWeek < 0 || dayOfWeek > 6 || trainingDayId == 0 || SessionUserId != userId)
return RedirectToAction("Index");
var key = new TrainingDayKey()
{
UserId = userId,
Year = year,
WeekOfYear = weekOfYear,
DayOfWeek = dayOfWeek,
TrainingDayId = trainingDayId
};
var trainingDayScenario = new TrainingDayScenario() { ManageExercise = true };
var trainingDay = _trainingDaysService.GetTrainingDay(key, trainingDayScenario);
if (trainingDay == null) // no data found
return RedirectToAction("View", new { userId = userId, year = year, weekOfYear = weekOfYear, dayOfWeek = dayOfWeek });
var userInfo = _userInfosService.GetUserInfo(new UserInfoKey() { UserId = SessionUserId });
if (userInfo == null)
userInfo = new UserInfo();
return View(TrainingViewModelTransformer.TrainingDayToViewModel(trainingDay, userInfo));
}
internal List<TrainingDay> FindTrainingDay(TrainingDayCriteria trainingDayCriteria, TrainingDayScenario trainingDayScenario)
{
var trainingDays = _trainingDayModule.Find(trainingDayCriteria);
if (trainingDayScenario != null && trainingDayScenario.ManageExercise && trainingDays != null)
{
foreach (var trainingDay in trainingDays)
{
CompleteTrainingDayWithExercise(trainingDay);
}
}
return trainingDays;
}
