Beispiel #1
0
        /// <summary>
        /// Validates an instance of type <typeparamref name="TRequestBody" />,
        /// according to it's attributes.
        /// </summary>
        /// <typeparam name="TRequestBody">
        /// A type deriving from <see cref="Models.ModelsBase" />.
        /// </typeparam>
        /// <param name="loggerProvider">
        /// An instance of <see cref="ILoggerProvider" />.
        /// </param>
        /// <param name="requestBody">
        /// An instance of type <typeparamref name="TRequestBody" />.
        /// </param>
        /// <returns>
        /// True if the instance passed validation, otherwise false.
        /// </returns>
        public static bool ValidateModel <TRequestBody>(
            ILoggerProvider loggerProvider,
            TRequestBody requestBody)
            where TRequestBody : Models.ModelsBase
        {
            bool toReturn = false;

            ValidationContext validationContext = new ValidationContext(
                requestBody,
                null,
                null);

            List <ValidationResult> validationResults =
                new List <ValidationResult>();

            loggerProvider.Debug($"Performing validation of {requestBody}...");

            toReturn = Validator.TryValidateObject(
                requestBody,
                validationContext,
                validationResults,
                true);

            if (toReturn)
            {
                loggerProvider.Info($"{requestBody} passed validation!");
            }
            else
            {
                string[] validationList = validationResults
                                          .Select(ValidationResultToString)
                                          .ToArray();

                string validationListConcat =
                    string.Join(", ", validationList);

                string validationFailuresDesc =
                    $"{validationResults.Count} validation error(s) were " +
                    $"highlighted. These are: {validationListConcat}";

                loggerProvider.Warning(
                    $"{requestBody} failed validation. " +
                    $"{validationFailuresDesc}.");
            }

            return(toReturn);
        }
Beispiel #2
0
        private static TRequestBody ParseRequestBody <TRequestBody>(
            HttpRequest httpRequest,
            ILoggerProvider loggerProvider)
            where TRequestBody : Models.ModelsBase
        {
            TRequestBody toReturn = null;

            Type requestBodyType = typeof(TRequestBody);

            loggerProvider.Debug("Reading the request body...");

            string requestBody = null;

            using (StreamReader streamReader = new StreamReader(httpRequest.Body))
            {
                requestBody = streamReader.ReadToEnd();
            }

            loggerProvider.Debug(
                $"Request body: \"{requestBody}\". Parsing body into " +
                $"{requestBodyType.Name} instance...");

            try
            {
                toReturn = JsonConvert.DeserializeObject <TRequestBody>(
                    requestBody);

                loggerProvider.Info($"Parsed: {toReturn}.");
            }
            catch (JsonReaderException jsonReaderException)
            {
                loggerProvider.Warning(
                    $"A {nameof(JsonReaderException)} was thrown when " +
                    $"deserialising the request body \"{requestBody}\". The " +
                    $"exception message: \"{jsonReaderException.Message}\".");
            }

            return(toReturn);
        }