public async Task Add(AccountLegalEntity accountLegalEntity)
{
using (var transaction = _dataContext.Database.BeginTransaction())
{
var existingEntity = await _dataContext.AccountLegalEntities.SingleOrDefaultAsync(c =>
c.AccountLegalEntityId.Equals(accountLegalEntity.AccountLegalEntityId));
if (existingEntity != null)
{
return;
}
try
{
await _dataContext.AccountLegalEntities.AddAsync(accountLegalEntity);
_dataContext.SaveChanges();
transaction.Commit();
}
catch (DbUpdateException e)
{
if (e.GetBaseException() is SqlException sqlException &&
(sqlException.Number == UniqueConstraintViolation || sqlException.Number == UniqueKeyViolation))
{
_log.LogWarning($"AccountLegalEntityRepository: Rolling back Id:{accountLegalEntity.AccountLegalEntityId} - item already exists.");
transaction.Rollback();
}
}
}
}
public async Task Then_The_AccountLegalEntity_Is_Added_To_The_Repository_And_Committed()
{
//Arrange
var expectedAccountLegalEntity = new AccountLegalEntity
{
Id = Guid.NewGuid(),
ReservationLimit = 1,
AccountId = 1234,
LegalEntityId = 543,
AccountLegalEntityId = 5677,
AgreementSigned = true,
AccountLegalEntityName = "Test"
};
_dataContext.Setup(x => x.AccountLegalEntities)
.ReturnsDbSet(new List <AccountLegalEntity>());
_dataContext.Setup(x => x.Database)
.Returns(_dataFacade.Object);
_accountLegalEntityRepository = new Data.Repository.AccountLegalEntityRepository(_dataContext.Object, Mock.Of <ILogger <Data.Repository.AccountLegalEntityRepository> >());
//Act
await _accountLegalEntityRepository.Add(expectedAccountLegalEntity);
//Assert
_dataContext.Verify(x => x.SaveChanges(), Times.Once);
_dbContextTransaction.Verify(x => x.Commit(), Times.Once);
}
public UpdateAccountLegalEntityNameCommandHandlerTestsFixture SetAccountLegalEntityUpdatedAfterCommand()
{
AccountLegalEntity.Set(a => a.Updated, Now);
Db.SaveChanges();
return(this);
}
public void Arrange()
{
_dbAccountLegalEntity = new AccountLegalEntity
{
Id = Guid.NewGuid(),
AccountId = 8376234,
AgreementSigned = false,
LegalEntityId = 4,
};
_updatedAccountLegalEntity = new AccountLegalEntity
{
Id = Guid.NewGuid(),
AccountId = 8376234,
AgreementSigned = false,
LegalEntityId = 4,
};
_dbContextTransaction = new Mock <IDbContextTransaction>();
_dbContext = new Mock <DbContext>();
_dataContext = new Mock <IReservationsDataContext>();
_dataFacade = new Mock <DatabaseFacade>(_dbContext.Object);
_dataFacade.Setup(x => x.BeginTransaction()).Returns(_dbContextTransaction.Object);
_dataContext.Setup(x => x.Database)
.Returns(_dataFacade.Object);
_dataContext.Setup(x => x.AccountLegalEntities).ReturnsDbSet(new List <AccountLegalEntity>
{
_dbAccountLegalEntity
});
_accountLegalEntityRepository = new Data.Repository.AccountLegalEntityRepository(_dataContext.Object, Mock.Of <ILogger <Data.Repository.AccountLegalEntityRepository> >());
}
public WhenCohortIsCreatedTestFixture WithChangeOfPartyType(ChangeOfPartyRequestType value, bool employerLed = false)
{
Request.SetValue(x => x.ChangeOfPartyType, value);
Request.SetValue(x => x.OriginatingParty, value == ChangeOfPartyRequestType.ChangeEmployer ? Party.Provider : Party.Employer);
if (value == ChangeOfPartyRequestType.ChangeEmployer)
{
var accountLegalEntity = new AccountLegalEntity();
accountLegalEntity.SetValue(x => x.Id, _autoFixture.Create <long>());
accountLegalEntity.SetValue(x => x.Account, new Account());
accountLegalEntity.Account.SetValue(x => x.Id, _autoFixture.Create <long>());
accountLegalEntity.SetValue(x => x.AccountId, accountLegalEntity.Account.Id);
Request.SetValue(x => x.AccountLegalEntity, accountLegalEntity);
Request.SetValue(x => x.AccountLegalEntityId, accountLegalEntity?.Id);
ContinuedApprenticeship.Cohort.SetValue(x => x.ProviderId, _autoFixture.Create <long>());
}
else
{
if (employerLed)
{
var date = new DateTime(DateTime.Now.Year, DateTime.Now.Month, 1);
Request.SetValue(x => x.StartDate, date);
Request.SetValue(x => x.EndDate, date.AddYears(1));
Request.SetValue(x => x.Price, 1000);
}
Request.SetValue(x => x.ProviderId, _autoFixture.Create <long>());
ContinuedApprenticeship.Cohort.SetValue(x => x.AccountLegalEntityId, _autoFixture.Create <long>());
ContinuedApprenticeship.Cohort.SetValue(x => x.EmployerAccountId, _autoFixture.Create <long>());
}
return(this);
}
And_User_Has_Transactor_Role_And_Chosen_Legal_Entity_Has_Not_Signed_Agreement_Then_Redirect_To_Transactor_Sign_Route(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
GetLegalEntitiesResponse getLegalEntitiesResponse,
[Frozen] Mock <IMediator> mockMediator,
[Frozen] Mock <IUserClaimsService> mockClaimsService,
EmployerReservationsController controller)
{
getLegalEntitiesResponse.AccountLegalEntities =
new List <AccountLegalEntity>
{
accountLegalEntity
};
accountLegalEntity.AgreementSigned = false;
mockMediator
.Setup(mediator => mediator.Send(
It.IsAny <GetLegalEntitiesQuery>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
mockClaimsService
.Setup(service => service.UserIsInRole(
routeModel.EmployerAccountId,
EmployerUserRole.Owner,
It.IsAny <IEnumerable <Claim> >()))
.Returns(false);
var result = await controller.SelectLegalEntity(routeModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.EmployerTransactorSignAgreement);
result.RouteValues[nameof(ReservationsRouteModel.PreviousPage)].Should().Be(RouteNames.EmployerIndex);
}
public async Task Then_The_Values_Are_Returned_In_The_Response()
{
//Arrange
var legalEntityId = 123;
var accountLegalEntityId = 6543;
var agreementSigned = true;
var isLevy = false;
var accountLegalEntity = new AccountLegalEntity(Guid.Empty, ExpectedAccountId, ExpectedAccountLegalEntityName, legalEntityId, accountLegalEntityId, agreementSigned, isLevy);
_service.Setup(x => x.GetAccountLegalEntities(ExpectedAccountId)).ReturnsAsync(new List <AccountLegalEntity> {
accountLegalEntity
});
//Act
var actual = await _handler.Handle(_query, _cancellationToken);
//Assert
Assert.IsNotNull(actual.AccountLegalEntities);
Assert.AreEqual(ExpectedAccountId, actual.AccountLegalEntities[0].AccountId);
Assert.AreEqual(ExpectedAccountLegalEntityName, actual.AccountLegalEntities[0].AccountLegalEntityName);
Assert.AreEqual(legalEntityId, actual.AccountLegalEntities[0].LegalEntityId);
Assert.AreEqual(accountLegalEntityId, actual.AccountLegalEntities[0].AccountLegalEntityId);
Assert.AreEqual(agreementSigned, actual.AccountLegalEntities[0].AgreementSigned);
Assert.AreEqual(isLevy, actual.AccountLegalEntities[0].IsLevy);
}
public async Task And_Only_One_Legal_Entity_Then_Adds_Legal_Entity_To_Reservation_And_Redirects_To_Course_Selection(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
routeModel.Id = null;
var getLegalEntitiesResponse = new GetLegalEntitiesResponse
{
AccountLegalEntities = new List <AccountLegalEntity> {
accountLegalEntity
}
};
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(getLegalEntitiesResponse);
var result = await controller.SelectLegalEntity(routeModel) as RedirectToRouteResult;
result.RouteName.Should().Be(RouteNames.EmployerSelectCourse);
mockMediator.Verify(mediator => mediator.Send(
It.Is <CacheReservationEmployerCommand>(command =>
command.Id != Guid.Empty &&
command.AccountId == accountLegalEntity.AccountId &&
command.AccountLegalEntityId == accountLegalEntity.AccountLegalEntityId &&
command.AccountLegalEntityName == accountLegalEntity.AccountLegalEntityName &&
command.AccountLegalEntityPublicHashedId == accountLegalEntity.AccountLegalEntityPublicHashedId &&
command.EmployerHasSingleLegalEntity),
It.IsAny <CancellationToken>()),
Times.Once);
}
public async Task Then_The_Values_Are_Returned_In_The_Response()
{
//Arrange
const int legalEntityId = 123;
const int accountId = 6543;
const int reservationLimit = 4;
const bool agreementSigned = true;
const bool isLevy = false;
const string legalEntityName = "Test Entity";
var accountLegalEntity = new AccountLegalEntity(Guid.Empty, accountId, legalEntityName, legalEntityId, ExpectedAccountLegalEntityId, reservationLimit, agreementSigned, isLevy);
_service.Setup(x => x.GetAccountLegalEntity(It.IsAny <long>())).ReturnsAsync(accountLegalEntity);
//Act
var actual = await _handler.Handle(_query, _cancellationToken);
//Assert
Assert.IsNotNull(actual.LegalEntity);
Assert.AreEqual(accountId, actual.LegalEntity.AccountId);
Assert.AreEqual(legalEntityName, actual.LegalEntity.AccountLegalEntityName);
Assert.AreEqual(legalEntityId, actual.LegalEntity.LegalEntityId);
Assert.AreEqual(ExpectedAccountLegalEntityId, actual.LegalEntity.AccountLegalEntityId);
Assert.AreEqual(reservationLimit, actual.LegalEntity.ReservationLimit);
Assert.AreEqual(agreementSigned, actual.LegalEntity.AgreementSigned);
Assert.AreEqual(isLevy, actual.LegalEntity.IsLevy);
}
public CohortCreationWithOtherPartyTestFixture()
{
UnitOfWorkContext = new UnitOfWorkContext();
Provider = new CommitmentsV2.Models.Provider(_autoFixture.Create <long>(), _autoFixture.Create <string>(),
_autoFixture.Create <DateTime>(), _autoFixture.Create <DateTime>());
var account = new Account(_autoFixture.Create <long>(), _autoFixture.Create <string>(),
_autoFixture.Create <string>(), _autoFixture.Create <string>(), _autoFixture.Create <DateTime>());
UserInfo = _autoFixture.Create <UserInfo>();
AccountLegalEntity = new AccountLegalEntity(account,
_autoFixture.Create <long>(),
_autoFixture.Create <long>(),
_autoFixture.Create <string>(),
_autoFixture.Create <string>(),
_autoFixture.Create <string>(),
_autoFixture.Create <OrganisationType>(),
_autoFixture.Create <string>(),
_autoFixture.Create <DateTime>());
TransferSenderId = _autoFixture.Create <long>();
TransferSenderName = _autoFixture.Create <string>();
TransferSender = new Account(TransferSenderId.Value, "XXX", "ZZZ", TransferSenderName, new DateTime());
}
public async Task Then_The_Available_Dates_Service_Is_Called_And_Dates_Returned(
GetAvailableDatesQuery query,
[Frozen] ValidationResult validationResult,
AccountLegalEntity accountLegalEntity,
List <AvailableDateStartWindow> availableDateStartWindows,
[Frozen] Mock <IAccountLegalEntitiesService> mockAleService,
[Frozen] Mock <IAvailableDatesService> mockDatesService,
GetAvailableDatesQueryHandler handler)
{
//Arrange
validationResult.ValidationDictionary.Clear();
mockAleService
.Setup(service => service.GetAccountLegalEntity(query.AccountLegalEntityId))
.ReturnsAsync(accountLegalEntity);
mockDatesService
.Setup(x => x.GetAvailableDates())
.Returns(availableDateStartWindows);
//Act
var actual = await handler.Handle(query, CancellationToken.None);
//Assert
Assert.IsAssignableFrom <GetAvailableDatesResult>(actual);
Assert.AreSame(availableDateStartWindows, actual.AvailableDates);
}
public RemoveAccountLegalEntityCommandHandlerTestsFixture SetAccountLegalEntityDeletedBeforeCommand()
{
AccountLegalEntity.Set(ale => ale.Deleted, Command.Removed.AddHours(-1));
Db.SaveChanges();
return(this);
}
public void Then_The_Fields_Are_Correctly_Mapped(AccountLegalEntity source)
{
var actual = (AccountLegalEntityDto)source;
actual.Should().BeEquivalentTo(source, options => options.Excluding(c => c.LegalEntityName));
actual.LegalEntityName.Should().Be(source.LegalEntityName);
}
public void Arrange()
{
_expectedLegalEntity = new AccountLegalEntity
{
AccountId = 1,
AccountLegalEntityId = 2,
AccountLegalEntityName = "Test entity",
AccountLegalEntityPublicHashedId = "ABC123",
LegalEntityId = 3
};
_query = new GetAccountLegalEntityQuery();
_validator = new Mock <IValidator <GetAccountLegalEntityQuery> >();
_providerService = new Mock <IProviderService>();
_encodingService = new Mock <IEncodingService>();
_handler = new GetAccountLegalEntityQueryHandler(_providerService.Object, _encodingService.Object, _validator.Object);
_providerService.Setup(s => s.GetAccountLegalEntityById(It.IsAny <long>()))
.ReturnsAsync(_expectedLegalEntity);
_encodingService.Setup(s => s.Decode(It.IsAny <string>(), EncodingType.PublicAccountLegalEntityId))
.Returns(EmployerExpectedLegalEntityId);
_validator.Setup(v => v.ValidateAsync(It.IsAny <GetAccountLegalEntityQuery>()))
.ReturnsAsync(() => new ValidationResult());
}
public async Task Then_The_Item_Is_Not_Saved_If_It_Already_Exists()
{
//Arrange
var expectedAccountLegalEntity = new AccountLegalEntity
{
Id = Guid.NewGuid(),
ReservationLimit = 1,
AccountId = 1234,
LegalEntityId = 543,
AccountLegalEntityId = 5677,
AgreementSigned = true,
AccountLegalEntityName = "Test"
};
_dataContext.Setup(x => x.AccountLegalEntities)
.ReturnsDbSet(new List <AccountLegalEntity> {
expectedAccountLegalEntity
});
_dataContext.Setup(x => x.Database)
.Returns(_dataFacade.Object);
_accountLegalEntityRepository = new Data.Repository.AccountLegalEntityRepository(_dataContext.Object, Mock.Of <ILogger <Data.Repository.AccountLegalEntityRepository> >());
//Act
await _accountLegalEntityRepository.Add(expectedAccountLegalEntity);
//Assert
_dataContext.Verify(x => x.SaveChanges(), Times.Never);
}
private void SeedData()
{
var employer = new AccountLegalEntity();
employer.SetValue(x => x.Name, _employerName);
_changeOfPartyRequests = new List <ChangeOfPartyRequest>();
for (var i = 1; i <= 10; i++)
{
var request = new ChangeOfPartyRequest();
request.SetValue(x => x.Id, i);
request.SetValue(x => x.ApprenticeshipId, _apprenticeshipId);
request.SetValue(x => x.ChangeOfPartyType, _autoFixture.Create <ChangeOfPartyRequestType>());
request.SetValue(x => x.OriginatingParty, _autoFixture.Create <Party>());
request.SetValue(x => x.Status, _autoFixture.Create <ChangeOfPartyRequestStatus>());
request.SetValue(x => x.AccountLegalEntity, employer);
request.SetValue(x => x.StartDate, _autoFixture.Create <DateTime>());
request.SetValue(x => x.EndDate, _autoFixture.Create <DateTime>());
request.SetValue(x => x.ProviderId, _autoFixture.Create <long?>());
_changeOfPartyRequests.Add(request);
}
_db.AccountLegalEntities.Add(employer);
_db.ChangeOfPartyRequests.AddRange(_changeOfPartyRequests);
_db.SaveChanges();
}
private void AssertRefreshLegalEntityWasPublished(AccountLegalEntity accountLegalEntity)
{
var publishedEvents = _testContext.EventsPublished.OfType <RefreshLegalEntityEvent>();
var publishedEvent = publishedEvents.SingleOrDefault(e => e.AccountId == accountLegalEntity.AccountId &&
e.AccountLegalEntityId == accountLegalEntity.AccountLegalEntityId &&
e.LegalEntityId == accountLegalEntity.LegalEntityId &&
e.OrganisationName == accountLegalEntity.Name);
publishedEvent.Should().NotBeNull();
}
public async Task Remove(AccountLegalEntity accountLegalEntity)
{
var entity = await _dataContext.AccountLegalEntities.SingleOrDefaultAsync(c =>
c.AccountLegalEntityId.Equals(accountLegalEntity.AccountLegalEntityId));
if (entity != null)
{
_dataContext.AccountLegalEntities.Remove(entity);
_dataContext.SaveChanges();
}
}
public void Arrange()
{
_expectedLegalEntity = new AccountLegalEntity();
_apiClient = new Mock <IApiClient>();
_options = new Mock <IOptions <ReservationsApiConfiguration> >();
_options.Setup(x => x.Value.Url).Returns(ExpectedBaseUrl);
_service = new Application.Providers.Services.ProviderService(_apiClient.Object, _options.Object);
_apiClient.Setup(c => c.Get <AccountLegalEntity>(It.IsAny <GetAccountLegalEntityRequest>()))
.ReturnsAsync(_expectedLegalEntity);
}
public RemoveAccountLegalEntityCommandHandlerTestsFixture SetAccountProviderLegalEntities()
{
AccountProviderLegalEntities = new List <AccountProviderLegalEntity>
{
EntityActivator.CreateInstance <AccountProviderLegalEntity>().Set(aple => aple.Id, 4).Set(aple => aple.AccountProvider, AccountProvider),
EntityActivator.CreateInstance <AccountProviderLegalEntity>().Set(aple => aple.Id, 5).Set(aple => aple.AccountProvider, AccountProvider),
};
AccountLegalEntity.AddRange(ale => ale.AccountProviderLegalEntities, AccountProviderLegalEntities);
Db.SaveChanges();
return(this);
}
public void Arrange()
{
_hashingService = new Mock <IHashingService>();
_validator = new Mock <IValidator <GetNextUnsignedEmployerAgreementRequest> >();
_validator.Setup(x => x.ValidateAsync(It.IsAny <GetNextUnsignedEmployerAgreementRequest>())).ReturnsAsync(new ValidationResult());
_db = new Mock <EmployerAccountsDbContext>();
_accountLegalEntity = new AccountLegalEntity();
_accountLegalEntityDbSet = new DbSetStub <AccountLegalEntity>(_accountLegalEntity);
_db.Setup(d => d.AccountLegalEntities).Returns(_accountLegalEntityDbSet);
_handler = new GetNextUnsignedEmployerAgreementQueryHandler(new Lazy <EmployerAccountsDbContext>(() => _db.Object), _hashingService.Object, _validator.Object);
}
public async Task Then_Returns_Legal_Entity(
GetLegalEntityQuery query,
AccountLegalEntity legalEntity,
[Frozen] Mock <IApiClient> mockApiClient,
GetLegalEntityQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <AccountLegalEntity>(It.IsAny <GetAccountLegalEntityRequest>()))
.ReturnsAsync(legalEntity);
var result = await handler.Handle(query, CancellationToken.None);
result.AccountLegalEntity.Should().Be(legalEntity);
}
public async Task Then_The_AccountLegalEntity_Is_Returned(
GetLegalEntityQuery query,
AccountLegalEntity response,
[Frozen] Mock <ILegalEntitiesService> legalEntitiesService,
GetLegalEntityHandler handler
)
{
legalEntitiesService.Setup(x =>
x.GetLegalEntity(query.AccountId, query.AccountLegalEntityId)).ReturnsAsync(response);
var actual = await handler.Handle(query, CancellationToken.None);
actual.AccountLegalEntity.Should().BeEquivalentTo(response);
}
public async Task Then_Gets_Legal_Entity(
GetLegalEntityQuery query,
AccountLegalEntity legalEntity,
[Frozen] Mock <IApiClient> mockApiClient,
GetLegalEntityQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <AccountLegalEntity>(It.IsAny <GetAccountLegalEntityRequest>()))
.ReturnsAsync(legalEntity);
await handler.Handle(query, CancellationToken.None);
mockApiClient.Verify(client => client.Get <AccountLegalEntity>(It.Is <GetAccountLegalEntityRequest>(r => r.Id.Equals(query.Id))), Times.Once);
}
public GetCohortsHandlerTestFixtures()
{
SeedCohorts = new List <Cohort>();
SeedAccounts = new List <Account>();
_autoFixture = new Fixture();
AccountId = _autoFixture.Create <long>();
ProviderId = _autoFixture.Create <long>();
TransferSenderId = AccountId + 1;
TransferSender = new Account(TransferSenderId, "", "", "TransferSender", DateTime.UtcNow);
Account = new Account(AccountId, "", "", "TEST", DateTime.UtcNow);
AccountLegalEntity = new AccountLegalEntity(Account, 1, 1, "", "", "TEST", OrganisationType.Charities, "", DateTime.UtcNow);
Provider = new Provider(ProviderId, "TEST PROVIDER", DateTime.UtcNow, DateTime.UtcNow);
}
public async Task And_Reservation_Limit_Has_Been_Exceeded_Then_Shows_Reservation_Limit_Reached_Page(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new ReservationLimitReachedException(10));
var result = await controller.SelectLegalEntity(routeModel) as ViewResult;
Assert.AreEqual("ReservationLimitReached", result?.ViewName);
}
public async Task And_Global_Rule_Exists_Then_Shows_Funding_Paused_Page(
ReservationsRouteModel routeModel,
AccountLegalEntity accountLegalEntity,
[Frozen] Mock <IMediator> mockMediator,
EmployerReservationsController controller)
{
mockMediator
.Setup(mediator => mediator.Send(It.IsAny <GetLegalEntitiesQuery>(), It.IsAny <CancellationToken>()))
.ThrowsAsync(new GlobalReservationRuleException(10));
var result = await controller.SelectLegalEntity(routeModel) as ViewResult;
Assert.AreEqual("EmployerFundingPaused", result?.ViewName);
}
public async Task Then_Hashes_The_Id(
GetLegalEntityQuery query,
AccountLegalEntity legalEntity,
[Frozen] Mock <IApiClient> mockApiClient,
[Frozen] Mock <IEncodingService> encodingService,
GetLegalEntityQueryHandler handler)
{
mockApiClient
.Setup(client => client.Get <AccountLegalEntity>(It.IsAny <GetAccountLegalEntityRequest>()))
.ReturnsAsync(legalEntity);
await handler.Handle(query, CancellationToken.None);
encodingService.Verify(service => service.Encode(legalEntity.AccountLegalEntityId, EncodingType.PublicAccountLegalEntityId), Times.Once);
}
public async Task Remove(AccountLegalEntity accountLegalEntity)
{
using (var transaction = _dataContext.Database.BeginTransaction())
{
var entity = await _dataContext.AccountLegalEntities.SingleOrDefaultAsync(c =>
c.AccountLegalEntityId.Equals(accountLegalEntity.AccountLegalEntityId));
if (entity != null)
{
_dataContext.AccountLegalEntities.Remove(entity);
_dataContext.SaveChanges();
}
transaction.Commit();
}
}
private async Task CacheReservation(ReservationsRouteModel routeModel, AccountLegalEntity accountLegalEntity, bool employerHasSingleLegalEntity = false)
{
var reservationId = routeModel.Id ?? Guid.NewGuid();
await _mediator.Send(new CacheReservationEmployerCommand
{
Id = reservationId,
AccountId = accountLegalEntity.AccountId,
AccountLegalEntityId = accountLegalEntity.AccountLegalEntityId,
AccountLegalEntityName = accountLegalEntity.AccountLegalEntityName,
AccountLegalEntityPublicHashedId = accountLegalEntity.AccountLegalEntityPublicHashedId,
EmployerHasSingleLegalEntity = employerHasSingleLegalEntity
});
routeModel.Id = reservationId;
}
