public void UpdateHomeAddress(APIPerson apiPerson, ref Person person)
{
if (apiPerson.Address == null)
{
_logger.LogWarning($"No home address supplied for {apiPerson.FirstName} {apiPerson.LastName}");
return;
}
var splitStreetAddress = SplitAddressOnNumber(apiPerson.Address.Street);
var apiAddress = new Address
{
Description = person.FullName,
StreetName = splitStreetAddress.ElementAt(0),
StreetNumber = splitStreetAddress.Count > 1 ? splitStreetAddress.ElementAt(1) : "1",
ZipCode = apiPerson.Address.PostalCode,
Town = apiPerson.Address.City ?? "",
};
apiAddress = _launderer.Launder(apiAddress);
var apiPersonalAddress = new PersonalAddress()
{
PersonId = person.Id,
Type = PersonalAddressType.Home,
StreetName = apiAddress.StreetName,
StreetNumber = apiAddress.StreetNumber,
ZipCode = apiAddress.ZipCode,
Town = apiAddress.Town,
Latitude = apiAddress.Latitude ?? "",
Longitude = apiAddress.Longitude ?? "",
Description = apiAddress.Description
};
var homeAddress = person.PersonalAddresses.Where(a => a.Type == PersonalAddressType.Home).FirstOrDefault();
if (homeAddress == null)
{
person.PersonalAddresses.Add(apiPersonalAddress);
}
else if (homeAddress != apiPersonalAddress)
{
homeAddress.Type = PersonalAddressType.OldHome;
person.PersonalAddresses.Add(apiPersonalAddress);
}
}
public void UpdateAddressHistories_WithTwoActiveHistories_ChangesInOneHomeAddressOneWorkAddress_ShouldDeactivateBothHistories()
{
var homeAddress1 = new PersonalAddress
{
StreetName = "TestStreetHome",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234",
Type = PersonalAddressType.Home,
PersonId = 1
};
var workAddress1 = new WorkAddress
{
StreetName = "TestStreetWork",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234"
};
var homeAddress2 = new PersonalAddress
{
StreetName = "TestStreetHome",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234",
Type = PersonalAddressType.Home,
PersonId = 2
};
var workAddress2 = new WorkAddress
{
StreetName = "TestStreetWork",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234"
};
var emplRepoMock = NSubstitute.Substitute.For <IGenericRepository <Employment> >();
emplRepoMock.AsQueryable().ReturnsForAnyArgs(new List <Employment>
{
new Employment()
{
Id = 1,
PersonId = 1,
OrgUnit = new OrgUnit()
{
Address = workAddress1
}
},
new Employment()
{
Id = 2,
PersonId = 2,
OrgUnit = new OrgUnit()
{
Address = new WorkAddress
{
StreetName = "NewTestStreetWork",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234"
}
}
}
}.AsQueryable());
var addressHistoryRepoMock = NSubstitute.Substitute.For <IGenericRepository <AddressHistory> >();
var historyList = new List <AddressHistory>
{
new AddressHistory()
{
EmploymentId = 1,
EndTimestamp = 0,
Employment = emplRepoMock.AsQueryable().Single(x => x.Id == 1),
WorkAddress = workAddress1,
HomeAddress = homeAddress1,
},
new AddressHistory()
{
EmploymentId = 2,
EndTimestamp = 0,
Employment = emplRepoMock.AsQueryable().Single(x => x.Id == 2),
WorkAddress = workAddress2,
HomeAddress = homeAddress2,
}
};
var personalAddressRepoMock = NSubstitute.Substitute.For <IGenericRepository <PersonalAddress> >();
personalAddressRepoMock.AsQueryable().ReturnsForAnyArgs(new List <PersonalAddress>
{
new PersonalAddress
{
StreetName = "NewTestStreetHome",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234",
Type = PersonalAddressType.Home,
PersonId = 1
}, homeAddress2
}.AsQueryable());
addressHistoryRepoMock.AsQueryable().ReturnsForAnyArgs(historyList.AsQueryable());
var uut = new AddressHistoryService(emplRepoMock, addressHistoryRepoMock, personalAddressRepoMock);
uut.UpdateAddressHistories();
Assert.AreNotEqual(0, historyList.ElementAt(0).EndTimestamp);
Assert.AreNotEqual(0, historyList.ElementAt(1).EndTimestamp);
}
public void UpdateAddressHistories_WithOneActiveHistory_NoChangesInAddress_ShouldNotDeactivate()
{
var homeAddress = new PersonalAddress
{
StreetName = "TestStreetHome",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234",
Type = PersonalAddressType.Home,
PersonId = 1
};
var workAddress = new WorkAddress
{
StreetName = "TestStreetWork",
StreetNumber = "1",
ZipCode = 1234,
Town = "TestTown",
Latitude = "1234",
Longitude = "1234"
};
var emplRepoMock = NSubstitute.Substitute.For <IGenericRepository <Employment> >();
emplRepoMock.AsQueryable().ReturnsForAnyArgs(new List <Employment>
{
new Employment()
{
Id = 1,
PersonId = 1,
OrgUnit = new OrgUnit()
{
Address = workAddress
}
}
}.AsQueryable());
var addressHistoryRepoMock = NSubstitute.Substitute.For <IGenericRepository <AddressHistory> >();
var historyList = new List <AddressHistory>
{
new AddressHistory()
{
EmploymentId = 1,
EndTimestamp = 0,
Employment = emplRepoMock.AsQueryable().First(),
WorkAddress = workAddress,
HomeAddress = homeAddress,
}
};
var personalAddressRepoMock = NSubstitute.Substitute.For <IGenericRepository <PersonalAddress> >();
personalAddressRepoMock.AsQueryable().ReturnsForAnyArgs(new List <PersonalAddress>
{
homeAddress
}.AsQueryable());
addressHistoryRepoMock.AsQueryable().ReturnsForAnyArgs(historyList.AsQueryable());
var uut = new AddressHistoryService(emplRepoMock, addressHistoryRepoMock, personalAddressRepoMock);
uut.UpdateAddressHistories();
Assert.AreEqual(0, historyList.ElementAt(0).EndTimestamp);
}
public void TransferFromTempToActual()
{
var tempRepo = NinjectWebKernel.CreateKernel().Get <IGenericRepository <TempAddressHistory> >();
var actualRepo = NinjectWebKernel.CreateKernel().Get <IGenericRepository <AddressHistory> >();
var workAddressRepo = NinjectWebKernel.CreateKernel().Get <IGenericRepository <WorkAddress> >();
var personalAddressRepo = NinjectWebKernel.CreateKernel().Get <IGenericRepository <PersonalAddress> >();
var coords = new AddressCoordinates();
var emplRepo = NinjectWebKernel.CreateKernel().Get <IGenericRepository <Employment> >();
var i = 0;
var rows = tempRepo.AsQueryable().Where(x => !x.WorkIsDirty && !x.HomeIsDirty).ToList();
foreach (var tempHistory in rows)
{
i++;
Console.WriteLine(i + " of " + rows.Count);
var currentTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
var empls = emplRepo.AsQueryable().Where(x => x.EmploymentId == tempHistory.MaNr).ToList();
if (empls.Count == 0)
{
continue;;
}
var empl = new Employment();
if (empls.Count == 1)
{
// If only one empl with manr exists just use that
empl = empls.First();
}
else
{
// If more than one exists then select the active one.
// If an active one does not exist then select the one that ended most recently
empl = empls.FirstOrDefault(x => x.EndDateTimestamp == 0) ??
empls.OrderByDescending(x => x.EndDateTimestamp).First();
}
var workTemp = coords.GetAddressCoordinates(new WorkAddress()
{
StreetName = SplitAddressOnNumber(tempHistory.ArbejdsAdresse)[0],
StreetNumber = SplitAddressOnNumber(tempHistory.ArbejdsAdresse)[1],
ZipCode = tempHistory.ArbejdsPostNr,
Town = tempHistory.ArbejdsBy,
});
var workAddress = new WorkAddress
{
StreetName = workTemp.StreetName,
StreetNumber = workTemp.StreetNumber,
ZipCode = workTemp.ZipCode,
Town = workTemp.Town,
Latitude = workTemp.Latitude,
Longitude = workTemp.Longitude
};
var homeTemp = coords.GetAddressCoordinates(new PersonalAddress
{
StreetName = SplitAddressOnNumber(tempHistory.HjemmeAdresse)[0],
StreetNumber = SplitAddressOnNumber(tempHistory.HjemmeAdresse)[1],
ZipCode = tempHistory.HjemmePostNr,
Town = tempHistory.HjemmeBy,
});
var homeAddress = new PersonalAddress()
{
StreetName = homeTemp.StreetName,
StreetNumber = homeTemp.StreetNumber,
ZipCode = homeTemp.ZipCode,
Town = homeTemp.Town,
Latitude = homeTemp.Latitude,
Longitude = homeTemp.Longitude,
PersonId = empl.PersonId,
Type = PersonalAddressType.OldHome,
};
workAddressRepo.Insert(workAddress);
personalAddressRepo.Insert(homeAddress);
workAddressRepo.Save();
personalAddressRepo.Save();
var addressHistory = new Core.DomainModel.AddressHistory
{
WorkAddressId = workAddress.Id,
HomeAddressId = homeAddress.Id,
StartTimestamp = tempHistory.AktivFra,
EndTimestamp = tempHistory.AktivTil,
EmploymentId = empl.Id,
IsMigrated = true,
};
actualRepo.Insert(addressHistory);
}
actualRepo.Save();
}
/// <summary>
/// Updates home address for person identified by personId.
/// </summary>
/// <param name="empl"></param>
/// <param name="personId"></param>
public void UpdateHomeAddressIDM(IDMEmployee empl, string cpr)
{
try
{
if (empl.Vejnavn == null || empl.Vejnavn == "")
{
return;
}
var person = _personRepo.AsQueryable().FirstOrDefault(x => x.CprNumber == cpr);
if (person == null)
{
throw new Exception("Person does not exist.");
}
var launderer = new CachedAddressLaunderer(_cachedRepo, _actualLaunderer, _coordinates);
var splitStreetAddress = SplitAddressIDM(empl.Vejnavn, empl.PostNr, empl.PostDistrikt);
var addressToLaunder = new Address
{
Description = person.FirstName + " " + person.LastName + " [" + person.Initials + "]",
StreetName = splitStreetAddress.ElementAtOrDefault(0),
StreetNumber = splitStreetAddress.ElementAtOrDefault(1) ?? "",
ZipCode = Convert.ToInt32(splitStreetAddress.ElementAtOrDefault(3) ?? "9999"),
Town = splitStreetAddress.ElementAtOrDefault(2) ?? ""
};
addressToLaunder = launderer.Launder(addressToLaunder);
var launderedAddress = new PersonalAddress()
{
PersonId = person.Id,
Type = PersonalAddressType.Home,
StreetName = addressToLaunder.StreetName,
StreetNumber = addressToLaunder.StreetNumber,
ZipCode = addressToLaunder.ZipCode,
Town = addressToLaunder.Town,
Latitude = addressToLaunder.Latitude ?? "",
Longitude = addressToLaunder.Longitude ?? "",
Description = addressToLaunder.Description
};
var homeAddr = _personalAddressRepo.AsQueryable().FirstOrDefault(x => x.PersonId.Equals(person.Id) &&
x.Type == PersonalAddressType.Home);
if (homeAddr == null)
{
_personalAddressRepo.Insert(launderedAddress);
}
else
{
if (homeAddr != launderedAddress)
{
// Address has changed
// Change type of current (The one about to be changed) home address to OldHome.
// Is done in loop because there was an error that created one or more home addresses for the same person.
// This will make sure all home addresses are set to old if more than one exists.
foreach (var addr in _personalAddressRepo.AsQueryable().Where(x => x.PersonId.Equals(person.Id) && x.Type == PersonalAddressType.Home).ToList())
{
addr.Type = PersonalAddressType.OldHome;;
}
// Update actual current home address.
_personalAddressRepo.Insert(launderedAddress);
_personalAddressRepo.Save();
}
}
}
catch (Exception e)
{
_logger.Error($"{this.GetType().Name}, UpdateHomeAddressIDM(), Error when updating address for CPR={cpr}", e);
throw;
}
}
/// <summary>
/// Updates home address for person identified by personId.
/// </summary>
/// <param name="empl"></param>
/// <param name="personId"></param>
public void UpdateHomeAddress(Employee empl, int personId)
{
if (empl.Adresse == null)
{
return;
}
var person = _personRepo.AsQueryable().FirstOrDefault(x => x.Id == personId);
if (person == null)
{
_logger.Error($"{this.GetType().Name}, UpdateHomeAddress(), Person does not exist. personId={personId}, MaNr={empl.MaNr}");
throw new Exception("Person does not exist.");
}
var launderer = new CachedAddressLaunderer(_cachedRepo, _actualLaunderer, _coordinates);
List <string> splitStreetAddress = null;
try
{
splitStreetAddress = SplitAddressOnNumber(empl.Adresse);
}
catch (Exception e)
{
_logger.Error($"{this.GetType().Name}, UpdateHomeAddress(), Error when splitting address. personId={personId}, address={empl.Adresse}", e);
throw;
}
var addressToLaunder = new Address
{
Description = person.FirstName + " " + person.LastName + " [" + person.Initials + "]",
StreetName = splitStreetAddress.ElementAt(0),
StreetNumber = splitStreetAddress.Count > 1 ? splitStreetAddress.ElementAt(1) : "1",
ZipCode = empl.PostNr ?? 0,
Town = empl.By ?? "",
};
addressToLaunder = launderer.Launder(addressToLaunder);
var launderedAddress = new PersonalAddress()
{
PersonId = personId,
Type = PersonalAddressType.Home,
StreetName = addressToLaunder.StreetName,
StreetNumber = addressToLaunder.StreetNumber,
ZipCode = addressToLaunder.ZipCode,
Town = addressToLaunder.Town,
Latitude = addressToLaunder.Latitude ?? "",
Longitude = addressToLaunder.Longitude ?? "",
Description = addressToLaunder.Description
};
var homeAddr = _personalAddressRepo.AsQueryable().FirstOrDefault(x => x.PersonId.Equals(personId) &&
x.Type == PersonalAddressType.Home);
if (homeAddr == null)
{
_personalAddressRepo.Insert(launderedAddress);
}
else
{
if (homeAddr != launderedAddress)
{
// Address has changed
// Change type of current (The one about to be changed) home address to OldHome.
// Is done in loop because there was an error that created one or more home addresses for the same person.
// This will make sure all home addresses are set to old if more than one exists.
foreach (var addr in _personalAddressRepo.AsQueryable().Where(x => x.PersonId.Equals(personId) && x.Type == PersonalAddressType.Home).ToList())
{
addr.Type = PersonalAddressType.OldHome;;
}
// Update actual current home address.
_personalAddressRepo.Insert(launderedAddress);
_personalAddressRepo.Save();
}
}
}
public void MigrateHistories()
{
var historiesToMigrate = _provider.GetAddressHistoriesAsQueryable();
var failedWorkAddresses = new List <string>();
var failedHomeAddresses = new List <string>();
var i = 0;
var max = historiesToMigrate.Count();
foreach (var ah in historiesToMigrate)
{
if (i % 10 == 0)
{
Console.WriteLine("Migrating AddressHistory " + i + " of " + max + ".");
}
i++;
var currentDateTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
var employments = _employmentRepo.AsQueryable().Where(x => x.EmploymentId == ah.MaNr);
var employment = new Employment();
if (employments.Count() == 1)
{
employment = employments.First();
}
else if (employments.Count() > 1)
{
employment = employments.Single(x => x.EndDateTimestamp == 0 || x.EndDateTimestamp > currentDateTimestamp);
}
var homeAddressLookup = new Address();
var homeAddress = new PersonalAddress();
try
{
homeAddressLookup = _coords.GetAddressCoordinates(new Address()
{
StreetName = SplitAddressOnNumber(ah.HjemmeAdresse)[0],
StreetNumber = SplitAddressOnNumber(ah.HjemmeAdresse)[1],
ZipCode = ah.HjemmePostNr,
Town = ah.HjemmeBy
});
homeAddress = new PersonalAddress()
{
Type = PersonalAddressType.OldHome,
PersonId = employment.PersonId,
StreetNumber = homeAddressLookup.StreetNumber,
StreetName = homeAddressLookup.StreetName,
Town = homeAddressLookup.Town,
ZipCode = homeAddressLookup.ZipCode,
Latitude = homeAddressLookup.Latitude,
Longitude = homeAddressLookup.Longitude
};
homeAddress = _personalAddressRepo.Insert(homeAddress);
_personalAddressRepo.Save();
}
catch (Exception)
{
failedHomeAddresses.Add(ah.HjemmeAdresse);
}
var workAddressLookup = new Address();
var workAddress = new WorkAddress();
try
{
workAddressLookup = _coords.GetAddressCoordinates(new Address()
{
StreetName = SplitAddressOnNumber(ah.ArbejdsAdresse)[0],
StreetNumber = SplitAddressOnNumber(ah.ArbejdsAdresse)[1],
ZipCode = ah.ArbejdsPostNr,
Town = ah.ArbejdsBy
});
workAddress = new WorkAddress()
{
StreetNumber = workAddressLookup.StreetNumber,
StreetName = workAddressLookup.StreetName,
Town = workAddressLookup.Town,
ZipCode = workAddressLookup.ZipCode,
Latitude = workAddressLookup.Latitude,
Longitude = workAddressLookup.Longitude
};
workAddress = _workAddressRepo.Insert(workAddress);
_workAddressRepo.Save();
}
catch (Exception)
{
failedWorkAddresses.Add(ah.ArbejdsAdresse);
}
var history = new Core.DomainModel.AddressHistory()
{
EmploymentId = employment.Id,
StartTimestamp = (Int32)(ah.AktivFra.Subtract(new DateTime(1970, 1, 1))).TotalSeconds,
EndTimestamp = (Int32)(ah.AktivTil.Subtract(new DateTime(1970, 1, 1))).TotalSeconds,
HomeAddressId = homeAddress.Id,
WorkAddressId = workAddress.Id
};
_historyRepo.Insert(history);
}
_historyRepo.Save();
}
