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 async Task <ResponseDto <GoogleTask> > UpdateAsync(GoogleTask entity)
{
return(await Task.Run(async() =>
{
_logger.Information($"UpdateAsync: Trying to update taskId = {entity.ID}");
var response = new ResponseDto <GoogleTask>
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
context.Entry(entity).State = EntityState.Modified;
response.Succeed = await context.SaveChangesAsync() > 0;
response.Result = entity;
_logger.Information("UpdateAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "UpdateAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public async Task <EmptyResponseDto> RemoveAsync(GoogleTask entity)
{
return(await Task.Run(async() =>
{
_logger.Information($"RemoveAsync: Trying to delete taskId = {entity.ID}");
var response = new EmptyResponseDto
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
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));
}
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 void ReturnsIntermediateFileFromVariable()
{
var contents = "SampleGoogleServices";
var environmentName = nameof(ReturnsIntermediateFileFromVariable);
Environment.SetEnvironmentVariable(environmentName, contents, EnvironmentVariableTarget.Process);
var path = GoogleTask.GetResourcePath(environmentName, IntermediateOutputDirectory, "google-services.json");
var expectedPath = Path.Combine(IntermediateOutputDirectory, "google-services", "google-services.json");
Assert.Equal(expectedPath, path);
Assert.Equal(contents, File.ReadAllText(path));
}
public async Task <ResponseDto <GoogleTask> > AddAsync(string taskListID, GoogleTask task)
{
return(await Task.Run(async() =>
{
_logger.Information($"AddAsync: Trying to add a new task into taskListId = {taskListID}");
var response = new ResponseDto <GoogleTask>
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var taskList = await context.TaskLists
.FirstOrDefaultAsync(tl => tl.GoogleTaskListID == taskListID);
if (taskList == null)
{
response.Message = $"Couldn't find the tasklist where {task.Title} is going to be saved";
_logger.Warning($"AddAsync: Couldn't find a tasklist with id = {taskListID}");
}
else
{
if (string.IsNullOrEmpty(task.Position))
{
string position = await GetLastestPosition(context, taskList.GoogleTaskListID, task.ParentTask);
task.Position = position;
}
task.TaskList = taskList;
await context.AddAsync(task);
response.Succeed = await context.SaveChangesAsync() > 0;
response.Result = task;
}
_logger.Information("AddAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "AddAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
public void ReturnsSpecifiedFileFromAbsolutePath()
{
var contents = "SampleGoogleServices";
var directory = Path.Combine("Generated", "tests", nameof(ReturnsSpecifiedFileFromAbsolutePath));
Directory.CreateDirectory(directory);
var expectedPath = new FileInfo(Path.Combine(directory, "google-test.json")).FullName;
File.WriteAllText(expectedPath, contents);
var environmentName = nameof(ReturnsSpecifiedFileFromAbsolutePath);
Environment.SetEnvironmentVariable(environmentName, expectedPath, EnvironmentVariableTarget.Process);
var path = GoogleTask.GetResourcePath(environmentName, IntermediateOutputDirectory, "google-services.json");
Assert.Equal(expectedPath, path);
}
private void ReAddReminderDate(
int notificationId,
TaskListItemViewModel taskList,
GoogleTask task)
{
if (!TasksHelper.CanReAddReminder(task.RemindOn.Value))
{
return;
}
string notes = TasksHelper.GetNotesForNotification(task.Notes);
_notificationService.RemoveScheduledNotification(notificationId);
_notificationService.ScheduleNotification(new TaskReminderNotification
{
Id = notificationId,
TaskListId = taskList.Id,
TaskId = task.ID,
TaskListTitle = taskList.Title,
TaskTitle = task.Title,
TaskBody = notes,
DeliveryOn = task.RemindOn.Value
});
}
private async Task <IEnumerable <TaskItemViewModel> > SaveSubTasksAsync(
IEnumerable <TaskItemViewModel> subTasksToSave,
bool isNewTask,
bool moveToDifferentTaskList,
List <TaskItemViewModel> currentSubTasks)
{
ShowTaskProgressRing = true;
string taskListID = moveToDifferentTaskList
? SelectedTaskList.TaskListID
: _currentTaskList.TaskListID;
if (moveToDifferentTaskList && !isNewTask)
{
foreach (var subTask in subTasksToSave)
{
var lastStID = currentSubTasks.LastOrDefault()?.TaskID;
var moveResponse = await _dataService
.TaskService
.MoveAsync(taskListID, subTask.TaskID, subTask.ParentTask, lastStID);
if (moveResponse.Succeed)
{
currentSubTasks.Add(_mapper.Map <TaskItemViewModel>(moveResponse.Result));
}
}
}
else
{
foreach (var subTask in subTasksToSave)
{
var lastStID = currentSubTasks.LastOrDefault()?.TaskID;
var entity = new GoogleTask
{
CompletedOn = subTask.CompletedOn,
CreatedAt = DateTimeOffset.UtcNow,
GoogleTaskID = subTask.IsNew
? Guid.NewGuid().ToString()
: subTask.TaskID,
IsDeleted = subTask.IsDeleted,
IsHidden = subTask.IsHidden,
LocalStatus = LocalStatus.CREATED,
Notes = subTask.Notes,
ParentTask = isNewTask && moveToDifferentTaskList
? subTask.ParentTask
: CurrentTask.TaskID,
Position = lastStID,
Status = subTask.Status,
Title = subTask.Title,
ToBeCompletedOn = subTask.ToBeCompletedOn,
ToBeSynced = true,
UpdatedAt = DateTimeOffset.UtcNow
};
var response = await _dataService
.TaskService
.AddAsync(taskListID, entity);
if (response.Succeed)
{
currentSubTasks.Add(_mapper.Map <TaskItemViewModel>(response.Result));
}
}
}
ShowTaskProgressRing = false;
return(currentSubTasks);
}
private async Task SaveChangesAsync()
{
bool isNewTask = CurrentTask.IsNew;
if (SelectedTaskList?.TaskListID == null || _currentTaskList?.TaskListID == null)
{
await _dialogService.ShowMessageDialogAsync(
$"An error occurred while trying to {(isNewTask ? "save" : "update")} the task.",
$"The selected task list and the current task list cant be null");
return;
}
if (CurrentTask.RemindOn.HasValue)
{
var minutesDiff = (CurrentTask.RemindOn.Value - DateTimeOffset.Now).TotalMinutes;
if (minutesDiff < 2)
{
_messenger.Send(
$"The date of the reminder must be at least 2 mins above the current time.",
$"{MessageType.SHOW_IN_APP_NOTIFICATION}");
return;
}
}
//If the task list selected in the combo is not the same as the one in the
//navigation view, its because we are trying to save/update a
//task into a different task list
bool moveToDifferentTaskList = SelectedTaskList.TaskListID != _currentTaskList.TaskListID;
//If we are updating a task but also moving it into a different tasklist
if (moveToDifferentTaskList && !isNewTask)
{
bool move = await _dialogService.ShowConfirmationDialogAsync(
"Confirm",
"Since you are moving an existing task to a different task list, any change made here will be lost. Do you want to continue ?",
"Yes",
"No");
if (move)
{
await MoveCurrentTaskAsync();
}
return;
}
GoogleTask entity;
ShowTaskProgressRing = true;
if (isNewTask)
{
entity = new GoogleTask();
}
else
{
var dbResponse = await _dataService
.TaskService
.FirstOrDefaultAsNoTrackingAsync(t => t.GoogleTaskID == CurrentTask.TaskID);
if (!dbResponse.Succeed || dbResponse.Result == null)
{
ShowTaskProgressRing = false;
await _dialogService.ShowMessageDialogAsync(
"Error",
$"Couldn't find the task to update from db. Error = {dbResponse.Message}");
return;
}
entity = dbResponse.Result;
}
if (!moveToDifferentTaskList || moveToDifferentTaskList && isNewTask)
{
if (isNewTask)
{
entity.CreatedAt = DateTimeOffset.UtcNow;
}
entity.CompletedOn = CurrentTask.CompletedOn;
entity.GoogleTaskID = CurrentTask.IsNew
? Guid.NewGuid().ToString()
: CurrentTask.TaskID;
entity.IsDeleted = CurrentTask.IsDeleted;
entity.IsHidden = CurrentTask.IsHidden;
entity.Notes = CurrentTask.Notes;
entity.ParentTask = CurrentTask.ParentTask;
entity.Position = CurrentTask.Position;
entity.Status = CurrentTask.IsNew
? GoogleTaskStatus.NEEDS_ACTION.GetString()
: CurrentTask.Status;
entity.Title = CurrentTask.Title;
entity.LocalStatus = CurrentTask.IsNew
? LocalStatus.CREATED
: entity.LocalStatus == LocalStatus.CREATED
? LocalStatus.CREATED
: LocalStatus.UPDATED;
entity.ToBeSynced = true;
entity.UpdatedAt = DateTimeOffset.UtcNow;
entity.ToBeCompletedOn = CurrentTask.ToBeCompletedOn;
entity.RemindOn = CurrentTask.RemindOn;
}
//If the current task has a reminder date and the entity doesn't have
//a reminder guid, we set it up. I do this to avoid replacing the guid
if (CurrentTask.RemindOn.HasValue && string.IsNullOrEmpty(entity.RemindOnGUID))
{
//the 12 is because uwp toast notif. doesnt work with strings longer than that
//and the '-' is because hashcode can return a negative integer
entity.RemindOnGUID = string.Join("", $"{entity.GetHashCode()}".Take(12).Where(c => c != '-'));
}
ResponseDto <GoogleTask> response;
var subTasksToSave = GetSubTasksToSave(isNewTask, moveToDifferentTaskList);
var currentSts = GetCurrentSubTasks();
//If we are creating a new task but in a different tasklist
if (moveToDifferentTaskList)
{
response = await _dataService
.TaskService
.AddAsync(SelectedTaskList.TaskListID, entity);
if (!response.Succeed)
{
ShowTaskProgressRing = false;
await _dialogService.ShowMessageDialogAsync(
$"An error occurred while trying to seve the task into {SelectedTaskList.Title}.",
$"Error = {response.Message}.");
return;
}
_messenger.Send(false, $"{MessageType.OPEN_PANE}");
subTasksToSave.ForEach(st => st.ParentTask = entity.GoogleTaskID);
await SaveSubTasksAsync(
subTasksToSave,
isNewTask,
moveToDifferentTaskList,
Enumerable.Empty <TaskItemViewModel>().ToList());
_messenger.Send(
$"The task was sucessfully created into {SelectedTaskList.Title}",
$"{MessageType.SHOW_IN_APP_NOTIFICATION}");
return;
}
else if (isNewTask)
{
response = await _dataService
.TaskService
.AddAsync(_currentTaskList.TaskListID, entity);
}
else
{
response = await _dataService
.TaskService
.UpdateAsync(entity);
}
ShowTaskProgressRing = false;
if (!response.Succeed)
{
await _dialogService.ShowMessageDialogAsync(
$"An error occurred while trying to {(isNewTask ? "save" : "update")} the task.",
$"Error: {response.Message}.");
return;
}
CurrentTask = _mapper.Map <TaskItemViewModel>(response.Result);
var sts = await SaveSubTasksAsync(subTasksToSave, isNewTask, moveToDifferentTaskList, currentSts);
CurrentTask.SubTasks = new ObservableCollection <TaskItemViewModel>(sts);
if (CurrentTask.RemindOn.HasValue)
{
string notes = CurrentTask.Notes.Length > 15
? $"{CurrentTask.Notes.Substring(0, 15)}...."
: $"{CurrentTask.Notes}....";
int id = int.Parse(response.Result.RemindOnGUID);
_notificationService.RemoveScheduledNotification(id);
_notificationService.ScheduleNotification(new TaskReminderNotification
{
Id = id,
TaskListId = _currentTaskList.Id,
TaskId = CurrentTask.Id,
TaskListTitle = _currentTaskList.Title,
TaskTitle = CurrentTask.Title,
TaskBody = notes,
DeliveryOn = CurrentTask.RemindOn.Value
});
}
_messenger.Send(CurrentTask.TaskID, $"{MessageType.TASK_SAVED}");
UpdateTaskOperationTitle(isNewTask, CurrentTask.HasParentTask);
_changedProperties.Clear();
}
public async Task <ResponseDto <GoogleTask> > MoveAsync(string selectedTaskListID, string taskID, string parentTask, string previous)
{
return(await Task.Run(async() =>
{
_logger.Information($"MoveAsync: Trying to move the taskID = {taskID} to tasklistID {selectedTaskListID} with parentTask = {parentTask} and previousTaskID = {previous}");
var response = new ResponseDto <GoogleTask>
{
Message = string.Empty,
Succeed = false
};
using (var context = new MiraiNotesContext())
{
try
{
var taskList = await context
.TaskLists
.FirstOrDefaultAsync(tl => tl.GoogleTaskListID == selectedTaskListID);
if (taskList == null)
{
response.Message = $"Couldn't find the selected task list in db";
_logger.Warning($"MoveAsync: Couldn't find the selected task list id = {selectedTaskListID}");
return response;
}
var oldEntity = await context
.Tasks
.FirstOrDefaultAsync(t => t.GoogleTaskID == taskID);
if (oldEntity == null)
{
response.Message = $"Couldn't find the task to be moved in db";
_logger.Warning($"MoveAsync: Couldn't find the task to be moved. TaskID = {taskID}");
return response;
}
string position = await GetLastestPosition(context, taskList.GoogleTaskListID, parentTask);
var entity = new GoogleTask
{
CompletedOn = oldEntity.CompletedOn,
CreatedAt = DateTimeOffset.UtcNow,
GoogleTaskID = Guid.NewGuid().ToString(),
IsDeleted = oldEntity.IsDeleted,
IsHidden = oldEntity.IsHidden,
LocalStatus = LocalStatus.CREATED,
Notes = oldEntity.Notes,
ParentTask = parentTask,
Position = position,
RemindOn = oldEntity.RemindOn,
RemindOnGUID = oldEntity.RemindOnGUID,
Status = oldEntity.Status,
TaskList = taskList,
Title = oldEntity.Title,
ToBeCompletedOn = oldEntity.ToBeCompletedOn,
ToBeSynced = true,
UpdatedAt = DateTimeOffset.UtcNow
};
if (oldEntity.LocalStatus == LocalStatus.CREATED)
{
context.Remove(oldEntity);
}
else
{
oldEntity.LocalStatus = LocalStatus.DELETED;
oldEntity.ToBeSynced = true;
oldEntity.UpdatedAt = DateTimeOffset.UtcNow;
}
await context.Tasks.AddAsync(entity);
response.Succeed = await context.SaveChangesAsync() > 0;
response.Result = entity;
_logger.Information("MoveAsync: Completed successfully");
}
catch (Exception e)
{
_logger.Error(e, "MoveAsync: An unknown error occurred");
response.Message = GetExceptionMessage(e);
}
}
return response;
}).ConfigureAwait(false));
}
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);
}
