public async Task <GetOrganisationAgreementsResponse> Handle(GetOrganisationAgreementsRequest message)
        {
            var validationResult = await _validator.ValidateAsync(message);

            if (!validationResult.IsValid())
            {
                throw new InvalidRequestException(validationResult.ValidationDictionary);
            }

            var accountLegalEntityId = _accountLegalEntityPublicHashingService.DecodeValue(message.AccountLegalEntityHashedId);

            var accountLegalEntity = await _employerAgreementRepository.GetOrganisationsAgreements(accountLegalEntityId);

            if (accountLegalEntity == null)
            {
                return(new GetOrganisationAgreementsResponse());
            }

            var organisationLookupByIdPossible = await _referenceDataService.IsIdentifiableOrganisationType(accountLegalEntity.LegalEntity.Source);

            var employerAgreements = accountLegalEntity.Agreements.Where(x => x.StatusId == EmployerAgreementStatus.Pending || x.SignedDate.HasValue).ToList();

            var agreements = _mapper.Map <ICollection <EmployerAgreement>, ICollection <EmployerAgreementDto> >
                                 (employerAgreements,
                                 opt =>
            {
                opt.AfterMap((src, dest) =>
                {
                    dest.ToList().ForEach(e =>
                    {
                        e.HashedAccountId            = _hashingService.HashValue(accountLegalEntity.AccountId);
                        e.HashedAgreementId          = _hashingService.HashValue(e.Id);
                        e.HashedLegalEntityId        = _hashingService.HashValue(accountLegalEntity.Id);
                        e.OrganisationLookupPossible = organisationLookupByIdPossible;
                    });
                });
            });

            return(new GetOrganisationAgreementsResponse {
                Agreements = agreements.OrderByDescending(a => a.TemplateId).ToList()
            });
        }