private async Task DeleteActionAsync(BindingTrainingWeek bindingTrainingWeek)
{
try
{
if (bindingTrainingWeek == null)
{
return;
}
var trainingWeek = bindingTrainingWeek.TrainingWeek;
if (trainingWeek != null)
{
await TrainingWeekWebService.DeleteTrainingWeekByKeyAsync(trainingWeek);
bool onlineDataRefreshed = await RefreshDataActionAsync();
if (!onlineDataRefreshed)
{
// delete data in local database
_trainingWeekService.DeleteTrainingWeek(trainingWeek);
}
//Refresh data
RetreiveLocalData();
SynchronizeData();
}
}
catch (Exception except)
{
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
private async Task <bool> ValidateFieldsAsync()
{
var userDialog = Resolver.Resolve <IUserDialogs>();
bool result = false;
// check NewTrainingWeek not empty and NewTrainingWeek != OriginTrainingWeek
if (CopyTrainingWeek != null && CopyTrainingWeek.Year > 0 && CopyTrainingWeek.WeekOfYear > 0 &&
(CopyTrainingWeek.Year != CopyTrainingWeek.OriginYear || CopyTrainingWeek.WeekOfYear != CopyTrainingWeek.OriginWeekOfYear))
{
//Check new training doesn't exist
var key = new TrainingWeekKey()
{
UserId = CopyTrainingWeek.UserId, Year = CopyTrainingWeek.Year, WeekOfYear = CopyTrainingWeek.WeekOfYear
};
var trainingWeek = await TrainingWeekWebService.GetTrainingWeekAsync(key);
if (trainingWeek != null)
{
await userDialog.AlertAsync(string.Format(Translation.Get(TRS.P0_ALREADY_EXIST), Translation.Get(TRS.TRAINING_WEEK)), Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
return(false);
}
result = true;
}
else
{
await userDialog.AlertAsync(string.Format(Translation.Get(TRS.IMPOSSIBLE_TO_CREATE_P0), Translation.Get(TRS.TRAINING_WEEK)), Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
return(result);
}
private async Task <bool> SaveDataAsync()
{
TrainingWeek trainingWeek = null;
if (EditMode == TEditMode.Create)
{
trainingWeek = await TrainingWeekWebService.CreateTrainingWeekAsync(TrainingWeek);
if (trainingWeek != null)
{
var trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true
};
_trainingWeekService.UpdateTrainingWeek(trainingWeek, trainingWeekScenario);
}
}
else
{
var trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = false
};
trainingWeek = await TrainingWeekWebService.UpdateTrainingWeekAsync(TrainingWeek, trainingWeekScenario);
if (trainingWeek != null)
{
_trainingWeekService.UpdateTrainingWeek(trainingWeek, trainingWeekScenario);
}
}
return(trainingWeek != null);
}
private async Task <bool> ValidateFieldsAsync()
{
if (TrainingWeek != null && TrainingWeek.Year > 0 && TrainingWeek.WeekOfYear > 0 &&
TrainingWeek.UserHeight > 0 && TrainingWeek.UserWeight > 0 && !string.IsNullOrWhiteSpace(TrainingWeek.UserId))
{
var onlineTrainingWeek = await TrainingWeekWebService.GetTrainingWeekAsync(TrainingWeek);
if (EditMode == TEditMode.Create)
{
//verify training week doesn't exist
if (onlineTrainingWeek != null)
{
throw new Exception(string.Format(Translation.Get(TRS.P0_ALREADY_EXIST), Translation.Get(TRS.TRAINING_WEEK)));
}
return(true);
}
else
{
//verify training week exist
if (onlineTrainingWeek == null)
{
throw new Exception(string.Format(Translation.Get(TRS.P0_NOT_EXIST), Translation.Get(TRS.TRAINING_WEEK)));
}
return(true);
}
}
return(false);
}
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));
}
}
private async Task <bool> SaveDataAsync()
{
bool result = false;
TrainingWeek trainingWeek = await TrainingWeekWebService.CopyTrainingWeekAsync(CopyTrainingWeek);
if (trainingWeek != null)
{
var trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true
};
_trainingWeekService.UpdateTrainingWeek(trainingWeek, trainingWeekScenario);
result = true;
}
return(result);
}
private async Task ViewTrainingWeekActionAsync(BindingTrainingWeek bindingTrainingWeek)
{
try
{
if (bindingTrainingWeek != null && bindingTrainingWeek.TrainingWeek != null)
{
TrainingWeek trainingWeek = null;
var trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true
};
try
{
//load server data (only header)
trainingWeek = await TrainingWeekWebService.GetTrainingWeekAsync(bindingTrainingWeek.TrainingWeek, false);
if (trainingWeek != null)
{
if (trainingWeek.ModificationDate != bindingTrainingWeek.TrainingWeek.ModificationDate)
{
//load server data (full)
trainingWeek = await TrainingWeekWebService.GetTrainingWeekAsync(bindingTrainingWeek.TrainingWeek, true);
if (trainingWeek != null)
{
//Save data on local database
_trainingWeekService.UpdateTrainingWeek(trainingWeek, trainingWeekScenario);
}
}
else
{
trainingWeek = null; // force reload local data
}
}
}
catch
{
// Unable to retreive local data
ILogger.Instance.Info("Unable to retreive TrainingWeek on server");
trainingWeek = null;
}
if (trainingWeek == null)
{ //load local data
trainingWeek = _trainingWeekService.GetTrainingWeek(bindingTrainingWeek.TrainingWeek, trainingWeekScenario);
}
if (trainingWeek != null)
{
//Display view model
if (await TrainingWeekViewModel.ShowAsync(trainingWeek, this))
{
//Refresh data
RetreiveLocalData();
SynchronizeData();
}
}
}
}
catch (Exception except)
{
await _userDialog.AlertAsync(except.Message, Translation.Get(TRS.ERROR), Translation.Get(TRS.OK));
}
}
public static async Task <bool> SynchronizeTrainingWeeksAsync(SQLiteConnection dbContext)
{
bool result = false;
try
{
//Synchronize TrainingWeek with server (with trainingday and exercise)
var criteria = new TrainingWeekCriteria();
criteria.UserId = new StringCriteria()
{
Equal = UserData.Instance.UserInfo.UserId
};
TrainingWeekScenario trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = false
};
var trainingWeekService = new TrainingWeekService(dbContext);
//retreive local data
var localTrainingWeekList = trainingWeekService.FindTrainingWeek(criteria, trainingWeekScenario);
//retreive online data
var criteriaList = new CriteriaList <TrainingWeekCriteria>()
{
criteria
};
var onlineTrainingWeekList = await TrainingWeekWebService.FindTrainingWeeksAsync(criteriaList, trainingWeekScenario);
bool found;
//Delete local data if not found on server
if (localTrainingWeekList != null)
{
var deletedTrainingWeekList = new List <TrainingWeek>();
foreach (var localTrainingWeek in localTrainingWeekList)
{
found = false;
if (onlineTrainingWeekList != null)
{
foreach (var onlineTrainingWeek in onlineTrainingWeekList)
{
if (TrainingWeekKey.IsEqualByKey(onlineTrainingWeek, localTrainingWeek))
{
found = true;
break;
}
}
}
if (!found)
{
deletedTrainingWeekList.Add(localTrainingWeek);
}
}
if (deletedTrainingWeekList.Count > 0)
{
var deletedTrainingWeekKeyList = new List <TrainingWeekKey>();
foreach (var key in deletedTrainingWeekList)
{
deletedTrainingWeekKeyList.Add(key);
}
//Delete in local database
trainingWeekService.DeleteTrainingWeekList(deletedTrainingWeekKeyList);
foreach (var deleteTrainingWeek in deletedTrainingWeekList)
{
localTrainingWeekList.Remove(deleteTrainingWeek);
}
}
}
//if modification date online != local, get full trainingWeek online data and save them on local database
var synchronizeTrainingWeekList = new List <TrainingWeek>();
if (onlineTrainingWeekList != null)
{
foreach (var onlineTrainingWeek in onlineTrainingWeekList)
{
found = false;
if (localTrainingWeekList != null)
{
foreach (var localTrainingWeek in localTrainingWeekList)
{
//Same trainingWeek
if (TrainingWeekKey.IsEqualByKey(onlineTrainingWeek, localTrainingWeek))
{
if (onlineTrainingWeek.ModificationDate.ToUniversalTime() != localTrainingWeek.ModificationDate.ToUniversalTime()) //ToUniversalTime for security...
{
synchronizeTrainingWeekList.Add(onlineTrainingWeek);
}
found = true;
break;
}
}
}
if (!found)
{
synchronizeTrainingWeekList.Add(onlineTrainingWeek);
}
}
}
//Synchronize all trainingWeek data
trainingWeekScenario = new TrainingWeekScenario()
{
ManageTrainingDay = true,
TrainingDayScenario = new TrainingDayScenario()
{
ManageExercise = true
}
};
if (synchronizeTrainingWeekList.Count > 0)
{
criteriaList.Clear();
foreach (var trainingWeek in synchronizeTrainingWeekList)
{
criteria = new TrainingWeekCriteria();
criteria.UserId = new StringCriteria()
{
Equal = trainingWeek.UserId
};
criteria.Year = new IntegerCriteria()
{
Equal = trainingWeek.Year
};
criteria.WeekOfYear = new IntegerCriteria()
{
Equal = trainingWeek.WeekOfYear
};
criteriaList.Add(criteria);
}
onlineTrainingWeekList = await TrainingWeekWebService.FindTrainingWeeksAsync(criteriaList, trainingWeekScenario);
if (onlineTrainingWeekList != null && onlineTrainingWeekList.Count > 0)
{
trainingWeekService.UpdateTrainingWeekList(onlineTrainingWeekList, trainingWeekScenario);
}
}
result = true;
}
catch (Exception except)
{
ILogger.Instance.Error("Unable to synchronize training weeks", except);
}
return(result);
}
