public MotivoNaoCompensado ValidarExistenciaTag()
{
Log.Debug($"Passagem ID: {Response.PassagemPendenteArtesp.MensagemItemId} - Fluxo: ValidadorPassagemHandler | ValidarExistenciaTag");
if (!_validator.Validate(Response.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.ValidarExistenciaTag.ToString()))
{
return(MotivoNaoCompensado.TagInvalido);
}
return(MotivoNaoCompensado.SemMotivoNaoCompensado);
}
private MotivoNaoCompensado ValidarIdentificadorPassagem(ValidadorPassagemPendenteConcessionariaRequest request, long mensagemItemId)
{
Log.Debug($"Passagem ID: {mensagemItemId} - Fluxo: ValidadorPassagemPendenteHandler | Validar IdentificadorPassagem");
if (!_validator.Validate(request.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.ValidarIdentificadorPassagem.ToString()))
{
return(MotivoNaoCompensado.IdentificadorPassagemInvalido);
}
return(MotivoNaoCompensado.SemMotivoNaoCompensado);
}
public Task <Result <string> > Send(UserInvitationData prefilledData, UserInvitationTypes invitationType,
int inviterUserId, int?inviterAgencyId = null)
{
return(Validate()
.Bind(CreateInvitation)
.Check(SendInvitationMailPipe));
Task <Result> SendInvitationMailPipe(string invitationCode)
=> SendInvitationMail(invitationCode, prefilledData, invitationType, inviterAgencyId);
Result Validate()
=> GenericValidator <UserInvitationData> .Validate(v =>
{
v.RuleFor(x => x.UserRegistrationInfo.FirstName).NotEmpty()
.WithMessage("FirstName is required");
v.RuleFor(x => x.UserRegistrationInfo.LastName).NotEmpty()
.WithMessage("LastName is required");
v.RuleFor(x => x.UserRegistrationInfo.Title).NotEmpty()
.WithMessage("Title is required");
v.RuleFor(e => e.UserRegistrationInfo.Email).NotEmpty().EmailAddress()
.WithMessage("Valid email is required");
}, prefilledData);
Task <Result <string> > CreateInvitation()
=> Create(prefilledData, invitationType, inviterUserId, inviterAgencyId);
}
public Task <Result <Models.Responses.Room> > UpdateRoom(int accommodationId, int roomId, Models.Requests.Room roomRequest)
{
return(ValidateRoom()
.Bind(() => _managerContext.GetServiceSupplier())
.Check(serviceSupplier => _serviceSupplierContext.EnsureAccommodationBelongsToServiceSupplier(serviceSupplier, accommodationId))
.Ensure(serviceSupplier => DoesRoomBelongToAccommodation(accommodationId, roomId), $"The room with {nameof(roomId)} '{roomId}' doesn't belong to the accommodation with {nameof(accommodationId)} '{accommodationId}'")
.Map(serviceSupplier => CreateRoom(accommodationId, roomRequest))
.Map(NormalizeRoomAmenities)
.Map(UpdateRoom)
.Tap(AddRoomAmenitiesToStoreIfNeeded)
.Map(Build));
Result ValidateRoom()
=> GenericValidator <Models.Requests.Room> .Validate(configureAction => configureAction.RuleFor(exp => exp)
.SetValidator(new RoomValidator()), roomRequest);
async Task <Room> UpdateRoom(Room room)
{
room.Id = roomId;
_dbContext.Rooms.Update(room);
await _dbContext.SaveChangesAsync();
return(room);
}
}
public Result Validate()
{
return(GenericValidator <MarkupPolicyScope> .Validate(v =>
{
v.RuleFor(s => s.AgencyId).NotEmpty()
.When(t => t.Type == SubjectMarkupScopeTypes.Agency)
.WithMessage("AgencyId is required");
v.RuleFor(s => s.AgencyId).NotEmpty()
.When(t => t.Type == SubjectMarkupScopeTypes.Agent)
.WithMessage("AgencyId is required");
v.RuleFor(s => s.AgentId).NotEmpty()
.When(t => t.Type == SubjectMarkupScopeTypes.Agent)
.WithMessage("AgentId is required");
v.RuleFor(s => s.LocationId).NotEmpty()
.When(t => t.Type == SubjectMarkupScopeTypes.Country || t.Type == SubjectMarkupScopeTypes.Locality)
.WithMessage("LocationId is required");
v.RuleFor(s => s.AgencyId).Empty()
.When(t => t.Type != SubjectMarkupScopeTypes.Agency && t.Type != SubjectMarkupScopeTypes.Agent)
.WithMessage("AgencyId must be empty");
v.RuleFor(s => s.AgentId).Empty()
.When(t => t.Type != SubjectMarkupScopeTypes.Agent)
.WithMessage("AgentId must be empty");
}, this));
}
public void Validar(Customer entity)
{
GenericValidator<Customer> target = new GenericValidator<Customer>();
var resultado = target.Validate(entity).ToList();
resultado.ForEach(x => Console.WriteLine(x.ErrorMessage));
}
private static Result Validate(AdministratorRoleInfo roleInfo)
=> GenericValidator <AdministratorRoleInfo> .Validate(v =>
{
v.RuleFor(r => r.Name).NotEmpty();
v.RuleFor(r => r.Permissions).NotEmpty();
},
roleInfo);
private Result Validate(AgentRoleInfo roleInfo)
=> GenericValidator <AgentRoleInfo> .Validate(v =>
{
v.RuleFor(r => r.Name).NotEmpty();
v.RuleFor(r => r.Permissions).NotEmpty();
},
roleInfo);
protected ValidationResult ValidateAs <TModel>(Action <GenericValidator <TModel> > action) where TModel : BaseViewModel
{
var validator = new GenericValidator <TModel>();
action(validator);
return(validator.Validate((TModel)this));
}
public static void Start()
{
var entity = new Customer
{
FirstName = "Test"
};
var validations = GenericValidator <Customer> .Validate(entity);
}
private MotivoNaoCompensado ValidarReenvio(ValidadorPassagemSistemaRequest request)
{
var motivoNaoCompensado = MotivoNaoCompensado.SemMotivoNaoCompensado;
if (_validator.Validate(request.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.EReenvio.ToString()))
{
if (motivoNaoCompensado == MotivoNaoCompensado.SemMotivoNaoCompensado)
{
motivoNaoCompensado = ValidarPassagemEnviadaForaDoPrazo(request);
}
if (motivoNaoCompensado == MotivoNaoCompensado.SemMotivoNaoCompensado)
{
motivoNaoCompensado = ValidarReenvioInvalido(request);
}
}
return(motivoNaoCompensado);
}
private Result Validate(PaymentHistoryRequest paymentHistoryRequest)
{
return(GenericValidator <PaymentHistoryRequest> .Validate(setup =>
{
setup.RuleFor(i => i.ToDate)
.GreaterThanOrEqualTo(request => request.FromDate)
.WithMessage($"{nameof(paymentHistoryRequest.ToDate)} must be greater then {nameof(paymentHistoryRequest.FromDate)}");
setup.RuleFor(i => (i.ToDate - i.FromDate).Days)
.LessThanOrEqualTo(MaxRequestDaysNumber)
.WithMessage(
$"Total days between {nameof(paymentHistoryRequest.FromDate)} and {nameof(paymentHistoryRequest.ToDate)} should be less or equal {MaxRequestDaysNumber}");
}, paymentHistoryRequest));
}
public ValidarPassagemParkResponse Execute(ValidarPassagemParkRequest request)
{
PassagemPendenteEstacionamento = request.PassagemPendenteEstacionamento;
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValidarConveniado");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarConveniado.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.ConveniadoNaoEstacionamento);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValidarTag");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarTag.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.TagInvalida);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValidarPraca");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPraca.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.PracaInvalida);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValidarPista");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPista.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.PistaInvalida);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValidarDataTransacaoUltrapassaLimitePermitido");
ValidarDataTransacaoUltrapassaLimitePermitido();
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemParkResponse | ValorTransacaoUltrapassaLimitePermitido");
ValorTransacaoUltrapassaLimitePermitido();
return(new ValidarPassagemParkResponse {
PassagemPendenteEstacionamento = request.PassagemPendenteEstacionamento
});
}
public JsonSchemaValidationException Validate <T>(JsonSchemaValidationContext c, T o)
{
if (o == null)
{
return(new JsonSchemaValidationException(c, "null"));
}
if (Properties.Count < MinProperties)
{
return(new JsonSchemaValidationException(c, "no properties"));
}
return(GenericValidator <T> .Validate(Required, Properties, c, o));
}
public Task <Result <PaymentLink> > Register(PaymentLinkCreationRequest paymentLinkCreationData)
{
return(Validate(paymentLinkCreationData)
.Map(CreateLink));
Result Validate(PaymentLinkCreationRequest linkData)
{
var linkSettings = _paymentLinkOptions.ClientSettings;
return(GenericValidator <PaymentLinkCreationRequest> .Validate(v =>
{
v.RuleFor(data => data.ServiceType).IsInEnum();
v.RuleFor(data => data.Currency).IsInEnum();
v.RuleFor(data => data.Amount).GreaterThan(decimal.Zero);
v.RuleFor(data => data.Email).EmailAddress();
v.RuleFor(data => data.Comment).NotEmpty();
v.RuleFor(data => data.Currency)
.Must(linkSettings.Currencies.Contains);
v.RuleFor(data => data.ServiceType)
.Must(serviceType => linkSettings.ServiceTypes.ContainsKey(serviceType));
}, linkData));
}
async Task <PaymentLink> CreateLink()
{
var referenceCode = await _tagProcessor.GenerateNonSequentialReferenceCode(paymentLinkCreationData.ServiceType, LinkDestinationCode);
var paymentLink = new PaymentLink
{
Email = paymentLinkCreationData.Email,
Amount = paymentLinkCreationData.Amount,
Currency = paymentLinkCreationData.Currency,
ServiceType = paymentLinkCreationData.ServiceType,
Comment = paymentLinkCreationData.Comment,
Created = _dateTimeProvider.UtcNow(),
Code = Base64UrlEncoder.Encode(Guid.NewGuid().ToByteArray()),
ReferenceCode = referenceCode,
PaymentProcessor = paymentLinkCreationData.PaymentProcessor,
InvoiceNumber = paymentLinkCreationData.InvoiceNumber
};
_context.PaymentLinks.Add(paymentLink);
await _context.SaveChangesAsync();
return(paymentLink);
}
}
private async Task <Result> Validate(int serviceSupplierId, int contractId, List <Models.Requests.AvailabilityRestriction> availabilityRestrictions)
{
var contract = await _dbContext.Contracts.SingleOrDefaultAsync(c => c.Id == contractId && c.ServiceSupplierId == serviceSupplierId);
if (contract == null)
{
return(Result.Failure($"Contract '{contractId}' doesn't belong to the service supplier"));
}
return(Result.Combine(GenericValidator <List <Models.Requests.AvailabilityRestriction> > .Validate(
configure => configure.RuleFor(restrictions => restrictions).SetValidator(new AvailabilityRestrictionsValidator(contract)), availabilityRestrictions),
await _dbContext.CheckIfRoomsBelongToContract(contractId, serviceSupplierId,
availabilityRestrictions.Select(availabilityRestriction => availabilityRestriction.RoomId).ToList())));
}
public ValidarPassagemPendenteParkResponse Execute(ValidarPassagemPendenteParkRequest request)
{
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemPendenteParkHandler | ValidarPossuiNumeroConveniado");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPossuiNumeroConveniado.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.ConveniadoNaoInformado);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemPendenteParkHandler | ValidarPossuiNumeroTag");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPossuiNumeroTag.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.TagNaoInformada);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemPendenteParkHandler | ValidarPossuiNumeroPraca");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPossuiNumeroPraca.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.PracaNaoInformada);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemPendenteParkHandler | ValidarPossuiNumeroPista");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarPossuiNumeroPista.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.PistaNaoInformada);
}
Log.Info($"Passagem RegistroTransacaoId: {request.PassagemPendenteEstacionamento.RegistroTransacaoId} - Fluxo: ValidarPassagemPendenteParkHandler | ValidarValor");
if (!_validator.Validate(request.PassagemPendenteEstacionamento, PassagemPendenteParkValidatorEnum.ValidarValor.ToString()))
{
throw new ParkException(request.PassagemPendenteEstacionamento, EstacionamentoErros.ValorCobradoMenorZero);
}
return(new ValidarPassagemPendenteParkResponse {
PassagemPendenteEstacionamento = request.PassagemPendenteEstacionamento
});
}
private void VerificarMotivoSemValor(ValidadorPassagemPendenteAceiteManualReenvioRequest request, long mensagemItemId)
{
if (request.PassagemPendenteArtesp.PassagemRecusadaMensageria != true)
{
if (request.PassagemPendenteArtesp.Valor == 0)
{
Log.Debug($"Passagem ID: {mensagemItemId} - Fluxo: ValidadorPassagemPendenteHandler | Validar MotivoSemValor");
if (!_validator.Validate(request.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.ValidarMotivoSemValor.ToString()))
{
request.PassagemPendenteArtesp.PassagemRecusadaMensageria = true;
}
}
}
}
private async ValueTask <Result> Validate(UserDescriptionInfo agentRegistration, string externalIdentity)
{
var fieldValidateResult = GenericValidator <UserDescriptionInfo> .Validate(v =>
{
v.RuleFor(a => a.Title).NotEmpty();
v.RuleFor(a => a.FirstName).NotEmpty();
v.RuleFor(a => a.LastName).NotEmpty();
}, agentRegistration);
if (fieldValidateResult.IsFailure)
{
return(fieldValidateResult);
}
return(await CheckIdentityIsUnique(externalIdentity));
}
static Result Validate(NewCreditCardPaymentRequest payment)
{
return(GenericValidator <NewCreditCardPaymentRequest>
.Validate(p =>
{
if (payment.IsSaveCardNeeded)
{
p.RuleFor(r => r.CardInfo)
.ChildRules(c =>
{
c.RuleFor(info => info.HolderName)
.NotEmpty()
.WithMessage($"{nameof(CreditCardInfo.HolderName)} is required to save card");
});
}
}, payment));
}
static Result Validate(ReportAccommodationDuplicateRequest duplicateRequest)
{
return(GenericValidator <ReportAccommodationDuplicateRequest> .Validate(v =>
{
v.RuleFor(r => r.Duplicates).NotEmpty();
v.RuleForEach(r => r.Duplicates.Union(new[] { r.Accommodation }))
.ChildRules(d =>
{
d.RuleFor(d => d.Id).NotEmpty();
d.RuleFor(d => d.Supplier).IsInEnum();
d.RuleFor(d => d.Supplier)
.Must(p => p != Suppliers.Unknown)
.WithMessage("Provider code is required");
})
.OverridePropertyName("Accommodations");
}, duplicateRequest));
}
private static Result <SignDto> ValidateDto(SignDto dto)
{
var(_, isFailure, error) = Validate();
return(isFailure
? Result.Failure <SignDto>(error)
: Result.Ok(dto));
Result Validate()
{
return(GenericValidator <SignDto> .Validate(v =>
{
v.RuleFor(c => c.Email).EmailAddress().NotEmpty();
v.RuleFor(c => c.Password).NotEmpty();
v.RuleFor(c => c.Token).NotEmpty();
}, dto));
}
}
public ValidadorPassagemSistemaEdiActorResponse Execute(ValidadorPassagemSistemaEdiActorRequest request)
{
#region Validar transacao repetida
_validator = new TransacaoRepetidaEdiValidator(request.PassagemPendenteEdi);
_validator.Validate();
#endregion
var possuiTransacaoAprovadaManualmente = _validatorRuleSet.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.PossuiTransacaoAprovadaManualmente.ToString());
if (!possuiTransacaoAprovadaManualmente)
{
#region HorarioDePassagemEIncompativel
Log.Info($"Passagem ID: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemSistemaEdiHandler | HorarioDePassagemEIncompativel");
_validator = new HorarioPassagemIncompativelValidator(_dataSourceConectSysReadOnly, _dataSourceFallBack, request.PassagemPendenteEdi);
_validator.Validate();
#endregion
#region PassagemEvasiva
Log.Info($"Passagem ID: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemSistemaEdiHandler | PassagemEvasiva");
_validator = new PassagemEvasivaValidator(request.PassagemPendenteEdi);
_validator.Validate();
#endregion
}
#region ValidarTransacaoConfirmacao ( CATCobradaNaoCompativel - PassagemForaDoPeriodo )
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemSistemaEdiHandler | TransacaoConfirmacaoValidator");
_validator = new TransacaoConfirmacaoValidator(request.PassagemPendenteEdi);
_validator.Validate();
#endregion
#region PrimeiraPassagemManualValidator
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemSistemaEdiHandler | PrimeiraPassagemManualValidator");
var primeiraPassagemManualValidator = new PrimeiraPassagemManualValidator();
request.PassagemPendenteEdi.PossuiEventoPrimeiraPassagemManual = primeiraPassagemManualValidator.EhPrimeiraPassagemManual(request.PassagemPendenteEdi.Adesao.Id.TryToInt(), request.PassagemPendenteEdi.StatusPassagem);
#endregion
return(new ValidadorPassagemSistemaEdiActorResponse {
PassagemPendenteEdi = request.PassagemPendenteEdi
});
}
public Task <Result <SlimAgencyInfo> > Edit(AgentContext agent, EditAgencyRequest editAgencyRequest,
string languageCode = LocalizationHelper.DefaultLanguageCode)
{
return(Validate()
.Tap(UpdateAgencyRecord)
.Bind(GetUpdatedAgencyInfo));
Result Validate()
{
return(GenericValidator <EditAgencyRequest> .Validate(v =>
{
v.RuleFor(c => c.Address).NotEmpty();
v.RuleFor(c => c.Phone).NotEmpty();
v.RuleFor(c => c.BillingEmail).EmailAddress().When(i => !string.IsNullOrWhiteSpace(i.BillingEmail));
}, editAgencyRequest));
}
async Task UpdateAgencyRecord()
{
var agencyRecord = await _context.Agencies.SingleAsync(a => a.Id == agent.AgencyId);
agencyRecord.Address = editAgencyRequest.Address;
agencyRecord.Phone = editAgencyRequest.Phone;
agencyRecord.Fax = editAgencyRequest.Fax;
agencyRecord.PostalCode = editAgencyRequest.PostalCode;
agencyRecord.Website = editAgencyRequest.Website;
agencyRecord.BillingEmail = editAgencyRequest.BillingEmail;
agencyRecord.VatNumber = editAgencyRequest.VatNumber;
agencyRecord.PreferredPaymentMethod = editAgencyRequest.PreferredPaymentMethod;
agencyRecord.Modified = _dateTimeProvider.UtcNow();
_context.Update(agencyRecord);
await _context.SaveChangesAsync();
}
Task <Result <SlimAgencyInfo> > GetUpdatedAgencyInfo()
=> Get(agent, languageCode);
}
public ValidationResult Validate() => _validator.Validate(this as T);
private MotivoNaoCompensado ValidarGrupoIsento(ValidadorPassagemPendenteRequest request, long mensagemItemId)
{
Log.Debug($"Passagem ID: {mensagemItemId} - Fluxo: ValidadorPassagemPendenteHandler | ValidarGrupoIsentoDadosInvalidos");
if (_validator.Validate(request.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.ValidarGrupoIsentoDadosInvalidos.ToString()))
{
return(MotivoNaoCompensado.DadosInvalidos);
}
Log.Debug($"Passagem ID: {mensagemItemId} - Fluxo: ValidadorPassagemPendenteHandler | ValidarGrupoIsentoMotivoSemValorNaoInformado");
if (_validator.Validate(request.PassagemPendenteArtesp, PassagemPendenteArtespValidatorEnum.ValidarGrupoIsentoMotivoSemValorNaoInformado.ToString()))
{
return(MotivoNaoCompensado.MotivoSemValorNaoInformado);
}
return(MotivoNaoCompensado.SemMotivoNaoCompensado);
}
public ValidadorPassagemPendenteEdiResponse Execute(ValidadorPassagemPendenteEdiRequest request)
{
var possuiTransacaoAprovadaManualmente = _validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.PossuiTransacaoAprovadaManualmente.ToString());
#region ValidarArquivoNulo Regra 1
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarArquivoNulo");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarArquivoNulo.ToString()))
{
throw new EdiDomainException($"DetalheTRN não existente:{request.PassagemPendenteEdi.DetalheTrnId}", request.PassagemPendenteEdi);
}
#endregion
#region ValidarPossuiArquivoTrn Regra 2
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPossuiArquivoTrn");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPossuiArquivoTrn.ToString()))
{
throw new EdiDomainException($"ArquivoTRN não existente do DetaheTrnId:{request.PassagemPendenteEdi.DetalheTrnId}", request.PassagemPendenteEdi);
}
#endregion
#region ValidarPossuiArquivoTrf Regra 3
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPossuiArquivoTrf");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPossuiArquivoTrf.ToString()))
{
throw new EdiDomainException($"ArquivoTRF não existente do DetaheTrnId: {request.PassagemPendenteEdi.DetalheTrnId}", request.PassagemPendenteEdi);
}
#endregion
#region ValidarPossuiNumeroTag Regra 4
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPossuiNumeroTag");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPossuiNumeroTag.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.EmissorTagInvalido, request.PassagemPendenteEdi);
}
#endregion
#region ValidarPassagemManualComNumeroTagInvalida Regra 9
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPassagemManualComNumeroTagInvalida");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPassagemManualComNumeroTagInvalida.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PassagemManualSemTag, request.PassagemPendenteEdi);
}
#endregion
#region ValidarPassagemListaNela Regra 13
if (!possuiTransacaoAprovadaManualmente)
{
Log.Info(
$"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPassagemListaNela");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPassagemListaNela.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PassagemValidaListaNela,
request.PassagemPendenteEdi);
}
}
#endregion
#region ValidarPassagemIsenta
if (!possuiTransacaoAprovadaManualmente)
{
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.PassagemIsenta.ToString()))
{
Log.Info(
$"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar ValidarPassagemIsentaComValor");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPassagemIsentaComValor.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PassageIsentoValorDifZero,
request.PassagemPendenteEdi);
}
}
else
{
Log.Info(
$"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemPendenteEdiHandler | Validar PassagemValorZerado");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.PassagemValorZerado.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PassagensIsentas,
request.PassagemPendenteEdi);
}
}
#endregion
}
return(new ValidadorPassagemPendenteEdiResponse {
PassagemPendenteEdi = request.PassagemPendenteEdi
});
}
public ValidadorPassagemEdiActorResponse Execute(ValidadorPassagemEdiActorRequest request)
{
var possuiTransacaoAprovadaManualmente = _validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.PossuiTransacaoAprovadaManualmente.ToString());
#region ValidarTempoSlaEnvioPassagem
if (!possuiTransacaoAprovadaManualmente)
{
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarTempoSlaEnvioPassagem");
if (!_validator.Validate(request.PassagemPendenteEdi,
PassagemPendenteEdiValidatorEnum.ValidarTempoSlaEnvioPassagem.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PassagemForaDoPeriodo,
request.PassagemPendenteEdi);
}
}
#endregion
#region ValidarEmissorTagId
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarEmissorTagId");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarEmissorTagId.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.EmissorTagInvalido, request.PassagemPendenteEdi);
}
#endregion
#region ValidarCategoria
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarCategoria");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarCategoria.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.CATCobradaNaoCompativel, request.PassagemPendenteEdi);
}
#endregion
#region ValidarTag
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarTag");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarTag.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.EmissorTagInvalido, request.PassagemPendenteEdi);
}
#endregion
#region ValidarAdesao
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarAdesao");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarAdesao.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.EmissorTagInvalido, request.PassagemPendenteEdi);
}
#endregion
#region ValidarPistaPraca
Log.Info($"Passagem DetalheTrnId: {request.PassagemPendenteEdi.DetalheTrnId} - Fluxo: ValidadorPassagemEdiHandler | Validar ValidarPistaPraca");
if (!_validator.Validate(request.PassagemPendenteEdi, PassagemPendenteEdiValidatorEnum.ValidarPistaPraca.ToString()))
{
throw new EdiTransacaoException(CodigoRetornoTransacaoTRF.PracaInvalida, request.PassagemPendenteEdi);
}
#endregion
return(new ValidadorPassagemEdiActorResponse {
PassagemPendenteEdi = request.PassagemPendenteEdi
});
}