import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
@Override
public void afterScan(Reader reader, Swagger swagger) {
    OAuth2Definition tokenScheme = new OAuth2Definition();
    tokenScheme.setType("oauth2");
    tokenScheme.setFlow("application");
    tokenScheme.setTokenUrl("https://" + swagger.getHost() + "/oauth2/token");
    tokenScheme.setAuthorizationUrl("https://" + swagger.getHost() + "/oauth2/authorize");
    tokenScheme.addScope("write:everything", "Full access");

    Map<String, SecuritySchemeDefinition> schemes = new HashMap<>();
    schemes.put(TOKEN_AUTH_SCHEME, tokenScheme);

    swagger.setSecurityDefinitions(schemes);
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
/**
 * Check if all operations contains valid authentication types
 */
private SwaggerModelInfo validateAuthTypes(final SwaggerModelInfo swaggerModelInfo) {

    if (swaggerModelInfo.getModel() == null) {
        return swaggerModelInfo;
    }

    final SwaggerModelInfo.Builder withWarnings = new SwaggerModelInfo.Builder().createFrom(swaggerModelInfo);

    for (final Map.Entry<String, SecuritySchemeDefinition> definitionEntry : notNull(
        swaggerModelInfo.getModel().getSecurityDefinitions()).entrySet()) {
        final String authType = definitionEntry.getValue().getType();
        if (!SUPPORTED_AUTH_TYPES.contains(authType)) {
            withWarnings.addWarning(new Violation.Builder()//
                .property("")//
                .error("unsupported-auth")//
                .message("Authentication type " + authType + " is currently not supported")//
                .build());
        }
    }

    return withWarnings.build();
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private void processUris(final Map<String, Path> swagger,
    final Map<String, Model> definitionsMap,
    final Map<String, SecuritySchemeDefinition> securityDefinitionsMap,
    final int i) {

    int j = 0;
    while (env.containsProperty(String.format("swagger[%d].uris[%d].swagger", i, j))) {
        try {
            final URL swaggerUrl = env.getProperty(String.format("swagger[%d].uris[%d].swagger", i, j), URL.class);

            final Swagger remoteSwagger = io.swagger.util.Json.mapper().readerFor(Swagger.class).readValue(swaggerUrl.openConnection().getInputStream());

            processPaths(swagger, definitionsMap, securityDefinitionsMap, remoteSwagger, i, j);
            ++j;
        } catch (final IOException e) {
            throw new UncheckedIOException(e);
        }

    }

}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private Boolean isApiKeyRequired(Operation op) {
    Optional<Map.Entry<String, SecuritySchemeDefinition>> apiKeySecurityDefinition = Optional.empty();

    if (swagger.getSecurityDefinitions() != null) {
        apiKeySecurityDefinition = swagger.getSecurityDefinitions().entrySet()
                .stream().filter(p -> p.getValue().getType().equals("apiKey")).findFirst();
    }

    if (!apiKeySecurityDefinition.isPresent()) {
        return false;
    }

    String securityDefinitionName = apiKeySecurityDefinition.get().getKey();

    if (op.getSecurity() != null) {
        return op.getSecurity().stream().anyMatch(s -> s.containsKey(securityDefinitionName));
    }
    if (swagger.getSecurityRequirement() != null) {
        return swagger.getSecurityRequirement().stream().anyMatch(s -> s.getName().equals(securityDefinitionName));
    }
    return false;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
@Override
public MarkupDocBuilder apply(MarkupDocBuilder markupDocBuilder, Parameters params) {
    String securitySchemeDefinitionName = params.securitySchemeDefinitionName;
    SecuritySchemeDefinition securitySchemeDefinition = params.securitySchemeDefinition;
    applySecurityDocumentExtension(new SecurityDocumentExtension.Context(Position.SECURITY_SCHEME_BEFORE, markupDocBuilder, securitySchemeDefinitionName, securitySchemeDefinition));
    markupDocBuilder.sectionTitleWithAnchorLevel(params.titleLevel, securitySchemeDefinitionName);
    applySecurityDocumentExtension(new SecurityDocumentExtension.Context(Position.SECURITY_SCHEME_BEGIN, markupDocBuilder, securitySchemeDefinitionName, securitySchemeDefinition));
    String description = securitySchemeDefinition.getDescription();
    if (isNotBlank(description)) {
        markupDocBuilder.paragraph(markupDescription(config.getSwaggerMarkupLanguage(), markupDocBuilder, description));
    }
    buildSecurityScheme(markupDocBuilder, securitySchemeDefinition);
    applySecurityDocumentExtension(new SecurityDocumentExtension.Context(Position.SECURITY_SCHEME_END, markupDocBuilder, securitySchemeDefinitionName, securitySchemeDefinition));
    applySecurityDocumentExtension(new SecurityDocumentExtension.Context(Position.SECURITY_SCHEME_AFTER, markupDocBuilder, securitySchemeDefinitionName, securitySchemeDefinition));
    return markupDocBuilder;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
@Test
public void testSecuritySchemeDefinitionComponentWithOAuth() throws URISyntaxException {
    //Given
    Path file = Paths.get(SecuritySchemeDefinitionComponentTest.class.getResource("/yaml/swagger_petstore.yaml").toURI());
    Swagger2MarkupConverter converter = Swagger2MarkupConverter.from(file).build();
    Swagger swagger = converter.getContext().getSwagger();

    SecuritySchemeDefinition securitySchemeDefinition = swagger.getSecurityDefinitions().get("petstore_auth");

    Swagger2MarkupConverter.Context context = converter.getContext();
    MarkupDocBuilder markupDocBuilder = context.createMarkupDocBuilder();

    markupDocBuilder = new SecuritySchemeDefinitionComponent(context).apply(
            markupDocBuilder, SecuritySchemeDefinitionComponent.parameters("petstore_auth",
                    securitySchemeDefinition,
                    OverviewDocument.SECTION_TITLE_LEVEL));
    markupDocBuilder.writeToFileWithoutExtension(oauthOutputDirectory, StandardCharsets.UTF_8);

    Path expectedFile = getExpectedFile(O_AUTH_NAME);
    DiffUtils.assertThatFileIsEqual(expectedFile, oauthOutputDirectory, getReportName(O_AUTH_NAME));

}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
@Test
public void testSecuritySchemeDefinitionComponentWithApiKey() throws URISyntaxException {
    //Given
    Path file = Paths.get(SecuritySchemeDefinitionComponentTest.class.getResource("/yaml/swagger_petstore.yaml").toURI());
    Swagger2MarkupConverter converter = Swagger2MarkupConverter.from(file).build();
    Swagger swagger = converter.getContext().getSwagger();

    SecuritySchemeDefinition securitySchemeDefinition = swagger.getSecurityDefinitions().get("api_key");

    Swagger2MarkupConverter.Context context = converter.getContext();
    MarkupDocBuilder markupDocBuilder = context.createMarkupDocBuilder();

    markupDocBuilder = new SecuritySchemeDefinitionComponent(context).apply(
            markupDocBuilder, SecuritySchemeDefinitionComponent.parameters("api_key",
                    securitySchemeDefinition,
                    OverviewDocument.SECTION_TITLE_LEVEL));
    markupDocBuilder.writeToFileWithoutExtension(apiKeyOutputDirectory, StandardCharsets.UTF_8);

    Path expectedFile = getExpectedFile(API_KEY_NAME);
    DiffUtils.assertThatFileIsEqual(expectedFile, apiKeyOutputDirectory, getReportName(API_KEY_NAME));

}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
public Map<String, SecuritySchemeDefinition> generateSecuritySchemeDefinitions() throws GenerateException {
    Map<String, SecuritySchemeDefinition> map = new HashMap<String, SecuritySchemeDefinition>();

    List<JsonNode> securityDefinitions = new ArrayList<JsonNode>();
    if (json != null || jsonPath != null) {
        securityDefinitions = loadSecurityDefintionsFromJsonFile();
    } else {
        securityDefinitions.add(new ObjectMapper().valueToTree(this));
    }

    for (JsonNode securityDefinition : securityDefinitions) {
        SecuritySchemeDefinition ssd = getSecuritySchemeDefinitionByType(securityDefinition.get("type").asText(), securityDefinition);
        if (ssd != null) {
            map.put(securityDefinition.get("name").asText(), ssd);
        }
    }

    return map;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
public ClonableSwagger getSwagger(final String basePath,
    final UriInfo uriInfo) {

    ClonableSwagger swagger = swaggerMap.get(basePath);
    if (swagger == null) {
        final int i = swaggerPaths.get(basePath);

        swagger = new ClonableSwagger();
        final String title = env.getProperty(String.format("swagger[%d].info.title", i));
        final String version = env.getProperty(String.format("swagger[%d].info.version", i));

        swagger.setBasePath('/' + basePath);
        final Info info = new Info();
        info.setTitle(title);
        info.setVersion(version);
        swagger.setInfo(info);
        final Map<String, Path> pathsMap = new TreeMap<>();
        final Map<String, Model> definitionsMap = new TreeMap<>();
        final Map<String, SecuritySchemeDefinition> securityDefinitionsMap = new TreeMap<>();
        processUris(pathsMap, definitionsMap, securityDefinitionsMap, i);
        swagger.setPaths(pathsMap);
        swagger.setDefinitions(definitionsMap);
        swagger.setSecurityDefinitions(securityDefinitionsMap);

        swaggerMap.putIfAbsent(basePath, swagger);
    }
    return swagger.withUriInfo(uriInfo);
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private void processPaths(final Map<String, Path> swagger,
    final Map<String, Model> definitionsMap,
    final Map<String, SecuritySchemeDefinition> securityDefinitionsMap,
    final Swagger remoteSwagger,
    final int i,
    final int j) {

    int k = 0;
    while (env.containsProperty(String.format("swagger[%d].uris[%d].paths[%d].from", i, j, k)) || env.containsProperty(String.format("swagger[%d].uris[%d].paths[%d]", i, j, k))) {
        if (env.containsProperty(String.format("swagger[%d].uris[%d].paths[%d].from", i, j, k))) {
            final String from = env.getRequiredProperty(String.format("swagger[%d].uris[%d].paths[%d].from", i, j, k));
            final String to = env.getRequiredProperty(String.format("swagger[%d].uris[%d].paths[%d].to", i, j, k));

            LOG.debug("getting path={} from paths={} and transform to={}", from, remoteSwagger.getPaths().keySet(), to);
            Optional.ofNullable(remoteSwagger.getPaths())
                .ifPresent(t -> remoteSwagger.getPaths().keySet().parallelStream()
                    .filter(s -> s.startsWith(from))
                    .forEach(p -> swagger.put(to + p.substring(from.length()), remoteSwagger.getPath(p))));

            updateDefinitions(definitionsMap, securityDefinitionsMap, remoteSwagger);
        } else {
            final String path = env.getRequiredProperty(String.format("swagger[%d].uris[%d].paths[%d]", i, j, k));
            if (LOG.isDebugEnabled()) {
                LOG.debug("getting path={} from paths={}", path, remoteSwagger.getPaths().keySet());
            }
            if (remoteSwagger.getPaths() != null) {
                remoteSwagger.getPaths().keySet().parallelStream()
                    .filter(s -> s.startsWith(path))
                    .forEach(p -> swagger.put(p, remoteSwagger.getPath(p)));
            }
            updateDefinitions(definitionsMap, securityDefinitionsMap, remoteSwagger);
        }
        ++k;
    }
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
/**
 * Update the current definition maps.
 * 
 * @param currentDefinitionsMap
 *            current definitions map
 * @param currentSecurityDefinitionsMap
 *            current security defintions map
 * @param swagger
 *            remote swagger data
 */
private void updateDefinitions(final Map<String, Model> currentDefinitionsMap,
    final Map<String, SecuritySchemeDefinition> currentSecurityDefinitionsMap,
    final Swagger swagger) {

    Optional.ofNullable(swagger.getDefinitions())
        .ifPresent(t -> t.entrySet().parallelStream()
            .forEach(e -> currentDefinitionsMap.put(e.getKey(), e.getValue())));

    Optional.ofNullable(swagger.getSecurityDefinitions())
        .ifPresent(t -> t.entrySet().parallelStream()
            .forEach(e -> currentSecurityDefinitionsMap.put(e.getKey(), e.getValue())));
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private static String getOAuth2Name() {
    String name = null;
    Map<String, SecuritySchemeDefinition> defMap = swagger.getSecurityDefinitions();
    if(defMap != null) {
        for(Map.Entry<String, SecuritySchemeDefinition> entry : defMap.entrySet()) {
            if(entry.getValue().getType().equals("oauth2")) {
                name = entry.getKey();
                break;
            }
        }
    }
    return name;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private AuthHandler getAuthHandler(String name) {
    AuthHandler authHandler = this.authHandlers.get(name);
    if (authHandler != null) {
        return authHandler;
    }

    AuthProvider authProvider = getAuthProviderFactory().getAuthProviderByName(name);
    if (authProvider == null) {
        return null;
    }

    SecuritySchemeDefinition securityScheme = this.securitySchemes.get(name);
    if(securityScheme != null) {
     switch (securityScheme.getType()) {
         case "apiKey":
             ApiKeyAuthDefinition apiKeyAuthDefinition = (ApiKeyAuthDefinition) securityScheme;
             Location apiKeyLocation = Location.valueOf(apiKeyAuthDefinition.getIn().name());
             authHandler = ApiKeyAuthHandler.create(authProvider, apiKeyLocation, apiKeyAuthDefinition.getName());
             break;
         case "basic":
             authHandler = BasicAuthHandler.create(authProvider);
             break;
         case "oauth2":
             vertxLogger.warn("OAuth2 authentication has not been implemented yet!");
             break;
         default:
             vertxLogger.warn("SecurityScheme is not authorized : " + securityScheme.getType());
             break;
     }
     
	
     if (authHandler != null) {
         this.authHandlers.put(name, authHandler);
     }
    } else {
        vertxLogger.warn("No securityScheme definition in swagger file for auth provider: " + name);
    }

    return authHandler;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private static SecuritySchemeDefinition toScheme(
    IssuerConfig issuerConfig, ImmutableSet<String> audiences) {
  OAuth2Definition tokenDef = new OAuth2Definition().implicit("");
  tokenDef.setVendorExtension("x-google-issuer", issuerConfig.getIssuer());
  if (!com.google.common.base.Strings.isNullOrEmpty(issuerConfig.getJwksUri())) {
    tokenDef.setVendorExtension("x-google-jwks_uri", issuerConfig.getJwksUri());
  }
  tokenDef.setVendorExtension("x-google-audiences", COMMA_JOINER.join(audiences));
  return tokenDef;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private static Map<String, SecuritySchemeDefinition> getOrCreateSecurityDefinitionMap(
    Swagger swagger) {
  Map<String, SecuritySchemeDefinition> securityDefinitions = swagger.getSecurityDefinitions();
  if (securityDefinitions == null) {
    securityDefinitions = new HashMap<>();
    swagger.setSecurityDefinitions(securityDefinitions);
  }
  return securityDefinitions;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
private static String addNonConflictingSecurityDefinition(
    Swagger swagger, IssuerConfig issuerConfig, ImmutableSet<String> audiences)
    throws ApiConfigException {
  Map<String, SecuritySchemeDefinition> securityDefinitions =
      getOrCreateSecurityDefinitionMap(swagger);
  String issuerPlusHash = String.format("%s-%x", issuerConfig.getName(), audiences.hashCode());
  SecuritySchemeDefinition existingDef = securityDefinitions.get(issuerConfig.getName());
  SecuritySchemeDefinition newDef = toScheme(issuerConfig, audiences);
  if (existingDef != null && !existingDef.equals(newDef)) {
    throw new ApiConfigException(
        "Multiple conflicting definitions found for issuer " + issuerConfig.getName());
  }
  swagger.securityDefinition(issuerPlusHash, newDef);
  return issuerPlusHash;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
@Override
public void afterScan(Reader reader, Swagger swagger) {
    OAuth2Definition tokenScheme = new OAuth2Definition();
    tokenScheme.setType("oauth2");
    tokenScheme.setFlow("application");
    tokenScheme.setTokenUrl("https://" + swagger.getHost() + "/oauth2/token");
    tokenScheme.setAuthorizationUrl("https://" + swagger.getHost() + "/oauth2/authorize");
    tokenScheme.addScope("write:everything", "Full access");

    Map<String, SecuritySchemeDefinition> schemes = new HashMap<>();
    schemes.put(TOKEN_AUTH_SCHEME, tokenScheme);

    swagger.setSecurityDefinitions(schemes);
   //TODO: Have to add wso2-scopes to swagger definition from here
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
/**
 * @param position           the current position
 * @param docBuilder         the MarkupDocBuilder
 * @param securitySchemeName the name of the current securityScheme
 * @param securityScheme     the current security scheme securityScheme
 */
public Context(Position position, MarkupDocBuilder docBuilder, String securitySchemeName, SecuritySchemeDefinition securityScheme) {
    super(docBuilder);
    Validate.inclusiveBetween(Position.SECURITY_SCHEME_BEFORE, Position.SECURITY_SCHEME_AFTER, position);
    Validate.notNull(securitySchemeName);
    Validate.notNull(securityScheme);
    this.position = position;
    this.securitySchemeName = securitySchemeName;
    this.securityScheme = securityScheme;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
public Parameters(String securitySchemeDefinitionName,
                  SecuritySchemeDefinition securitySchemeDefinition,
                  int titleLevel) {
    this.securitySchemeDefinitionName = Validate.notBlank(securitySchemeDefinitionName, "SecuritySchemeDefinitionName must not be empty");
    this.securitySchemeDefinition = Validate.notNull(securitySchemeDefinition, "SecuritySchemeDefinition must not be null");
    this.titleLevel = titleLevel;
}
 

import io.swagger.models.auth.SecuritySchemeDefinition; //导入依赖的package包/类
/**
 * Builds the security MarkupDocument.
 *
 * @return the security MarkupDocument
 */
@Override
public MarkupDocBuilder apply(MarkupDocBuilder markupDocBuilder, SecurityDocument.Parameters params) {
    Map<String, SecuritySchemeDefinition> definitions = params.securitySchemeDefinitions;
    if (MapUtils.isNotEmpty(definitions)) {
        applySecurityDocumentExtension(new Context(Position.DOCUMENT_BEFORE, markupDocBuilder));
        buildSecurityTitle(markupDocBuilder, labels.getLabel(SECURITY));
        applySecurityDocumentExtension(new Context(Position.DOCUMENT_BEGIN, markupDocBuilder));
        buildSecuritySchemeDefinitionsSection(markupDocBuilder, definitions);
        applySecurityDocumentExtension(new Context(Position.DOCUMENT_END, markupDocBuilder));
        applySecurityDocumentExtension(new Context(Position.DOCUMENT_AFTER, markupDocBuilder));
    }
    return markupDocBuilder;
}