• Home
• com.qdesrame
• openapi-diff
• 1.1.1
• source code
• HtmlRender.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.qdesrame.openapi.diff.output.HtmlRender Maven / Gradle / Ivy

package com.qdesrame.openapi.diff.output;

import com.qdesrame.openapi.diff.model.*;
import io.swagger.v3.oas.models.media.MediaType;
import io.swagger.v3.oas.models.parameters.Parameter;
import io.swagger.v3.oas.models.responses.ApiResponse;
import j2html.tags.ContainerTag;

import java.util.List;
import java.util.Map;

import static j2html.TagCreator.*;

public class HtmlRender implements Render {

    private String title;
    private String linkCss;

    public HtmlRender() {
        this("Api Change Log", "http://deepoove.com/swagger-diff/stylesheets/demo.css");
    }

    public HtmlRender(String title, String linkCss) {
        this.title = title;
        this.linkCss = linkCss;
    }


    public String render(ChangedOpenApi diff) {
        List newEndpoints = diff.getNewEndpoints();
        ContainerTag ol_newEndpoint = ol_newEndpoint(newEndpoints);

        List missingEndpoints = diff.getMissingEndpoints();
        ContainerTag ol_missingEndpoint = ol_missingEndpoint(missingEndpoints);

        List deprecatedEndpoints = diff.getDeprecatedEndpoints();
        ContainerTag ol_deprecatedEndpoint = ol_deprecatedEndpoint(deprecatedEndpoints);

        List changedOperations = diff.getChangedOperations();
        ContainerTag ol_changed = ol_changed(changedOperations);

        return renderHtml(ol_newEndpoint, ol_missingEndpoint, ol_deprecatedEndpoint, ol_changed);
    }

    public String renderHtml(ContainerTag ol_new, ContainerTag ol_miss, ContainerTag ol_deprec, ContainerTag ol_changed) {
        ContainerTag html = html().attr("lang", "en").with(
                head().with(
                        meta().withCharset("utf-8"),
                        title(title),
                        link().withRel("stylesheet").withHref(linkCss)
                ),
                body().with(
                        header().with(h1(title)),
                        div().withClass("article").with(
                                div().with(h2("What's New"), hr(), ol_new),
                                div().with(h2("What's Deleted"), hr(), ol_miss),
                                div().with(h2("What's Deprecated"), hr(), ol_deprec),
                                div().with(h2("What's Changed"), hr(), ol_changed)
                        )
                )
        );

        return document().render() + html.render();
    }


    private ContainerTag ol_newEndpoint(List endpoints) {
        if (null == endpoints) return ol();
        ContainerTag ol = ol();
        for (Endpoint endpoint : endpoints) {
            ol.with(li_newEndpoint(endpoint.getMethod().toString(),
                    endpoint.getPathUrl(), endpoint.getSummary()));
        }
        return ol;
    }

    private ContainerTag li_newEndpoint(String method, String path,
                                        String desc) {
        return li().with(span(method).withClass(method)).withText(path + " ")
                .with(span(desc));
    }

    private ContainerTag ol_missingEndpoint(List endpoints) {
        if (null == endpoints) return ol();
        ContainerTag ol = ol();
        for (Endpoint endpoint : endpoints) {
            ol.with(li_missingEndpoint(endpoint.getMethod().toString(),
                    endpoint.getPathUrl(), endpoint.getSummary()));
        }
        return ol;
    }

    private ContainerTag li_missingEndpoint(String method, String path,
                                            String desc) {
        return li().with(span(method).withClass(method),
                del().withText(path)).with(span(" " + desc));
    }

    private ContainerTag ol_deprecatedEndpoint(List endpoints) {
        if (null == endpoints) return ol();
        ContainerTag ol = ol();
        for (Endpoint endpoint : endpoints) {
            ol.with(li_deprecatedEndpoint(endpoint.getMethod().toString(),
                    endpoint.getPathUrl(), endpoint.getSummary()));
        }
        return ol;
    }

    private ContainerTag li_deprecatedEndpoint(String method, String path,
                                               String desc) {
        return li().with(span(method).withClass(method),
                del().withText(path)).with(span(" " + desc));
    }

    private ContainerTag ol_changed(List changedOperations) {
        if (null == changedOperations) return ol();
        ContainerTag ol = ol();
        for (ChangedOperation changedOperation : changedOperations) {
            String pathUrl = changedOperation.getPathUrl();
            String method = changedOperation.getHttpMethod().toString();
            String desc = changedOperation.getSummary();

            ContainerTag ul_detail = ul().withClass("detail");
            if (changedOperation.isDiffParam()) {
                ul_detail.with(li().with(h3("Parameters")).with(ul_param(changedOperation.getChangedParameters())));
            }
            if (changedOperation.isDiffRequest()) {
                ul_detail.with(li().with(h3("Request")).with(ul_request(changedOperation.getChangedRequestBody().getChangedContent())));
            } else {
            }
            if (changedOperation.isDiffResponse()) {
                ul_detail.with(li().with(h3("Response")).with(ul_response(changedOperation.getChangedApiResponse())));
            }
            ol.with(li().with(span(method).withClass(method)).withText(pathUrl + " ").with(span(desc))
                    .with(ul_detail));
        }
        return ol;
    }

    private ContainerTag ul_response(ChangedApiResponse changedApiResponse) {
        Map addResponses = changedApiResponse.getAddResponses();
        Map delResponses = changedApiResponse.getMissingResponses();
        Map changedResponses = changedApiResponse.getChangedResponses();
        ContainerTag ul = ul().withClass("change response");
        for (String propName : addResponses.keySet()) {
            ul.with(li_addResponse(propName, addResponses.get(propName)));
        }
        for (String propName : delResponses.keySet()) {
            ul.with(li_missingResponse(propName, delResponses.get(propName)));
        }
        for (String propName : changedResponses.keySet()) {
            ul.with(li_changedResponse(propName, changedResponses.get(propName)));
        }
        return ul;
    }

    private ContainerTag li_addResponse(String name, ApiResponse response) {
        return li().withText(String.format("New response : [%s]", name)).with(span(null == response.getDescription() ? "" : ("//" + response.getDescription())).withClass("comment"));
    }

    private ContainerTag li_missingResponse(String name, ApiResponse response) {
        return li().withText(String.format("Deleted response : [%s]", name)).with(span(null == response.getDescription() ? "" : ("//" + response.getDescription())).withClass("comment"));
    }

    private ContainerTag li_changedResponse(String name, ChangedResponse response) {
        return li().withText(String.format("Changed response : [%s]", name))
                .with(span((null == response.getNewApiResponse() || null == response.getNewApiResponse().getDescription()) ? "" : ("//" + response.getNewApiResponse().getDescription())).withClass("comment"))
                .with(ul_request(response.getChangedContent()));
    }

    private ContainerTag ul_request(ChangedContent changedContent) {
        ContainerTag ul = ul().withClass("change request-body");
        if(changedContent != null) {
            for (String propName : changedContent.getIncreased().keySet()) {
                ul.with(li_addRequest(propName, changedContent.getIncreased().get(propName)));
            }
            for (String propName : changedContent.getMissing().keySet()) {
                ul.with(li_missingRequest(propName, changedContent.getMissing().get(propName)));
            }
            for (String propName : changedContent.getChanged().keySet()) {
                ul.with(li_changedRequest(propName, changedContent.getChanged().get(propName)));
            }
        }
        return ul;
    }

    private ContainerTag li_addRequest(String name, MediaType request) {
        return li().withText(String.format("New body: '%s'", name));
    }

    private ContainerTag li_missingRequest(String name, MediaType request) {
        return li().withText(String.format("Deleted body: '%s'", name));
    }

    private ContainerTag li_changedRequest(String name, ChangedMediaType request) {
        return li().withText(String.format("Changed body: '%s'", name)).with(div_changedSchema(request.getChangedSchema()));
    }

    private ContainerTag div_changedSchema(ChangedSchema schema) {
        ContainerTag div = div();
        div.with(h3("Schema"));
        return div;
    }

    private ContainerTag ul_param(ChangedParameters changedParameters) {
        List addParameters = changedParameters.getIncreased();
        List delParameters = changedParameters.getMissing();
        List changed = changedParameters.getChanged();
        ContainerTag ul = ul().withClass("change param");
        for (Parameter param : addParameters) {
            ul.with(li_addParam(param));
        }
        for (ChangedParameter param : changed) {
            ul.with(li_changedParam(param));
        }
        for (Parameter param : delParameters) {
            ul.with(li_missingParam(param));
        }
        return ul;
    }

    private ContainerTag li_addParam(Parameter param) {
        return li().withText("Add " + param.getName() + " in " + param.getIn()).with(span(null == param.getDescription() ? "" : ("//" + param.getDescription())).withClass("comment"));
    }

    private ContainerTag li_missingParam(Parameter param) {
        return li().withClass("missing").with(span("Delete")).with(del(param.getName())).with(span("in ").withText(param.getIn())).with(span(null == param.getDescription() ? "" : ("//" + param.getDescription())).withClass("comment"));
    }

    private ContainerTag li_deprecatedParam(ChangedParameter param) {
        return li().withClass("missing").with(span("Deprecated"))
                .with(del(param.getName())).with(span("in ").withText(param.getIn()))
                .with(span(null == param.getNewParameter().getDescription() ? "" : ("//" + param.getNewParameter().getDescription())).withClass("comment"));
    }

    private ContainerTag li_changedParam(ChangedParameter changeParam) {
        if (changeParam.isDeprecated()) {
            return li_deprecatedParam(changeParam);
        }
        boolean changeRequired = changeParam.isChangeRequired();
        boolean changeDescription = changeParam.isChangeDescription();
        Parameter rightParam = changeParam.getNewParameter();
        Parameter leftParam = changeParam.getNewParameter();
        ContainerTag li = li().withText(changeParam.getName() + " in " + changeParam.getIn());
        if (changeRequired) {
            li.withText(" change into " + (rightParam.getRequired() ? "required" : "not required"));
        }
        if (changeDescription) {
            li.withText(" Notes ").with(del(leftParam.getDescription()).withClass("comment")).withText(" change into ").with(span(rightParam.getDescription()).withClass("comment"));
        }
        return li;
    }

}