private async Task <EmptyResponseDto> SaveUpTaskList(GoogleTaskList taskList)
{
var response = await _apiService.SaveTaskList(new GoogleTaskListModel
{
Title = taskList.Title,
UpdatedAt = taskList.UpdatedAt
});
var result = new EmptyResponseDto
{
Succeed = response.Succeed
};
if (response.Succeed)
{
taskList.GoogleTaskListID = response.Result.TaskListID;
taskList.ToBeSynced = false;
taskList.LocalStatus = LocalStatus.DEFAULT;
taskList.UpdatedAt = response.Result.UpdatedAt;
result = await _dataService
.TaskListService
.UpdateAsync(taskList);
}
else
{
result.Message = response.Message ??
$"An unkwon error occurred while trying to create task list {taskList.Title}";
_logger.Error(
$"{nameof(SyncUpTaskListsAsync)}: An error occurred while trying to " +
$"save remotely taskListId = {taskList.ID}. {result.Message}");
}
return(result);
}
public async Task <EmptyResponseDto> SyncUpTasksAsync(bool isInBackground)
{
_logger.Information($"{nameof(SyncUpTasksAsync)}: Starting the sync up of tasks");
var syncUpResult = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
var syncUpResults = new List <EmptyResponseDto>();
if (!_networkService.IsInternetAvailable())
{
syncUpResult.Message = "Network is not available";
_logger.Warning($"{nameof(SyncUpTasksAsync)}: Network is not available");
return(syncUpResult);
}
var tasksToBeSyncedDbResponse = await _dataService
.TaskService
.GetAsNoTrackingAsync(
task => task.ToBeSynced && task.TaskList.User.IsActive,
includeProperties : nameof(GoogleTask.TaskList));
if (!tasksToBeSyncedDbResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: Couldn't get all the tasks to sync from db. " +
$"Error = {tasksToBeSyncedDbResponse.Message}");
return(tasksToBeSyncedDbResponse);
}
var tasks = new List <Task>
{
//Here we save the tasks that were created locally
SaveUpTasks(tasksToBeSyncedDbResponse.Result, syncUpResults),
//Here we save the tasks that were deleted locally
DeleteUpTasks(tasksToBeSyncedDbResponse.Result, syncUpResults),
//Here we update the tasks that were updated locally
UpdateUpTasks(tasksToBeSyncedDbResponse.Result, syncUpResults),
};
await Task.WhenAll(tasks);
if (syncUpResults.Any(r => !r.Succeed))
{
syncUpResult.Message = string.Join(
$".{Environment.NewLine}",
syncUpResults
.Where(r => !r.Succeed)
.Select(r => r.Message));
}
else
{
syncUpResult.Succeed = true;
}
_logger.Information($"{nameof(SyncUpTasksAsync)}: Completed successfully");
return(syncUpResult);
}
public async Task <EmptyResponseDto> RemoveRangeAsync(IEnumerable <GoogleTask> entities)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveRangeAsync: Trying to delete {entities.Count()} tasks");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
context.RemoveRange(entities);
response.Succeed = await context.SaveChangesAsync() > 0;
_logger.Information("RemoveRangeAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "RemoveRangeAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
private async Task <EmptyResponseDto> DeleteUpTask(GoogleTask task)
{
var response = await _apiService.DeleteTask(task.TaskList.GoogleTaskListID, task.GoogleTaskID);
var result = new EmptyResponseDto
{
Succeed = response.Succeed
};
if (response.Succeed)
{
result = await _dataService.TaskService.RemoveAsync(task);
}
else
{
result.Message = response.Message ??
$"An unkwon error occurred while trying to delete task {task.Title}";
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: An error occurred while trying to " +
$"delete remotely taskId = {task.ID}. {result.Message}",
task, result.Message);
}
return(result);
}
public Task <EmptyResponseDto> DeleteTask(string taskListId, string taskId)
{
var response = new EmptyResponseDto
{
Succeed = true
};
return(Task.FromResult(response));
}
public Task <EmptyResponseDto> ClearTasks(string taskListId)
{
var response = new EmptyResponseDto
{
Succeed = true
};
return(Task.FromResult(response));
}
private async Task <EmptyResponseDto> UpdateUpTaskList(GoogleTaskList taskList)
{
var response = await _apiService.GetTaskList(taskList.GoogleTaskListID);
var result = new EmptyResponseDto
{
Succeed = response.Succeed
};
if (!response.Succeed)
{
result.Message = response.Message ??
$"An unknow error occurred while trying to get {taskList.Title} from remote to be updated";
_logger.Error(
$"{nameof(SyncUpTaskListsAsync)}: An error occurred while trying to get the task to " +
$"update remotely taskListId = {taskList.ID}. {result.Message}");
}
//We need to update the remote contrapart
else if (taskList.UpdatedAt > response.Result.UpdatedAt)
{
response.Result.UpdatedAt = taskList.UpdatedAt;
response.Result.Title = taskList.Title;
response = await _apiService.UpdateTaskList(response.Result.TaskListID, response.Result);
result.Succeed = response.Succeed;
if (!response.Succeed)
{
result.Message = response.Message ??
$"An unknow error occurred while trying to get {taskList.Title} from remote to be updated";
_logger.Error(
$"{nameof(SyncUpTaskListsAsync)}: An error occurred while trying to " +
$"update remotely taskListId = {taskList.ID}. {result.Message}");
}
else
{
taskList.LocalStatus = LocalStatus.DEFAULT;
taskList.ToBeSynced = false;
result = await _dataService.TaskListService.UpdateAsync(taskList);
}
}
//we need to update the local contrapart
else
{
taskList.Title = response.Result.Title;
taskList.LocalStatus = LocalStatus.DEFAULT;
taskList.ToBeSynced = false;
taskList.UpdatedAt = response.Result.UpdatedAt;
result = await _dataService.TaskListService.UpdateAsync(taskList);
}
return(result);
}
private async Task <EmptyResponseDto> SaveUpTask(GoogleTask task)
{
var result = new EmptyResponseDto();
var t = new GoogleTaskModel
{
Notes = task.Notes,
Status = task.Status,
Title = task.Title,
ToBeCompletedOn = task.ToBeCompletedOn,
UpdatedAt = task.UpdatedAt
};
var previousResponse = await _dataService
.TaskService
.GetPreviousTaskId(task.TaskList.GoogleTaskListID, task.ParentTask);
if (!previousResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: Couldnt get the previous taskId " +
$"for taskListId = {task.TaskList.GoogleTaskListID} - parentTask = {task.ParentTask}");
result.Message = "Couldnt get the previous taskId";
return(result);
}
var response = await _apiService.SaveTask(task.TaskList.GoogleTaskListID, t, task.ParentTask, previousResponse.Result);
if (response.Succeed)
{
task.LocalStatus = LocalStatus.DEFAULT;
task.ToBeSynced = false;
task.GoogleTaskID = response.Result.TaskID;
task.UpdatedAt = response.Result.UpdatedAt;
task.Position = response.Result.Position;
task.ParentTask = response.Result.ParentTask;
result = await _dataService.TaskService.UpdateAsync(task);
}
else
{
result.Message = response.Message ??
$"An unkwon error occurred while trying to create task {task.Title}";
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: An error occurred while trying to " +
$"save remotely taskId = {task.ID}. {result.Message}");
}
return(result);
}
public async Task <EmptyResponseDto> ChangeCurrentUserStatus(bool isActive)
{
return(await Task.Run(async() =>
{
_logger.Information($"ChangeCurrentUserStatus: Trying to change the current active user status to {(isActive ? "Active" : "Inactive")}");
var response = new EmptyResponseDto
{
Succeed = false,
Message = string.Empty
};
var currentUserResponse = await GetCurrentActiveUserAsync();
if (!currentUserResponse.Succeed)
{
return currentUserResponse;
}
currentUserResponse.Result.IsActive = isActive;
return await UpdateAsync(currentUserResponse.Result);
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> DeleteTask(string taskListId, string taskId)
{
var response = new EmptyResponseDto();
try
{
await _googleApi.DeleteTask(taskListId, taskId);
response.Succeed = true;
}
catch (ApiException apiEx)
{
await HandleApiException(apiEx, response);
}
catch (Exception ex)
{
HandleException(ex, response);
}
return(response);
}
public async Task <EmptyResponseDto> RemoveAsync(Expression <Func <GoogleTask, bool> > filter)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveAsync: Trying to delete tasks that matches filter");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var entitiesToDelete = context
.Tasks
.Where(filter);
if (entitiesToDelete.Count() > 0)
{
context.RemoveRange(entitiesToDelete);
response.Succeed = await context.SaveChangesAsync() > 0;
}
else
{
response.Succeed = true;
}
_logger.Information("RemoveAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "RemoveAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> RemoveAsync(object id)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveAsync: Trying to delete user with id {id}");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var entity = await context.Users.FindAsync(id);
if (entity == null)
{
response.Message = "Entity couldn't be removed cause it wasnt found";
_logger.Warning("RemoveAsync: Task list couldn't be removed cause it wasnt found");
}
else
{
context.Remove(entity);
response.Succeed = await context.SaveChangesAsync() > 0;
}
_logger.Information("RemoveAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "RemoveAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> RemoveTaskAsync(IEnumerable <string> taskIds)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveTaskAsync: Trying to remove following taskIDs = {string.Join(",", taskIds)}");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var entities = context
.Tasks
.Where(t => taskIds.Any(a => a == t.GoogleTaskID));
if (entities.Count() == 0)
{
response.Message = "Couldn't find the tasks to delete";
_logger.Warning($"RemoveTaskAsync: Couldn't find any of the taskIDs = {string.Join(",", taskIds)}");
return response;
}
if (entities.Any(t => t.LocalStatus == LocalStatus.CREATED))
{
var tasksToDelete = entities.Where(t => t.LocalStatus == LocalStatus.CREATED);
var subTasks = context
.Tasks
.Where(st => tasksToDelete.Any(t => st.ParentTask == t.GoogleTaskID));
context.RemoveRange(tasksToDelete);
if (subTasks.Count() > 0)
{
context.RemoveRange(subTasks);
}
}
if (entities.Any(t => t.LocalStatus != LocalStatus.CREATED))
{
var tasksToUpdate = entities.Where(t => t.LocalStatus != LocalStatus.CREATED);
var subTasks = context
.Tasks
.Where(st => tasksToUpdate.Any(t => st.ParentTask == t.GoogleTaskID));
await tasksToUpdate.ForEachAsync(t =>
{
t.UpdatedAt = DateTimeOffset.UtcNow;
t.LocalStatus = LocalStatus.DELETED;
t.ToBeSynced = true;
});
await subTasks.ForEachAsync(t =>
{
t.UpdatedAt = DateTimeOffset.UtcNow;
t.LocalStatus = LocalStatus.DELETED;
t.ToBeSynced = true;
});
context.UpdateRange(tasksToUpdate);
if (subTasks.Count() > 0)
{
context.UpdateRange(subTasks);
}
}
response.Succeed = await context.SaveChangesAsync() > 0;
_logger.Information("RemoveTaskAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "RemoveTaskAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> RemoveTaskAsync(string taskID)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveTaskAsync: Trying to remove taskID = {taskID}");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var entity = await context
.Tasks
.FirstOrDefaultAsync(t => t.GoogleTaskID == taskID);
if (entity == null)
{
response.Message = "Couldn't find the task to delete";
_logger.Warning($"RemoveTaskAsync: Couldn't find the task with taskID = {taskID}");
return response;
}
var subTasks = context
.Tasks
.Where(t => t.ParentTask == entity.GoogleTaskID);
if (entity.LocalStatus == LocalStatus.CREATED)
{
context.Remove(entity);
if (subTasks.Count() > 0)
{
context.RemoveRange(subTasks);
}
}
else
{
entity.LocalStatus = LocalStatus.DELETED;
entity.UpdatedAt = DateTimeOffset.UtcNow;
entity.ToBeSynced = true;
context.Update(entity);
if (subTasks.Count() > 0)
{
await subTasks.ForEachAsync(st =>
{
st.LocalStatus = LocalStatus.DELETED;
st.UpdatedAt = DateTimeOffset.UtcNow;
st.ToBeSynced = true;
});
context.UpdateRange(subTasks);
}
}
response.Succeed = await context.SaveChangesAsync() > 0;
_logger.Information("RemoveTaskAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "RemoveTaskAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> SyncDownTaskListsAsync(bool isInBackground)
{
_logger.Information($"{nameof(SyncDownTaskListsAsync)}: Starting the sync down of task lists");
var syncResult = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
var syncDownResults = new List <EmptyResponseDto>();
if (!_networkService.IsInternetAvailable())
{
syncResult.Message = "Network is not available";
_logger.Warning($"{nameof(SyncDownTaskListsAsync)}: Network is not available");
return(syncResult);
}
string nextPageToken = null;
bool hasMorePages = true;
while (hasMorePages)
{
var response = await _apiService.GetAllTaskLists(pageToken : nextPageToken);
nextPageToken = response.Result?.NextPageToken;
if (string.IsNullOrEmpty(nextPageToken))
{
hasMorePages = false;
}
if (!response.Succeed)
{
//TODO: I SHOULD DO SOMETHING HERE...
syncResult.Message = response.Message ?? "Unkwnon error";
_logger.Error(
$"{nameof(SyncDownTaskListsAsync)}: Couldn't get all the task lists from api. " +
$"Error = {syncResult.Message}");
return(syncResult);
}
var downloadedTaskLists = response.Result.Items.ToList();
var dbResponse = await _dataService
.TaskListService
.GetAsNoTrackingAsync(tl => tl.User.IsActive);
if (!dbResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncDownTaskListsAsync)}: Couldn't get all the task lists from db. " +
$"Error = {dbResponse.Message}");
return(dbResponse);
}
var tasks = new List <Task>
{
//Here we save any new remote task list
Task.Run(async() =>
{
var taskListsToSave = downloadedTaskLists
.Where(dt => dbResponse.Result.All(ct => ct.GoogleTaskListID != dt.TaskListID))
.Select(t => new GoogleTaskList
{
GoogleTaskListID = t.TaskListID,
CreatedAt = DateTimeOffset.UtcNow,
Title = t.Title,
UpdatedAt = t.UpdatedAt
}).ToList();
if (!taskListsToSave.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncDownTaskListsAsync)}: Trying to save into db {taskListsToSave.Count} " +
$"new remote task lists");
var r = await _dataService
.TaskListService
.AddRangeAsync(taskListsToSave);
if (r.Succeed)
{
syncDownResults.Add(r);
}
}),
//Here we delete any task list that is not in remote
Task.Run(async() =>
{
var deletedTaskLists = dbResponse.Result
.Where(ct =>
downloadedTaskLists.All(dt => dt.TaskListID != ct.GoogleTaskListID) &&
ct.LocalStatus != LocalStatus.CREATED)
.ToList();
if (!deletedTaskLists.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncDownTaskListsAsync)}: Trying to delete from db {deletedTaskLists.Count} task lists");
var r = await _dataService
.TaskListService
.RemoveRangeAsync(deletedTaskLists);
if (r.Succeed)
{
syncDownResults.Add(r);
}
}),
//Here we update the local tasklists
Task.Run(async() =>
{
foreach (var taskList in dbResponse.Result)
{
var t = downloadedTaskLists
.FirstOrDefault(dt => dt.TaskListID == taskList.GoogleTaskListID);
if (t == null)
{
return;
}
if (taskList.UpdatedAt >= t.UpdatedAt)
{
continue;
}
_logger.Information(
$"{nameof(SyncDownTaskListsAsync)}: Trying to update the local tasklistId = {taskList.ID}");
taskList.Title = t.Title;
taskList.UpdatedAt = t.UpdatedAt;
var r = await _dataService
.TaskListService
.UpdateAsync(taskList);
if (r.Succeed)
{
syncDownResults.Add(r);
}
}
})
};
await Task.WhenAll(tasks);
}
if (syncDownResults.Any(r => !r.Succeed))
{
syncResult.Message = string.Join($".{Environment.NewLine}", syncDownResults.Select(r => r.Message));
}
else
{
syncResult.Succeed = true;
}
_logger.Information($"{nameof(SyncDownTaskListsAsync)}: Completed successfully");
return(syncResult);
}
public async Task <EmptyResponseDto> SyncDownTasksAsync(bool isInBackground)
{
_logger.Information($"{nameof(SyncDownTasksAsync)}: Starting the sync down of tasks");
var syncResult = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
var syncDownResults = new List <EmptyResponseDto>();
if (!_networkService.IsInternetAvailable())
{
syncResult.Message = "Network is not available";
_logger.Warning($"{nameof(SyncDownTasksAsync)}: Network is not available");
return(syncResult);
}
var dbResponse = await _dataService
.TaskListService
.GetAsNoTrackingAsync(
tl => tl.User.IsActive &&
tl.LocalStatus != LocalStatus.CREATED &&
tl.LocalStatus != LocalStatus.DELETED);
if (!dbResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncDownTasksAsync)}: Couldn't get all the task lists from db. " +
$"Error = {dbResponse.Message}");
return(dbResponse);
}
foreach (var taskList in dbResponse.Result)
{
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Trying to get all the tasks " +
$"associated to taskListId = {taskList.ID} from api");
string nextPageToken = null;
bool hasMorePages = true;
while (hasMorePages)
{
var response = await _apiService.GetAllTasks(taskList.GoogleTaskListID, pageToken : nextPageToken);
nextPageToken = response.Result?.NextPageToken;
if (string.IsNullOrEmpty(nextPageToken))
{
hasMorePages = false;
}
if (!response.Succeed)
{
//TODO: I SHOULD DO SOMETHING HERE TOO...
syncResult.Message = response.Message ?? "Unknown error";
syncResult.Succeed = false;
_logger.Error(
$"{nameof(SyncDownTasksAsync)}: Couldn't get all the tasks associated to " +
$"taskListId = {taskList.ID} from api. Error = {syncResult.Message}");
return(syncResult);
}
var downloadedTasks = response.Result?.Items?.ToList();
//if this task list doesnt contains task
if (downloadedTasks == null || !downloadedTasks.Any())
{
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Task list = {taskList.Title} does not contains tasks, " +
$"trying to remove any local task associated to it");
var deleteResponse = await _dataService
.TaskService
.RemoveAsync(
t => t.TaskList.GoogleTaskListID == taskList.GoogleTaskListID &&
t.LocalStatus != LocalStatus.CREATED);
syncDownResults.Add(deleteResponse);
continue;
}
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Trying to get all the tasks associated to " +
$"tasklistID = {taskList.GoogleTaskListID} from db");
//I think i dont need to include the tasklist property
var currentTasksDbResponse = await _dataService
.TaskService
.GetAsync(t => t.TaskList.GoogleTaskListID == taskList.GoogleTaskListID, null, string.Empty);
if (!currentTasksDbResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncDownTasksAsync)}: Couldn't get all the tasks associated to " +
$"tasklistID = {taskList.GoogleTaskListID} from db");
return(currentTasksDbResponse);
}
var tasks = new List <Task>
{
//Here we save any new remote task
Task.Run(async() =>
{
var tasksToSave = downloadedTasks
.Where(dt => currentTasksDbResponse.Result.All(ct => ct.GoogleTaskID != dt.TaskID))
.Select(t => new GoogleTask
{
GoogleTaskID = t.TaskID,
CreatedAt = DateTimeOffset.UtcNow,
Title = t.Title,
UpdatedAt = t.UpdatedAt,
CompletedOn = t.CompletedOn,
IsDeleted = t.IsDeleted,
IsHidden = t.IsHidden,
Notes = t.Notes,
ParentTask = t.ParentTask,
Position = t.Position,
Status = t.Status,
ToBeCompletedOn = t.ToBeCompletedOn
}).ToList();
if (!tasksToSave.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Trying to save into db {tasksToSave.Count} " +
$"new remote task associated to tasklistID = {taskList.GoogleTaskListID}");
syncDownResults.Add(await _dataService
.TaskService
.AddRangeAsync(taskList.GoogleTaskListID, tasksToSave));
}),
//Here we delete any task that is not in remote
Task.Run(async() =>
{
var deletedTasks = currentTasksDbResponse.Result
.Where(ct =>
downloadedTasks.All(dt => dt.TaskID != ct.GoogleTaskID) &&
ct.LocalStatus != LocalStatus.CREATED)
.ToList();
if (!deletedTasks.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Trying to delete from db {deletedTasks.Count} " +
$"tasks associated to tasklistID = {taskList.GoogleTaskListID}");
syncDownResults.Add(await _dataService
.TaskService
.RemoveRangeAsync(deletedTasks));
}),
//Here we update the local tasks
Task.Run(async() =>
{
foreach (var task in currentTasksDbResponse.Result)
{
var downloadedTask = downloadedTasks
.FirstOrDefault(dt => dt.TaskID == task.GoogleTaskID);
if (downloadedTask == null)
{
return;
}
if (task.UpdatedAt >= downloadedTask.UpdatedAt)
{
continue;
}
_logger.Information(
$"{nameof(SyncDownTasksAsync)}: Trying to update the local taskId = {task.ID} " +
$"associated to tasklistID = {taskList.ID}");
task.CompletedOn = downloadedTask.CompletedOn;
task.GoogleTaskID = downloadedTask.TaskID;
task.IsDeleted = downloadedTask.IsDeleted;
task.IsHidden = downloadedTask.IsHidden;
task.Notes = downloadedTask.Notes;
task.ParentTask = downloadedTask.ParentTask;
task.Position = downloadedTask.Position;
task.Status = downloadedTask.Status;
task.Title = downloadedTask.Title;
task.ToBeCompletedOn = downloadedTask.ToBeCompletedOn;
task.UpdatedAt = downloadedTask.UpdatedAt;
syncDownResults.Add(await _dataService
.TaskService
.UpdateAsync(task));
}
})
};
await Task.WhenAll(tasks);
}
}
if (syncDownResults.Any(r => !r.Succeed))
{
syncResult.Message = string.Join($".{Environment.NewLine}", syncDownResults.Select(r => r.Message));
}
else
{
syncResult.Succeed = true;
}
_logger.Information($"{nameof(SyncDownTasksAsync)}: Completed successfully");
return(syncResult);
}
public async Task <EmptyResponseDto> SyncUpTaskListsAsync(bool isInBackground)
{
_logger.Information($"{nameof(SyncUpTaskListsAsync)}: Starting the sync up of task lists");
var syncUpResult = new EmptyResponseDto
{
Succeed = false,
Message = string.Empty
};
var syncUpResults = new List <EmptyResponseDto>();
if (!_networkService.IsInternetAvailable())
{
syncUpResult.Message = "Network is not available";
_logger.Warning($"{nameof(SyncUpTaskListsAsync)}: Network is not available");
return(syncUpResult);
}
var taskListToSyncDbResponse = await _dataService
.TaskListService
.GetAsNoTrackingAsync(
taskList => taskList.ToBeSynced && taskList.User.IsActive,
taskList => taskList.OrderBy(tl => tl.UpdatedAt),
string.Empty);
if (!taskListToSyncDbResponse.Succeed)
{
_logger.Error(
$"{nameof(SyncUpTaskListsAsync)}: Couldn't get all the task lists to sync from db. " +
$"Error = {taskListToSyncDbResponse.Message}");
return(taskListToSyncDbResponse);
}
var tasks = new List <Task>
{
//Here we take the taskLists that were created
Task.Run(async() =>
{
var createdTaskLists = taskListToSyncDbResponse.Result
.Where(tl => tl.LocalStatus == LocalStatus.CREATED)
.ToList();
if (!createdTaskLists.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncUpTaskListsAsync)}: Trying to save remotely {createdTaskLists.Count} task lists");
foreach (var taskList in createdTaskLists)
{
syncUpResults.Add(await SaveUpTaskList(taskList));
}
}),
//Here we take the tasklists that were deleted
Task.Run(async() =>
{
var deletedTaskLists = taskListToSyncDbResponse.Result
.Where(tl => tl.LocalStatus == LocalStatus.DELETED)
.ToList();
if (!deletedTaskLists.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncUpTaskListsAsync)}: Trying to delete remotely {deletedTaskLists.Count} task lists");
foreach (var taskList in deletedTaskLists)
{
syncUpResults.Add(await DeleteUpTaskList(taskList));
}
}),
//Here we take the taskLists that were updated
Task.Run(async() =>
{
var updatedTaskLists = taskListToSyncDbResponse.Result
.Where(tl => tl.LocalStatus == LocalStatus.UPDATED)
.ToList();
if (!updatedTaskLists.Any())
{
return;
}
_logger.Information(
$"{nameof(SyncUpTaskListsAsync)}: Trying to delete remotely {updatedTaskLists.Count} task lists");
foreach (var taskList in updatedTaskLists)
{
syncUpResults.Add(await UpdateUpTaskList(taskList));
}
})
};
await Task.WhenAll(tasks);
if (syncUpResults.Any(r => !r.Succeed))
{
syncUpResult.Message = string.Join(
$".{Environment.NewLine}",
syncUpResults
.Where(r => !r.Succeed)
.Select(r => r.Message));
}
else
{
syncUpResult.Succeed = true;
}
_logger.Information($"{nameof(SyncUpTaskListsAsync)}: Completed successfully");
return(syncUpResult);
}
private async Task <EmptyResponseDto> UpdateUpTask(GoogleTask task)
{
var response = await _apiService.GetTask(task.TaskList.GoogleTaskListID, task.GoogleTaskID);
var result = new EmptyResponseDto
{
Succeed = response.Succeed
};
if (!response.Succeed)
{
result.Message = response.Message ??
$"An unkwon error occurred while trying to get task {task.Title}";
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: An error occurred while trying to get the task to " +
$"update remotely taskId = {task.ID}. {result.Message}");
}
else if (task.UpdatedAt > response.Result.UpdatedAt)
{
response.Result.CompletedOn = task.CompletedOn;
response.Result.IsDeleted = task.IsDeleted;
response.Result.Notes = task.Notes;
response.Result.Status = task.Status;
response.Result.Title = task.Title;
response.Result.ToBeCompletedOn = task.ToBeCompletedOn;
response.Result.UpdatedAt = task.UpdatedAt;
response = await _apiService.UpdateTask(task.TaskList.GoogleTaskListID, task.GoogleTaskID, response.Result);
result.Succeed = response.Succeed;
if (response.Succeed)
{
task.LocalStatus = LocalStatus.DEFAULT;
task.ToBeSynced = false;
result = await _dataService.TaskService.UpdateAsync(task);
}
else
{
result.Message = response.Message ??
$"An unkwon error occurred while trying to delete task {task.Title}";
_logger.Error(
$"{nameof(SyncUpTasksAsync)}: An error occurred while trying to " +
$"update remotely taskId = {task.ID}. {result.Message}");
}
}
else
{
task.CompletedOn = response.Result.CompletedOn;
task.IsDeleted = response.Result.IsDeleted;
task.IsHidden = response.Result.IsHidden;
task.Notes = response.Result.Notes;
task.ParentTask = response.Result.ParentTask;
task.Position = response.Result.Position;
task.Status = response.Result.Status;
task.Title = response.Result.Title;
task.ToBeCompletedOn = response.Result.ToBeCompletedOn;
task.UpdatedAt = response.Result.UpdatedAt;
task.LocalStatus = LocalStatus.DEFAULT;
task.ToBeSynced = false;
result = await _dataService.TaskService.UpdateAsync(task);
}
return(result);
}
private Task SendMsg(EmptyResponseDto response)
{
string json = JsonConvert.SerializeObject(response);
return(BroadcastAsync(json));
}
