Esempio n. 1
0
 public IEnumerable <ChangedInfosBO> GetChangesOfType(ChangedOpenApiBO changedOpenAPI, DiffResultEnum changeType)
 {
     return(changedOpenAPI.GetChangedElements()
            .SelectMany(x => x.Change.GetAllChangeInfoFlat(null))
            .Where(y => y.ChangeType.DiffResult == changeType)
            .ToList());
 }
Esempio n. 2
0
        public Task <string> Render(ChangedOpenApiBO diff)
        {
            _diff   = diff;
            _output = new StringBuilder();
            if (diff.IsUnchanged())
            {
                _output.Append("No differences. Specifications are equivalents");
            }
            else
            {
                _output
                .Append(Environment.NewLine)
                .Append(BigTitle("Api Change Log"))
                .Append(Center(diff.NewSpecOpenApi.Info.Title))
                .Append(Environment.NewLine);

                var newEndpoints  = diff.NewEndpoints;
                var olNewEndpoint = ListEndpoints(newEndpoints, "What's New");

                var missingEndpoints  = diff.MissingEndpoints;
                var olMissingEndpoint = ListEndpoints(missingEndpoints, "What's Deleted");

                var deprecatedEndpoints  = diff.GetDeprecatedEndpoints();
                var olDeprecatedEndpoint = ListEndpoints(deprecatedEndpoints, "What's Deprecated");

                var changedOperations = diff.ChangedOperations;
                var olChanged         = OlChanged(changedOperations);

                _output
                .Append(renderBody(olNewEndpoint, olMissingEndpoint, olDeprecatedEndpoint, olChanged))
                .Append(Title("Result"))
                .Append(
                    Center(
                        diff.IsCompatible()
                                ? "API changes are backward compatible"
                                : "API changes broke backward compatibility"))
                .Append(Environment.NewLine)
                .Append(Separator('-'));
            }

            return(Task.FromResult(_output.ToString()));
        }
Esempio n. 3
0
        public async Task <string> Render(ChangedOpenApiBO diff)
        {
            var model = !_title.IsNullOrEmpty() ? GetRenderModel(diff, _title) : GetRenderModel(diff);

            return(await _engine.CompileRenderAsync("Views.Index", model));
        }
Esempio n. 4
0
        protected RenderViewModel GetRenderModel(ChangedOpenApiBO diff,
                                                 string reportName      = "OpenAPI Compatibility Report",
                                                 string logoUrl         = "",
                                                 string pageTitle       = "Api Change Log",
                                                 string pageDescription = null)
        {
            pageDescription ??= $"This report was generated by {typeof(BaseRenderer).Namespace}.OpenAPI.Diff";

            return(new RenderViewModel
            {
                PageTitle = pageTitle,
                Author = $"{typeof(BaseRenderer).Namespace}.OpenAPI.Diff",
                Description = pageDescription,
                Name = reportName,
                LogoUrl = logoUrl,
                ChangeType = diff.IsChanged(),
                OldSpecIdentifier = diff.OldSpecIdentifier,
                NewSpecIdentifier = diff.NewSpecIdentifier,
                NewEndpoints = diff.NewEndpoints
                               .OrderBy(x => x.PathUrl.NormalizePath())
                               .ThenBy(x => x.Method)
                               .ToList(),
                MissingEndpoints = diff.MissingEndpoints
                                   .OrderBy(x => x.PathUrl.NormalizePath())
                                   .ThenBy(x => x.Method)
                                   .ToList(),
                DeprecatedEndpoints = diff.GetDeprecatedEndpoints()
                                      .OrderBy(x => x.PathUrl.NormalizePath())
                                      .ThenBy(x => x.Method)
                                      .ToList(),
                ChangedEndpoints = diff.ChangedOperations
                                   .Select(x => new ChangedEndpointViewModel
                {
                    Method = x.HttpMethod,
                    PathUrl = x.PathUrl,
                    Summary = x.Description?.Right ?? x.Summary?.Right,
                    ChangeType = x.IsChanged(),
                    ChangesByType = x.GetAllChangeInfoFlat(null)
                                    .Where(y => !y.ChangeType.IsUnchanged())
                                    .Select(y => new ChangeViewModel
                    {
                        Path = y.Path.Where(z => !z.IsNullOrEmpty()).ToList(),
                        ChangeType = y.ChangeType,
                        Changes = y.Changes
                                  .Select(z => new SingleChangeViewModel
                        {
                            ElementType = z.ElementType,
                            ChangeType = z.ChangeType,
                            FieldName = z.FieldName,
                            NewValue = z.NewValue,
                            OldValue = z.OldValue
                        })
                                  .ToList()
                    })
                                    .ToList()
                })
                                   .OrderByDescending(x => x.ChangeType.DiffResult)
                                   .ThenBy(x => x.PathUrl.NormalizePath())
                                   .ThenBy(x => x.Method)
                                   .ToList()
            });
        }
Esempio n. 5
0
        public Task <string> Render(ChangedOpenApiBO diff)
        {
            var model = !_title.IsNullOrEmpty() ? GetRenderModel(diff, _title) : GetRenderModel(diff);

            return(Task.FromResult(GetIndex(model)));
        }