public async Task UserByUserIdQueryHandlerInvokesGetUserWithTheCorrectUserId()
{
var options = CreateNewContextOptions();
const string userId = "1";
var message = new UserByUserIdQuery {
UserId = userId
};
using (var context = new AllReadyContext(options))
{
context.Users.Add(new ApplicationUser
{
Id = userId
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new UserByUserIdQueryHandler(context);
var user = await sut.Handle(message);
Assert.Equal(user.Id, userId);
}
}
protected override async Task HandleCore(DeclineCampaignManagerInviteCommand message)
{
var invite = _context.CampaignManagerInvites.Single(i => i.Id == message.CampaignManagerInviteId);
invite.RejectedDateTimeUtc = DateTimeUtcNow();
await _context.SaveChangesAsync();
}
public async Task <int> Handle(EditCampaignCommand message)
{
var campaign = await _context.Campaigns
.Include(l => l.Location)
.Include(tc => tc.CampaignContacts)
.Include(i => i.CampaignImpact)
.SingleOrDefaultAsync(c => c.Id == message.Campaign.Id) ?? new Campaign();
campaign.Name = message.Campaign.Name;
campaign.Description = message.Campaign.Description;
campaign.FullDescription = message.Campaign.FullDescription;
campaign.ExternalUrl = message.Campaign.ExternalUrl;
campaign.ExternalUrlText = message.Campaign.ExternalUrlText;
campaign.TimeZoneId = message.Campaign.TimeZoneId;
campaign.StartDateTime = dateTimeOffsetsConverter.ConvertDateTimeOffsetTo(campaign.TimeZoneId, message.Campaign.StartDate);
campaign.EndDateTime = dateTimeOffsetsConverter.ConvertDateTimeOffsetTo(campaign.TimeZoneId, message.Campaign.EndDate, 23, 59, 59);
campaign.ManagingOrganizationId = message.Campaign.OrganizationId;
campaign.ImageUrl = message.Campaign.ImageUrl;
CreateUpdateOrDeleteCampaignPrimaryContact(campaign, message.Campaign);
campaign.CampaignImpact = campaign.CampaignImpact.UpdateModel(message.Campaign.CampaignImpact);
campaign.Location = campaign.Location.UpdateModel(message.Campaign.Location);
campaign.Featured = message.Campaign.Featured;
campaign.Headline = message.Campaign.Headline;
_context.AddOrUpdate(campaign);
await _context.SaveChangesAsync();
return(campaign.Id);
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var options = this.CreateNewContextOptions();
const string userId = "12345";
const string firstName = "changed";
var message = new UpdateUser { User = new ApplicationUser {
Id = userId,
FirstName = firstName
} };
using (var context = new AllReadyContext(options)) {
context.Users.Add(new ApplicationUser {
Id = userId,
FirstName = "notChanged"
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateUserHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var user = context.Users.FirstOrDefault(u => u.Id == userId);
Assert.NotNull(user);
Assert.Equal(user.FirstName, firstName);
}
}
public async Task <SetTeamLeadResult> Handle(SetTeamLeadCommand message)
{
var itineraryTaskSignups = await
_context.VolunteerTaskSignups.Where(
x => x.ItineraryId == message.ItineraryId).ToListAsync();
var existingTeamLead = itineraryTaskSignups.FirstOrDefault(x => x.IsTeamLead);
if (existingTeamLead != null)
{
existingTeamLead.IsTeamLead = false;
}
var newTeamLead = itineraryTaskSignups.FirstOrDefault(x => x.Id == message.VolunteerTaskId);
if (newTeamLead == null)
{
return(SetTeamLeadResult.VolunteerTaskSignupNotFound);
}
newTeamLead.IsTeamLead = true;
var changed = await _context.SaveChangesAsync();
return(changed == 0 ? SetTeamLeadResult.SaveChangesFailed : SetTeamLeadResult.Success);
}
public async Task WhenProviderIdIsProvidedAndIsValid_TheStatusOfTheExistingRequestIsUpdated()
{
string pid = "someId";
var request = new Request
{
ProviderId = pid,
Status = RequestStatus.Assigned
};
var command = new AddRequestCommand{Request = request};
var options = this.CreateNewContextOptions();
using (var context = new AllReadyContext(options)) {
context.Requests.Add(new Request {
ProviderId = pid,
Status = RequestStatus.Assigned
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var geocoder = new Mock<IGeocoder>();
AddRequestCommandHandler sut = new AddRequestCommandHandler(context, geocoder.Object);
await sut.Handle(command);
}
using (var context = new AllReadyContext(options)) {
var entity = context.Requests.FirstOrDefault(x => x.ProviderId == pid);
Assert.Equal(entity.Status, RequestStatus.Assigned);
}
}
protected override async Task HandleCore(DeleteOrganization message)
{
var organization = await _context.Organizations.SingleAsync(t => t.Id == message.Id).ConfigureAwait(false);
_context.Organizations.Remove(organization);
await _context.SaveChangesAsync().ConfigureAwait(false);
}
public async Task <int> Handle(EditTaskCommand message)
{
var @task = await _context.Tasks.Include(t => t.RequiredSkills).SingleOrDefaultAsync(t => t.Id == message.Task.Id) ?? new AllReadyTask();
@task.Name = message.Task.Name;
@task.Description = message.Task.Description;
@task.Event = _context.Events.SingleOrDefault(a => a.Id == message.Task.EventId);
@task.Organization = _context.Organizations.SingleOrDefault(t => t.Id == message.Task.OrganizationId);
@task.StartDateTime = message.Task.StartDateTime;
@task.EndDateTime = message.Task.EndDateTime;
@task.NumberOfVolunteersRequired = message.Task.NumberOfVolunteersRequired;
@task.IsLimitVolunteers = @task.Event.IsLimitVolunteers;
@task.IsAllowWaitList = @task.Event.IsAllowWaitList;
if (@task.Id > 0)
{
var taskSkillsToRemove = _context.TaskSkills.Where(ts => ts.TaskId == @task.Id && (message.Task.RequiredSkills == null || message.Task.RequiredSkills.All(ts1 => ts1.SkillId != ts.SkillId)));
_context.TaskSkills.RemoveRange(taskSkillsToRemove);
}
if (message.Task.RequiredSkills != null)
{
@task.RequiredSkills.AddRange(message.Task.RequiredSkills.Where(mt => @task.RequiredSkills.All(ts => ts.SkillId != mt.SkillId)));
}
_context.AddOrUpdate(@task);
await _context.SaveChangesAsync();
return(@task.Id);
}
public async Task InvokeUpdateTaskSignupAsyncForEachTaskSignupViewModelOnCommand()
{
var options = CreateNewContextOptions();
const string userId = "1";
const int firstId = 1;
const int secondId = 2;
var user = new ApplicationUser {Id = userId};
var taskSignupViewModels = new List<TaskSignupViewModel> {new TaskSignupViewModel {Id = firstId}, new TaskSignupViewModel {Id = secondId}};
using (var context = new AllReadyContext(options))
{
context.Users.Add(user);
context.TaskSignups.Add(new TaskSignup { Id = firstId });
context.TaskSignups.Add(new TaskSignup { Id = secondId });
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new UpdateMyTasksCommandHandler(context) { DateTimeUtcNow = () => DateTime.UtcNow };
await sut.Handle(new UpdateMyTasksCommand { TaskSignups = taskSignupViewModels });
}
using (var context = new AllReadyContext(options))
{
var signup1 = context.TaskSignups.FirstOrDefault(x => x.Id == firstId);
Assert.Equal(signup1 != null, true);
var signup2 = context.TaskSignups.FirstOrDefault(x => x.Id == secondId);
Assert.Equal(signup2 != null, true);
}
}
public async Task <bool> Handle(RemoveRequestCommand message)
{
var itineraryRequests = await _context.ItineraryRequests
.Include(r => r.Itinerary)
.Include(r => r.Request)
.Where(r => r.ItineraryId == message.ItineraryId)
.ToListAsync().ConfigureAwait(false);
var requestToRemove = itineraryRequests.FirstOrDefault(r => r.RequestId == message.RequestId);
if (requestToRemove == null || requestToRemove.Request.Status == RequestStatus.Completed)
{
return(false);
}
// Update the request status
requestToRemove.Request.Status = RequestStatus.Unassigned;
// remove the request to itinerary assignment
_context.ItineraryRequests.Remove(requestToRemove);
var requestsToMoveUp = itineraryRequests.Where(r => r.ItineraryId == message.ItineraryId && r.OrderIndex > requestToRemove.OrderIndex);
foreach (var requestToMoveUp in requestsToMoveUp)
{
requestToMoveUp.OrderIndex--;
}
await _context.SaveChangesAsync().ConfigureAwait(false);
return(true);
}
public async Task HandleReturnsEventsWitUnlockedCampaigns()
{
var options = CreateNewContextOptions();
const int unlockedEventId = 1;
using (var context = new AllReadyContext(options))
{
var campaignEvents = new List<Event>
{
new Event {Id = unlockedEventId, Campaign = new Campaign {Locked = false, ManagingOrganization = new Organization()}},
new Event {Id = 2, Campaign = new Campaign {Locked = true, ManagingOrganization = new Organization()}}
};
context.Events.AddRange(campaignEvents);
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new EventsWithUnlockedCampaignsQueryHandler(context);
var results = sut.Handle(new EventsWithUnlockedCampaignsQuery());
Assert.Equal(results[0].Id, unlockedEventId);
}
}
public async Task <int> Handle(EditEventCommand message)
{
var campaignEvent = await GetEvent(message) ?? new Event();
campaignEvent.Name = message.Event.Name;
campaignEvent.Description = message.Event.Description;
campaignEvent.EventType = message.Event.EventType;
var timeZone = TimeZoneInfo.FindSystemTimeZoneById(message.Event.TimeZoneId);
var startDateTimeOffset = timeZone.GetUtcOffset(message.Event.StartDateTime);
campaignEvent.StartDateTime = new DateTimeOffset(message.Event.StartDateTime.Year, message.Event.StartDateTime.Month, message.Event.StartDateTime.Day, message.Event.StartDateTime.Hour, message.Event.StartDateTime.Minute, 0, startDateTimeOffset);
var endDateTimeOffset = timeZone.GetUtcOffset(message.Event.EndDateTime);
campaignEvent.EndDateTime = new DateTimeOffset(message.Event.EndDateTime.Year, message.Event.EndDateTime.Month, message.Event.EndDateTime.Day, message.Event.EndDateTime.Hour, message.Event.EndDateTime.Minute, 0, endDateTimeOffset);
campaignEvent.CampaignId = message.Event.CampaignId;
campaignEvent.ImageUrl = message.Event.ImageUrl;
campaignEvent.NumberOfVolunteersRequired = message.Event.NumberOfVolunteersRequired;
if (campaignEvent.IsLimitVolunteers != message.Event.IsLimitVolunteers || campaignEvent.IsAllowWaitList != message.Event.IsAllowWaitList)
{
campaignEvent.IsAllowWaitList = message.Event.IsAllowWaitList;
campaignEvent.IsLimitVolunteers = message.Event.IsLimitVolunteers;
// cascade values to all tasks associated with this event
foreach (var task in _context.Tasks.Where(task => task.Event.Id == campaignEvent.Id))
{
task.IsLimitVolunteers = campaignEvent.IsLimitVolunteers;
task.IsAllowWaitList = campaignEvent.IsAllowWaitList;
_context.Update(task);
}
}
if (campaignEvent.Id > 0)
{
var skillsToRemove = _context.EventSkills.Where(skill => skill.EventId == campaignEvent.Id && (message.Event.RequiredSkills == null ||
!message.Event.RequiredSkills.Any(ts1 => ts1.SkillId == skill.SkillId)));
_context.EventSkills.RemoveRange(skillsToRemove);
}
if (message.Event.RequiredSkills != null)
{
campaignEvent.RequiredSkills.AddRange(message.Event.RequiredSkills.Where(mt => !campaignEvent.RequiredSkills.Any(ts => ts.SkillId == mt.SkillId)));
}
if (message.Event.Location != null)
{
campaignEvent.Location = campaignEvent.Location.UpdateModel(message.Event.Location);
_context.Update(campaignEvent.Location);
}
campaignEvent.Headline = message.Event.Headline;
_context.Update(campaignEvent);
await _context.SaveChangesAsync().ConfigureAwait(false);
return(campaignEvent.Id);
}
public async Task HandleReturnsEventsWitUnlockedCampaigns()
{
var options = this.CreateNewContextOptions();
const int unlockedEventId = 1;
using (var context = new AllReadyContext(options)) {
var campaignEvents = new List <Models.Event> {
new Models.Event {
Id = unlockedEventId, Campaign = new Campaign {
Locked = false, ManagingOrganization = new Organization()
}
},
new Models.Event {
Id = 2, Campaign = new Campaign {
Locked = true, ManagingOrganization = new Organization()
}
}
};
context.Events.AddRange(campaignEvents);
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new EventsWithUnlockedCampaignsQueryHandler(context);
var results = sut.Handle(new EventsWithUnlockedCampaignsQuery());
Assert.Equal(results[0].Id, unlockedEventId);
}
}
protected override async Task HandleCore(CreateEventManagerInviteCommand message)
{
var eventManagerInvite = new EventManagerInvite
{
InviteeEmailAddress = message.Invite.InviteeEmailAddress,
SentDateTimeUtc = DateTimeUtcNow(),
CustomMessage = message.Invite.CustomMessage,
SenderUserId = message.UserId,
EventId = message.Invite.EventId
};
_context.EventManagerInvites.Add(eventManagerInvite);
await _context.SaveChangesAsync();
await _mediator.PublishAsync(new EventManagerInvited
{
InviteeEmail = message.Invite.InviteeEmailAddress,
EventName = message.Invite.EventName,
SenderName = message.SenderName,
AcceptUrl = _urlHelper.Link("EventManagerInviteAcceptRoute", new { inviteId = eventManagerInvite.Id }),
DeclineUrl = _urlHelper.Link("EventManagerInviteDeclineRoute", new { inviteId = eventManagerInvite.Id }),
RegisterUrl = message.RegisterUrl,
IsInviteeRegistered = message.IsInviteeRegistered,
Message = message.Invite.CustomMessage
});
}
public async Task SetUserSkillsToNull_WhenAppUserIsNull_AndEventIsNotNullAndEventsCampaignIsUnlocked()
{
var options = CreateNewContextOptions();
const int eventId = 1;
const string userId = "asdfasdf";
var appUser = new ApplicationUser { Id = userId };
var message = new ShowEventQuery { EventId = eventId, UserId = userId };
using (var context = new AllReadyContext(options))
{
context.Users.Add(appUser);
context.Events.Add(CreateAllReadyEventWithTasks(message.EventId, appUser));
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new ShowEventQueryHandler(context);
var eventViewModel = await sut.Handle(message);
eventViewModel.UserSkills.ShouldBeEmpty();
}
}
public async Task WhenProviderIdIsProvidedAndIsValid_TheStatusOfTheExistingRequestIsUpdated()
{
string pid = "someId";
var request = new Request
{
ProviderId = pid,
Status = RequestStatus.Assigned
};
var command = new AddRequestCommandAsync {
Request = request
};
var options = this.CreateNewContextOptions();
using (var context = new AllReadyContext(options)) {
context.Requests.Add(new Request {
ProviderId = pid,
Status = RequestStatus.Assigned
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var geocoder = new Mock <IGeocoder>();
AddRequestCommandHandlerAsync sut = new AddRequestCommandHandlerAsync(context, geocoder.Object);
await sut.Handle(command);
}
using (var context = new AllReadyContext(options)) {
var entity = context.Requests.FirstOrDefault(x => x.ProviderId == pid);
Assert.Equal(entity.Status, RequestStatus.Assigned);
}
}
protected override async Task HandleCore(AcceptEventManagerInviteCommand message)
{
var invite = _context.EventManagerInvites.Single(i => i.Id == message.EventManagerInviteId);
invite.AcceptedDateTimeUtc = DateTimeUtcNow();
await _context.SaveChangesAsync();
}
public async Task CanSaveZeroTasks()
{
var options = CreateNewContextOptions();
const string userId = "1";
var user = new ApplicationUser {Id = userId};
using (var context = new AllReadyContext(options))
{
context.Users.Add(user);
await context.SaveChangesAsync();
}
var message = new UpdateMyTasksCommand { UserId =userId, TaskSignups = new List<TaskSignupViewModel>() };
using (var context = new AllReadyContext(options))
{
var sut = new UpdateMyTasksCommandHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options))
{
var taskSignups = context.TaskSignups.Count();
Assert.Equal(taskSignups, 0);
}
}
public async Task ReturnsExpectedTasks()
{
var options = CreateNewContextOptions();
const int eventId = 1;
const string userId = "9D0929AC-BE6A-4A0B-A758-6C6FC31A8C47";
var message = new GetMyTasksQuery { EventId = eventId, UserId = userId };
using (var context = new AllReadyContext(options))
{
context.TaskSignups.Add(new TaskSignup
{
User = new ApplicationUser { Id = userId },
Task = new AllReadyTask { Event = new Event { Id = eventId, Campaign = new Campaign { Locked = false }}}
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new GetMyTasksQueryHandler(context);
var response = sut.Handle(message);
Assert.True(response.Any());
}
}
public async Task HandleInvokesUpdateTaskAsyncWithCorrectData()
{
var options = this.CreateNewContextOptions();
const int taskId = 1;
var message = new UpdateTaskCommand {
AllReadyTask = new AllReadyTask {
Id = taskId
}
};
using (var context = new AllReadyContext(options)) {
context.Tasks.Add(new AllReadyTask {
Id = taskId,
RequiredSkills = new List <TaskSkill> {
new TaskSkill()
}
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateTaskCommandHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var @task = context.Tasks.Include(t => t.RequiredSkills).FirstOrDefault(t => t.Id == taskId);
Assert.NotNull(@task);
Assert.Equal(@task.RequiredSkills.Count, 0);
}
}
public async Task HandleInvokesUpdateTaskAsyncWithCorrectData()
{
var options = this.CreateNewContextOptions();
const int taskId = 1;
var message = new UpdateTaskCommand { AllReadyTask = new AllReadyTask {Id = taskId} };
using (var context = new AllReadyContext(options)) {
context.Tasks.Add(new AllReadyTask {
Id = taskId,
RequiredSkills = new List<TaskSkill> {
new TaskSkill()
}
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateTaskCommandHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var task = context.Tasks.Include(t => t.RequiredSkills).FirstOrDefault(t => t.Id == taskId);
Assert.NotNull(task);
Assert.Equal(task.RequiredSkills.Count, 0);
}
}
public async Task <Guid> Handle(EditRequestCommand message)
{
var request = await _context.Requests
.Include(l => l.Event)
.SingleOrDefaultAsync(t => t.RequestId == message.RequestModel.Id) ?? _context.Add(new Request {
Source = RequestSource.UI
}).Entity;
bool addressChanged = DetermineIfAddressChanged(message, request);
request.EventId = message.RequestModel.EventId;
request.Address = message.RequestModel.Address;
request.City = message.RequestModel.City;
request.Name = message.RequestModel.Name;
request.State = message.RequestModel.State;
request.Zip = message.RequestModel.Zip;
request.Email = message.RequestModel.Email;
request.Phone = message.RequestModel.Phone;
//If lat/long not provided or we detect the address changed, then use geocoding API to get the lat/long
if ((request.Latitude == 0 && request.Longitude == 0) || addressChanged)
{
//Assume the first returned address is correct
var address = _geocoder.Geocode(request.Address, request.City, request.State, request.Zip, string.Empty)
.FirstOrDefault();
request.Latitude = address?.Coordinates.Latitude ?? 0;
request.Longitude = address?.Coordinates.Longitude ?? 0;
}
_context.AddOrUpdate(request);
await _context.SaveChangesAsync();
return(request.RequestId);
}
public async Task CallsGetEventWithTheCorrectEventId()
{
var options = CreateNewContextOptions();
const int eventId = 1;
var message = new EventByEventIdQuery {
EventId = eventId
};
using (var context = new AllReadyContext(options))
{
context.Events.Add(new Event
{
Id = eventId
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new EventByEventIdQueryHandler(context);
var e = await sut.Handle(message);
Assert.Equal(e.Id, eventId);
}
}
public async Task UpdateUserHandlerInvokesUpdateUserWithTheCorrectUser()
{
var options = this.CreateNewContextOptions();
const string userId = "12345";
const string firstName = "changed";
var message = new UpdateUser {
User = new ApplicationUser {
Id = userId,
FirstName = firstName
}
};
using (var context = new AllReadyContext(options)) {
context.Users.Add(new ApplicationUser {
Id = userId,
FirstName = "notChanged"
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new UpdateUserHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options)) {
var user = context.Users.FirstOrDefault(u => u.Id == userId);
Assert.NotNull(user);
Assert.Equal(user.FirstName, firstName);
}
}
public async Task ReturnsExpectedTasks()
{
var options = CreateNewContextOptions();
const int eventId = 1;
const string userId = "9D0929AC-BE6A-4A0B-A758-6C6FC31A8C47";
var message = new GetMyTasksQuery {
EventId = eventId, UserId = userId
};
using (var context = new AllReadyContext(options)) {
context.TaskSignups.Add(new TaskSignup {
User = new ApplicationUser {
Id = userId
},
Task = new AllReadyTask {
Event = new Event {
Id = eventId,
Campaign = new Campaign {
Locked = false
}
}
}
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new GetMyTasksQueryHandler(context);
var response = sut.Handle(message);
Assert.True(response.Any());
}
}
protected override async Task HandleCore(DeleteResourceCommand message)
{
var resource = _context.Resources.Single(r => r.Id == message.ResourceId);
_context.Resources.Remove(resource);
await _context.SaveChangesAsync();
}
public async Task <int> Handle(EditTaskCommandAsync message)
{
var task = await _context.Tasks.Include(t => t.RequiredSkills).SingleOrDefaultAsync(t => t.Id == message.Task.Id);
if (task == null)
{
task = new AllReadyTask();
}
task.Name = message.Task.Name;
task.Description = message.Task.Description;
task.Activity = _context.Activities.SingleOrDefault(a => a.Id == message.Task.ActivityId);
task.Organization = _context.Organizations.SingleOrDefault(t => t.Id == message.Task.OrganizationId);
var timeZoneInfo = TimeZoneInfo.FindSystemTimeZoneById(message.Task.TimeZoneId);
if (message.Task.StartDateTime.HasValue)
{
var startDateValue = message.Task.StartDateTime.Value;
var startDateTimeOffset = timeZoneInfo.GetUtcOffset(startDateValue);
task.StartDateTime = new DateTimeOffset(startDateValue.Year, startDateValue.Month, startDateValue.Day, startDateValue.Hour, startDateValue.Minute, 0, startDateTimeOffset);
}
else
{
task.StartDateTime = null;
}
if (message.Task.EndDateTime.HasValue)
{
var endDateValue = message.Task.EndDateTime.Value;
var endDateTimeOffset = timeZoneInfo.GetUtcOffset(endDateValue);
task.EndDateTime = new DateTimeOffset(endDateValue.Year, endDateValue.Month, endDateValue.Day, endDateValue.Hour, endDateValue.Minute, 0, endDateTimeOffset);
}
else
{
task.EndDateTime = null;
}
task.NumberOfVolunteersRequired = message.Task.NumberOfVolunteersRequired;
task.IsLimitVolunteers = task.Activity.IsLimitVolunteers;
task.IsAllowWaitList = task.Activity.IsAllowWaitList;
if (task.Id > 0)
{
var tsToRemove = _context.TaskSkills
.Where(ts => ts.TaskId == task.Id && (message.Task.RequiredSkills == null || !message.Task.RequiredSkills.Any(ts1 => ts1.SkillId == ts.SkillId)));
_context.TaskSkills.RemoveRange(tsToRemove);
}
if (message.Task.RequiredSkills != null)
{
task.RequiredSkills.AddRange(message.Task.RequiredSkills.Where(mt => !task.RequiredSkills.Any(ts => ts.SkillId == mt.SkillId)));
}
_context.Update(task);
await _context.SaveChangesAsync();
return(task.Id);
}
public async Task <int> Handle(EditCampaignCommand message)
{
var campaign = await _context.Campaigns
.Include(l => l.Location)
.Include(tc => tc.CampaignContacts)
.Include(i => i.CampaignGoals)
.SingleOrDefaultAsync(c => c.Id == message.Campaign.Id) ?? new Campaign();
campaign.Name = message.Campaign.Name;
campaign.Description = message.Campaign.Description;
campaign.FullDescription = message.Campaign.FullDescription;
campaign.ExternalUrl = message.Campaign.ExternalUrl;
campaign.ExternalUrlText = message.Campaign.ExternalUrlText;
campaign.TimeZoneId = message.Campaign.TimeZoneId;
campaign.StartDateTime = message.Campaign.StartDate;
campaign.EndDateTime = message.Campaign.EndDate.AddDays(1).AddSeconds(-1); //Adjusted to the end of the day
campaign.ManagingOrganizationId = message.Campaign.OrganizationId;
campaign.ImageUrl = message.Campaign.ImageUrl;
CreateUpdateOrDeleteCampaignPrimaryContact(campaign, message.Campaign);
CreateUpdateOrDeleteCampaignGoals(campaign, message.Campaign.CampaignGoals);
campaign.Location = campaign.Location.UpdateModel(message.Campaign.Location);
campaign.Featured = message.Campaign.Featured;
campaign.Published = message.Campaign.Published;
campaign.Headline = message.Campaign.Headline;
_context.AddOrUpdate(campaign);
await _context.SaveChangesAsync();
return(campaign.Id);
}
public async Task InvokeGetUserIdWithTheCorrectUser_WhenEventIsNotNullAndEventsCampaignIsUnlocked()
{
var options = this.CreateNewContextOptions();
const int eventId = 1;
const string userId = "1";
var message = new ShowEventQuery {
EventId = eventId, User = new ClaimsPrincipal()
};
var userManager = CreateUserManagerMock();
userManager.Setup(x => x.GetUserId(It.IsAny <ClaimsPrincipal>())).Returns(userId);
using (var context = new AllReadyContext(options)) {
context.Events.Add(new Models.Event {
Id = eventId,
Campaign = new Campaign {
Locked = false
}
});
context.Users.Add(new ApplicationUser {
Id = userId
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new ShowEventQueryHandler(context, userManager.Object);
sut.Handle(message);
userManager.Verify(x => x.GetUserId(message.User), Times.Once);
}
}
public async Task CanSaveZeroTasks()
{
var options = CreateNewContextOptions();
const string userId = "1";
var user = new ApplicationUser {
Id = userId
};
using (var context = new AllReadyContext(options))
{
context.Users.Add(user);
await context.SaveChangesAsync();
}
var message = new UpdateMyVolunteerTasksCommand {
UserId = userId, VolunteerTaskSignups = new List <VolunteerTaskSignupViewModel>()
};
using (var context = new AllReadyContext(options))
{
var sut = new UpdateMyVolunteerTasksCommandHandler(context);
await sut.Handle(message);
}
using (var context = new AllReadyContext(options))
{
var volunteerTaskSignups = context.VolunteerTaskSignups.Count();
Assert.Equal(volunteerTaskSignups, 0);
}
}
public async Task SetUserSkillsToNull_WhenAppUserIsNotNull_AndAppUserseAssociatedSkillsIsNull_AndEventIsNotNullAndEventsCampaignIsUnlocked()
{
var options = this.CreateNewContextOptions();
const int eventId = 1;
const string userId = "asdfasdf";
var appUser = new ApplicationUser()
{
Id = userId,
AssociatedSkills = null
};
var message = new ShowEventQuery()
{
EventId = eventId, User = new ClaimsPrincipal()
};
var userManager = CreateUserManagerMock();
userManager.Setup(x => x.GetUserId(message.User)).Returns(appUser.Id);
using (var context = new AllReadyContext(options)) {
context.Users.Add(appUser);
context.Events.Add(CreateAllReadyEventWithTasks(message.EventId, appUser));
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new ShowEventQueryHandler(context, userManager.Object);
var eventViewModel = sut.Handle(message);
eventViewModel.UserSkills.ShouldBeEmpty();
}
}
public async Task <bool> Handle(AddRequestsToItineraryCommand message)
{
var itinerary = await _context.Itineraries
.Where(x => x.Id == message.ItineraryId)
.Select(x => new { x.Id, x.Name })
.SingleOrDefaultAsync();
if (itinerary == null)
{
// todo: sgordon: enhance this with a error message so the controller can better respond to the issue
return(false);
}
var requestsToUpdate = await _context.Requests.AsAsyncEnumerable()
.Where(r => message.RequestIdsToAdd.Contains(r.RequestId.ToString()))
.ToList();
var foundRequests = new HashSet <string>(requestsToUpdate.Select(s => s.RequestId.ToString()));
var notFound = message.RequestIdsToAdd.Where(m => !foundRequests.Contains(m));
if (notFound.Any())
{
// Something went wrong as some of the ids passed in where not matched in the database
// todo: sgordon: we should enhance the returned object to include a message so that the controller can provide better feedback to the user
return(false);
}
if (requestsToUpdate.Count > 0)
{
var orderIndex = await _context.ItineraryRequests.AsAsyncEnumerable()
.Where(i => i.ItineraryId == itinerary.Id)
.OrderByDescending(i => i.OrderIndex)
.Select(i => i.OrderIndex)
.FirstOrDefault();
foreach (var request in requestsToUpdate)
{
orderIndex++;
if (request.Status == RequestStatus.Unassigned)
{
request.Status = RequestStatus.Assigned;
_context.ItineraryRequests.Add(new ItineraryRequest
{
ItineraryId = itinerary.Id,
Request = request,
OrderIndex = orderIndex,
DateAssigned = DateTimeUtcNow()
});
}
}
await _context.SaveChangesAsync();
await _mediator.PublishAsync(new RequestsAssignedToItinerary { ItineraryId = message.ItineraryId, RequestIds = requestsToUpdate.Select(x => x.RequestId).ToList() });
}
return(true);
}
public async Task <int> Handle(EditOrganization message)
{
var org = await _context.Organizations
.Include(l => l.Location)
.Include(tc => tc.OrganizationContacts)
.SingleOrDefaultAsync(t => t.Id == message.Organization.Id) ?? _context.Add(new Organization()).Entity;
org.Name = message.Organization.Name;
org.LogoUrl = message.Organization.LogoUrl;
org.WebUrl = message.Organization.WebUrl;
org.DescriptionHtml = message.Organization.Description;
org.Summary = message.Organization.Summary;
//TODO: mgmccarthy: pull code from ContactExtension.UpdateOrganizationContact into this handler as this the only code that uses it and it should not be in an extension method... espeically doing database access
org = await org.UpdateOrganizationContact(message.Organization, _context);
org.Location = org.Location.UpdateModel(message.Organization.Location);
org.Location.PostalCode = message.Organization.Location.PostalCode;
org.PrivacyPolicy = message.Organization.PrivacyPolicy;
org.PrivacyPolicyUrl = message.Organization.PrivacyPolicyUrl;
await _context.SaveChangesAsync();
return(org.Id);
}
public async Task ReturnNullWhenEventsCampaignIsLocked()
{
var options = CreateNewContextOptions();
const int eventId = 1;
var message = new ShowEventQuery { EventId = eventId };
using (var context = new AllReadyContext(options))
{
context.Events.Add(new Models.Event
{
Id = eventId,
Campaign = new Campaign { Locked = true }
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new ShowEventQueryHandler(context);
var result = await sut.Handle(message);
result.ShouldBeNull();
}
}
public async Task SetTasksToListOfTaskViewModelForAnyTasksWhereTheUserHasNotVolunteeredInAscendingOrderByTaskStartDateTime_AndEventIsNotNullAndEventsCampaignIsUnlocked()
{
var options = CreateNewContextOptions();
const int eventId = 1;
const string userId = "asdfasdf";
var appUser = new ApplicationUser { Id = userId };
var message = new ShowEventQuery { EventId = eventId, UserId = userId };
var allReadyEvent = CreateAllReadyEventWithTasks(message.EventId, appUser);
using (var context = new AllReadyContext(options))
{
context.Users.Add(appUser);
context.Events.Add(allReadyEvent);
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new ShowEventQueryHandler(context);
var eventViewModel = await sut.Handle(message);
Assert.Equal(allReadyEvent.Tasks.Where(x => !x.AssignedVolunteers.Any(v => v.User.Id.Equals(appUser.Id))).Count(),
eventViewModel.Tasks.Count);
var previousDateTime = DateTimeOffset.MinValue;
foreach (var userTask in eventViewModel.Tasks)
{
Assert.True(userTask.StartDateTime > previousDateTime);
previousDateTime = userTask.StartDateTime;
}
}
}
public async Task SetsTaskSignupViewModel_WithTheCorrectData()
{
var options = CreateNewContextOptions();
var appUser = new ApplicationUser
{
Id = "asdfasasdfaf",
Email = "*****@*****.**",
FirstName = "Foo",
LastName = "Bar",
PhoneNumber = "555-555-5555",
};
var message = new ShowEventQuery { EventId = 1, UserId = appUser.Id };
using (var context = new AllReadyContext(options))
{
context.Users.Add(appUser);
context.Events.Add(CreateAllReadyEventWithTasks(message.EventId, appUser));
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new ShowEventQueryHandler(context);
var eventViewModel = await sut.Handle(message);
Assert.Equal(message.EventId, eventViewModel.SignupModel.EventId);
Assert.Equal(appUser.Id, eventViewModel.SignupModel.UserId);
Assert.Equal($"{appUser.FirstName} {appUser.LastName}", eventViewModel.SignupModel.Name);
}
}
protected override async Task HandleCore(AddApiRequestCommand message)
{
//TODO mgmccarthy: I can probably move the Request creation to the controller and put the entity on the command instead of the view model mapping code below
var request = new Request
{
RequestId = NewRequestId(),
ProviderId = message.ViewModel.ProviderRequestId,
ProviderData = message.ViewModel.ProviderData,
Address = message.ViewModel.Address,
City = message.ViewModel.City,
DateAdded = DateTimeUtcNow(),
Email = message.ViewModel.Email,
Name = message.ViewModel.Name,
Phone = message.ViewModel.Phone,
State = message.ViewModel.State,
Zip = message.ViewModel.Zip,
Status = RequestStatus.Unassigned,
Source = RequestSource.Api
};
var address = geocoder.Geocode(message.ViewModel.Address, message.ViewModel.City, message.ViewModel.State, message.ViewModel.Zip, string.Empty).FirstOrDefault();
request.Latitude = message.ViewModel.Latitude == 0 ? address?.Coordinates.Latitude ?? 0 : message.ViewModel.Latitude;
request.Longitude = message.ViewModel.Longitude == 0 ? address?.Coordinates.Longitude ?? 0 : message.ViewModel.Longitude;
context.AddOrUpdate(request);
await context.SaveChangesAsync();
await mediator.PublishAsync(new ApiRequestAddedNotification { RequestId = request.RequestId });
}
public async Task WhenHandlingTaskByTaskIdQueryGetTaskIsInvokedWithCorrectTaskId() {
var options = this.CreateNewContextOptions();
const int taskId = 1;
var message = new TaskByTaskIdQuery { TaskId = taskId };
using (var context = new AllReadyContext(options)) {
context.Tasks.Add(new AllReadyTask {Id = taskId});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new TaskByTaskIdQueryHandler(context);
var task = await sut.Handle(message);
Assert.Equal(task.Id, taskId);
}
}
public async Task HandleCallsEventsByGeographyWithTheCorrectLatitiudeLongitudeAndMiles()
{
var options = this.CreateNewContextOptions();
var message = new EventsByGeographyQuery() { Latitude = 1, Longitude = 2, Miles = 3 };
using (var context = new AllReadyContext(options)) {
context.Events.Add(new Event());
context.Events.Add(new Event());
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new EventsByGeographyQueryHandler(context);
var events = sut.Handle(message);
Assert.Equal(events.Count, 2);
}
}
public async Task HandleCallsEventsByPostalCodeWithCorrectPostalCodeAndDistance()
{
var options = this.CreateNewContextOptions();
var message = new EventsByPostalCodeQuery { PostalCode = "PostalCode", Distance = 100 };
using (var context = new AllReadyContext(options)) {
context.Events.Add(new Event());
context.Events.Add(new Event());
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new EventsByPostalCodeQueryHandler(context);
var events = sut.Handle(message);
Assert.Equal(events.Count, 2);
}
}
public async Task HandleInvokesGetResourcesByCategoryWithCorrectCategory()
{
var options = this.CreateNewContextOptions();
const string category = "category";
var message = new ResourcesByCategoryQuery { Category = category };
using (var context = new AllReadyContext(options)) {
context.Resources.Add(new Resource {
CategoryTag = category
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options)) {
var sut = new ResourcesByCategoryQueryHandler(context);
var resource = sut.Handle(message);
Assert.Equal(resource.Count, 1);
}
}
public async Task CallsGetEventWithTheCorrectEventId()
{
var options = CreateNewContextOptions();
const int eventId = 1;
var message = new EventByEventIdQuery { EventId = eventId };
using (var context = new AllReadyContext(options))
{
context.Events.Add(new Event
{
Id = eventId
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new EventByEventIdQueryHandler(context);
var e = await sut.Handle(message);
Assert.Equal(e.Id, eventId);
}
}
public async Task UserByUserIdQueryHandlerInvokesGetUserWithTheCorrectUserId()
{
var options = CreateNewContextOptions();
const string userId = "1";
var message = new UserByUserIdQuery { UserId = userId };
using (var context = new AllReadyContext(options))
{
context.Users.Add(new ApplicationUser
{
Id = userId
});
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new UserByUserIdQueryHandler(context);
var user = await sut.Handle(message);
Assert.Equal(user.Id, userId);
}
}
public async Task InvokeUpdateTaskSignupAsyncWithTheCorrectParametersForEachTaskSignupViewModelOnCommand()
{
var options = CreateNewContextOptions();
const string userId = "1";
const int taskSignupId = 1;
var user = new ApplicationUser {Id = userId};
var dateTimeUtcNow = DateTime.UtcNow;
var taskSignupViewModels = new List<TaskSignupViewModel>
{
new TaskSignupViewModel { Id = taskSignupId, StatusDescription = "statusDescription1", Status = "Status1", TaskId = 1, }
};
var message = new UpdateMyTasksCommand { TaskSignups = taskSignupViewModels, UserId = userId};
using (var context = new AllReadyContext(options))
{
context.Users.Add(user);
context.TaskSignups.Add(new TaskSignup { Id = taskSignupId });
context.Tasks.Add(new AllReadyTask { Id = 1 });
await context.SaveChangesAsync();
}
using (var context = new AllReadyContext(options))
{
var sut = new UpdateMyTasksCommandHandler(context) { DateTimeUtcNow = () => dateTimeUtcNow };
await sut.Handle(message);
}
using (var context = new AllReadyContext(options))
{
var signup = context.TaskSignups.FirstOrDefault(x => x.Id == taskSignupId);
Assert.Equal(signup != null, true);
}
}
