private async Task <bool> UploadSynchronization(IEnumerable <VacantionRequest> changedModels, CancellationToken cancellationToken)
{
foreach (var model in changedModels)
{
cancellationToken.ThrowIfCancellationRequested();
var dto = SetupVacationDto(model);
if (model.SyncState == SynchronizationState.New)
{
await CreateOnServer(model, dto, cancellationToken);
}
else
{
await UpdateOnServer(model, dto, cancellationToken);
}
model.SyncState = SynchronizationState.Synced;
lock (_syncRoot)
VacationRequestsRepository.Update(model);
}
return(true);
}
public void AddVacation(NewVacationRequest newVacantion)
{
var vacation = SetupVacationRequest(newVacantion);
ChangeLocalDataAndRunSync(() => VacationRequestsRepository.Add(vacation));
RaiseVacationAdded(vacation);
}
private void AddNewBackendModel(VacantionRequest backendModel)
{
backendModel.LocalId = backendModel.Id;
backendModel.SyncState = SynchronizationState.Synced;
VacationRequestsRepository.Add(backendModel);
}
public void UpdateVacation(VacantionRequest vacation)
{
var current = VacationRequestsRepository.GetByKey(vacation.LocalId);
if (current.Equals(vacation))
{
return;
}
if (vacation.SyncState == SynchronizationState.Synced)
{
vacation.SyncState = SynchronizationState.Changed;
}
ChangeLocalDataAndRunSync(() => VacationRequestsRepository.Update(vacation));
RaiseVacationChanged(vacation);
}
private void ResetLocalItems(IEnumerable <VacantionRequest> localSyncedModels, IEnumerable <VacantionRequest> backendModels, CancellationToken cancellationToken)
{
lock (_syncRoot)
{
VacationRequestsRepository.RemoveRange(localSyncedModels);
cancellationToken.ThrowIfCancellationRequested();
foreach (var item in backendModels)
{
item.LocalId = item.Id;
}
VacationRequestsRepository.AddRange(backendModels);
}
RaiseVacationsChanged();
}
public VacantionRequest GetVacantion(string localId) => VacationRequestsRepository.GetByKey(localId);
public IEnumerable <VacantionRequest> GetVacantionRequests() => VacationRequestsRepository.GetAll();
private void UpdateByBackendModel(VacantionRequest backendModel)
{
backendModel.SyncState = SynchronizationState.Synced;
VacationRequestsRepository.Update(backendModel);
}
private async Task Synchronization(CancellationToken cancellationToken)
{
bool success = false;
try
{
var changedModels =
VacationRequestsRepository.GetAll()
.Where((arg) => arg.SyncState != SynchronizationState.Synced)
.ToList();
var uploadSuccess = !changedModels.Any();
if (!uploadSuccess)
{
var uploadNotSyncModels = await UploadSynchronization(changedModels, cancellationToken);
uploadSuccess = uploadNotSyncModels;
}
if (uploadSuccess)
{
var vacationDtos = await VacationRequestsApiService.GetVacations(cancellationToken);
var backendModels = vacationDtos
?.Select(SetupVacationRequest)
.ToList()
?? new List <VacantionRequest>();
cancellationToken.ThrowIfCancellationRequested();
var localSyncedModels = VacationRequestsRepository
.GetAll()
.Where(t => t.SyncState == SynchronizationState.Synced)
.ToList();
var removedModels = localSyncedModels
.Any(l => backendModels
.All(b => b.Id != l.Id));
if (removedModels || (backendModels.Any() && !localSyncedModels.Any()))
{
ResetLocalItems(localSyncedModels, backendModels, cancellationToken);
}
else
{
UpdateLocalItems(localSyncedModels, backendModels, cancellationToken);
}
success = true;
}
}
catch (OperationCanceledException)
{
}
catch (Exception)
{
}
lock (_syncRoot)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
_syncTCS.TrySetResult(success);
_syncTCS = null;
}
}
