public bool IsOlderThan(IPerson other)
        {
            DateTime firstDate, secondDate;

            try
            {
                firstDate = DateTime.Parse(this.OtherInfo.Substring(this.OtherInfo.Length - 10));
            }
            catch (Exception)
            {
                throw new InvalidCastException("First data is not valid!");
            }

            try
            {
                secondDate = DateTime.Parse(other.OtherInfo.Substring(other.OtherInfo.Length - 10));
            }
            catch (Exception)
            {

                throw new InvalidCastException("Second data is not valid!");
            }

            return firstDate < secondDate;
        }

 public virtual void MapToEntity(IPersonModel model, ref IPerson entity, int currentDepth = 1)
 {
     currentDepth++;
     // Assign Base properties
     NameableEntityMapper.MapToEntity(model, ref entity);
     // Person Properties
     entity.Hometown = model.Hometown;
     entity.Country = model.Country;
     entity.Email = model.Email;
     entity.Website = model.Website;
     entity.BirthDate = model.BirthDate;
     entity.DeathDate = model.DeathDate;
     // Related Objects
     entity.PrimaryImageFileId = model.PrimaryImageFileId;
     entity.PrimaryImageFile = (ImageFile)model.PrimaryImageFile?.MapToEntity();
     entity.GenderId = model.GenderId;
     entity.Gender = (Gender)model.Gender?.MapToEntity();
     // Associated Objects
     entity.CharactersCreated = model.CharactersCreated?.Where(i => i.Active).Select(CreatorCharacterMapperExtensions.MapToEntity).ToList();
     entity.PersonAliases = model.PersonAliases?.Where(i => i.Active).Select(PersonAliasMapperExtensions.MapToEntity).ToList();
     entity.IssuesWritten = model.IssuesWritten?.Where(i => i.Active).Select(IssueWriterMapperExtensions.MapToEntity).ToList();
     entity.MoviesProduced = model.MoviesProduced?.Where(i => i.Active).Select(MovieProducerMapperExtensions.MapToEntity).ToList();
     entity.MoviesWritten = model.MoviesWritten?.Where(i => i.Active).Select(MovieWriterMapperExtensions.MapToEntity).ToList();
     entity.PromosWritten = model.PromosWritten?.Where(i => i.Active).Select(PromoMapperExtensions.MapToEntity).ToList();
     entity.StoryArcsWritten = model.StoryArcsWritten?.Where(i => i.Active).Select(StoryArcWriterMapperExtensions.MapToEntity).ToList();
     entity.VolumesWritten = model.VolumesWritten?.Where(i => i.Active).Select(VolumeWriterMapperExtensions.MapToEntity).ToList();
 }

 public void UpdatePerson(IPerson person)
 {
     var ctx = new AddressBookContext();
     var entity = ctx.Persons.Find(person.ID);
     Mappings.Map(person, entity);
     ctx.SaveChanges();
 }

        public bool ContainsPerson(IPerson person)
        {
            if (person == null)
                throw new ArgumentNullException(nameof(person));

            return _cache.ContainsKey(person);
        }

        /// <summary>
        /// Adds the person.
        /// </summary>
        /// <param name="person">The person.</param>
        /// <param name="hostName">Name of the host.</param>
        /// <returns></returns>
        /// <exception cref="InverGrove.Domain.Exceptions.ParameterNullException">person</exception>
        public IPerson AddPerson(IPerson person, string hostName)
        {
            Guard.ParameterNotNull(person, "person");

            /* TODO - Check if this EMAIL address exists.  Email will be the sole check to guard against duplicate persons.
               TODO - People will be a cached list that is placed into cache when a person logs into the website.
                      This list will never be more than a couple hundred (likley around 150) so no big deal caching that.
            */
            var existingPerson = this.personRepository.Get(p => p.EmailPrimary == person.PrimaryEmail).FirstOrDefault().ToModel();
            var existingEmail = this.EmailExists(person, existingPerson);

            if (!string.IsNullOrEmpty(person.PrimaryEmail) && existingEmail)
            {
                person.PersonId = existingPerson.PersonId;
                person.ErrorMessage = "This email address already exists.";

                return person;
            }

            person.PersonId = this.personRepository.Add(person);

            if (person.IsUser && (person.PersonId > 0))
            {
                this.SendNewUserVerification(person, hostName);
            }

            return person;
        }

        public IContact AddNewContact(IPerson person, string typeContact, string valueContact)
        {
            if (person == null) throw new ArgumentNullException("person");
            if (string.IsNullOrWhiteSpace(typeContact)) throw new ArgumentNullException("typeContact");
            if (string.IsNullOrWhiteSpace(valueContact)) throw new ArgumentNullException("valueContact");

            int newId = 1;

            while (true)
            {
                bool flag = true;

                foreach (var z in Persons)
                    foreach(var cont in z.Contacts)
                        if (cont.ID == newId)
                        {
                            ++newId;
                            flag = false;
                        }

                if(flag)
                    break;
            }

            var newContact = new Contact(newId, person.ID, typeContact, valueContact);
            person.Contacts.Add(newContact);

            RaisePropertyChanged("Persons");

            return newContact;
        }

		public void it_must_have_a_converter(BindingManager bindingManager, MultiSourceBinding binding, IPerson targetObject, IAddress sourceObject)
		{
			bindingManager.Bindings.Remove(binding);
			binding.Converter = null;
			var ex = Assert.Throws<InvalidOperationException>(() => bindingManager.Bindings.Add(binding));
			Assert.Equal("All MultiSourceBindings require a converter.", ex.Message);
		}

		public void changes_to_the_source_should_be_marshalled_via_a_call_to_send(Mock<SynchronizationContext> synchronizationContext, BindingManager bindingManager, IPerson targetObject, IAddress sourceObject)
		{
			synchronizationContext.Setup(x => x.Send(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()));
			sourceObject.Line1 = "Line 1, mighty fine";

			synchronizationContext.VerifyAll();
		}

		public void the_converted_value_is_used_when_the_target_is_changed(BindingManager bindingManager, SingleSourceBinding binding, Mock<IValueConverter> converter, IPerson targetObject, IPerson sourceObject)
		{
			converter.Setup(x => x.ConvertBack("Value", typeof(string), "parameter", null)).Returns("Converted Value");
			targetObject.Address.Line2 = "Value";
			Assert.Equal("Converted Value", sourceObject.Address.Line1);
			converter.VerifyAll();
		}

		public void conversions_from_target_to_source_are_ignored_when_there_is_no_converter(BindingManager bindingManager, SingleSourceBinding binding, IPerson targetObject, IPerson sourceObject)
		{
			targetObject.Name = "Kent";
			Assert.Null(sourceObject.Gender);

			targetObject.Name = "Male";
			Assert.Null(sourceObject.Gender);
		}

		public void updating_the_target_does_not_update_the_source(BindingManager bindingManager, IPerson targetObject, IAddress sourceObject)
		{
			targetObject.Name = "A new address";
			Assert.Null(sourceObject.Line1);

			targetObject.Name = "Another new address";
			Assert.Null(sourceObject.Line1);
		}

		public void it_is_not_yet_active(SingleSourceBinding binding, IPerson targetObject, IPerson sourceObject)
		{
			sourceObject.Name = "New Name";
			Assert.Null(targetObject.Name);

			targetObject.Name = "Another Name";
			Assert.Equal("New Name", sourceObject.Name);
		}

 public Spouse(IPerson me, IPerson so, DateTime marriageDt, DateTime? divorceDt, int ordinal)
 {
     _me = me;
     _est = so;
     _marriedOn = marriageDt;
     _separatedOn = divorceDt;
     _ordinal = ordinal;
 }

		public void conversions_from_target_to_source_are_automatically_converted_where_possible(BindingManager bindingManager, SingleSourceBinding binding, IPerson targetObject, IPerson sourceObject)
		{
			targetObject.Name = "69";
			Assert.Equal(69, sourceObject.Age);

			targetObject.Name = "13a";
			Assert.Equal(69, sourceObject.Age);
		}

 public void InsertPerson(IPerson person)
 {
     var ctx = new AddressBookContext();
     var entity = new Person();
     Mappings.Map(person, entity);
     ctx.Persons.Add(entity);
     ctx.SaveChanges();
 }

        public int CompareTo(IPerson other)
        {
            if (this.Id < other.Id) return -1;

            return this.Id > other.Id ? 1 : 0;
            // If ids are both 0 (no id for students), then no guidelines are given => equals.
            // But we could consider sorting them by their family names if needed.
        }

		public void it_becomes_active(BindingManager bindingManager, SingleSourceBinding binding, IPerson targetObject, IPerson sourceObject)
		{
			sourceObject.Name = "New Name";
			Assert.Equal("New Name", targetObject.Name);

			targetObject.Name = "Another Name";
			Assert.Equal("Another Name", sourceObject.Name);
		}

 public Supplement(bool isHourCanceled, DateTime date, ITeachingHour hour, ISchedule schedule, IPerson teacher = null)
 {
     this.IsHourCanceled = isHourCanceled;
     this.Date = date;
     this.Hour = hour;
     this.Schedule = schedule;
     this.Teacher = teacher;
 }

 private bool IsDismissed(IPerson person, DateTime day)
 {
     if (person.DayOfWeekDismisses.Any(d => d.GetDismissStatus(day).Dismissed))
         return true;
     if (person.TemporaryDismisses.Any(d => d.GetDismissStatus(day).Dismissed))
         return true;
     return false;
 }

		public void it_is_not_yet_active(MultiSourceBinding binding, IPerson targetObject, IAddress sourceObject)
		{
			sourceObject.Line1 = "Line 1";
			Assert.Null(targetObject.Name);

			targetObject.Name = "Another Name";
			Assert.Equal("Line 1", sourceObject.Line1);
		}