Example #1
0
        public ConfirmEmailValidator(IQueryEntities entities)
        {
            CascadeMode = CascadeMode.StopOnFirstFailure;

            EmailConfirmation confirmation = null;

            RuleFor(p => p.SecretCode)
            // secret cannot be empty
            .NotEmpty()
            .WithMessage(FailedBecauseSecretCodeWasEmpty)
            // token must match a confirmation
            .Must((o, p) => ValidateEmailConfirmation.TokenMatchesEntity(o.Token, entities, out confirmation))
            .WithMessage(FailedBecauseOfInconsistentData)
            // intent must match entity
            .Must((o, p) => ValidateEmailConfirmation.IntentIsCorrect(confirmation, o.Intent))
            .WithMessage(FailedBecauseOfInconsistentData)
            ;

            RuleFor(p => p.SecretCode)
            // secret must match entity
            .Must(p => ValidateEmailConfirmation.SecretCodeIsCorrect(confirmation, p))
            .When(p =>
                  !string.IsNullOrWhiteSpace(p.SecretCode) &&
                  confirmation != null &&
                  ValidateEmailConfirmation.IntentIsCorrect(confirmation, p.Intent))
            .WithMessage(FailedBecauseSecretCodeWasIncorrect)
            ;
        }
Example #2
0
        public RedeemEmailConfirmationValidator(IQueryEntities entities)
        {
            CascadeMode = CascadeMode.StopOnFirstFailure;

            EmailConfirmation confirmation = null;

            RuleFor(p => p.Token)
            // token cannot be an empty guid
            .NotEmpty()
            .WithMessage(ValidateEmailConfirmation.FailedBecauseTokenWasEmpty,
                         p => p.Token)
            // token must match a confirmation
            .Must(p => ValidateEmailConfirmation.TokenMatchesEntity(p, entities, out confirmation))
            .WithMessage(ValidateEmailConfirmation.FailedBecauseTokenMatchedNoEntity,
                         p => p.Token)
            ;

            RuleFor(p => p.SecretCode)
            // secret cannot be empty
            .NotEmpty()
            .WithMessage(ValidateEmailConfirmation.FailedBecauseSecretCodeWasEmpty)
            ;

            // when confirmation is not null,
            When(p => confirmation != null, () =>
            {
                RuleFor(p => p.Token)
                // it cannot be expired
                .Must(p => !confirmation.IsExpired)
                .WithMessage(ValidateEmailConfirmation.FailedBecauseIsExpired,
                             p => confirmation.Token, p => confirmation.ExpiresOnUtc)
                // it cannot be retired
                .Must(p => !confirmation.IsRetired)
                .WithMessage(ValidateEmailConfirmation.FailedBecauseIsRetired,
                             p => confirmation.Token, p => confirmation.RetiredOnUtc)
                ;

                RuleFor(p => p.SecretCode)
                // secret must match entity
                .Must(p => ValidateEmailConfirmation.SecretCodeIsCorrect(confirmation, p))
                .WithMessage(ValidateEmailConfirmation.FailedBecauseSecretCodeWasIncorrect,
                             p => p.SecretCode, p => confirmation.Token)
                ;

                RuleFor(p => p.Intent)
                // intent must match entity
                .Must(p => ValidateEmailConfirmation.IntentIsCorrect(confirmation, p))
                .WithMessage(ValidateEmailConfirmation.FailedBecauseIntentWasIncorrect,
                             p => p.Intent, p => confirmation.Token)
                ;
            });
        }