private async Task DeleteTrainingDayActionAsync(TrainingDay trainingDay)
{
if (trainingDay == null)
{
return;
}
try
{
if (await _userDialog.ConfirmAsync(string.Format(Translation.Get(TRS.ARE_YOU_SURE_YOU_WANNA_DELETE_THIS_ELEMENT_PI), Translation.Get(TRS.TRAINING_DAY)),
Translation.Get(TRS.QUESTION), Translation.Get(TRS.YES), Translation.Get(TRS.NO)))
{
//Delete on server
if (await TrainingDayWebService.DeleteTrainingDayAsync(trainingDay))
{
//Delete on local
_trainingDayService.DeleteTrainingDay(trainingDay);
//Binding trainingDay for refresh view
_trainingDays.Remove(trainingDay);
var collection = GroupedTrainingExercises.Where(lgte => TrainingDayKey.IsEqualByKey((TrainingDay)lgte.ReferenceObject, trainingDay)).FirstOrDefault();
if (collection != null)
{
GroupedTrainingExercises.Remove(collection);
}
}
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to delete training day", except);
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
public IActionResult Delete([FromBody] TrainingDayKey trainingDayKey)
{
try
{
if (trainingDayKey == null || string.IsNullOrWhiteSpace(trainingDayKey.UserId) || trainingDayKey.Year == 0)
{
return(BadRequest());
}
//Verify valid week of year
if (trainingDayKey.WeekOfYear > 0 && trainingDayKey.WeekOfYear <= 52)
{
_trainingDaysService.DeleteTrainingDay(trainingDayKey);
return(new OkObjectResult(true)); // Boolean
}
else
{
return(BadRequest());
}
}
catch (Exception exception)
{
return(BadRequest(new WebApiException("Error", exception)));
}
}
private void CreateOrReplaceBindingTrainingDay(TrainingDay trainingDay)
{
var newGroupedTrainingExercises = PopulateBindingTrainingDay(trainingDay);
var collection = GroupedTrainingExercises.Where(lgte => TrainingDayKey.IsEqualByKey((TrainingDay)lgte.ReferenceObject, trainingDay)).FirstOrDefault();
if (collection == null)
{
collection = new GenericGroupModelCollection <BindingTrainingExercise>();
GroupedTrainingExercises.Add(newGroupedTrainingExercises);
}
else
{
int indexOf = GroupedTrainingExercises.IndexOf(collection);
if (indexOf == -1)
{
return;
}
GroupedTrainingExercises[indexOf] = newGroupedTrainingExercises;
}
if (newGroupedTrainingExercises != null && newGroupedTrainingExercises.Count > 0)
{
List <BindingTrainingExercise> bindingList = new List <BindingTrainingExercise>();
bindingList.AddRange(newGroupedTrainingExercises);
Task t = CachingImagesAsync(bindingList);
}
}
public IActionResult CopyDay([FromBody] CopyDayParameter copyDayParameter)
{
if (copyDayParameter == null || copyDayParameter.TrainingDayKey == null)
{
return(BadRequest());
}
try
{
TrainingDayKey trainingDayKey = copyDayParameter.TrainingDayKey;
int copyDayOfWeek = copyDayParameter.CopyDayOfWeek;
if (trainingDayKey == null || string.IsNullOrWhiteSpace(trainingDayKey.UserId) ||
trainingDayKey.Year == 0 || trainingDayKey.WeekOfYear == 0 || trainingDayKey.DayOfWeek < 0 || trainingDayKey.DayOfWeek > 6 ||
copyDayOfWeek < 0 || copyDayOfWeek > 6 || SessionUserId != trainingDayKey.UserId)
{
return(BadRequest());
}
_trainingDaysService.CopyDayOnTrainingDay(trainingDayKey.UserId, trainingDayKey.Year, trainingDayKey.WeekOfYear, trainingDayKey.DayOfWeek, copyDayOfWeek);
return(new OkObjectResult(true)); //bool
}
catch (Exception exception)
{
return(BadRequest(new WebApiException("Error", exception)));
};
}
public static void TrainingExerciseChange(ApplicationDbContext dbContext, TrainingExercise trainingExercise, bool deleted = false)
{
if (trainingExercise == null || (!deleted && trainingExercise.ModificationDate == null))
{
return;
}
var trainingDayKey = new TrainingDayKey()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear,
DayOfWeek = trainingExercise.DayOfWeek,
TrainingDayId = trainingExercise.TrainingDayId
};
var modificationDate = deleted ? Utils.DateTimeWithoutMs : trainingExercise.ModificationDate;
UpdateTrainingDayModificationDate(dbContext, modificationDate, trainingDayKey);
var trainingWeekKey = new TrainingWeekKey()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear
};
UpdateTrainingWeekModificationDate(dbContext, modificationDate, trainingWeekKey);
}
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);
}
public async Task CopyTrainingDayActionAsync(DayOfWeek dayOfWeek)
{
if (TrainingWeek == null)
{
return;
}
try
{
var trainingDayKey = new TrainingDayKey()
{
UserId = TrainingWeek.UserId,
Year = TrainingWeek.Year,
WeekOfYear = TrainingWeek.WeekOfYear,
DayOfWeek = (int)dayOfWeek
};
List <GenericData> datas = new List <GenericData>();
foreach (DayOfWeek dayOfWeekTmp in Enum.GetValues(typeof(DayOfWeek)))
{
if (dayOfWeekTmp != dayOfWeek)
{
datas.Add(new GenericData()
{
Tag = (int)dayOfWeekTmp, Name = Translation.Get(dayOfWeekTmp.ToString().ToUpper())
});
}
}
var result = await ListViewModel.ShowGenericListAsync(Translation.Get(TRS.DAY_OF_WEEK), datas, null, this);
if (result.Validated && result.SelectedData != null)
{
int dayOfWeekSelected = (int)result.SelectedData.Tag;
//Copy day on server
await TrainingDayWebService.CopyDayOfTrainingDay(trainingDayKey, dayOfWeekSelected);
//Reload updated TrainingWeek on server
var updatedTrainingWeek = await TrainingWeekWebService.GetTrainingWeekAsync(TrainingWeek, true);
if (updatedTrainingWeek != null)
{
var trainingWeekService = new TrainingWeekService(DbContext);
var trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true
};
trainingWeekService.UpdateTrainingWeek(updatedTrainingWeek, trainingWeekScenario);
//Update UI
TrainingWeek = updatedTrainingWeek;
await SynchronizeDataAsync();
}
}
}
catch (Exception except)
{
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
internal TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario scenario)
{
var trainingDay = _trainingDayModule.Get(key, AppUtils.GetUserUnit(_userInfosService, key.UserId));
if (scenario != null && scenario.ManageExercise && trainingDay != null)
{
CompleteTrainingDayWithExercise(trainingDay);
}
return(trainingDay);
}
internal TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario scenario)
{
var trainingDay = _trainingDayModule.Get(key);
if (scenario != null && scenario.ManageExercise && trainingDay != null)
{
CompleteTrainingDayWithExercise(trainingDay);
}
return(trainingDay);
}
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 static async Task <bool> CopyDayOfTrainingDay(TrainingDayKey trainingDayKey, int copyDayOfWeek)
{
if (trainingDayKey == null)
{
return(false);
}
var copyDayParameter = new CopyDayParameter()
{
TrainingDayKey = trainingDayKey,
CopyDayOfWeek = copyDayOfWeek
};
return(await HttpConnector.Instance.PostAsync <CopyDayParameter, bool>("Api/TrainingDays/CopyDay", copyDayParameter));
}
internal static async Task <bool> SwitchDayOfTrainingDay(TrainingDayKey trainingDayKey, int switchDayOfWeek)
{
if (trainingDayKey == null)
{
return(false);
}
var switchDayParameter = new SwitchDayParameter()
{
TrainingDayKey = trainingDayKey,
SwitchDayOfWeek = switchDayOfWeek
};
return(await HttpConnector.Instance.PostAsync <SwitchDayParameter, bool>("Api/TrainingDays/SwitchDay", switchDayParameter));
}
public static async Task <SelectTrainingExercisesViewModelResut> ShowAsync(TrainingDayKey trainingDayKey, BaseViewModel parent = null, ValidateInputDataDelegate onValidateInputData = null)
{
var selectTrainingExercisesViewModelResut = new SelectTrainingExercisesViewModelResut();
var viewModel = new SelectTrainingExercisesViewModel();
viewModel._onValidateInputData = onValidateInputData;
viewModel._trainingDayKey = trainingDayKey;
if (await ShowModalViewModelAsync(viewModel, parent))
{
selectTrainingExercisesViewModelResut.Result = true;
selectTrainingExercisesViewModelResut.BodyExerciseList = viewModel.SelectedBodyExerciseList;
}
viewModel._onValidateInputData = null;
return(selectTrainingExercisesViewModelResut);
}
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 static async Task <TrainingDay> GetTrainingDayAsync(TrainingDayKey key, TrainingDayScenario trainingDayScenario)
{
if (key == null || trainingDayScenario == null)
{
return(null);
}
Dictionary <string, string> datas = new Dictionary <string, string>();
datas.Add("UserId", key.UserId);
datas.Add("Year", key.Year.ToString());
datas.Add("WeekOfYear", key.WeekOfYear.ToString());
datas.Add("DayOfWeek", key.DayOfWeek.ToString());
datas.Add("TrainingDayId", key.TrainingDayId.ToString());
datas.Add("ManageExercise", trainingDayScenario.ManageExercise.ToString());
return(await HttpConnector.Instance.GetAsync <TrainingDay>("Api/TrainingDays/Get", datas));
}
/// <summary>
/// Delete data in database
/// </summary>
/// <param name="key">Primary Key</param>
public void Delete(TrainingDayKey key)
{
if (key == null || string.IsNullOrWhiteSpace(key.UserId) || key.Year == 0 ||
key.WeekOfYear == 0 || key.DayOfWeek < 0 || key.DayOfWeek > 6 || key.TrainingDayId == 0)
{
return;
}
var row = _dbContext.Table <TrainingDayRow>().Where(t => t.UserId == key.UserId && t.Year == key.Year &&
t.WeekOfYear == key.WeekOfYear && t.DayOfWeek == key.DayOfWeek &&
t.TrainingDayId == key.TrainingDayId).FirstOrDefault();
if (row != null)
{
_dbContext.Delete(row);
}
}
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)
{
BeginTransaction();
try
{
GetTrainingDayManager().DeleteTrainingDay(key);
CommitTransaction();
}
catch (Exception exception)
{
_logger.LogCritical("Unable to delete training day", exception);
RollbackTransaction();
throw exception;
}
finally
{
EndTransaction();
}
}
/// <summary>
/// Get data in database
/// </summary>
/// <param name="key">Primary Key</param>
/// <returns>read data</returns>
public TrainingDay Get(TrainingDayKey key, TUnitType userUnit)
{
if (key == null || string.IsNullOrWhiteSpace(key.UserId) ||
key.Year == 0 || key.WeekOfYear == 0 || key.DayOfWeek < 0 || key.DayOfWeek > 6 || key.TrainingDayId == 0)
{
return(null);
}
var row = _dbContext.TrainingDay.Where(t => t.UserId == key.UserId &&
t.Year == key.Year &&
t.WeekOfYear == key.WeekOfYear &&
t.DayOfWeek == key.DayOfWeek &&
t.TrainingDayId == key.TrainingDayId).FirstOrDefault();
if (row != null)
{
return(TrainingDayTransformer.ToBean(row, userUnit));
}
return(null);
}
public TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario scenario)
{
TrainingDay result = null;
BeginTransaction();
try
{
result = GetTrainingDayManager().GetTrainingDay(key, scenario);
CommitTransaction();
}
catch
{
RollbackTransaction();
throw;
}
finally
{
EndTransaction();
}
return(result);
}
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);
}
}
}
}
internal void DeleteTrainingDay(TrainingDayKey key)
{
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
var trainingDay = GetTrainingDay(key, trainingDayScenario);
if (trainingDay != null)
{
_trainingDayModule.Delete(trainingDay);
if (trainingDay.TrainingExercises != null)
{
var trainingExerciseService = new TrainingExerciseService(DbContext);
foreach (var trainingExercise in trainingDay.TrainingExercises)
{
trainingExerciseService.DeleteTrainingExercise(trainingExercise);
}
}
}
}
private async Task ValidateActionAsync()
{
try
{
if (BindingTrainingExerciseSetReps != null && BindingTrainingExerciseSetReps.Count > 0 &&
_trainingExercise != null)
{
var trainingExercise = _trainingExercise.Clone();
if (trainingExercise.TrainingExerciseSets == null)
{
trainingExercise.TrainingExerciseSets = new List <TrainingExerciseSet>();
}
else
{
trainingExercise.TrainingExerciseSets.Clear(); // empty sets for replacing
}
trainingExercise.RestTime = RestTime; // don't forget restime...
trainingExercise.EccentricContractionTempo = EccentricContractionTempo;
trainingExercise.StretchPositionTempo = StretchPositionTempo;
trainingExercise.ConcentricContractionTempo = ConcentricContractionTempo;
trainingExercise.ContractedPositionTempo = ContractedPositionTempo;
int nbSet = 0, currentRepValue = 0;
var tupleSetRepList = new List <Tuple <int, int, double> >();
int repValue;
double weightValue, currentWeightValue = 0;
for (int i = 0; i < BindingTrainingExerciseSetReps.Count; i++)
{
repValue = BindingTrainingExerciseSetReps[i].Reps;
weightValue = BindingTrainingExerciseSetReps[i].Weights;
if (repValue == 0)
{
continue;
}
if (weightValue == currentWeightValue && repValue == currentRepValue)
{
nbSet++;
}
else
{
if (nbSet != 0)
{
tupleSetRepList.Add(new Tuple <int, int, double>(nbSet, currentRepValue, currentWeightValue));
}
currentRepValue = repValue;
currentWeightValue = weightValue;
nbSet = 1;
}
}
//last data
if (nbSet != 0)
{
tupleSetRepList.Add(new Tuple <int, int, double>(nbSet, currentRepValue, currentWeightValue));
}
var unit = await GetExerciseUnit();
int id = 1;
foreach (Tuple <int, int, double> tupleSetRep in tupleSetRepList)
{
trainingExercise.TrainingExerciseSets.Add(new TrainingExerciseSet()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear,
DayOfWeek = trainingExercise.DayOfWeek,
TrainingDayId = trainingExercise.TrainingDayId,
TrainingExerciseId = trainingExercise.Id,
Id = id,
NumberOfSets = tupleSetRep.Item1,
NumberOfReps = tupleSetRep.Item2,
Weight = tupleSetRep.Item3,
Unit = unit
});
id++;
}
//Save in server
var trainingDayKey = new TrainingDayKey()
{
UserId = trainingExercise.UserId,
Year = trainingExercise.Year,
WeekOfYear = trainingExercise.WeekOfYear,
DayOfWeek = trainingExercise.DayOfWeek,
TrainingDayId = trainingExercise.TrainingDayId
};
var trainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
};
var trainingDay = await TrainingDayWebService.GetTrainingDayAsync(trainingDayKey, trainingDayScenario);
//modify datas
var trainingExerciseTmp = trainingDay.TrainingExercises.Where(t => TrainingExerciseKey.IsEqualByKey(t, trainingExercise)).FirstOrDefault();
var indexOf = trainingDay.TrainingExercises.IndexOf(trainingExerciseTmp);
if (indexOf != -1)
{
//Replace exercise and sets
trainingDay.TrainingExercises[indexOf] = trainingExercise;
//update to server
trainingDay = await TrainingDayWebService.UpdateTrainingDayAsync(trainingDay, trainingDayScenario);
//Save modified data in local database
_trainingDayService.UpdateTrainingDay(trainingDay, trainingDayScenario);
CloseViewModel();
}
}
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to validate training rep/set", except);
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
public static async Task <bool> DeleteTrainingDayAsync(TrainingDayKey trainingDayKey)
{
return(await HttpConnector.Instance.PostAsync <TrainingDayKey, bool>("Api/TrainingDays/Delete", trainingDayKey));
}
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));
}
}
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 TrainingDay GetTrainingDay(TrainingDayKey key, TrainingDayScenario trainingDayScenario)
{
return(GetTrainingDayManager().GetTrainingDay(key, trainingDayScenario));
}
