Beispiel #1
0
        public override async Task ValidatingAsync(ValidateContentContext context, AutoroutePart part)
        {
            // Only validate the path if it's not empty.
            if (String.IsNullOrWhiteSpace(part.Path))
            {
                return;
            }

            if (part.Path == "/")
            {
                context.Fail(S["Your permalink can't be set to the homepage, please use the homepage option instead."]);
            }

            if (part.Path?.IndexOfAny(AutoroutePartDisplay.InvalidCharactersForPath) > -1 || part.Path?.IndexOf(' ') > -1 || part.Path?.IndexOf("//") > -1)
            {
                var invalidCharactersForMessage = string.Join(", ", AutoroutePartDisplay.InvalidCharactersForPath.Select(c => $"\"{c}\""));
                context.Fail(S["Please do not use any of the following characters in your permalink: {0}. No spaces, or consecutive slashes, are allowed (please use dashes or underscores instead).", invalidCharactersForMessage]);
            }

            if (part.Path?.Length > AutoroutePartDisplay.MaxPathLength)
            {
                context.Fail(S["Your permalink is too long. The permalink can only be up to {0} characters.", AutoroutePartDisplay.MaxPathLength]);
            }

            if (!await IsAbsolutePathUniqueAsync(part.Path, part.ContentItem.ContentItemId))
            {
                context.Fail(S["Your permalink is already in use."]);
            }
        }
Beispiel #2
0
        public override async Task ValidatingAsync(ValidateContentContext context, AliasPart part)
        {
            // Only validate the alias if it's not empty.
            if (String.IsNullOrWhiteSpace(part.Alias))
            {
                return;
            }

            await foreach (var item in part.ValidateAsync(S, _session))
            {
                context.Fail(item);
            }
        }
Beispiel #3
0
        public async Task <ContentValidateResult> ValidateAsync(ContentItem contentItem)
        {
            var validateContext = new ValidateContentContext(contentItem);

            await Handlers.InvokeAsync((handler, context) => handler.ValidatingAsync(context), validateContext, _logger);

            await ReversedHandlers.InvokeAsync((handler, context) => handler.ValidatedAsync(context), validateContext, _logger);

            if (!validateContext.ContentValidateResult.Succeeded)
            {
                await _session.CancelAsync();
            }

            return(validateContext.ContentValidateResult);
        }
Beispiel #4
0
        public override async Task ValidatingAsync(ValidateContentContext context, AutoroutePart part)
        {
            // Only validate the path if it's not empty.
            if (String.IsNullOrWhiteSpace(part.Path))
            {
                return;
            }

            foreach (var item in part.ValidatePathFieldValue(S))
            {
                context.Fail(item);
            }

            if (!await IsAbsolutePathUniqueAsync(part.Path, part.ContentItem.ContentItemId))
            {
                context.Fail(S["Your permalink is already in use."], nameof(part.Path));
            }
        }
        public override async Task ValidatingAsync(ValidateContentContext context, AliasPart part)
        {
            // Only validate the alias if it's not empty.
            if (String.IsNullOrWhiteSpace(part.Alias))
            {
                return;
            }

            if (part.Alias.Length > AliasPartDisplayDriver.MaxAliasLength)
            {
                context.Fail(S["Your alias is too long. The alias can only be up to {0} characters.", AliasPartDisplayDriver.MaxAliasLength]);
            }

            if (!await IsAliasUniqueAsync(part.Alias, part))
            {
                context.Fail(S["Your alias is already in use."]);
            }
        }
 public static void Fail(this ValidateContentContext context, params string[] errors)
 {
     context.ContentValidateResult.Fail(errors);
 }