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 }); }