Пример #1
0
        public async Task <ValidationResult> ValidateAsync(CreateReservationLevyEmployerCommand query)
        {
            var validationResult = new ValidationResult();

            if (query.AccountId < 1)
            {
                validationResult.AddError(nameof(query.AccountId));
            }

            if (query.AccountLegalEntityId < 1)
            {
                validationResult.AddError(nameof(query.AccountLegalEntityId));
            }

            if (!validationResult.IsValid())
            {
                return(validationResult);
            }

            if (!string.IsNullOrEmpty(query.TransferSenderEmployerAccountId))
            {
                var transferConnections = await _employerAccountService.GetTransferConnections(_encodingService.Encode(query.AccountId, EncodingType.AccountId));

                var connection = transferConnections.ToList().Find(c => c.FundingEmployerPublicHashedAccountId.Equals(query.TransferSenderEmployerAccountId));
                if (connection == null)
                {
                    validationResult.FailedTransferReceiverCheck = true;
                }
                return(validationResult);
            }
            var response =
                await _apiClient.Get <AccountReservationStatusResponse>(
                    new AccountReservationStatusRequest(_config.Url, query.AccountId));

            validationResult.FailedAutoReservationCheck = !response.CanAutoCreateReservations;
            validationResult.FailedAgreementSignedCheck = !response.AccountLegalEntityAgreementStatus[query.AccountLegalEntityId];

            return(validationResult);
        }
Пример #2
0
        public async Task <GetAccountReservationStatusResponse> Handle(GetAccountReservationStatusQuery request, CancellationToken cancellationToken)
        {
            var validationResult = await _validator.ValidateAsync(request);

            if (!validationResult.IsValid())
            {
                throw new ValidationException(validationResult.ConvertToDataAnnotationsValidationResult(), null, null);
            }


            if (!string.IsNullOrEmpty(request.TransferSenderAccountId) &&
                !string.IsNullOrEmpty(request.HashedEmployerAccountId))
            {
                var transferSenderResponse = await _accountsService.GetTransferConnections(request.HashedEmployerAccountId);

                var employerTransferConnection = transferSenderResponse.ToList().Find(c =>
                                                                                      c.FundingEmployerPublicHashedAccountId.Equals(request.TransferSenderAccountId,
                                                                                                                                    StringComparison.CurrentCultureIgnoreCase));
                if (employerTransferConnection != null)
                {
                    return(new GetAccountReservationStatusResponse
                    {
                        CanAutoCreateReservations = true,
                        TransferAccountId = employerTransferConnection.FundingEmployerAccountId
                    });
                }

                throw new TransferSenderNotAllowedException(request.AccountId, request.TransferSenderAccountId);
            }

            var response =
                await _apiClient.Get <AccountReservationStatusResponse>(
                    new AccountReservationStatusRequest(_config.Url, request.AccountId));

            return(new GetAccountReservationStatusResponse {
                CanAutoCreateReservations = response.CanAutoCreateReservations
            });
        }