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 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);
        }

 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);
        }