private static async Task ParallelLoadEvacueeAsync(EssContext ctx, era_evacuationfile file, CancellationToken ct)
{
ctx.AttachTo(nameof(EssContext.era_evacuationfiles), file);
var loadTasks = new List <Task>();
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_animal_ESSFileid), ct));
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_TaskId), ct));
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId), ct));
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_EvacuatedFromID), ct));
if (file.era_CurrentNeedsAssessmentid == null)
{
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_CurrentNeedsAssessmentid), ct));
}
await Task.WhenAll(loadTasks);
var householdMembers = (await((DataServiceQuery <era_householdmember>)ctx.era_householdmembers
.Expand(m => m.era_Registrant)
.Where(m => m._era_evacuationfileid_value == file.era_evacuationfileid))
.GetAllPagesAsync(ct))
.ToArray();
householdMembers.AsParallel().ForAll(m => m.era_EvacuationFileid = file);
file.era_era_evacuationfile_era_householdmember_EvacuationFileid = new Collection <era_householdmember>(householdMembers);
if (file.era_TaskId != null)
{
file.era_TaskId.era_JurisdictionID = ctx.LookupJurisdictionByCode(file.era_TaskId._era_jurisdictionid_value?.ToString());
}
}
private static async Task ParallelLoadSupportAsync(EssContext ctx, era_evacuationfile file)
{
ctx.AttachTo(nameof(EssContext.era_evacuationfiles), file);
var loadTasks = new List <Task>();
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_TaskId))));
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_EvacuatedFromID))));
loadTasks.Add(Task.Run(async() =>
{
await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId));
foreach (var support in file.era_era_evacuationfile_era_evacueesupport_ESSFileId)
{
ctx.AttachTo(nameof(EssContext.era_evacueesupports), support);
var loadSubTasks = new List <Task>();
loadSubTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(support, nameof(era_evacueesupport.era_SupplierId))));
loadSubTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(support, nameof(era_evacueesupport.era_GroupLodgingCityID))));
loadSubTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(support, nameof(era_evacueesupport.era_era_householdmember_era_evacueesupport))));
await Task.WhenAll(loadSubTasks.ToArray());
ctx.Detach(support);
}
}));
await Task.WhenAll(loadTasks.ToArray());
}
private void CreateHouseholdMember(era_evacuationfile eraEvacuationFile, era_needassessment eraNeedsAssessment, era_householdmember member)
{
member.era_householdmemberid = Guid.NewGuid();
var contact = member.era_Registrant;
if (contact.contactid.HasValue)
{
//TODO: figure out a nicer way to handle already tracked primary contact handling
var trackedContact = (contact)essContext.EntityTracker.Entities.SingleOrDefault(e => e.Entity is contact c && c.contactid == contact.contactid).Entity;
if (trackedContact != null)
{
contact = trackedContact;
}
else
{
essContext.AttachTo(nameof(essContext.contacts), contact);
}
}
else
{
contact.contactid = Guid.NewGuid();
contact.era_authenticated = false;
contact.era_verified = false;
contact.era_registrationdate = DateTimeOffset.UtcNow;
essContext.AddTocontacts(contact);
}
essContext.AddToera_householdmembers(member);
essContext.AddLink(member, nameof(era_householdmember.era_era_householdmember_era_needassessment), eraNeedsAssessment);
//essContext.AddLink(eraNeedsAssessment, nameof(era_needassessment.era_era_householdmember_era_needassessment), member);
essContext.SetLink(member, nameof(era_householdmember.era_EvacuationFileid), eraEvacuationFile);
essContext.SetLink(member, nameof(era_householdmember.era_Registrant), contact);
essContext.AddLink(contact, nameof(contact.era_contact_era_householdmember_Registrantid), member);
}
private void VerifyEvacuationFileInvariants(EvacuationFile evacuationFile, era_evacuationfile currentFile = null)
{
//Check invariants
if (string.IsNullOrEmpty(evacuationFile.PrimaryRegistrantId))
{
throw new ArgumentNullException($"The file has no associated primary registrant");
}
if (evacuationFile.NeedsAssessment == null)
{
throw new ArgumentNullException($"File {evacuationFile.Id} must have a needs assessment");
}
if (evacuationFile.Id == null)
{
if (evacuationFile.NeedsAssessment.HouseholdMembers.Count(m => m.IsPrimaryRegistrant) != 1)
{
throw new InvalidOperationException($"File {evacuationFile.Id} must have a single primary registrant household member");
}
}
else
{
if (evacuationFile.NeedsAssessment.HouseholdMembers.Count(m => m.IsPrimaryRegistrant) > 1)
{
throw new InvalidOperationException($"File {evacuationFile.Id} can not have multiple primary registrant household members");
}
if (currentFile != null && currentFile.era_era_evacuationfile_era_householdmember_EvacuationFileid != null &&
currentFile.era_era_evacuationfile_era_householdmember_EvacuationFileid.Any(m => m.era_isprimaryregistrant == true) &&
evacuationFile.NeedsAssessment.HouseholdMembers.Any(m => m.IsPrimaryRegistrant && string.IsNullOrEmpty(m.Id)))
{
throw new InvalidOperationException($"File {evacuationFile.Id} can not have multiple primary registrant household members");
}
}
}
private static async Task ParallelLoadEvacueeAsync(EssContext ctx, era_evacuationfile file)
{
ctx.AttachTo(nameof(EssContext.era_evacuationfiles), file);
var loadTasks = new List <Task>();
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_animal_ESSFileid))));
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_TaskId))));
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId))));
loadTasks.Add(Task.Run(async() => await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_EvacuatedFromID))));
loadTasks.Add(Task.Run(async() =>
{
await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid));
if (file.era_CurrentNeedsAssessmentid == null)
{
await ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_CurrentNeedsAssessmentid));
}
foreach (var member in file.era_era_evacuationfile_era_householdmember_EvacuationFileid)
{
if (member._era_registrant_value.HasValue)
{
ctx.AttachTo(nameof(EssContext.era_householdmembers), member);
await ctx.LoadPropertyAsync(member, nameof(era_householdmember.era_Registrant));
ctx.Detach(member);
}
}
}));
await Task.WhenAll(loadTasks.ToArray());
}
private void UpdateSupport(era_evacuationfile file, era_evacueesupport support)
{
var existingSupport = essContext.era_evacueesupports
.Where(s => s.era_name == support.era_name)
.SingleOrDefault();
if (existingSupport == null)
{
throw new Exception($"Support {support.era_name} not found");
}
if (existingSupport._era_evacuationfileid_value != file.era_evacuationfileid)
{
throw new Exception($"Support {support.era_name} not found in file {file.era_name}");
}
essContext.LoadProperty(existingSupport, nameof(era_evacueesupport.era_era_householdmember_era_evacueesupport));
var currentHouseholdMembers = existingSupport.era_era_householdmember_era_evacueesupport.ToArray();
essContext.Detach(existingSupport);
//foreach (var member in existingSupport.era_era_householdmember_era_evacueesupport) essContext.Detach(member);
support.era_evacueesupportid = existingSupport.era_evacueesupportid;
essContext.AttachTo(nameof(EssContext.era_evacueesupports), support);
var teamMember = essContext.era_essteamusers.ByKey(support._era_issuedbyid_value).GetValue();
essContext.SetLink(support, nameof(era_evacueesupport.era_IssuedById), teamMember);
essContext.UpdateObject(support);
//remove household members no longer part of the support
RemoveHouseholdMembersFromSupport(support, currentHouseholdMembers.Where(m => !support.era_era_householdmember_era_evacueesupport.Any(im => im.era_householdmemberid == m.era_householdmemberid)));
//add household members to support
AssignHouseholdMembersToSupport(support, support.era_era_householdmember_era_evacueesupport.Where(m => !currentHouseholdMembers.Any(im => im.era_householdmemberid == m.era_householdmemberid)));
AssignSupplierToSupport(support);
}
private void AddNeedsAssessment(era_evacuationfile file, era_needassessment needsAssessment)
{
essContext.AddToera_needassessments(needsAssessment);
essContext.SetLink(file, nameof(era_evacuationfile.era_CurrentNeedsAssessmentid), needsAssessment);
essContext.AddLink(file, nameof(era_evacuationfile.era_needsassessment_EvacuationFile), needsAssessment);
essContext.SetLink(needsAssessment, nameof(era_needassessment.era_EvacuationFile), file);
essContext.SetLink(needsAssessment, nameof(era_needassessment.era_Jurisdictionid), essContext.LookupJurisdictionByCode(needsAssessment._era_jurisdictionid_value?.ToString()));
if (needsAssessment._era_reviewedbyid_value.HasValue)
{
var teamMember = essContext.era_essteamusers.ByKey(needsAssessment._era_reviewedbyid_value).GetValue();
essContext.SetLink(needsAssessment, nameof(era_needassessment.era_ReviewedByid), teamMember);
essContext.AddLink(teamMember, nameof(era_essteamuser.era_era_essteamuser_era_needassessment_ReviewedByid), needsAssessment);
}
foreach (var member in needsAssessment.era_era_householdmember_era_needassessment)
{
if (member.era_householdmemberid.HasValue)
{
//update member
essContext.AttachTo(nameof(essContext.era_householdmembers), member);
essContext.UpdateObject(member);
}
else
{
//create member
member.era_householdmemberid = Guid.NewGuid();
essContext.AddToera_householdmembers(member);
}
AssignHouseholdMember(file, member);
AssignHouseholdMember(needsAssessment, member);
}
}
private void RemovePets(era_evacuationfile file)
{
foreach (var pet in file.era_era_evacuationfile_era_animal_ESSFileid)
{
essContext.AttachTo(nameof(essContext.era_animals), pet);
essContext.DeleteObject(pet);
}
}
private void AddPets(era_evacuationfile file)
{
foreach (var pet in file.era_era_evacuationfile_era_animal_ESSFileid)
{
essContext.AddToera_animals(pet);
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_animal_ESSFileid), pet);
essContext.SetLink(pet, nameof(era_animal.era_ESSFileid), file);
}
}
private void RemovePets(era_evacuationfile file)
{
essContext.LoadProperty(file, nameof(era_evacuationfile.era_era_evacuationfile_era_animal_ESSFileid));
foreach (var pet in file.era_era_evacuationfile_era_animal_ESSFileid)
{
essContext.DeleteObject(pet);
essContext.DeleteLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_animal_ESSFileid), pet);
}
}
private void CreateEvacueeSupports(EssContext essContext, era_evacuationfile file, contact contact, era_essteamuser creator, string prefix)
{
var referralSupportTypes = new[] { 174360001, 174360002, 174360003, 174360004, 174360007 };
var etransferSupportTypes = new[] { 174360000, 174360005, 174360006, 174360008 };
var referrals = referralSupportTypes.Select((t, i) => new era_evacueesupport
{
era_evacueesupportid = Guid.NewGuid(),
era_suppliernote = $"{prefix}-ref-{i}",
era_validfrom = DateTime.UtcNow.AddDays(-3),
era_validto = DateTime.UtcNow.AddDays(3),
era_supporttype = t,
era_supportdeliverytype = 174360000, //referral
statuscode = 1, //active
statecode = 0
}).ToArray();
var etransfers = etransferSupportTypes.Select((t, i) => new era_evacueesupport
{
era_evacueesupportid = Guid.NewGuid(),
era_suppliernote = $"{prefix}-etr-{i}",
era_validfrom = DateTime.UtcNow.AddDays(-3),
era_validto = DateTime.UtcNow.AddDays(3),
era_supporttype = t,
era_supportdeliverytype = 174360001, //etransfer
era_totalamount = 100m,
statuscode = 174360002, //approved
statecode = 0
}).ToArray();
foreach (var support in referrals)
{
essContext.AddToera_evacueesupports(support);
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId), support);
essContext.SetLink(support, nameof(era_evacueesupport.era_IssuedById), creator);
}
foreach (var support in etransfers)
{
essContext.AddToera_evacueesupports(support);
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId), support);
essContext.SetLink(support, nameof(era_evacueesupport.era_IssuedById), creator);
essContext.SetLink(support, nameof(era_evacueesupport.era_PayeeId), contact);
}
var supports = referrals.Concat(etransfers).ToArray();
var householdMembers = file.era_era_evacuationfile_era_householdmember_EvacuationFileid.ToArray();
foreach (var support in supports)
{
var supportHouseholdMembers = householdMembers.TakeRandom();
foreach (var member in supportHouseholdMembers)
{
essContext.AddLink(member, nameof(era_householdmember.era_era_householdmember_era_evacueesupport), support);
}
}
}
private void AssignToTask(era_evacuationfile file, string taskId)
{
if (string.IsNullOrEmpty(taskId))
{
return;
}
var task = essContext.era_tasks.Where(t => t.era_name == taskId).SingleOrDefault();
if (task == null)
{
throw new ArgumentException($"Task {taskId} not found");
}
essContext.AddLink(task, nameof(era_task.era_era_task_era_evacuationfileId), file);
}
private void AssignHouseholdMember(era_evacuationfile file, era_householdmember member)
{
if (member._era_registrant_value != null)
{
var registrant = essContext.contacts.Where(c => c.contactid == member._era_registrant_value).SingleOrDefault();
if (registrant == null)
{
throw new ArgumentException($"Household member has registrant id {member._era_registrant_value} which was not found");
}
essContext.AddLink(registrant, nameof(contact.era_contact_era_householdmember_Registrantid), member);
}
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid), member);
essContext.SetLink(member, nameof(era_householdmember.era_EvacuationFileid), file);
}
private void CreateSupport(era_evacuationfile file, era_evacueesupport support)
{
support.era_evacueesupportid = Guid.NewGuid();
essContext.AddToera_evacueesupports(support);
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId), support);
essContext.AddLink(file.era_CurrentNeedsAssessmentid, nameof(era_needassessment.era_era_needassessment_era_evacueesupport_NeedsAssessmentID), support);
essContext.SetLink(support, nameof(era_evacueesupport.era_EvacuationFileId), file);
essContext.SetLink(support, nameof(era_evacueesupport.era_NeedsAssessmentID), file.era_CurrentNeedsAssessmentid);
var teamMember = essContext.era_essteamusers.Where(tu => tu.era_essteamuserid == support._era_issuedbyid_value).SingleOrDefault();
essContext.SetLink(support, nameof(era_evacueesupport.era_IssuedById), teamMember);
AssignSupplierToSupport(support);
AssignHouseholdMembersToSupport(support, support.era_era_householdmember_era_evacueesupport);
}
private void CreateNeedsAssessment(era_evacuationfile eraEvacuationFile, era_needassessment eraNeedsAssessment, IEnumerable <era_householdmember> members, IEnumerable <era_needsassessmentanimal> pets)
{
eraNeedsAssessment.era_needassessmentid = Guid.NewGuid();
eraNeedsAssessment.era_needsassessmentdate = DateTimeOffset.UtcNow;
essContext.AddToera_needassessments(eraNeedsAssessment);
essContext.AddLink(eraEvacuationFile, nameof(eraEvacuationFile.era_needsassessment_EvacuationFile), eraNeedsAssessment);
foreach (var member in members)
{
CreateHouseholdMember(eraEvacuationFile, eraNeedsAssessment, member);
}
foreach (var pet in pets)
{
CreatePet(eraNeedsAssessment, pet);
}
}
private era_referralprint CreateReferralPrint(era_evacuationfile file, era_essteamuser member, IEnumerable <era_evacueesupport> supports)
{
var referralPrint = new era_referralprint()
{
era_referralprintid = Guid.NewGuid(),
era_name = testPrefix + "-referral",
};
essContext.AddToera_referralprints(referralPrint);
essContext.SetLink(referralPrint, nameof(era_referralprint.era_ESSFileId), file);
essContext.SetLink(referralPrint, nameof(era_referralprint.era_RequestingUserId), member);
foreach (var support in supports)
{
essContext.AddLink(referralPrint, nameof(era_referralprint.era_era_referralprint_era_evacueesupport), support);
}
return(referralPrint);
}
private IEnumerable <era_evacueesupport> CreateEvacueeSupports(era_evacuationfile file)
{
var supports = Enumerable.Range(1, random.Next(1, 5)).Select(i => new era_evacueesupport
{
era_evacueesupportid = Guid.NewGuid(),
era_name = $"{file.era_name}-support-{i}",
era_validfrom = DateTime.UtcNow.AddDays(-3),
era_validto = DateTime.UtcNow.AddDays(3),
era_supporttype = 174360006
}).ToArray();
foreach (var support in supports)
{
essContext.AddToera_evacueesupports(support);
essContext.AddLink(file, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId), support);
}
return(supports);
}
private static async Task ParallelLoadSupportAsync(EssContext ctx, era_evacuationfile file, CancellationToken ct)
{
ctx.AttachTo(nameof(EssContext.era_evacuationfiles), file);
var loadTasks = new List <Task>();
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_TaskId), ct));
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_EvacuatedFromID), ct));
if (file.era_CurrentNeedsAssessmentid == null)
{
loadTasks.Add(ctx.LoadPropertyAsync(file, nameof(era_evacuationfile.era_CurrentNeedsAssessmentid), ct));
}
var supports = (await((DataServiceQuery <era_evacueesupport>)ctx.era_evacueesupports
.Expand(s => s.era_SupplierId)
.Expand(s => s.era_GroupLodgingCityID)
.Where(s => s._era_evacuationfileid_value == file.era_evacuationfileid))
.GetAllPagesAsync(ct))
.ToArray();
supports.AsParallel().ForAll(s => ctx.AttachTo(nameof(EssContext.era_evacueesupports), s));
loadTasks.AddRange(supports.Select(s => ctx.LoadPropertyAsync(s, nameof(era_evacueesupport.era_era_householdmember_era_evacueesupport), ct)));
await Task.WhenAll(loadTasks);
file.era_era_evacuationfile_era_evacueesupport_ESSFileId = new Collection <era_evacueesupport>(supports.ToArray());
if (file.era_TaskId != null)
{
file.era_TaskId.era_JurisdictionID = ctx.LookupJurisdictionByCode(file.era_TaskId._era_jurisdictionid_value?.ToString());
}
supports.AsParallel().ForAll(s =>
{
if (s.era_SupplierId != null)
{
s.era_SupplierId.era_RelatedCity = ctx.LookupJurisdictionByCode(s.era_SupplierId._era_relatedcity_value.ToString());
}
s.era_EvacuationFileId = file;
});
}
private EvacuationFile MapEvacuationFile(era_evacuationfile file, bool maskSecurityPhrase = true) => mapper.Map <EvacuationFile>(file, opt => opt.Items["MaskSecurityPhrase"] = maskSecurityPhrase.ToString());
public async Task <string> CreateRegistrationAnonymous(AnonymousRegistration registration)
{
var now = DateTimeOffset.Now;
#pragma warning disable CA5394 // Do not use insecure randomness
var essFileNumber = new Random().Next(999999999); //temporary ESS file number random generator
#pragma warning restore CA5394 // Do not use insecure randomness
// evacuation file
var file = new era_evacuationfile
{
era_evacuationfileid = Guid.NewGuid(),
era_essfilenumber = essFileNumber,
era_evacuationfiledate = now,
era_addressline1 = registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.AddressLine1,
era_addressline2 = registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.AddressLine2,
era_city = registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.AddressLine1,
era_Jurisdiction = Lookup(registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.Jurisdiction),
era_province = registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.StateProvince.StateProvinceCode,
era_country = registration.PreliminaryNeedsAssessment.EvacuatedFromAddress.Country.CountryCode,
era_collectionandauthorization = registration.RegistrationDetails.InformationCollectionConsent,
era_sharingrestriction = registration.RegistrationDetails.RestrictedAccess,
era_phonenumberrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Phone),
era_emailrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Email),
era_secrettext = registration.RegistrationDetails.SecretPhrase,
};
// registrant
var registrant = new contact
{
contactid = Guid.NewGuid(),
era_registranttype = 174360000,
era_authenticated = false,
era_verified = false,
era_registrationdate = now,
firstname = registration.RegistrationDetails.PersonalDetails.FirstName,
lastname = registration.RegistrationDetails.PersonalDetails.LastName,
era_preferredname = registration.RegistrationDetails.PersonalDetails.PreferredName,
era_initial = registration.RegistrationDetails.PersonalDetails.Initials,
gendercode = LookupGender(registration.RegistrationDetails.PersonalDetails.Gender),
birthdate = FromDateTime(DateTime.Parse(registration.RegistrationDetails.PersonalDetails.DateOfBirth)),
era_collectionandauthorization = registration.RegistrationDetails.InformationCollectionConsent,
era_sharingrestriction = registration.RegistrationDetails.RestrictedAccess,
address1_line1 = registration.RegistrationDetails.PrimaryAddress.AddressLine1,
address1_line2 = registration.RegistrationDetails.PrimaryAddress.AddressLine2,
address1_city = registration.RegistrationDetails.PrimaryAddress.Jurisdiction.JurisdictionName,
address1_country = registration.RegistrationDetails.PrimaryAddress.Country.CountryCode,
era_City = Lookup(registration.RegistrationDetails.PrimaryAddress.Jurisdiction),
era_ProvinceState = Lookup(registration.RegistrationDetails.PrimaryAddress.StateProvince),
era_Country = Lookup(registration.RegistrationDetails.PrimaryAddress.Country),
address1_postalcode = registration.RegistrationDetails.PrimaryAddress.PostalCode,
address2_line1 = registration.RegistrationDetails.MailingAddress.AddressLine1,
address2_line2 = registration.RegistrationDetails.MailingAddress.AddressLine2,
address2_city = registration.RegistrationDetails.MailingAddress.Jurisdiction.JurisdictionName,
address2_country = registration.RegistrationDetails.MailingAddress.Country.CountryName,
era_MailingCity = Lookup(registration.RegistrationDetails.MailingAddress.Jurisdiction),
era_MailingProvinceState = Lookup(registration.RegistrationDetails.MailingAddress.StateProvince),
era_MailingCountry = Lookup(registration.RegistrationDetails.MailingAddress.Country),
address2_postalcode = registration.RegistrationDetails.MailingAddress.PostalCode,
emailaddress1 = registration.RegistrationDetails.ContactDetails.Email,
address1_telephone1 = registration.RegistrationDetails.ContactDetails.Phone,
era_phonenumberrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Phone),
era_emailrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Email),
era_secrettext = registration.RegistrationDetails.SecretPhrase
};
// members
var members = (registration.PreliminaryNeedsAssessment.FamilyMembers ?? Array.Empty <PersonDetails>()).Select(fm => new contact
{
contactid = Guid.NewGuid(),
era_registranttype = 174360001,
era_authenticated = false,
era_verified = false,
era_registrationdate = now,
firstname = fm.FirstName,
lastname = fm.LastName,
era_preferredname = fm.PreferredName,
era_initial = fm.Initials,
gendercode = LookupGender(fm.Gender),
birthdate = FromDateTime(DateTime.Parse(fm.DateOfBirth)),
era_collectionandauthorization = registration.RegistrationDetails.InformationCollectionConsent,
era_sharingrestriction = registration.RegistrationDetails.RestrictedAccess,
address1_line1 = registration.RegistrationDetails.PrimaryAddress.AddressLine1,
address1_line2 = registration.RegistrationDetails.PrimaryAddress.AddressLine2,
address1_city = registration.RegistrationDetails.PrimaryAddress.Jurisdiction.JurisdictionName,
address1_country = registration.RegistrationDetails.PrimaryAddress.Country.CountryCode,
era_City = Lookup(registration.RegistrationDetails.PrimaryAddress.Jurisdiction),
era_ProvinceState = Lookup(registration.RegistrationDetails.PrimaryAddress.StateProvince),
era_Country = Lookup(registration.RegistrationDetails.PrimaryAddress.Country),
address1_postalcode = registration.RegistrationDetails.PrimaryAddress.PostalCode,
address2_line1 = registration.RegistrationDetails.MailingAddress.AddressLine1,
address2_line2 = registration.RegistrationDetails.MailingAddress.AddressLine2,
address2_city = registration.RegistrationDetails.MailingAddress.Jurisdiction.JurisdictionName,
address2_country = registration.RegistrationDetails.MailingAddress.Country.CountryName,
era_MailingCity = Lookup(registration.RegistrationDetails.MailingAddress.Jurisdiction),
era_MailingProvinceState = Lookup(registration.RegistrationDetails.MailingAddress.StateProvince),
era_MailingCountry = Lookup(registration.RegistrationDetails.MailingAddress.Country),
address2_postalcode = registration.RegistrationDetails.MailingAddress.PostalCode,
emailaddress1 = registration.RegistrationDetails.ContactDetails.Email,
address1_telephone1 = registration.RegistrationDetails.ContactDetails.Phone,
era_phonenumberrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Phone),
era_emailrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Email),
era_secrettext = registration.RegistrationDetails.SecretPhrase
});
// needs assessment
var needsAssessment = new era_needassessment
{
era_needassessmentid = Guid.NewGuid(),
era_needsassessmentdate = now,
era_EvacuationFile = file,
era_needsassessmenttype = 174360000,
era_foodrequirement = Lookup(registration.PreliminaryNeedsAssessment.RequiresFood),
era_clothingrequirement = Lookup(registration.PreliminaryNeedsAssessment.RequiresClothing),
era_dietaryrequirement = registration.PreliminaryNeedsAssessment.HaveSpecialDiet,
era_incidentalrequirement = Lookup(registration.PreliminaryNeedsAssessment.RequiresIncidentals),
era_lodgingrequirement = Lookup(registration.PreliminaryNeedsAssessment.RequiresLodging),
era_transportationrequirement = Lookup(registration.PreliminaryNeedsAssessment.RequiresTransportation),
era_medicationrequirement = registration.PreliminaryNeedsAssessment.HaveMedication,
era_insurancecoverage = Lookup(registration.PreliminaryNeedsAssessment.Insurance),
era_collectionandauthorization = registration.RegistrationDetails.InformationCollectionConsent,
era_sharingrestriction = registration.RegistrationDetails.RestrictedAccess,
era_phonenumberrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Phone),
era_emailrefusal = string.IsNullOrEmpty(registration.RegistrationDetails.ContactDetails.Email)
};
// pets
var pets = (registration.PreliminaryNeedsAssessment.Pets ?? Array.Empty <Pet>()).Select(p => new era_evacuee
{
era_evacueeid = Guid.NewGuid(),
era_needsassessment = needsAssessment,
era_amountofpets = Convert.ToInt32(p.Quantity),
era_typeofpet = p.Type
});
// set enity data and entity links in Dynamics
// save evacuation file to dynamics
dynamicsClient.AddToera_evacuationfiles(file);
// save needs assessment to dynamics
dynamicsClient.AddToera_needassessments(needsAssessment);
// link evacuation file to needs assessment
dynamicsClient.AddLink(file, nameof(file.era_needsassessment_EvacuationFile), needsAssessment);
// save registrant to dynamics
dynamicsClient.AddTocontacts(registrant);
var evacueeRegistrant = new era_evacuee
{
era_evacueeid = Guid.NewGuid(),
era_needsassessment = needsAssessment,
era_Registrant = registrant
};
dynamicsClient.AddToera_evacuees(evacueeRegistrant);
// link registrant and needs assessment to evacuee record
dynamicsClient.AddLink(registrant, nameof(registrant.era_contact_evacuee_Registrant), evacueeRegistrant);
dynamicsClient.AddLink(needsAssessment, nameof(needsAssessment.era_era_needassessment_era_evacuee_needsassessment), evacueeRegistrant);
// save members to dynamics
foreach (var member in members)
{
dynamicsClient.AddTocontacts(member);
var evacueeMember = new era_evacuee
{
era_evacueeid = Guid.NewGuid(),
era_needsassessment = needsAssessment,
era_Registrant = member
};
dynamicsClient.AddToera_evacuees(evacueeMember);
// link members and needs assessment to evacuee record
dynamicsClient.AddLink(member, nameof(member.era_contact_evacuee_Registrant), evacueeMember);
dynamicsClient.AddLink(needsAssessment, nameof(needsAssessment.era_era_needassessment_era_evacuee_needsassessment), evacueeMember);
}
// save pets to dynamics
foreach (var pet in pets)
{
var petMember = new era_evacuee
{
era_evacueeid = Guid.NewGuid(),
era_needsassessment = needsAssessment,
era_typeofpet = pet.era_typeofpet,
era_amountofpets = pet.era_amountofpets
};
dynamicsClient.AddToera_evacuees(petMember);
try
{
// link pet to evacuee record
dynamicsClient.AddLink(needsAssessment, nameof(needsAssessment.era_era_needassessment_era_evacuee_needsassessment), petMember);
}
catch (ArgumentNullException)
{
logger.LogError("ArgumentNullException linking entities");
throw;
}
catch (InvalidOperationException)
{
logger.LogError("InvalidOperationException linking entities");
throw;
}
}
//post as batch is not accepted by SSG. Sending with default option (multiple requests to the server stopping on the first failure)
//var results = await dynamicsClient.SaveChangesAsync(SaveChangesOptions.BatchWithSingleChangeset);
var results = await dynamicsClient.SaveChangesAsync(SaveChangesOptions.ContinueOnError);
//var newEvacuationFileId = ((era_evacuationfile)results
// .Select(r => (EntityDescriptor)((ChangeOperationResponse)r).Descriptor)
// .Single(ed => ed.Entity is era_evacuationfile).Entity).era_evacuationfileid;
//var essFileNumber = dynamicsClient.era_evacuationfiles
// .Where(ef => ef.era_evacuationfileid == newEvacuationFileId)
// .Single().era_essfilenumber;
return($"E{essFileNumber:D9}");
}
private era_evacuationfile CreateEvacuationFile(EssContext essContext, contact primaryContact, string fileId, string?paperFileNumber = null)
{
var file = new era_evacuationfile()
{
era_evacuationfileid = Guid.NewGuid(),
era_name = fileId,
era_evacuationfiledate = DateTime.UtcNow,
era_securityphrase = EvacuationFileSecurityPhrase,
era_paperbasedessfile = paperFileNumber
};
essContext.AddToera_evacuationfiles(file);
essContext.SetLink(file, nameof(era_evacuationfile.era_TaskId), this.activeTask);
var needsAssessment = new era_needassessment
{
era_needassessmentid = Guid.NewGuid(),
era_needsassessmenttype = (int)NeedsAssessmentTypeOptionSet.Preliminary,
era_insurancecoverage = (int)InsuranceOptionOptionSet.Unknown
};
essContext.AddToera_needassessments(needsAssessment);
essContext.SetLink(file, nameof(era_evacuationfile.era_CurrentNeedsAssessmentid), needsAssessment);
essContext.AddLink(file, nameof(era_evacuationfile.era_needsassessment_EvacuationFile), needsAssessment);
essContext.SetLink(file, nameof(era_evacuationfile.era_Registrant), primaryContact);
var primaryMember = new era_householdmember
{
era_householdmemberid = Guid.NewGuid(),
era_dateofbirth = primaryContact.birthdate,
era_firstname = primaryContact.firstname,
era_lastname = primaryContact.lastname,
era_gender = primaryContact.gendercode,
era_initials = primaryContact.era_initial,
era_isprimaryregistrant = true
};
var householdMembers = Enumerable.Range(1, Random.Shared.Next(1, 5)).Select(i => new era_householdmember
{
era_householdmemberid = Guid.NewGuid(),
era_dateofbirth = new Date(2000 + i, i, i),
era_firstname = $"{testPrefix}-member-first-{i}",
era_lastname = $"{testPrefix}-member-last-{i}",
era_gender = Random.Shared.Next(1, 3),
era_isprimaryregistrant = false
}).Prepend(primaryMember)
.Append(new era_householdmember
{
era_householdmemberid = Guid.NewGuid(),
era_dateofbirth = new Date(1998, 1, 2),
era_firstname = $"{testPrefix}-member-no-registrant-first",
era_lastname = $"{testPrefix}-member-no-registrant-last",
era_gender = Random.Shared.Next(1, 3),
era_isprimaryregistrant = false
}).ToArray();
foreach (var member in householdMembers)
{
essContext.AddToera_householdmembers(member);
essContext.SetLink(member, nameof(era_householdmember.era_EvacuationFileid), file);
essContext.AddLink(member, nameof(era_householdmember.era_era_householdmember_era_needassessment), needsAssessment);
if (member.era_isprimaryregistrant == true)
{
essContext.SetLink(member, nameof(era_householdmember.era_Registrant), primaryContact);
essContext.SetLink(file, nameof(era_evacuationfile.era_Registrant), primaryContact);
}
}
file.era_era_evacuationfile_era_householdmember_EvacuationFileid = new Collection <era_householdmember>(householdMembers);
return(file);
}
public DynamicsTestData(IEssContextFactory essContextFactory)
{
var essContext = essContextFactory.Create();
jurisdictions = essContext.era_jurisdictions.OrderBy(j => j.era_jurisdictionid).ToArray();
canada = essContext.era_countries.Where(c => c.era_countrycode == "CAN").Single();
bc = essContext.era_provinceterritorieses.Where(c => c.era_code == "BC").Single();
#if DEBUG
this.testPrefix = $"autotest-dev";
#else
this.testPrefix = $"autotest-{TestHelper.GenerateNewUniqueId(string.Empty)}";
#endif
this.activeTaskId = testPrefix + "-active-task";
this.inactiveTaskId = testPrefix + "-inactive-task";
var existingTeam = essContext.era_essteams.Where(t => t.era_name == testPrefix + "-team").SingleOrDefault();
if (existingTeam != null)
{
essContext.LoadProperty(existingTeam, nameof(era_essteam.era_ESSTeam_ESSTeamArea_ESSTeamID));
this.testTeam = existingTeam;
this.CreateTeamMember(essContext, testTeam, Guid.NewGuid(), "-second");
CreateTeamMember(essContext, testTeam, Guid.NewGuid(), "-third");
CreateTeamMember(essContext, testTeam, Guid.NewGuid(), "-fourth");
}
else
{
this.testTeam = CreateTeam(essContext, Guid.NewGuid());
}
var otherTeam = essContext.era_essteams.Where(t => t.era_name == testPrefix + "-team-other").SingleOrDefault();
if (otherTeam != null)
{
essContext.LoadProperty(otherTeam, nameof(era_essteam.era_ESSTeam_ESSTeamArea_ESSTeamID));
this.otherTestTeam = otherTeam;
}
else
{
this.otherTestTeam = CreateTeam(essContext, Guid.NewGuid(), "-other");
}
this.activeTask = essContext.era_tasks.Where(t => t.era_name == activeTaskId).SingleOrDefault() ?? CreateTask(essContext, activeTaskId, DateTime.UtcNow);
this.inactiveTask = essContext.era_tasks.Where(t => t.era_name == activeTaskId).SingleOrDefault() ?? CreateTask(essContext, inactiveTaskId, DateTime.UtcNow.AddDays(-7));
this.tier4TeamMember = essContext.era_essteamusers.Where(tu => tu.era_firstname == this.testPrefix + "-first" && tu.era_lastname == this.testPrefix + "-last").SingleOrDefault()
?? CreateTeamMember(essContext, testTeam, Guid.NewGuid());
this.otherTeamMember = essContext.era_essteamusers.Where(tu => tu.era_firstname == this.testPrefix + "-first-other" && tu.era_lastname == this.testPrefix + "-last-other").SingleOrDefault()
?? CreateTeamMember(essContext, this.otherTestTeam, Guid.NewGuid(), "-other", EMBC.ESS.Resources.Teams.TeamUserRoleOptionSet.Tier1);
this.testContact = essContext.contacts.Where(c => c.firstname == this.testPrefix + "-first" && c.lastname == this.testPrefix + "-last").SingleOrDefault() ?? CreateContact(essContext);
this.supplierA = essContext.era_suppliers.Where(c => c.era_name == testPrefix + "-supplier-A").SingleOrDefault() ?? CreateSupplier(essContext, "A", this.testTeam);
this.supplierB = essContext.era_suppliers.Where(c => c.era_name == testPrefix + "-supplier-B").SingleOrDefault() ?? CreateSupplier(essContext, "B", this.testTeam);
this.supplierC = essContext.era_suppliers.Where(c => c.era_name == testPrefix + "-supplier-C").SingleOrDefault() ?? CreateSupplier(essContext, "C", this.otherTestTeam);
this.inactiveSupplier = essContext.era_suppliers.Where(c => c.era_name == testPrefix + "-supplier-inactive").SingleOrDefault() ?? CreateSupplier(essContext, "inactive", null);
var evacuationfile = essContext.era_evacuationfiles
.Expand(f => f.era_CurrentNeedsAssessmentid)
.Expand(f => f.era_Registrant)
.Where(f => f.era_name == testPrefix + "-digital").SingleOrDefault();
if (evacuationfile == null)
{
evacuationfile = CreateEvacuationFile(essContext, this.testContact, testPrefix + "-digital");
}
else
{
essContext.LoadProperty(evacuationfile, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid));
CreateEvacueeSupports(essContext, evacuationfile, this.testContact, this.tier4TeamMember, testPrefix);
}
var paperEvacuationfile = essContext.era_evacuationfiles
.Expand(f => f.era_CurrentNeedsAssessmentid)
.Expand(f => f.era_Registrant)
.Where(f => f.era_name == testPrefix + "-paper").SingleOrDefault();
if (paperEvacuationfile == null)
{
paperEvacuationfile = CreateEvacuationFile(essContext, this.testContact, testPrefix + "-paper", testPrefix + "-paper");
CreateEvacueeSupports(essContext, paperEvacuationfile, this.testContact, this.tier4TeamMember, testPrefix);
}
else
{
essContext.LoadProperty(paperEvacuationfile, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid));
}
essContext.SaveChanges();
essContext.DeactivateObject(this.inactiveSupplier, 2);
essContext.SaveChanges();
essContext.DetachAll();
this.testEvacuationfile = essContext.era_evacuationfiles
.Expand(f => f.era_CurrentNeedsAssessmentid)
.Expand(f => f.era_Registrant)
.Where(f => f.era_evacuationfileid == evacuationfile.era_evacuationfileid).Single();
essContext.LoadProperty(this.testEvacuationfile, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId));
essContext.LoadProperty(this.testEvacuationfile, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid));
this.testPaperEvacuationFile = essContext.era_evacuationfiles
.Expand(f => f.era_CurrentNeedsAssessmentid)
.Expand(f => f.era_Registrant)
.Where(f => f.era_evacuationfileid == paperEvacuationfile.era_evacuationfileid).Single();
essContext.LoadProperty(this.testPaperEvacuationFile, nameof(era_evacuationfile.era_era_evacuationfile_era_evacueesupport_ESSFileId));
essContext.LoadProperty(this.testPaperEvacuationFile, nameof(era_evacuationfile.era_era_evacuationfile_era_householdmember_EvacuationFileid));
essContext.DetachAll();
this.essContextFactory = essContextFactory;
}
private void AssignPrimaryRegistrant(era_evacuationfile file, contact primaryContact)
{
essContext.AddLink(primaryContact, nameof(primaryContact.era_evacuationfile_Registrant), file);
essContext.SetLink(file, nameof(era_evacuationfile.era_Registrant), primaryContact);
}
