WireMock.Net-wiremock/src/WireMock.Net/Serialization/LogEntryMapper.cs

using System.Linq;
using WireMock.Admin.Mappings;
using WireMock.Admin.Requests;
using WireMock.Logging;
using WireMock.Matchers.Request;
using WireMock.ResponseBuilders;
using WireMock.Types;

namespace WireMock.Serialization
{
    internal static class LogEntryMapper
    {
        public static LogEntryModel Map(ILogEntry logEntry)
        {
            var logRequestModel = new LogRequestModel
            {
                DateTime = logEntry.RequestMessage.DateTime,
                ClientIP = logEntry.RequestMessage.ClientIP,
                Path = logEntry.RequestMessage.Path,
                AbsolutePath = logEntry.RequestMessage.AbsolutePath,
                Url = logEntry.RequestMessage.Url,
                AbsoluteUrl = logEntry.RequestMessage.AbsoluteUrl,
                ProxyUrl = logEntry.RequestMessage.ProxyUrl,
                Query = logEntry.RequestMessage.Query,
                Method = logEntry.RequestMessage.Method,
                Headers = logEntry.RequestMessage.Headers,
                Cookies = logEntry.RequestMessage.Cookies
            };

            if (logEntry.RequestMessage.BodyData != null)
            {
                logRequestModel.DetectedBodyType = logEntry.RequestMessage.BodyData.DetectedBodyType?.ToString();
                logRequestModel.DetectedBodyTypeFromContentType = logEntry.RequestMessage.BodyData.DetectedBodyTypeFromContentType?.ToString();

                switch (logEntry.RequestMessage.BodyData.DetectedBodyType)
                {
                    case BodyType.String:
                        logRequestModel.Body = logEntry.RequestMessage.BodyData.BodyAsString;
                        break;

                    case BodyType.Json:
                        logRequestModel.Body = logEntry.RequestMessage.BodyData.BodyAsString; // In case of Json, do also save the Body as string (backwards compatible)
                        logRequestModel.BodyAsJson = logEntry.RequestMessage.BodyData.BodyAsJson;
                        break;

                    case BodyType.Bytes:
                        logRequestModel.BodyAsBytes = logEntry.RequestMessage.BodyData.BodyAsBytes;
                        break;
                }

                logRequestModel.BodyEncoding = logEntry.RequestMessage.BodyData.Encoding != null
                    ? new EncodingModel
                    {
                        EncodingName = logEntry.RequestMessage.BodyData.Encoding.EncodingName,
                        CodePage = logEntry.RequestMessage.BodyData.Encoding.CodePage,
                        WebName = logEntry.RequestMessage.BodyData.Encoding.WebName
                    }
                    : null;
            }

            var logResponseModel = new LogResponseModel
            {
                StatusCode = logEntry.ResponseMessage.StatusCode,
                Headers = logEntry.ResponseMessage.Headers
            };

            if (logEntry.ResponseMessage.FaultType != FaultType.NONE)
            {
                logResponseModel.FaultType = logEntry.ResponseMessage.FaultType.ToString();
                logResponseModel.FaultPercentage = logEntry.ResponseMessage.FaultPercentage;
            }

            if (logEntry.ResponseMessage.BodyData != null)
            {
                logResponseModel.BodyOriginal = logEntry.ResponseMessage.BodyOriginal;
                logResponseModel.BodyDestination = logEntry.ResponseMessage.BodyDestination;

                logResponseModel.DetectedBodyType = logEntry.ResponseMessage.BodyData.DetectedBodyType;
                logResponseModel.DetectedBodyTypeFromContentType = logEntry.ResponseMessage.BodyData.DetectedBodyTypeFromContentType;

                switch (logEntry.ResponseMessage.BodyData.DetectedBodyType)
                {
                    case BodyType.String:
                        logResponseModel.Body = logEntry.ResponseMessage.BodyData.BodyAsString;
                        break;

                    case BodyType.Json:
                        logResponseModel.BodyAsJson = logEntry.ResponseMessage.BodyData.BodyAsJson;
                        break;

                    case BodyType.Bytes:
                        logResponseModel.BodyAsBytes = logEntry.ResponseMessage.BodyData.BodyAsBytes;
                        break;

                    case BodyType.File:
                        logResponseModel.BodyAsFile = logEntry.ResponseMessage.BodyData.BodyAsFile;
                        logResponseModel.BodyAsFileIsCached = logEntry.ResponseMessage.BodyData.BodyAsFileIsCached;
                        break;
                }

                logResponseModel.BodyEncoding = logEntry.ResponseMessage.BodyData.Encoding != null
                    ? new EncodingModel
                    {
                        EncodingName = logEntry.ResponseMessage.BodyData.Encoding.EncodingName,
                        CodePage = logEntry.ResponseMessage.BodyData.Encoding.CodePage,
                        WebName = logEntry.ResponseMessage.BodyData.Encoding.WebName
                    }
                    : null;
            }

            return new LogEntryModel
            {
                Guid = logEntry.Guid,
                Request = logRequestModel,
                Response = logResponseModel,

                MappingGuid = logEntry.MappingGuid,
                MappingTitle = logEntry.MappingTitle,
                RequestMatchResult = Map(logEntry.RequestMatchResult),

                PartialMappingGuid = logEntry.PartialMappingGuid,
                PartialMappingTitle = logEntry.PartialMappingTitle,
                PartialRequestMatchResult = Map(logEntry.PartialMatchResult)
            };
        }

        private static LogRequestMatchModel Map(IRequestMatchResult matchResult)
        {
            if (matchResult == null)
            {
                return null;
            }

            return new LogRequestMatchModel
            {
                IsPerfectMatch = matchResult.IsPerfectMatch,
                TotalScore = matchResult.TotalScore,
                TotalNumber = matchResult.TotalNumber,
                AverageTotalScore = matchResult.AverageTotalScore,
                MatchDetails = matchResult.MatchDetails.Select(md => new
                {
                    Name = md.MatcherType.Name.Replace("RequestMessage", string.Empty),
                    Score = md.Score
                } as object).ToList()
            };
        }
    }
}