public async Task MoveSubTasks(string taskListID, MvxObservableCollection <TaskItemViewModel> subTasks)
{
var orderedSubTasks = subTasks.OrderBy(st => st.Position).ToList();
foreach (var st in orderedSubTasks)
{
var moveResponse = await _dataService
.TaskService
.MoveAsync(taskListID, st.GoogleId, st.ParentTask, null);
if (!moveResponse.Succeed)
{
Logger.Error(
$"{nameof(MoveSubTasks)}: An error occurred while trying to move subtaskId = {st.GoogleId}. " +
$"Error = {moveResponse.Message}");
}
else
{
var movedTask = moveResponse.Result;
if (TasksHelper.HasReminderId(movedTask.RemindOnGUID, out int id))
{
ReAddReminderDate(id, Parameter.NewTaskList, movedTask);
}
}
}
}
public async Task Interleaved_ShouldExecuteTasksByDuration()
{
var tasks = new[]
{
Task.Delay(3000).ContinueWith(_ => 3),
Task.Delay(1000).ContinueWith(_ => 1),
Task.Delay(2000).ContinueWith(_ => 2),
Task.Delay(5000).ContinueWith(_ => 5),
Task.Delay(4000).ContinueWith(_ => 4),
};
var res = new List <int>();
foreach (var bucket in TasksHelper.Interleaved(tasks))
{
var t = await bucket;
var result = await t;
res.Add(result);
}
Assert.Collection(res,
item => Assert.Equal(1, item),
item => Assert.Equal(2, item),
item => Assert.Equal(3, item),
item => Assert.Equal(4, item),
item => Assert.Equal(5, item)
);
}
public async Task SchedulePendingNotifications()
{
try
{
_logger.Information($"Getting tasks with a reminder date...");
var taskResponse = await _dataService.TaskService
.GetAsNoTrackingAsync(
t => t.RemindOnGUID != null && t.RemindOn.HasValue,
includeProperties : nameof(GoogleTask.TaskList));
if (!taskResponse.Succeed)
{
_logger.Warning(
$"Could not get all the task with a reminder date. " +
$"Error = {taskResponse.Message}");
return;
}
var tasks = taskResponse.Result;
_logger.Information($"Scheduling notifications for {tasks.Count()} task(s)");
foreach (var task in tasks)
{
string notes = TasksHelper.GetNotesForNotification(task.Notes);
int id = int.Parse(task.RemindOnGUID);
_notificationService.ScheduleNotification(new TaskReminderNotification
{
Id = id,
TaskListId = task.TaskList.ID,
TaskId = task.ID,
TaskListTitle = task.TaskList.Title,
TaskTitle = task.Title,
TaskBody = notes,
DeliveryOn = task.RemindOn.Value
});
}
_logger.Information($"Process completed");
}
catch (Exception e)
{
_logger?.Error(e,
$"An unknown error occurred while trying " +
$"to schedule pending notifications");
_telemetryService?.TrackError(e);
}
}
private async Task DeleteSubTaskAsync(TaskItemViewModel subTask)
{
bool deleteTask = await _dialogService.ShowConfirmationDialogAsync(
"Confirmation",
$"Are you sure you wanna delete {subTask.Title}?",
"Yes",
"No");
if (!deleteTask)
{
return;
}
if (subTask.IsNew)
{
CurrentTask.SubTasks?.Remove(subTask);
return;
}
ShowTaskProgressRing = true;
var deleteResponse = await _dataService
.TaskService
.RemoveTaskAsync(subTask.TaskID);
if (TasksHelper.HasReminderId(subTask.RemindOnGUID, out int id))
{
_notificationService.RemoveScheduledNotification(id);
}
ShowTaskProgressRing = false;
if (!deleteResponse.Succeed)
{
await _dialogService.ShowMessageDialogAsync(
"Error",
$"Coudln't delete the selected sub task. Error = {deleteResponse.Message}");
return;
}
CurrentTask.SubTasks?.Remove(subTask);
_messenger.Send(
new KeyValuePair <string, string>(CurrentTask.TaskID, subTask.TaskID),
$"{MessageType.SUBTASK_DELETED_FROM_PANE_FRAME}");
}
private async Task <bool> DeleteTask(TaskItemViewModel task)
{
if (task.HasParentTask && task.IsNew ||
task.IsNew)
{
Messenger.Publish(new TaskDeletedMsg(this, task.GoogleId, task.ParentTask));
return(true);
}
Messenger.Publish(new ShowProgressOverlayMsg(this));
var deleteResponse = await _dataService
.TaskService
.RemoveTaskAsync(task.GoogleId);
if (TasksHelper.HasReminderId(task.RemindOnGUID, out int id))
{
_notificationService.RemoveScheduledNotification(id);
}
if (task.HasSubTasks)
{
foreach (var st in task.SubTasks)
{
if (TasksHelper.HasReminderId(st.RemindOnGUID, out int stReminderId))
{
_notificationService.RemoveScheduledNotification(stReminderId);
}
}
}
Messenger.Publish(new ShowProgressOverlayMsg(this, false));
if (!deleteResponse.Succeed)
{
Logger.Error(
$"{nameof(DeleteTask)}: Couldn't delete the selected task." +
$"Error = {deleteResponse.Message}");
return(false);
}
Messenger.Publish(new TaskDeletedMsg(this, task.GoogleId, task.ParentTask));
return(true);
}
public object Convert(
object value, Type targetType,
object parameter, CultureInfo culture)
{
int taskID = (int)System.Convert.ChangeType(value, typeof(int));
TasksHelper client = new TasksHelper();
Task task = client.GetTask(taskID);
client.Close();
DateTime dueDate = task.DueDate;
double percentageCompleted = task.PercentageCompletion;
if (percentageCompleted < 100)
{
if (dueDate.CompareTo(DateTime.Now) < 0)
{
return -1;
}
else
return 0;
}
return 1;//normal
}
public ActionResult Login(LoginViewModel loginViewModel)
{
if (!ModelState.IsValid)
{
return(View(loginViewModel));
}
if (new CustomMemberShipProvider().ValidateUser(loginViewModel.UserName, loginViewModel.Password))
{
User MatchedUser = Users.FirstOrDefault(x => x.Username.Equals(loginViewModel.UserName));
if (MatchedUser != null)
{
FormsAuthentication.SetAuthCookie(MatchedUser.Username, true);
Session["UserId"] = new TasksHelper().GetUserID(MatchedUser.Username);
}
else
{
TempData["RegisterAlertMsg"] = "<script>alert('No user found please register');</script>";
return(RedirectToAction("Register"));
}
}
return(RedirectToAction("Index", "Home"));
}
private async Task <bool> MoveTask(TaskListItemViewModel selectedTaskList, TaskItemViewModel task)
{
Messenger.Publish(new ShowProgressOverlayMsg(this));
var moveResponse = await _dataService
.TaskService
.MoveAsync(selectedTaskList.GoogleId, task.GoogleId, null, null);
if (moveResponse.Succeed)
{
var movedTask = moveResponse.Result;
//If this task had a reminder, we need to recreate it
if (TasksHelper.HasReminderId(movedTask.RemindOnGUID, out int id))
{
ReAddReminderDate(id, selectedTaskList, movedTask);
}
foreach (var st in task.SubTasks)
{
st.ParentTask = moveResponse.Result.GoogleTaskID;
}
await MoveSubTasks(selectedTaskList.GoogleId, task.SubTasks);
}
else
{
Logger.Error(
$"{nameof(MoveTask)}: An error occurred while tryingg to move taskId = {task.Id}. " +
$"Error = {moveResponse.Message}");
}
Messenger.Publish(new TaskMovedMsg(this, task.GoogleId, selectedTaskList.GoogleId, task.ParentTask));
Messenger.Publish(new ShowProgressOverlayMsg(this, false));
return(moveResponse.Succeed);
}
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 NodeData()
{
RoutedMessagesId = new List <Guid>();
Task.Run(async() =>
{
while (true)
{
try
{
NodeKeysDto nodeKeys = await AppServiceProvider.Instance.KeysService.GetActualNodeKeysAsync(NodeSettings.Configs.Node.Id).ConfigureAwait(false);
if (nodeKeys == null ||
(nodeKeys.ExpirationTime - DateTime.UtcNow.ToUnixTime()) <= TimeSpan.FromDays(5).TotalSeconds)
{
nodeKeys = await AppServiceProvider.Instance.KeysService.CreateNewNodeKeysAsync(NodeSettings.Configs.Node.Id, HttpServer.Models.CreateNewKeysModel.KeyLength.Long, 10 * 24 * 3600).ConfigureAwait(false);
if (NodeKeys == null)
{
NodeKeys = nodeKeys;
}
await NodeNoticeService.SendNewNodeKeysNodeNoticeAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime).ConfigureAwait(false);
await LicensorClient.Instance.AddNewKeyAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime, nodeKeys.GenerationTime, true).ConfigureAwait(false);
}
NodeKeys = nodeKeys;
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
finally
{
await Task.Delay(TimeSpan.FromSeconds(60)).ConfigureAwait(false);
}
}
}).Wait(TimeSpan.FromSeconds(5));
TasksHelper.StartRemoveExpiredMessagesTask();
}
public void Configure(IApplicationBuilder app, IApplicationLifetime applicationLifetime)
{
AppServiceProvider.Instance = (AppServiceProvider)app.ApplicationServices.GetService <IAppServiceProvider>();
NodeData.NodeNoticeService = app.ApplicationServices.GetService <INodeNoticeService>();
NodeData.ConnectionsService = app.ApplicationServices.GetService <IConnectionsService>();
NodeConnector.ConnectionsService = app.ApplicationServices.GetService <IConnectionsService>();
app.UseRequestLocalization();
app.UseHsts();
app.UseHttpsRedirection();
app.UseMiddleware <IgnoreRouteMiddleware>();
app.UseMiddleware <AdminSignOutMiddleware>();
app.UseStaticFiles();
applicationLifetime.ApplicationStopping.Register(OnShutdown);
app.UseCors(builder =>
{
builder.AllowAnyHeader()
.AllowAnyMethod()
.AllowAnyOrigin();
});
app.UseWebSockets();
if (NodeSettings.IsAppConfigured)
{
app.UseFluffySpoonLetsEncryptChallengeApprovalMiddleware();
}
if (NodeSettings.IsAppConfigured &&
(NodeSettings.Configs.Certificate.Location != null &&
File.Exists(NodeSettings.Configs.Certificate.Location) ||
LetsEncryptRenewalService.Certificate != null))
{
app.UseHttpsRedirection();
}
app.UseCookiePolicy();
app.UseAuthentication();
app.UseMvc(routes =>
{
routes.MapRoute(
"Default",
"{controller}/{action}",
new
{
controller = "WebSocket",
action = "Index"
});
});
if (NodeSettings.IsAppConfigured)
{
try
{
AppServiceProvider.Instance.NodesService.CreateOrUpdateNodeInformationAsync(NodeSettings.Configs.Node);
LicensorClient.Instance.AuthAsync().Wait(5000);
NodeSettings.Configs.License = LicensorClient.Instance.GetLicenseAsync().Result;
TasksHelper.StartUpdateLicenseTask();
TasksHelper.StartUpdateSessionKeyTask();
try
{
NodeSettings.Configs.Node = LicensorClient.Instance.EditNodeAsync(NodeSettings.Configs.Node).Result;
}
catch (Exception ex)
{
Console.WriteLine($"An error ocurred while updating node information: {ex.Message}");
}
File.WriteAllText("Config/appsettings.json", ObjectSerializer.ObjectToJson(NodeSettings.Configs, true));
app.ApplicationServices.GetService <IPoolsService>().CheckNodePoolsAsync().Wait();
DbBackupHelper.StartDbBackupOperationAsync(NodeSettings.Configs.MessengerDbConnection);
InitializeNodeConnections();
TasksHelper.StartNodeConnectionsCheckTask();
DockerCleanHepler.Clear();
BlockchainSynchronizationService synchronizationService = new BlockchainSynchronizationService();
synchronizationService.CheckAndSyncBlockchainAsync().Wait();
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
}
private async Task MoveCurrentTaskAsync()
{
ShowTaskProgressRing = true;
var moveResponse = await _dataService
.TaskService
.MoveAsync(SelectedTaskList.TaskListID, CurrentTask.TaskID, null, null);
if (!moveResponse.Succeed)
{
ShowTaskProgressRing = false;
await _dialogService.ShowMessageDialogAsync(
$"An error occurred while trying to move the selected task from {_currentTaskList.Title} to {SelectedTaskList.Title}",
$"Error: {moveResponse.Message}.");
return;
}
var movedTask = moveResponse.Result;
if (movedTask != null &&
TasksHelper.HasReminderId(movedTask.RemindOnGUID, out int id) &&
TasksHelper.CanReAddReminder(movedTask.RemindOn.Value))
{
string notes = TasksHelper.GetNotesForNotification(movedTask.Notes);
_notificationService.RemoveScheduledNotification(id);
_notificationService.ScheduleNotification(new TaskReminderNotification
{
Id = id,
TaskListId = SelectedTaskList.Id,
TaskId = movedTask.ID,
TaskListTitle = SelectedTaskList.Title,
TaskTitle = movedTask.Title,
TaskBody = notes,
DeliveryOn = movedTask.RemindOn.Value
});
}
if (!CurrentTask.HasParentTask)
{
_messenger.Send(CurrentTask.TaskID, $"{MessageType.TASK_DELETED_FROM_PANE_FRAME}");
}
else
{
_messenger.Send(
new KeyValuePair <string, string>(CurrentTask.ParentTask, CurrentTask.TaskID),
$"{MessageType.SUBTASK_DELETED_FROM_PANE_FRAME}");
}
var subTasks = GetSubTasksToSave(false, true);
subTasks.ForEach(st => st.ParentTask = moveResponse.Result.GoogleTaskID);
ShowTaskProgressRing = false;
await SaveSubTasksAsync(subTasks, false, true, Enumerable.Empty <TaskItemViewModel>().ToList());
_changedProperties.Clear();
_messenger.Send(false, $"{MessageType.OPEN_PANE}");
_messenger.Send(
$"Task sucessfully moved from: {_currentTaskList.Title} to: {SelectedTaskList.Title}",
$"{MessageType.SHOW_IN_APP_NOTIFICATION}");
}
public async Task DeleteTaskAsync()
{
bool deleteTask = await _dialogService.ShowConfirmationDialogAsync(
"Confirmation",
"Are you sure you wanna delete this task?",
"Yes",
"No");
if (!deleteTask)
{
return;
}
ShowTaskProgressRing = true;
var deleteResponse = await _dataService
.TaskService
.RemoveTaskAsync(CurrentTask.TaskID);
if (TasksHelper.HasReminderId(CurrentTask.RemindOnGUID, out int id))
{
_notificationService.RemoveScheduledNotification(id);
}
if (CurrentTask.HasSubTasks)
{
foreach (var st in CurrentTask.SubTasks)
{
if (TasksHelper.HasReminderId(st.RemindOnGUID, out int stReminderId))
{
_notificationService.RemoveScheduledNotification(stReminderId);
}
}
}
ShowTaskProgressRing = false;
if (!deleteResponse.Succeed)
{
await _dialogService.ShowMessageDialogAsync(
"Error",
$"Coudln't delete the selected task. Error = {deleteResponse.Message}.");
return;
}
//If we are deleting a subtask
if (CurrentTask.HasParentTask)
{
_messenger.Send(
new KeyValuePair <string, string>(CurrentTask.ParentTask, CurrentTask.TaskID),
$"{MessageType.SUBTASK_DELETED_FROM_PANE_FRAME}");
}
else
{
_messenger.Send(
CurrentTask.TaskID,
$"{MessageType.TASK_DELETED_FROM_PANE_FRAME}");
}
CleanPanel();
}
public TasksController(ITasksContext context)
{
db = new TasksHelper(context);
}
public TasksController()
{
db = new TasksHelper();
}
