public ChangedAPIResponseBO Diff(OpenApiResponses left, OpenApiResponses right, DiffContextBO context)
{
var responseMapKeyDiff = MapKeyDiff <string, OpenApiResponse> .Diff(left, right);
var sharedResponseCodes = responseMapKeyDiff.SharedKey;
var responses = new Dictionary <string, ChangedResponseBO>();
foreach (var responseCode in sharedResponseCodes)
{
var diff = _openApiDiff
.ResponseDiff
.Diff(left[responseCode], right[responseCode], context);
if (diff != null)
{
responses.Add(responseCode, diff);
}
}
var changedApiResponse =
new ChangedAPIResponseBO(left, right, context)
{
Increased = responseMapKeyDiff.Increased,
Missing = responseMapKeyDiff.Missing,
Changed = responses,
Extensions = _openApiDiff
.ExtensionsDiff
.Diff(left.Extensions, right.Extensions, context)
};
return(ChangedUtils.IsChanged(changedApiResponse));
}
public ChangedPathBO Diff(OpenApiPathItem left, OpenApiPathItem right, DiffContextBO context)
{
var oldOperationMap = left.Operations;
var newOperationMap = right.Operations;
var operationsDiff =
MapKeyDiff <OperationType, OpenApiOperation> .Diff(oldOperationMap, newOperationMap);
var sharedMethods = operationsDiff.SharedKey;
var changedPath = new ChangedPathBO(context.URL, left, right, context)
{
Increased = operationsDiff.Increased,
Missing = operationsDiff.Missing
};
foreach (var operationType in sharedMethods)
{
var oldOperation = oldOperationMap[operationType];
var newOperation = newOperationMap[operationType];
var diff = _openApiDiff
.OperationDiff
.Diff(oldOperation, newOperation, context.CopyWithMethod(operationType));
if (diff != null)
{
changedPath.Changed.Add(diff);
}
}
changedPath.Extensions = _openApiDiff
.ExtensionsDiff
.Diff(left.Extensions, right.Extensions, context);
return(ChangedUtils.IsChanged(changedPath));
}
public ChangedHeadersBO Diff(IDictionary <string, OpenApiHeader> left, IDictionary <string, OpenApiHeader> right,
DiffContextBO context)
{
var headerMapDiff = MapKeyDiff <string, OpenApiHeader> .Diff(left, right);
var sharedHeaderKeys = headerMapDiff.SharedKey;
var changed = new Dictionary <string, ChangedHeaderBO>();
foreach (var headerKey in sharedHeaderKeys)
{
var oldHeader = left[headerKey];
var newHeader = right[headerKey];
var changedHeaders = _openApiDiff
.HeaderDiff
.Diff(oldHeader, newHeader, context);
if (changedHeaders != null)
{
changed.Add(headerKey, changedHeaders);
}
}
return(ChangedUtils.IsChanged(
new ChangedHeadersBO(left, right, context)
{
Increased = headerMapDiff.Increased,
Missing = headerMapDiff.Missing,
Changed = changed
}));
}
public ChangedContentBO Diff(IDictionary <string, OpenApiMediaType> left,
IDictionary <string, OpenApiMediaType> right, DiffContextBO context)
{
var leftDict = (Dictionary <string, OpenApiMediaType>)left;
var rightDict = (Dictionary <string, OpenApiMediaType>)right;
var mediaTypeDiff = MapKeyDiff <string, OpenApiMediaType> .Diff(leftDict, rightDict);
var sharedMediaTypes = mediaTypeDiff.SharedKey;
var changedMediaTypes = new Dictionary <string, ChangedMediaTypeBO>();
foreach (var sharedMediaType in sharedMediaTypes)
{
var oldMediaType = left[sharedMediaType];
var newMediaType = right[sharedMediaType];
var changedMediaType =
new ChangedMediaTypeBO(oldMediaType?.Schema, newMediaType?.Schema, context)
{
Schema = _openApiDiff
.SchemaDiff
.Diff(
oldMediaType?.Schema,
newMediaType?.Schema,
context.CopyWithRequired(true))
};
if (!ChangedUtils.IsUnchanged(changedMediaType))
{
changedMediaTypes.Add(sharedMediaType, changedMediaType);
}
}
return(ChangedUtils.IsChanged(new ChangedContentBO(leftDict, rightDict, context)
{
Increased = mediaTypeDiff.Increased,
Missing = mediaTypeDiff.Missing,
Changed = changedMediaTypes
}));
}
public static MapKeyDiff <T1, T2> Diff(IDictionary <T1, T2> mapLeft, IDictionary <T1, T2> mapRight)
{
var instance = new MapKeyDiff <T1, T2>();
if (null == mapLeft && null == mapRight)
{
return(instance);
}
if (null == mapLeft)
{
instance.Increased = (Dictionary <T1, T2>)mapRight;
return(instance);
}
if (null == mapRight)
{
instance.Missing = (Dictionary <T1, T2>)mapLeft;
return(instance);
}
instance.Increased = new Dictionary <T1, T2>(mapRight);
instance.Missing = new Dictionary <T1, T2>();
foreach (var entry in mapLeft)
{
var leftKey = entry.Key;
var leftValue = entry.Value;
if (mapRight.ContainsKey(leftKey))
{
instance.Increased.Remove(leftKey);
instance.SharedKey.Add(leftKey);
}
else
{
instance.Missing.Add(leftKey, leftValue);
}
}
return(instance);
}
