public OccupationDTO AddOccupation(OccupationDTO occupationDTO)
{
var occp = new Occupation()
{
OrganisationName = occupationDTO.OrganisationName,
PhoneNumber = occupationDTO.PhoneNumber,
WorkType = occupationDTO.WorkType,
Designation = occupationDTO.Designation,
Patientid = occupationDTO.Patientid
};
_context.Occupations.Add(occp);
_context.SaveChanges();
int Occpid = occp.OccupationId;
var addr = new WorkAddress()
{
StreetNumber = occupationDTO.StreetNumber,
Area = occupationDTO.Area,
City = occupationDTO.City,
State = occupationDTO.State,
Country = occupationDTO.Country,
ZipCode = occupationDTO.ZipCode,
Occupationid = Occpid
};
_context.WorkAddresses.Add(addr);
_context.SaveChanges();
return(occupationDTO);
}
public WorkAddress Update(WorkAddress addressChanges)
{
var address = _context.WorkAddresses.Attach(addressChanges);
address.State = Microsoft.EntityFrameworkCore.EntityState.Modified;
_context.SaveChanges();
return(addressChanges);
}
public WorkAddress GetWorkAddressIDM(IDMOrganisation org)
{
var launderer = new CachedAddressLaunderer(_cachedRepo, _actualLaunderer, _coordinates);
if (org.Vejnavn == null || org.Vejnavn == "")
{
return(null);
}
var splitStreetAddress = SplitAddressIDM(org.Vejnavn, org.PostNr, org.PostDistrikt);
var addressToLaunder = new Address
{
StreetName = splitStreetAddress.ElementAt(0),
StreetNumber = splitStreetAddress.ElementAt(1),
ZipCode = Convert.ToInt32(splitStreetAddress.ElementAt(3)),
Town = splitStreetAddress.ElementAt(2),
Description = org.Navn
};
addressToLaunder = launderer.Launder(addressToLaunder);
var launderedAddress = new WorkAddress()
{
StreetName = addressToLaunder.StreetName,
StreetNumber = addressToLaunder.StreetNumber,
ZipCode = addressToLaunder.ZipCode,
Town = addressToLaunder.Town,
Latitude = addressToLaunder.Latitude ?? "",
Longitude = addressToLaunder.Longitude ?? "",
Description = org.Navn
};
var existingOrg = _orgRepo.AsQueryable().FirstOrDefault(x => x.OrgOUID.Equals(org.OUID));
// If the address hasn't changed then set the Id to be the same as the existing one.
// That way a new address won't be created in the database.
// If the address is not the same as the existing one,
// Then the Id will be 0, and a new address will be created in the database.
if (existingOrg != null &&
existingOrg.Address != null &&
existingOrg.Address.StreetName == launderedAddress.StreetName &&
existingOrg.Address.StreetNumber == launderedAddress.StreetNumber &&
existingOrg.Address.ZipCode == launderedAddress.ZipCode &&
existingOrg.Address.Town == launderedAddress.Town &&
existingOrg.Address.Latitude == launderedAddress.Latitude &&
existingOrg.Address.Longitude == launderedAddress.Longitude &&
existingOrg.Address.Description == launderedAddress.Description)
{
launderedAddress.Id = (int)existingOrg.AddressId;
}
else
{
var a = 2;
}
return(launderedAddress);
}
/// <summary>
/// Gets work address wor organisation.
/// </summary>
/// <param name="org"></param>
/// <returns>WorkAddress</returns>
public WorkAddress GetWorkAddress(Organisation org)
{
var launderer = new CachedAddressLaunderer(_cachedRepo, _actualLaunderer, _coordinates);
if (org.Gade == null)
{
return(null);
}
var splitStreetAddress = SplitAddressOnNumber(org.Gade);
var addressToLaunder = new Address
{
StreetName = splitStreetAddress.ElementAt(0),
StreetNumber = splitStreetAddress.Count > 1 ? splitStreetAddress.ElementAt(1) : "1",
ZipCode = org.Postnr ?? 0,
Town = org.By,
Description = org.Navn
};
addressToLaunder = launderer.Launder(addressToLaunder);
var launderedAddress = new WorkAddress()
{
StreetName = addressToLaunder.StreetName,
StreetNumber = addressToLaunder.StreetNumber,
ZipCode = addressToLaunder.ZipCode,
Town = addressToLaunder.Town,
Latitude = addressToLaunder.Latitude ?? "",
Longitude = addressToLaunder.Longitude ?? "",
Description = org.Navn
};
var existingOrg = _orgRepo.AsQueryable().FirstOrDefault(x => x.OrgId.Equals(org.LOSOrgId));
// If the address hasn't changed then set the Id to be the same as the existing one.
// That way a new address won't be created in the database.
// If the address is not the same as the existing one,
// Then the Id will be 0, and a new address will be created in the database.
if (existingOrg != null &&
existingOrg.Address != null &&
existingOrg.Address.StreetName == launderedAddress.StreetName &&
existingOrg.Address.StreetNumber == launderedAddress.StreetNumber &&
existingOrg.Address.ZipCode == launderedAddress.ZipCode &&
existingOrg.Address.Town == launderedAddress.Town &&
existingOrg.Address.Latitude == launderedAddress.Latitude &&
existingOrg.Address.Longitude == launderedAddress.Longitude &&
existingOrg.Address.Description == launderedAddress.Description)
{
launderedAddress.Id = existingOrg.AddressId;
}
else
{
var a = 2;
}
return(launderedAddress);
}
public ActionResult Put(int id, [FromBody] WorkAddress address)
{
if (id > 0)
{
ar.Update(address);
return(Ok("Address Updated"));
}
return(NotFound());
}
public WorkAddress Delete(int id)
{
WorkAddress address = _context.WorkAddresses.Find(id);
if (address != null)
{
_context.WorkAddresses.Remove(address);
_context.SaveChanges();
}
return(address);
}
/// <summary>
/// To add the work address details of the user.
/// </summary>
/// <param name="workAddress"></param>
public void AddWorkAddressDetails(WorkAddress workAddress)
{
try
{
_clientDbContext.WorkAddress.Add(workAddress);
_clientDbContext.SaveChanges();
}
catch
{
throw;
}
}
/// <summary>
/// Gets work address from API Address.
/// </summary>
/// <param name="org"></param>
/// <returns>WorkAddress</returns>
private WorkAddress GetWorkAddress(APIOrgUnit apiOrgunit)
{
var launderer = new CachedAddressLaunderer(_cachedRepo, _actualLaunderer, _coordinates);
if (apiOrgunit.Address?.Street == null)
{
return(null);
}
var splitStreetAddress = SplitAddressOnNumber(apiOrgunit.Address.Street);
var addressToLaunder = new Address
{
StreetName = splitStreetAddress.ElementAt(0),
StreetNumber = splitStreetAddress.Count > 1 ? splitStreetAddress.ElementAt(1) : "1",
ZipCode = apiOrgunit.Address.PostalCode,
Town = apiOrgunit.Address.City,
Description = apiOrgunit.Name
};
addressToLaunder = launderer.Launder(addressToLaunder);
var launderedAddress = new WorkAddress()
{
StreetName = addressToLaunder.StreetName,
StreetNumber = addressToLaunder.StreetNumber,
ZipCode = addressToLaunder.ZipCode,
Town = addressToLaunder.Town,
Latitude = addressToLaunder.Latitude ?? "",
Longitude = addressToLaunder.Longitude ?? "",
Description = apiOrgunit.Name
};
var existingOrg = _orgUnitRepo.AsNoTracking().FirstOrDefault(x => x.OrgId.Equals(apiOrgunit.Id));
// If the address hasn't changed then set the Id to be the same as the existing one.
// That way a new address won't be created in the database.
// If the address is not the same as the existing one,
// Then the Id will be 0, and a new address will be created in the database.
if (existingOrg != null &&
existingOrg.Address != null &&
existingOrg.Address.StreetName == launderedAddress.StreetName &&
existingOrg.Address.StreetNumber == launderedAddress.StreetNumber &&
existingOrg.Address.ZipCode == launderedAddress.ZipCode &&
existingOrg.Address.Town == launderedAddress.Town &&
existingOrg.Address.Latitude == launderedAddress.Latitude &&
existingOrg.Address.Longitude == launderedAddress.Longitude &&
existingOrg.Address.Description == launderedAddress.Description)
{
launderedAddress.Id = existingOrg.AddressId;
}
return(launderedAddress);
}
/// <summary>
/// To delete the user work address details.
/// </summary>
/// <param name="workAddress"></param>
public void DeleteWorkAddressDetails(WorkAddress workAddress)
{
try
{
_clientDbContext.WorkAddress.Remove(workAddress);
_clientDbContext.SaveChanges();
}
catch
{
throw;
}
}
public WorkAddress Add(WorkAddress address)
{
_context.WorkAddresses.Add(address);
_context.SaveChanges();
//_context.Addresses.Add(new Address()
//{
// StreetNumber = address.StreetNumber,
// Area = address.Area,
// Locality = address.Locality,
// City = address.City,
// State = address.State,
// Country = address.Country,
// ZipCode = address.ZipCode
//});
//_context.SaveChanges();
return(address);
}
/// <summary>
/// To upadte the user work address details.
/// </summary>
/// <param name="workAddress"></param>
public void UpdateWorkAddressDetails(WorkAddress workAddress)
{
try
{
var workAdrs = _masterDbContext.WorkAddress.Where(a => a.UserID == workAddress.UserID && a.WorkAddressID == workAddress.WorkAddressID && a.RoleID == 1).FirstOrDefault();
if (workAdrs != null)
{
_masterDbContext.Entry(workAddress).State = System.Data.Entity.EntityState.Modified;
_masterDbContext.SaveChanges();
}
else
{
_clientDbContext.Entry(workAddress).State = System.Data.Entity.EntityState.Modified;
_clientDbContext.SaveChanges();
}
}
catch
{
throw;
}
}
/// <summary>
/// Validates this object. It validates dependencies between properties and also calls Validate on child collections;
/// </summary>
/// <param name="validationContext"></param>
/// <returns>A IEnumerable of ValidationResult. The IEnumerable is empty when the object is in a valid state.</returns>
public override IEnumerable <ValidationResult> Validate(ValidationContext validationContext)
{
if (Type == PersonType.None)
{
yield return(new ValidationResult("Type can't be None.", new[] { "Type" }));
}
if (DateOfBirth < DateTime.Now.AddYears(Constants.MaxAgePerson * -1))
{
yield return(new ValidationResult("Invalid range for DateOfBirth; must be between today and 130 years ago.", new[] { "DateOfBirth" }));
}
if (DateOfBirth > DateTime.Now)
{
yield return(new ValidationResult("Invalid range for DateOfBirth; must be between today and 130 years ago.", new[] { "DateOfBirth" }));
}
foreach (var result in PhoneNumbers.Validate())
{
yield return(result);
}
foreach (var result in EmailAddresses.Validate())
{
yield return(result);
}
foreach (var result in HomeAddress.Validate())
{
yield return(result);
}
foreach (var result in WorkAddress.Validate())
{
yield return(result);
}
}
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();
}
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 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();
}
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 ActionResult Post([FromBody] WorkAddress address)
{
ar.Add(address);
return(Ok());
}
