public async Task RemoveUsersThatAreNotInTheCurrentSignUpList()
{
var task = new AllReadyTask {
Id = 1
};
Context.Add(new ApplicationUser {
Id = "user2"
});
var previouslySignedupUser = new ApplicationUser
{
Id = "user1",
Email = "*****@*****.**",
PhoneNumber = "1234"
};
task.AssignedVolunteers = new List <TaskSignup> {
new TaskSignup {
User = previouslySignedupUser
}
};
Context.Add(task);
Context.SaveChanges();
var message = new AssignTaskCommand {
TaskId = task.Id, UserIds = new List <string> {
"user2"
}
};
await sut.Handle(message);
Assert.True(Context.Tasks.Single(x => x.Id == task.Id).AssignedVolunteers.Any(x => x.User.Id != previouslySignedupUser.Id));
}
public async Task PublishTaskAssignedToVolunteersNotification()
{
var task = new AllReadyTask {
Id = 1
};
var volunteer = new ApplicationUser
{
Id = "user1",
Email = "*****@*****.**",
PhoneNumber = "1234",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
Context.Add(volunteer);
Context.Add(task);
Context.SaveChanges();
var message = new AssignTaskCommand {
TaskId = task.Id, UserIds = new List <string> {
volunteer.Id
}
};
await sut.Handle(message);
mediator.Verify(b => b.PublishAsync(It.Is <TaskAssignedToVolunteersNotification>(notification =>
notification.TaskId == message.TaskId &&
notification.NewlyAssignedVolunteers.Contains(volunteer.Id)
)), Times.Once());
}
public async Task DoesNotPublishTaskAssignedNotificationToVolunteersPreviouslySignedUp()
{
var task = new AllReadyTask {
Id = 1
};
var previouslySignedupUser = new ApplicationUser
{
Id = "user1",
Email = "*****@*****.**",
PhoneNumber = "1234",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
Context.Add(previouslySignedupUser);
task.AssignedVolunteers = new List <TaskSignup> {
new TaskSignup {
User = previouslySignedupUser
}
};
Context.Add(task);
Context.SaveChanges();
var message = new AssignTaskCommand {
TaskId = task.Id, UserIds = new List <string> {
previouslySignedupUser.Id
}
};
await sut.Handle(message);
mediator.Verify(b => b.PublishAsync(It.Is <TaskAssignedToVolunteersNotification>(notification => !notification.NewlyAssignedVolunteers.Contains(previouslySignedupUser.Id))), Times.Once);
}
public async Task AssignsVolunteersToTask()
{
var newVolunteer = new ApplicationUser {
Id = "user1", Email = "*****@*****.**", PhoneNumber = "1234"
};
var task = new AllReadyTask {
Id = 1
};
Context.Add(newVolunteer);
Context.Add(task);
Context.SaveChanges();
var message = new AssignTaskCommand {
TaskId = task.Id, UserIds = new List <string> {
newVolunteer.Id
}
};
await sut.Handle(message);
var taskSignup = Context.Tasks.Single(x => x.Id == task.Id).AssignedVolunteers.Single();
Assert.Equal(taskSignup.User.Id, newVolunteer.Id);
Assert.Equal(taskSignup.Status, TaskStatus.Assigned.ToString());
}
public static AssignTaskCommand ToAssignTaskCommand(this TaskVm model)
{
var command = new AssignTaskCommand()
{
Id = model.Id,
AssignedToId = model.AssignedToId
};
return(command);
}
public async Task <IActionResult> AssignTask(AssignTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _taskService.AssignTaskCommandHandler(command);
return(Ok(result));
}
public async Task <IActionResult> Assign(AssignTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _taskService.AssignTaskCommandHandler(command);
return(Ok(result));
}
catch (NotFoundException <Guid> )
{
return(NotFound());
}
}
public async Task <IActionResult> AssignTaskToMember(Guid TaskId, [FromBody] AssignTaskCommand command)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await _taskService.AssignTaskCommandHandler(command);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
/// <summary>
/// Converts to assigntaskcommand.
/// </summary>
/// <param name="model">The model.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">model</exception>
/// <exception cref="ArgumentException">No member found - Id</exception>
public static AssignTaskCommand ToAssignTaskCommand(this TaskVm model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (model.Member?.Id == null)
{
throw new ArgumentException("No member selected", nameof(TaskVm.Member.Id));
}
AssignTaskCommand command = new AssignTaskCommand
{
Id = model.Id,
AssignedMemberId = model.Member.Id
};
return(command);
}
public async Task <AssignTaskCommandResult> AssignTaskCommandHandler(AssignTaskCommand command)
{
var isSucceed = true;
var task = await _taskRepository.ByIdAsync(command.TaskId);
task.AssignedToId = command.MemberId;
var affectedRecordsCount = await _taskRepository.UpdateRecordAsync(task);
if (affectedRecordsCount < 1)
{
isSucceed = false;
}
return(new AssignTaskCommandResult()
{
Success = isSucceed
});
}
public async Task <AssignTaskCommandResult> AssignTaskCommandHandler(AssignTaskCommand command)
{
var isSucceed = true;
var task = await _taskRepository.ByIdAsync(command.Id);
_mapper.Map(command, task);
var affectedRecordsCount = await _taskRepository.UpdateRecordAsync(task);
if (affectedRecordsCount < 1)
{
isSucceed = false;
}
return(new AssignTaskCommandResult
{
Succeed = isSucceed
});
}
public async Task <AssignTaskCommandResult> AssignTaskCommandHandler(AssignTaskCommand command)
{
if (command == null)
{
throw new ArgumentNullException(nameof(command));
}
var task = await _taskRepository.ByIdAsync(command.Id);
_mapper.Map(command, task);
var affectedRecordsCount = await _taskRepository.UpdateRecordAsync(task);
var Succees = affectedRecordsCount == 1;
return(new AssignTaskCommandResult
{
Succees = Succees
});
}
public static AssignTaskCommand ToAssignTaskCommand(this TaskVm model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (model.AssignedMember?.Id == null)
{
throw new ArgumentException("No member was found to assign to.", nameof(TaskVm.AssignedMember.Id));
}
var command = new AssignTaskCommand
{
Id = model.Id,
AssignedMemberId = model.AssignedMember.Id
};
return(command);
}
private void ListItemSelected(object sender, SelectedItemChangedEventArgs e)
{
ListView senderLV = (ListView)sender;
object tappedObj = e.SelectedItem;
//don't allow items to be selected
senderLV.SelectedItem = null;
//this will be called again when we clear the SelectedItem, so this is here to skip that call
if (tappedObj == null)
{
return;
}
if (senderLV == m_lstMembers && m_permManageMembers)
{ //member list triggered this event
Member tappedMember = tappedObj as Member;
//can't manage myself
if (tappedMember == m_me)
{
return;
}
ManageMemberPrompt p = new ManageMemberPrompt();
if (tappedMember.Role == Role.MEMBER)
{
p.State = ManageMemberPrompt.BtnState.PROMOTE;
}
else if (tappedMember.Role == Role.MANAGER)
{
p.State = ManageMemberPrompt.BtnState.DEMOTE;
}
p.OnPromote += new EventHandler((o, e2) =>
{
PromoteMemberCommand cmd = new PromoteMemberCommand()
{
Project = m_proj.ID, Member = tappedMember.ID
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
tappedMember.Role = Role.MANAGER;
p.State = ManageMemberPrompt.BtnState.DEMOTE;
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
});
p.OnDemote += new EventHandler((o, e2) =>
{
DemoteMemberCommand cmd = new DemoteMemberCommand()
{
Project = m_proj.ID, Member = tappedMember.ID
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
tappedMember.Role = Role.MEMBER;
p.State = ManageMemberPrompt.BtnState.PROMOTE;
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
});
p.OnDelete += new EventHandler((o, e2) =>
{
Prompt pc = new Prompt()
{
PromptTitle = "Are you sure?", PositiveButtonText = "Yes", NegativeButtonText = "No"
};
pc.OnPromptSaved += new Prompt.PromptClosedEventListener(() =>
{
DeleteMemberCommand cmd = new DeleteMemberCommand()
{
Project = m_proj.ID, Member = tappedMember.ID
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
m_proj.Members.Remove(tappedMember);
ReloadProjectDisplay();
pc.Dismiss();
p.Dismiss();
});
CondorAPI.getInstance().Execute(cmd);
});
pc.Show(m_mdp);
});
p.Show(m_mdp);
}
else if (senderLV == m_lstMyTasks)
{ //my tasks list triggered this event
Models.Task tappedTask = tappedObj as Models.Task;
ManageMyTaskPrompt p = new ManageMyTaskPrompt(tappedTask);
p.OnPromptSaved += new Prompt.PromptClosedEventListener(() =>
{
//do nothing if nothing was changed
if (p.SelectedStatus == tappedTask.Status)
{
return;
}
//execute the command to set the task status
SetTaskStatusCommand cmd = new SetTaskStatusCommand()
{
Project = m_proj.ID, Task = tappedTask.Name, Status = p.SelectedStatus.str
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//update the status and reload the display
tappedTask.Status = p.SelectedStatus;
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
});
p.Show(m_mdp);
}
else if (senderLV == m_lstAllTasks && m_permManageTasks)
{ //all tasks list triggered this event
Models.Task tappedTask = tappedObj as Models.Task;
ManageTaskPrompt p = new ManageTaskPrompt(m_proj);
p.Date = tappedTask.Due;
p.Description = tappedTask.Description;
p.Status = (tappedTask.Assigned == null) ? ManageTaskPrompt.BtnStatus.ASSIGN : ManageTaskPrompt.BtnStatus.DEASSIGN;
p.AssignedMember = tappedTask.Assigned;
p.OnAssign += new EventHandler((o, e2) =>
{
AssignTaskCommand cmd = new AssignTaskCommand()
{
Project = m_proj.ID, Task = tappedTask.Name, Member = p.AssignedMember.ID
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//update the dialog
p.HidePicker();
p.Status = ManageTaskPrompt.BtnStatus.DEASSIGN;
//update the task and reload the display
tappedTask.Assigned = p.AssignedMember;
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
});
p.OnDeassign += new EventHandler((o, e2) =>
{
DeassignTaskCommand cmd = new DeassignTaskCommand()
{
Project = m_proj.ID, Task = tappedTask.Name
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//update the dialog
p.Status = ManageTaskPrompt.BtnStatus.ASSIGN;
//update the task and reload the display
tappedTask.Assigned = null;
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
});
p.OnDelete += new EventHandler((o, e2) =>
{
DeleteTaskCommand cmd = new DeleteTaskCommand()
{
Project = m_proj.ID, Title = tappedTask.Name
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//remove the task from the list
m_proj.Tasks.Remove(tappedTask);
//reload the display
ReloadProjectDisplay();
//close the prompt
p.Dismiss();
});
CondorAPI.getInstance().Execute(cmd);
});
p.OnPromptSaved += new Prompt.PromptClosedEventListener(() =>
{
//update the due date if changed
if (p.Date.ToFileTimeUtc() != tappedTask.Due.ToFileTimeUtc())
{
SetTaskDueCommand cmd = new SetTaskDueCommand()
{
Project = m_proj.ID, Task = tappedTask.Name, Due = p.Date
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//update the due date
tappedTask.Due = p.Date;
//reload the display
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
}
//update the description if changed
if (p.Description != tappedTask.Description)
{
SetTaskDescCommand cmd = new SetTaskDescCommand()
{
Project = m_proj.ID, Task = tappedTask.Name, Description = p.Description
};
cmd.OnResponseReceived += new APICommand.ResponseReceivedHandler((response) =>
{
if ((string)response.GetValue("result") != "success")
{
DependencyService.Get <INotification>().ShortAlert("ERROR: " + (string)response.GetValue("msg"));
return;
}
//update the description
tappedTask.Description = p.Description;
//reload the display
ReloadProjectDisplay();
});
CondorAPI.getInstance().Execute(cmd);
}
});
p.Show(m_mdp);
}
}
private async Task <HttpResponseMessage> AssignTaskToMember(AssignTaskCommand command)
{
var httpContent = new StringContent(Newtonsoft.Json.JsonConvert.SerializeObject(command), Encoding.UTF8, "application/json");
return(await httpClient.PatchAsync($"tasks/{command.TaskId}", httpContent));
}
private async Task <AssignTaskCommandResult> AssignTask(AssignTaskCommand command)
{
return(await httpClient.PostJsonAsync <AssignTaskCommandResult>("tasks/assigntask", command));
}
private async Task <AssignTaskCommandResult> Assign(AssignTaskCommand command)
{
return(await httpClient.PutJsonAsync <AssignTaskCommandResult>($"tasktodo/{command.Id}/{command.AssignedToId}", command));
}
private async Task <AssignTaskCommandResult> Assign(AssignTaskCommand command) =>
await _httpClient.PutJsonAsync <AssignTaskCommandResult>("tasks/assign", command);
public async Task <AssignTaskCommandResult> Assign(AssignTaskCommand command)
{
return(await _httpClient.PutJsonAsync <AssignTaskCommandResult>($"tasks/{command.Id}:assign", command));
}
