public Commitment AssignToVolunteer(Disaster disaster, Person person, DateTime startDate, DateTime endDate)
{
if (disaster == null) throw new ArgumentNullException("disaster");
if (person == null) throw new ArgumentNullException("person");
if (DateTime.Compare(endDate, startDate) < 0) throw new ArgumentException("endDate cannot be earlier than startDate");
// check if the start and end date falls within an existing commitment
// disregard any disasters that are inactive
Expression<Func<Commitment, bool>> dateInRange = c =>
(DateTime.Compare(c.StartDate, startDate) <= 0 && DateTime.Compare(c.EndDate, startDate) >= 0) ||
(DateTime.Compare(c.StartDate, endDate) <= 0 && DateTime.Compare(c.EndDate, endDate) >= 0);
var hasExistingCommitment = (from c in ourService.Commitments
join d in ourService.Disasters on c.DisasterId equals d.Id
where d.IsActive
select c).Any(dateInRange);
if (hasExistingCommitment) {
throw new ArgumentException("there is already a commitment for this date range");
}
return ourService.AddCommitment(new Commitment()
{
PersonId = person.Id,
DisasterId = disaster.Id,
StartDate = startDate,
EndDate = endDate
});
}
public ActionResult Edit(Disaster disaster)
{
TempData["EditUrlDeprecatedWarning"] = "POST /Edit is deprecated. Use POST /Create instead";
if (ModelState.IsValid && !String.IsNullOrWhiteSpace(disaster.Name))
{
if (disaster.Id == -1)
{
try
{
_disasterSvc.Create(disaster);
}
catch (DisasterAlreadyExistsException)
{
ModelState.AddModelError("Name", "A Disaster already exists with that Name!");
return View("Create", disaster);
}
}
else
{
_disasterSvc.Update(disaster.Id, disaster.Name, disaster.IsActive);
}
return Redirect("/Disaster/List");
}
ModelState.AddModelError("Name", "Disaster Name is required!");
return View("Create", disaster);
}
public Disaster Create(Disaster disaster)
{
if (disaster == null) throw new ArgumentNullException("disaster");
if (String.IsNullOrWhiteSpace(disaster.Name)) throw new ArgumentNullException("disasterName");
return ourService.AddDisaster(disaster);
}
public IQueryable<Commitment> RetrieveCommitmentsForDisaster(Person person, Disaster disaster)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "Disaster cannot be null");
return RetrieveCommitments(person, true).Where(c => c.DisasterId == disaster.Id);
}
public ActionResult Edit(Disaster disaster)
{
if (ModelState.IsValid && !String.IsNullOrWhiteSpace(disaster.Name))
{
if (disaster.Id == -1)
{
try
{
_disasterSvc.Create(disaster);
}
catch (DisasterAlreadyExistsException)
{
ModelState.AddModelError("Name", "A Disaster already exists with that Name!");
return View("Edit", disaster);
}
}
else
{
_disasterSvc.Update(disaster.Id, disaster.Name, disaster.IsActive);
}
return Redirect("/Disaster/List");
}
ModelState.AddModelError("Name", "Disaster Name is required!");
return View(disaster);
}
DisasterClusterCoordinatorsViewModel GetDisasterClusterCoordinatorsViewModel(Disaster disaster)
{
IList<Person> allPersonDataForDisplay;
var clusterCoordinators = _clusterCoordinatorService.GetAllCoordinatorsForDisplay(disaster.Id, out allPersonDataForDisplay);
var allClusters = _cluster.GetList().ToList();
var disasterClusterCoordinatorsViewModel =
new DisasterClusterCoordinatorsViewModel
{
DisasterName = disaster.Name,
DisasterId = disaster.Id,
Clusters = allClusters
.Select(c => new ClusterViewModel
{
Name = c.Name,
Coordinators = clusterCoordinators
.Where(x => x.ClusterId == c.Id)
.Select(x => new ClusterCoordinatorViewModel
{
Name = x.Person.FullName,
Id = x.Id,
})
.ToList(),
})
.ToList(),
AvailableClusters = allClusters,
AvailablePeople = allPersonDataForDisplay
};
return disasterClusterCoordinatorsViewModel;
}
public IEnumerable<Person> GetVolunteersForDate(Disaster disaster, DateTime date)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "disaster cannot be null");
return GetVolunteersForDate(disaster.Id, date);
}
public ActionResult Create(DisasterViewModel model)
{
if (ModelState.IsValid)
{
try
{
var disaster = new Disaster
{
Id = model.Id,
Name = model.Name,
IsActive = model.IsActive
};
if (model.Id == -1)
{
_disasterSvc.Create(disaster);
}
else
{
_disasterSvc.Update(disaster);
}
}
catch (DisasterAlreadyExistsException)
{
ModelState.AddModelError("Name", "A Disaster already exists with that Name!");
return View("Create", model);
}
return Redirect("/Disaster/List");
}
return View("Create", model);
}
public IEnumerable<Person> GetVolunteersForDate(Disaster disaster, DateTime date, bool clusterCoordinatorsOnly, bool checkedInOnly = false)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "disaster cannot be null");
return GetVolunteersForDate(disaster.Id, date, clusterCoordinatorsOnly, checkedInOnly);
}
public Disaster Create(Disaster disaster)
{
if (disaster == null) throw new ArgumentNullException("disaster");
if (String.IsNullOrWhiteSpace(disaster.Name)) throw new ArgumentNullException("disasterName");
if (ourService.Disasters.Any(d => d.Name == disaster.Name)) throw new DisasterAlreadyExistsException();
return ourService.AddDisaster(disaster);
}
private IQueryable<Person> GetPeople(Disaster disaster)
{
var people = from p in dataService.Persons
join c in dataService.Commitments on p.Id equals c.PersonId
where c.DisasterId == disaster.Id
select p;
return people;
}
public void Arrange()
{
_dataService = new DataService(new CrisisCheckin());
_dataAccessHelper = new DataAccessHelper(_dataService);
_clusterCoordinatorService = new ClusterCoordinatorService(_dataService);
_disaster = _dataAccessHelper.Create_a_disaster();
_person = _dataAccessHelper.Create_a_volunteer();
_clusterId = _person.ClusterId.GetValueOrDefault();
}
public void Create(Disaster disaster)
{
if (disaster == null) throw new ArgumentNullException("disaster");
if (String.IsNullOrWhiteSpace(disaster.Name)) throw new ArgumentNullException("disaster");
if (_dataService.Disasters.Any(d => d.Name == disaster.Name)) throw new DisasterAlreadyExistsException();
// Why should disaster name be unique?
_dataService.AddDisaster(disaster);
}
public void Arrange()
{
_dataService = new DataService(new CrisisCheckin(), new CrisisCheckinMembership());
_dataAccessHelper = new DataAccessHelper(_dataService);
_clusterCoordinatorService = new ClusterCoordinatorService(_dataService);
_disaster = _dataAccessHelper.Create_a_disaster();
_clusterId = _dataAccessHelper.GetRandomClusterId();
_person = _dataAccessHelper.Create_a_volunteer();
}
void Create_a_disaster()
{
_disaster = new Disaster
{
IsActive = true,
Name = "Great Seattle Starbucks Strike",
};
_dataService.AddDisaster(_disaster);
_clusterId = _dataService.Clusters.First().Id;
}
public Disaster Create_a_disaster()
{
var disaster = new Disaster
{
IsActive = true,
Name = "Great Seattle Starbucks Strike",
};
_dataService.AddDisaster(disaster);
return disaster;
}
public IEnumerable<Person> GetVolunteers(Disaster disaster)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "disaster cannot be null");
var storedDisaster = dataService.Disasters.SingleOrDefault(d => d.Id == disaster.Id);
if (storedDisaster == null)
throw new ArgumentException("Disaster was not found", "disaster");
IQueryable<Person> people = GetPeople(disaster);
return people;
}
public IEnumerable<Person> GetVolunteers(Disaster disaster, bool checkedInOnly = false)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "disaster cannot be null");
var people = GetPeople(disaster.Id, checkedInOnly);
if (people == null)
throw new NullReferenceException(string.Format("Attempt to get volunteers for disaster ID {0} returned null.", disaster.Id));
return people.ToList();
}
public void Init()
{
_disaster = new Disaster {Id = 0, IsActive = true, Name = "Sharknado"};
_cluster = new Cluster {Id = 1, Name = "Red Zone"};
_person = new Person {Id = 2, FirstName = "John", LastName = "Doe"};
_dataService = new Mock<IDataService>();
_dataService.Setup(x => x.Disasters).Returns(new EnumerableQuery<Disaster>(new[] {_disaster}));
_dataService.Setup(x => x.Clusters).Returns(new EnumerableQuery<Cluster>(new[] {_cluster}));
_dataService.Setup(x => x.Persons).Returns(new EnumerableQuery<Person>(new[] {_person}));
_clusterCoordinatorService = new Services.ClusterCoordinatorService(_dataService.Object);
}
public Commitment AssignToVolunteer(Disaster disaster, Person person, DateTime startDate, DateTime endDate)
{
if (disaster == null) throw new ArgumentNullException("disaster");
if (person == null) throw new ArgumentNullException("person");
if (DateTime.Compare(endDate, startDate) < 0) throw new ArgumentException("endDate cannot be earlier than startDate");
return ourService.AddCommitment(new Commitment()
{
PersonId = person.Id,
DisasterId = disaster.Id,
StartDate = startDate,
EndDate = endDate
});
}
public void Assign_ValidDataAdd_ReturnsListView()
{
// Arrange
var disaster = new Mock<IDisaster>();
var controller = new DisasterController(disaster.Object);
// Act
var viewModel = new Disaster { Id = -1, Name ="test", IsActive = false};
var response = controller.Create(viewModel);
// Assert
var result = response as RedirectResult;
Assert.IsTrue(result.Url.Equals("/Disaster/List"));
}
public void Lookup_UnfilteredVolunteers_For_Disaster_Returns_AllVolunteers_ForTheDisaster()
{
//Arrange
int disasterId = 2;
var disaster = new Disaster();
_disasterSvc.Setup(x => x.Get(disasterId)).Returns(disaster);
var allVolunteers = new Collection<Person>();
_adminSvc.Setup(x => x.GetVolunteers(disaster)).Returns(allVolunteers);
var controller = CreateVolunteerController();
//Act
var response = controller.Filter(new ListByDisasterViewModel() { SelectedDisaster = disasterId, CommitmentDate = null });
//Assert
Assert.AreEqual(allVolunteers, response.Model);
}
public void Assign_duplicateName_ReturnsCreateView()
{
// Arrange
var disaster = new Mock<IDisaster>();
var controller = new DisasterController(disaster.Object);
disaster.Setup(x => x.Create(
It.IsAny<Disaster>())).Throws(new DisasterAlreadyExistsException());
var viewModel = new Disaster { Id = -1, Name = "test", IsActive = true };
var response = controller.Create(viewModel);
var view = response as ViewResult;
Assert.AreEqual("Create", view.ViewName);
Assert.IsTrue(view.ViewData.ModelState.Count >= 1);
}
public void Lookup_FilteredVolunteers_For_Disaster_Returns_Volunteers_ForTheDisaster_FilteredByDate()
{
//Arrange
int disasterId = 2;
DateTime filteredDateTime = new DateTime(2014, 6, 3, 10, 8, 6);
var disaster = new Disaster();
_disasterSvc.Setup(x => x.Get(disasterId)).Returns(disaster);
var filteredVolunteers = new Collection<Person>();
_adminSvc.Setup(x => x.GetVolunteersForDate(disaster, filteredDateTime)).Returns(filteredVolunteers);
var controller = CreateVolunteerController();
//Act
var response = controller.Filter(new ListByDisasterViewModel() { SelectedDisaster = disasterId, CommitmentDate = filteredDateTime });
//Assert
Assert.AreEqual(filteredVolunteers, response.Model);
}
public IEnumerable<Person> GetVolunteersForDate(Disaster disaster, DateTime date)
{
if (disaster == null)
throw new ArgumentNullException("disaster", "disaster cannot be null");
var storedDisaster = dataService.Disasters.SingleOrDefault(d => d.Id == disaster.Id);
if (storedDisaster == null)
throw new ArgumentException("Disaster was not found", "disaster");
var commitments = from c in dataService.Commitments
where c.DisasterId == disaster.Id
where date >= c.StartDate && date <= c.EndDate
select c;
var people = from c in commitments
join p in dataService.Persons on c.PersonId equals p.Id
select p;
people.Include(p => p.Cluster);
return people;
}
public ActionResult Edit(Disaster disaster)
{
if (ModelState.IsValid && !String.IsNullOrWhiteSpace(disaster.Name))
{
if (disaster.Id == -1)
{
_disasterSvc.Create(disaster);
}
else
{
_disasterSvc.Update(disaster.Id, disaster.Name, disaster.IsActive);
}
return Redirect("/Disaster/List");
}
ModelState.AddModelError("Name", "Disaster Name is required!");
return View(disaster);
}
public ActionResult Edit(string id)
{
int disasterId;
Disaster viewData;
bool validId = int.TryParse(id, out disasterId);
if (validId && disasterId != -1)
{
viewData = _disasterSvc.Get(disasterId);
}
else
{
// Adding new Disaster here
viewData = new Disaster {IsActive = true};
}
return View("Create", viewData);
}
public ResourceSearch(List<Disaster> disasters, List<ResourceType> resourceTypes)
{
var alldisasters = new Disaster()
{
Id = GeneralSelectId,
IsActive = true,
Name = "All Disasters"
};
disasters.Insert(0, alldisasters);
var allResourceTypes = new ResourceType()
{
ResourceTypeId = GeneralSelectId,
TypeName = "All Resource Types"
};
resourceTypes.Insert(0, allResourceTypes);
_disasters = disasters;
_resourceTypes = resourceTypes;
}
public void Lookup_UnfilteredVolunteers_For_Disaster_Returns_AllVolunteers_ForTheDisaster()
{
//Arrange
int disasterId = 2;
var disaster = new Disaster();
_disasterSvc.Setup(x => x.Get(disasterId)).Returns(disaster);
var allVolunteers = new List<Person>();
_adminSvc.Setup(x => x.GetVolunteersForDisaster(disaster.Id, null, false)).Returns(allVolunteers);
//Act
var response = _controllerUnderTest.Filter(new ListByDisasterViewModel
{
SelectedDisaster = disasterId, CommitmentDate = null
});
//Assert
var model = response.Model as CheckinListsResultsViewModel;
Assert.IsNotNull(model, "View Model is not an CheckinListsResultsViewModel.");
CollectionAssert.AreEquivalent(allVolunteers.ToArray(), model.VolunteerCheckins.ToArray());
}
public void Init()
{
_coordinatorId = 42;
_notCoordinatorId = 10;
_dataService = new Mock<IDataService>();
_disaster1 = new Disaster { Id = 1, IsActive = true, Name = "Sharknado" };
_disaster2 = new Disaster { Id = 2, IsActive = true, Name = "Ice Age" };
_cluster1 = new Cluster { Id = 2, Name = "Red Zone" };
_cluster2 = new Cluster { Id = 3, Name = "Other Cluster" };
_person1 = new Person { Id = 3, FirstName = "John", LastName = "Doe" };
_person2 = new Person { Id = 4, FirstName = "Richard", LastName = "Roe" };
_person3 = new Person { Id = 5, FirstName = "Little", LastName = "Toe" };
_dataService.Setup(x => x.Disasters).Returns(new EnumerableQuery<Disaster>(new[]
{
_disaster1,
_disaster2
}));
_dataService.Setup(x => x.Clusters).Returns(new EnumerableQuery<Cluster>(new[]
{
_cluster1,
_cluster2
}));
_dataService.Setup(x => x.Persons).Returns(new EnumerableQuery<Person>(new[]
{
_person1,
_person2,
_person3
}));
_dataService.Setup(x => x.Commitments).Returns(new EnumerableQuery<Commitment>(new[]
{
new Commitment { DisasterId = _disaster1.Id, PersonId = _person1.Id },
new Commitment { DisasterId = _disaster1.Id, PersonId = _person2.Id },
new Commitment { DisasterId = _disaster2.Id, PersonId = _person3.Id }
}));
_clusterCoordinatorService = new Services.ClusterCoordinatorService(_dataService.Object);
}
