private async Task EnsureNoProgramDuplicate(ServiceV1DTO serviceDTO)
{
if (serviceDTO.ProgramDTO == null)
{
return;
}
var program = await _context.Program
.Where(p => p.ProgramOfferNumber == serviceDTO.ProgramDTO.ProgramOfferNumber)
.FirstOrDefaultAsync();
if (program != null)
{
serviceDTO.ProgramId = program.ProgramId;
serviceDTO.ProgramDTO = null;
}
}
private async Task EnsureProgramExistence(ServiceV1DTO serviceDTO)
{
var program = await _context.Program
.Where(p => p.ProgramId == serviceDTO.ProgramId)
.SingleOrDefaultAsync();
if (program == null && serviceDTO.ProgramDTO != null)
{
var p = new Program();
_context.Program.Add(p);
_context.Entry(p).CurrentValues.SetValues(serviceDTO.ProgramDTO);
await _context.SaveChangesAsync();
serviceDTO.ProgramId = p.ProgramId;
}
}
private async Task EnsureNoDivisionDuplicate(ServiceV1DTO serviceDTO)
{
if (serviceDTO.DivisionDTO == null)
{
return;
}
var division = await _context.Division
.Where(d => d.DivisionCode == serviceDTO.DivisionDTO.DivisionCode)
.SingleOrDefaultAsync();
if (division != null)
{
serviceDTO.DivisionId = division.DivisionId;
serviceDTO.DivisionDTO = null;
}
}
private async Task EnsureDivisionExistence(ServiceV1DTO serviceDTO)
{
var division = await _context.Division
.Where(d => d.DivisionId == serviceDTO.DivisionId)
.SingleOrDefaultAsync();
if (division == null && serviceDTO.DivisionDTO != null)
{
var d = new Division();
_context.Division.Add(d);
_context.Entry(d).CurrentValues.SetValues(serviceDTO.DivisionDTO);
await _context.SaveChangesAsync();
serviceDTO.DivisionId = d.DivisionId;
}
}
private async Task EnsureNoDepartmentDuplicate(ServiceV1DTO serviceDTO)
{
if (serviceDTO.DepartmentDTO == null)
{
return;
}
var department = await _context.Department
.Where(d => d.DepartmentCode == serviceDTO.DepartmentDTO.DepartmentCode)
.SingleOrDefaultAsync();
if (department != null)
{
serviceDTO.DepartmentId = department.DepartmentId;
serviceDTO.DepartmentDTO = null;
}
}
private async Task EnsureDepartmentExistence(ServiceV1DTO serviceDTO)
{
var department = await _context.Department
.Where(d => d.DepartmentId == serviceDTO.DepartmentId)
.SingleOrDefaultAsync();
if (department == null && serviceDTO.DepartmentDTO != null)
{
var d = new Department();
_context.Department.Add(d);
_context.Entry(d).CurrentValues.SetValues(serviceDTO.DepartmentDTO);
await _context.SaveChangesAsync();
serviceDTO.DepartmentId = d.DepartmentId;
}
}
private async Task EnsureContactExistence(ServiceV1DTO serviceDTO)
{
var contact = await _context.Contact
.Where(c => c.ContactId == serviceDTO.ContactId)
.SingleOrDefaultAsync();
if (contact == null && serviceDTO.ContactDTO != null)
{
var c = new Contact();
_context.Contact.Add(c);
_context.Entry(c).CurrentValues.SetValues(serviceDTO.ContactDTO);
await _context.SaveChangesAsync();
serviceDTO.ContactId = c.ContactId;
}
}
private async Task EnsureNoContactDuplicate(ServiceV1DTO serviceDTO)
{
if (serviceDTO.ContactDTO == null)
{
return;
}
var contact = await _context.Contact
.Where(c => c.EmailAddress == serviceDTO.ContactDTO.EmailAddress && c.ContactName == serviceDTO.ContactDTO.ContactName && serviceDTO.ContactDTO.PhoneNumber == c.PhoneNumber)
.FirstOrDefaultAsync();
if (contact != null)
{
serviceDTO.ContactId = contact.ContactId;
serviceDTO.ContactDTO = null;
}
}
public async Task <IActionResult> PostService([FromBody] ServiceV1DTO serviceV1DTO)
{
//Check to ensure service does not exist in database before calling contextmanager method.
try
{
var service = await _contextManager.GetServiceByIdAsync(serviceV1DTO.ServiceId);
if (service != null)
{
return(Conflict());
}
await _contextManager.PostAsync(serviceV1DTO);
return(NoContent());
}
catch (Exception e)
{
throw e;
}
}
public async Task <IActionResult> PutService(int id, [FromBody] ServiceV1DTO serviceDTO)
{
try
{
// Check to ensure service exists before calling contextmanager method.
var service = await _contextManager.GetServiceByIdAsync(id);
if (service == null)
{
return(NotFound());
}
serviceDTO.ServiceId = id;
await _contextManager.PutAsync(serviceDTO);
return(NoContent());
}
catch (Exception e)
{
throw e;
}
}
public async Task PostAsync(ServiceV1DTO serviceDTO)
{
#region Handle one-to-one relations
#region Check to see if attempting to add duplicate contact/department/division/program with different ID
/*
* We are checking to see if the incoming Service is attempting to
* re-create an existing department/division using a different ID.
* This should be corrected to reference the existing department/division.
* We choose the passed DTO over the passed ID number, and change the ID
* to match the deperment/division pulled from the database context by "...Code".
*/
await EnsureNoContactDuplicate(serviceDTO);
await EnsureNoDepartmentDuplicate(serviceDTO);
await EnsureNoDivisionDuplicate(serviceDTO);
await EnsureNoProgramDuplicate(serviceDTO);
#endregion
#region Check existence of one-to-one items
await EnsureContactExistence(serviceDTO);
await EnsureDepartmentExistence(serviceDTO);
await EnsureDivisionExistence(serviceDTO);
await EnsureProgramExistence(serviceDTO);
#endregion
#endregion
var service = new Service();
_context.Service.Add(service);
_context.Entry(service).CurrentValues.SetValues(serviceDTO);
await _context.SaveChangesAsync();
#region Handle many-to-many relations
foreach (var cDTO in serviceDTO.CommunityDTOs)
{
var community = await EnsureCommunityExistence(cDTO);
var sca = new ServiceCommunityAssociation {
ServiceId = service.ServiceId, CommunityId = community.CommunityId
};
_context.ServiceCommunityAssociation.Add(sca);
}
foreach (var lDTO in serviceDTO.LanguageDTOs)
{
var language = await EnsureLanguageExistence(lDTO);
var sla = new ServiceLanguageAssociation {
ServiceId = service.ServiceId, LanguageId = language.LanguageId
};
_context.ServiceLanguageAssociation.Add(sla);
}
foreach (var lDTO in serviceDTO.LocationDTOs)
{
var location = await EnsureLocationExistence(lDTO);
var sla = new ServiceLocationAssociation {
ServiceId = service.ServiceId, LocationId = location.LocationId
};
_context.ServiceLocationAssociation.Add(sla);
}
#endregion
await _context.SaveChangesAsync();
}
public async Task PutAsync(ServiceV1DTO serviceDTO)
{
var service = await _context.Service
.Where(s => s.ServiceId == serviceDTO.ServiceId)
.SingleOrDefaultAsync();
#region Handle one-to-one relations
if (service.ContactId != serviceDTO.ContactId)
{
await EnsureNoContactDuplicate(serviceDTO);
await EnsureContactExistence(serviceDTO);
}
if (service.DepartmentId != serviceDTO.DepartmentId)
{
await EnsureNoDepartmentDuplicate(serviceDTO);
await EnsureDepartmentExistence(serviceDTO);
}
if (service.DivisionId != serviceDTO.DivisionId)
{
await EnsureNoDivisionDuplicate(serviceDTO);
await EnsureDivisionExistence(serviceDTO);
}
if (service.ProgramId != serviceDTO.ProgramId)
{
await EnsureNoProgramDuplicate(serviceDTO);
await EnsureProgramExistence(serviceDTO);
}
#endregion
#region Handle many-to-many relations
var communityIds = new HashSet <int>();
var scas = await _context.ServiceCommunityAssociation
.Where(sca => sca.ServiceId == serviceDTO.ServiceId)
.ToListAsync();
foreach (var cDTO in serviceDTO.CommunityDTOs)
{
//Build community if it needs to be built.
var community = await EnsureCommunityExistence(cDTO);
communityIds.Add(community.CommunityId);
}
foreach (var id in communityIds)
{
var sca = scas.FirstOrDefault(s => s.CommunityId == id);
// If this is a new entry in SCA table, we need to build the entry and add to table.
if (sca == null)
{
var scaEntry = new ServiceCommunityAssociation {
ServiceId = serviceDTO.ServiceId, CommunityId = id
};
_context.ServiceCommunityAssociation.Add(scaEntry);
}
else
{
scas.Remove(sca);
}
}
foreach (var sca in scas)
{
_context.ServiceCommunityAssociation.Remove(sca);
}
var languageIds = new HashSet <int>();
var slas = await _context.ServiceLanguageAssociation
.Where(sla => sla.ServiceId == serviceDTO.ServiceId)
.ToListAsync();
foreach (var lDTO in serviceDTO.LanguageDTOs)
{
var language = await EnsureLanguageExistence(lDTO);
languageIds.Add(language.LanguageId);
}
foreach (var id in languageIds)
{
var sla = slas.FirstOrDefault(l => l.LanguageId == id);
if (sla == null)
{
var slaEntry = new ServiceLanguageAssociation {
ServiceId = serviceDTO.ServiceId, LanguageId = id
};
_context.ServiceLanguageAssociation.Add(slaEntry);
}
else
{
slas.Remove(sla);
}
}
foreach (var sla in slas)
{
_context.ServiceLanguageAssociation.Remove(sla);
}
var locationIds = new HashSet <int>();
var slocs = await _context.ServiceLocationAssociation
.Where(sla => sla.ServiceId == serviceDTO.ServiceId)
.ToListAsync();
foreach (var lDTO in serviceDTO.LocationDTOs)
{
var location = await EnsureLocationExistence(lDTO);
locationIds.Add(location.LocationId);
}
foreach (var id in locationIds)
{
var sla = slocs.FirstOrDefault(l => l.LocationId == id);
if (sla == null)
{
var slaEntry = new ServiceLocationAssociation {
ServiceId = service.ServiceId, LocationId = id
};
_context.ServiceLocationAssociation.Add(slaEntry);
}
else
{
slocs.Remove(sla);
}
}
foreach (var sla in slocs)
{
_context.ServiceLocationAssociation.Remove(sla);
}
#endregion
_context.Entry(service).CurrentValues.SetValues(serviceDTO);
await _context.SaveChangesAsync();
}
