hope.common.wire.api.CommonApiCollector Maven / Gradle / Ivy

Go to download
package hope.common.wire.api;

import hope.common.Builder;
import hope.common.service.Collector;
import hope.common.service.api.Component;
import hope.common.wire.constant.ProblemPhase;
import hope.common.wire.constant.ProblemSeverity;
import hope.common.wire.constant.YesNoEnum;
import io.swagger.v3.oas.models.Components;
import io.swagger.v3.oas.models.OpenAPI;
import io.swagger.v3.oas.models.Paths;
import io.swagger.v3.oas.models.callbacks.Callback;
import io.swagger.v3.oas.models.examples.Example;
import io.swagger.v3.oas.models.headers.Header;
import io.swagger.v3.oas.models.links.Link;
import io.swagger.v3.oas.models.media.Schema;
import io.swagger.v3.oas.models.parameters.Parameter;
import io.swagger.v3.oas.models.parameters.RequestBody;
import io.swagger.v3.oas.models.responses.ApiResponse;
import io.swagger.v3.oas.models.security.SecurityScheme;
import io.swagger.v3.oas.models.tags.Tag;
import java.lang.Object;
import java.lang.Override;
import java.lang.String;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Generated;

@Generated("H.O.P.E. Infra Team")
public final class CommonApiCollector implements Collector {
  public static final String COMPONENTS_SCHEMAS_REF = Components.COMPONENTS_SCHEMAS_REF;

  protected final OpenAPI api;

  protected final Map servicesContext = new LinkedHashMap();

  protected final Map pathsContext = new LinkedHashMap();

  protected final Map schemas = new LinkedHashMap();

  protected final Map responses = new LinkedHashMap();

  protected final Map parameters = new LinkedHashMap();

  protected final Map examples = new LinkedHashMap();

  protected final Map requestBodies = new LinkedHashMap();

  protected final Map headers = new LinkedHashMap();

  protected final Map securitySchemes = new LinkedHashMap();

  protected final Map links = new LinkedHashMap();

  protected final Map callbacks = new LinkedHashMap();

  protected final Map tags = new LinkedHashMap();

  protected final Map extensions = new LinkedHashMap();

  protected final Map pathClzMap = new HashMap();

  protected final Map> clzPathMap = new HashMap();

  protected final Map clzContextMap = new LinkedHashMap();

  protected final Map componentMap = new LinkedHashMap();

  public CommonApiCollector() {
    this.api =  new OpenAPI();
    Components components = new Components();
    components.setSchemas(schemas);
    components.responses(responses);
    components.setParameters(parameters);
    components.setRequestBodies(requestBodies);
    components.setHeaders(headers);
    components.setExamples(examples);
    components.setSecuritySchemes(securitySchemes);
    components.setLinks(links);
    components.setCallbacks(callbacks);
    components.setExtensions(extensions);
    api.components(components);
    api.setPaths(new Paths());
    _init();
  }

  @Override
  public OpenAPI getApi() {
    return api;
  }

  @Override
  public Map getServicesContext() {
    return servicesContext;
  }

  @Override
  public Map getPathsContext() {
    return pathsContext;
  }

  @Override
  public Map getSchemas() {
    return schemas;
  }

  @Override
  public Map getResponses() {
    return responses;
  }

  @Override
  public Map getParameters() {
    return parameters;
  }

  @Override
  public Map getExamples() {
    return examples;
  }

  @Override
  public Map getRequestBodies() {
    return requestBodies;
  }

  @Override
  public Map getHeaders() {
    return headers;
  }

  @Override
  public Map getSecuritySchemes() {
    return securitySchemes;
  }

  @Override
  public Map getLinks() {
    return links;
  }

  @Override
  public Map getCallbacks() {
    return callbacks;
  }

  @Override
  public Map getTags() {
    return tags;
  }

  @Override
  public Map getExtensions() {
    return extensions;
  }

  @Override
  public Map getPathClzMap() {
    return pathClzMap;
  }

  @Override
  public Map> getClzPathMap() {
    return clzPathMap;
  }

  @Override
  public Map getClzContextMap() {
    return clzContextMap;
  }

  @Override
  public Map getComponentMap() {
    return componentMap;
  }

  public void registerPathClz(String path, String clz) {
    pathClzMap.put(path, clz);
    clzPathMap.computeIfAbsent(clz, s -> new LinkedHashSet<>()).add(path);
  }

  private final void _build_component_hope_common_wire_constant_ProblemPhase() {
    //  Build of the component: ProblemPhase proto: hope/common/proto/constant/common.proto
    Component res = new Component();
    componentMap.put("hope.common.wire.constant.ProblemPhase", res);
    res.setClzName("hope.common.wire.constant.ProblemPhase");
    res.setEnumClz(true);
    res.setName("ProblemPhase");
    res.setPayload(new Builder>() {
      @Override
      public Schema build() {
        Schema res  = new Schema();
        res.setTitle("Phase");
        res.setDescription("错误层次");
        List values  = new ArrayList();
        values.add(ProblemPhase.CONTROLLER);
        values.add(ProblemPhase.SERVICE);
        values.add(ProblemPhase.DOMAIN);
        res.setDefault(ProblemPhase.CONTROLLER);
        res.setEnum(values);
        return res;
      }
    }.build());
  }

  private final void _build_component_hope_common_wire_constant_ProblemSeverity() {
    //  Build of the component: ProblemSeverity proto: hope/common/proto/constant/common.proto
    Component res = new Component();
    componentMap.put("hope.common.wire.constant.ProblemSeverity", res);
    res.setClzName("hope.common.wire.constant.ProblemSeverity");
    res.setEnumClz(true);
    res.setName("ProblemSeverity");
    res.setPayload(new Builder>() {
      @Override
      public Schema build() {
        Schema res  = new Schema();
        res.setTitle("Severity");
        res.setDescription("错误严重程度");
        List values  = new ArrayList();
        values.add(ProblemSeverity.LOW);
        values.add(ProblemSeverity.WARN);
        values.add(ProblemSeverity.ERROR);
        values.add(ProblemSeverity.FATAL);
        res.setDefault(ProblemSeverity.LOW);
        res.setEnum(values);
        return res;
      }
    }.build());
  }

  private final void _build_component_hope_common_wire_constant_YesNoEnum() {
    //  Build of the component: YesNoEnum proto: hope/common/proto/constant/common.proto
    Component res = new Component();
    componentMap.put("hope.common.wire.constant.YesNoEnum", res);
    res.setClzName("hope.common.wire.constant.YesNoEnum");
    res.setEnumClz(true);
    res.setName("YesNoEnum");
    res.setPayload(new Builder>() {
      @Override
      public Schema build() {
        Schema res  = new Schema();
        res.setTitle("Yes No choice enum");
        res.setDescription("是选择");
        List values  = new ArrayList();
        values.add(YesNoEnum.YES);
        values.add(YesNoEnum.NO);
        res.setDefault(YesNoEnum.YES);
        res.setEnum(values);
        return res;
      }
    }.build());
  }

  private void _init() {
    // Build for Enum :hope.common.wire.constant.ProblemPhase
    _build_component_hope_common_wire_constant_ProblemPhase();
    // Build for Enum :hope.common.wire.constant.ProblemSeverity
    _build_component_hope_common_wire_constant_ProblemSeverity();
    // Build for Enum :hope.common.wire.constant.YesNoEnum
    _build_component_hope_common_wire_constant_YesNoEnum();
    api.tags(new ArrayList<>(tags.values()));
  }
}