javax.ws.rs.core.SecurityContext Java Examples

@GET
@Path("/rest/organizations/{organization}/pipelines/{pipeline}/runs")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "", notes = "Retrieve all runs details for an organization pipeline", response = PipelineRuns.class, authorizations = {
    @io.swagger.annotations.Authorization(value = "jenkins_auth")
}, tags={ "blueOcean", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "Successfully retrieved runs details", response = PipelineRuns.class),
    
    @io.swagger.annotations.ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    
    @io.swagger.annotations.ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class) })
public Response getPipelineRuns( @PathParam("organization") String organization, @PathParam("pipeline") String pipeline,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.getPipelineRuns(organization,pipeline,securityContext);
}
 

@POST
@Path("/{questionnaireId}/answer")
@Consumes(MediaType.APPLICATION_JSON)
@ApiOperation(value = "Allow the respondent save answers")
@ApiResponses(value = { @ApiResponse(code = 404, message = "Invalid invitation token supplied"),
        @ApiResponse(code = 200, message = "Answer saved correctly") })
public Response saveAnswer(@ApiParam(value = "Answer", required = true)
Answer answer, @Context
final SecurityContext context, @PathParam("questionnaireId")
@ApiParam(value = "Questionnair id", required = true)
Integer questionnaireId, @QueryParam("questionCode")
@ApiParam(value = "Question Code", required = true)
String questionCode) {
    logger.debug("New attempt for saving answer from {}", context.getUserPrincipal().getName());
    try {
        questionnairFacade.saveAnswer(questionnaireId, questionCode, answer);
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
        throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
    }
    return Response.ok().build();
}
 

@POST
@Path("/services/{serviceId}/configurations")
@Timed
public Response addServiceConfiguration(@PathParam("serviceId") Long serviceId, ServiceConfiguration serviceConfiguration,
                                        @Context SecurityContext securityContext) {
    SecurityUtil.checkPermissions(authorizer, securityContext, Cluster.NAMESPACE, getClusterId(serviceId), WRITE);
    // just overwrite the service id to given path param
    serviceConfiguration.setServiceId(serviceId);

    Service service = environmentService.getService(serviceId);
    if (service == null) {
        throw EntityNotFoundException.byId("service: " + serviceId.toString());
    }

    String configurationName = serviceConfiguration.getName();
    ServiceConfiguration result = environmentService.getServiceConfigurationByName(serviceId, configurationName);
    if (result != null) {
        throw EntityAlreadyExistsException.byName("service id " +
            serviceId + " and configuration name " + configurationName);
    }

    ServiceConfiguration createdConfiguration = environmentService.addServiceConfiguration(serviceConfiguration);
    return WSUtils.respondEntity(createdConfiguration, CREATED);
}
 

@POST
@Path("/topologies/{topologyId}/versions/{versionId}/actions/suspend")
@Timed
public Response suspendTopologyVersion(@PathParam("topologyId") Long topologyId,
                                       @PathParam("versionId") Long versionId,
                                       @Context SecurityContext securityContext) throws Exception {
    SecurityUtil.checkRoleOrPermissions(authorizer, securityContext, Roles.ROLE_TOPOLOGY_SUPER_ADMIN,
            NAMESPACE, topologyId, READ, EXECUTE);
    Topology result = catalogService.getTopology(topologyId, versionId);
    if (result != null) {
        actionsService.suspendTopology(result, WSUtils.getUserFromSecurityContext(securityContext));
        return WSUtils.respondEntity(result, OK);
    }

    throw EntityNotFoundException.byVersion(topologyId.toString(), versionId.toString());
}
 

@POST
    @Path("/{petId}/uploadImage")
    @Consumes({ "multipart/form-data" })
    @Produces({ "application/json" })
    @io.swagger.annotations.ApiOperation(value = "uploads an image", notes = "", response = ModelApiResponse.class, authorizations = {
        @io.swagger.annotations.Authorization(value = "petstore_auth", scopes = {
            @io.swagger.annotations.AuthorizationScope(scope = "write:pets", description = "modify pets in your account"),
            @io.swagger.annotations.AuthorizationScope(scope = "read:pets", description = "read your pets")
        })
    }, tags={ "pet", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = ModelApiResponse.class) })
    public Response uploadFile(@ApiParam(value = "ID of pet to update", required = true) @PathParam("petId") @NotNull  Long petId
,@ApiParam(value = "Additional data to pass to server")@FormDataParam("additionalMetadata")  String additionalMetadata
,
            @FormDataParam("file") InputStream fileInputStream,
            @FormDataParam("file") FormDataContentDisposition fileDetail
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.uploadFile(petId, additionalMetadata, fileInputStream, fileDetail, securityContext);
    }
 

@Override
public void filter(final ContainerRequestContext requestContext) throws IOException {
    requestContext.setSecurityContext(new SecurityContext() {
        @Override
        public Principal getUserPrincipal() {
            return () -> USER_NAME;
        }
        @Override
        public boolean isUserInRole(String string) {
            return true;
        }
        @Override
        public boolean isSecure() { return true; }
        @Override
        public String getAuthenticationScheme() { return "BASIC"; }
    });
}
 

@PUT
@Path("/services/{serviceId}/components")
@Timed
public Response addOrUpdateComponent(@PathParam("serviceId") Long serviceId, Component component,
                                     @Context SecurityContext securityContext) {
    SecurityUtil.checkPermissions(authorizer, securityContext, Cluster.NAMESPACE, getClusterId(serviceId), WRITE);
    // overwrite service id to given path param
    component.setServiceId(serviceId);

    Service service = environmentService.getService(serviceId);
    if (service == null) {
        throw EntityNotFoundException.byId("service: " + serviceId.toString());
    }

    Component createdComponent = environmentService.addOrUpdateComponent(serviceId, component);
    return WSUtils.respondEntity(createdComponent, CREATED);
}
 

@GET
@Path("/rest/users/{user}/favorites")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "", notes = "Retrieve user favorites details for an organization", response = UserFavorites.class, authorizations = {
    @io.swagger.annotations.Authorization(value = "jenkins_auth")
}, tags={ "blueOcean", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "Successfully retrieved users favorites details", response = UserFavorites.class),
    
    @io.swagger.annotations.ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    
    @io.swagger.annotations.ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class) })
public Response getUserFavorites( @PathParam("user") String user,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.getUserFavorites(user,securityContext);
}
 

@POST
    @Path("/{name}.rw.html")
    
    
    @io.swagger.annotations.ApiOperation(value = "", notes = "", response = Void.class, authorizations = {
        @io.swagger.annotations.Authorization(value = "aemAuth")
    }, tags={ "sling", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "Default response", response = Void.class) })
    public Response postNodeRw(@ApiParam(value = "",required=true) @PathParam("path") String path
,@ApiParam(value = "",required=true) @PathParam("name") String name
,@ApiParam(value = "") @QueryParam("addMembers") String addMembers
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.postNodeRw(path,name,addMembers,securityContext);
    }
 

@GET
@Path("/schemas/{name}/branches")
@ApiOperation(value = "Get list of registered schema branches",
        response = SchemaBranch.class, responseContainer = "List",
        tags = OPERATION_GROUP_OTHER)
@Timed
@UnitOfWork
public Response getAllBranches(@ApiParam(value = "Details about schema name",required = true) @PathParam("name") String schemaName,
                               @Context UriInfo uriInfo,
                               @Context SecurityContext securityContext) {
    try {
        Collection<SchemaBranch> schemaBranches = authorizationAgent.authorizeGetAllBranches(AuthorizationUtils.getUserAndGroups(securityContext),
                schemaRegistry, schemaName, schemaRegistry.getSchemaBranches(schemaName));
        return WSUtils.respondEntities(schemaBranches, Response.Status.OK);
    }  catch(SchemaNotFoundException e) {
        return WSUtils.respond(Response.Status.NOT_FOUND, CatalogResponse.ResponseMessage.ENTITY_NOT_FOUND, schemaName);
    } catch (Exception ex) {
        LOG.error("Encountered error while listing schema branches", ex);
        return WSUtils.respond(Response.Status.INTERNAL_SERVER_ERROR, CatalogResponse.ResponseMessage.EXCEPTION, ex.getMessage());
    }
}
 

@GET
@Path("/topologies/{topologyId}/testhistories/{historyId}")
@Timed
public Response getHistoryOfTestRunTopology (@Context UriInfo urlInfo,
                                             @PathParam("topologyId") Long topologyId,
                                             @PathParam("historyId") Long historyId,
                                             @QueryParam("simplify") Boolean simplify,
                                             @Context SecurityContext securityContext) throws Exception {
    SecurityUtil.checkRoleOrPermissions(authorizer, securityContext, Roles.ROLE_TOPOLOGY_USER,
            Topology.NAMESPACE, topologyId, READ);

    TopologyTestRunHistory history = catalogService.getTopologyTestRunHistory(historyId);

    if (history == null) {
        throw EntityNotFoundException.byId(String.valueOf(historyId));
    }

    if (!history.getTopologyId().equals(topologyId)) {
        throw BadRequestException.message("Test history " + historyId + " is not belong to topology " + topologyId);
    }

    if (BooleanUtils.isTrue(simplify)) {
        return WSUtils.respondEntity(new SimplifiedTopologyTestRunHistory(history), OK);
    } else {
        return WSUtils.respondEntity(history, OK);
    }
}
 

@Test
public void getArticle_NonSupportedAccept_ShouldReturnNotAcceptable() throws IOException {
	when(testService.getArticle(1)).thenReturn("some article");
	JRestlessResponseWriter responseWriter = createResponseWriterMock();
	TestRequest req = new TestRequest("/articles/1", "GET");
	req.getHeadersAsMultimap().add("Accept", MediaType.APPLICATION_XML);
	container.handleRequest(req, responseWriter, mock(SecurityContext.class));
	verify(responseWriter, times(1)).writeResponse(eq(Status.NOT_ACCEPTABLE), any(), emptyBaos());
}
 

@GET
@Path("/echo")
@RolesAllowed("Echoer")
public String echo(@Context SecurityContext sec, @QueryParam("input") String input) {
    Principal user = sec.getUserPrincipal();
    return input + ", user="+user.getName();
}
 

@GET
    @Path("/login")
    
    @Produces({ "application/xml", "application/json" })
    @io.swagger.annotations.ApiOperation(value = "Logs user into the system", notes = "", response = String.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = String.class),
        
        @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid username/password supplied", response = Void.class) })
    public Response loginUser(@ApiParam(value = "The user name for login", required = true) @QueryParam("username") @NotNull  String username
,@ApiParam(value = "The password for login in clear text", required = true) @QueryParam("password") @NotNull  String password
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.loginUser(username, password, securityContext);
    }
 

private boolean isAccessAllowed(List<Role> allowedRoles, SecurityContext securityContext) {
  for (Role allowedRole : allowedRoles) {
    if (securityContext.isUserInRole(allowedRole.name())) {
      return true;
    }
  }
  return false;
}
 

@Test
void testAdminRoles() {
    final SecurityContext mockDelegate = mock(SecurityContext.class);
    final String iss = "https://example.com/idp/";
    final String sub = "acoburn";
    final JwtClaims claims = new JwtClaims();
    claims.setSubject(sub);
    claims.setIssuer(iss);
    final JsonWebToken principal = new DefaultJWTCallerPrincipal(claims);

    final SecurityContext ctx = new WebIdSecurityContext(mockDelegate, principal, singleton(iss + sub));
    assertTrue(ctx.isUserInRole(WebIdSecurityContext.ADMIN_ROLE));
    assertFalse(ctx.isUserInRole("other-role"));
}
 

@POST
    @Path("/outer/composite")
    
    @Produces({ "*/*" })
    @io.swagger.annotations.ApiOperation(value = "", notes = "Test serialization of object with outer number type", response = OuterComposite.class, tags={ "fake", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "Output composite", response = OuterComposite.class) })
    public Response fakeOuterCompositeSerialize(@ApiParam(value = "Input composite as post body") @Valid  OuterComposite body
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.fakeOuterCompositeSerialize(body, securityContext);
    }
 

@GET()
@Path("permit-all")
@PermitAll
@Produces(MediaType.TEXT_PLAIN)
public String hello(@Context SecurityContext ctx) {
    Principal caller = ctx.getUserPrincipal();
    String name = caller == null ? "anonymous" : caller.getName();
    String helloReply = String.format("hello + %s, isSecure: %s, authScheme: %s", name, ctx.isSecure(),
            ctx.getAuthenticationScheme());
    return helloReply;
}
 

@GET
@Path("/inventory")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "Returns pet inventories by status", notes = "Returns a map of status codes to quantities", response = Integer.class, responseContainer = "Map", authorizations = {
    @io.swagger.annotations.Authorization(value = "api_key")
}, tags={ "store",  })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Map.class, responseContainer = "Map") })
public Response getInventory(
    @Context SecurityContext securityContext)
throws NotFoundException {
    return delegate.getInventory(securityContext);
}
 

@Path("/pipeline/{pipelineId}/stop")
@POST
@ApiOperation(value = "Stop Pipeline", response = PipelineStateJson.class,
  authorizations = @Authorization(value = "basic"))
@Produces(MediaType.APPLICATION_JSON)
@RolesAllowed({
    AuthzRole.MANAGER,
    AuthzRole.ADMIN,
    AuthzRole.MANAGER_REMOTE,
    AuthzRole.ADMIN_REMOTE
})
public Response stopPipeline(
  @PathParam("pipelineId") String pipelineId,
  @QueryParam("rev") @DefaultValue("0") String rev,
  @Context SecurityContext context
) throws PipelineException {
  PipelineInfo pipelineInfo = store.getInfo(pipelineId);
  RestAPIUtils.injectPipelineInMDC(pipelineInfo.getTitle(), pipelineInfo.getPipelineId());
  if (manager.isRemotePipeline(pipelineId, rev) && !context.isUserInRole(AuthzRole.ADMIN) &&
      !context.isUserInRole(AuthzRole.ADMIN_REMOTE)) {
    throw new PipelineException(ContainerError.CONTAINER_01101, "STOP_PIPELINE", pipelineId);
  }
  Runner runner = manager.getRunner(pipelineId, rev);
  Utils.checkState(runner.getState().getExecutionMode() != ExecutionMode.SLAVE,
    "This operation is not supported in SLAVE mode");
  runner.stop(user);
  return Response.ok()
      .type(MediaType.APPLICATION_JSON)
      .entity(BeanHelper.wrapPipelineState(runner.getState())).build();
}
 

@ResourceSecurity(WEB_UI)
@POST
@Path(UI_LOGIN)
public Response login(
        @FormParam("username") String username,
        @FormParam("password") String password,
        @FormParam("redirectPath") String redirectPath,
        @Context SecurityContext securityContext)
{
    username = emptyToNull(username);
    password = emptyToNull(password);
    redirectPath = emptyToNull(redirectPath);

    if (!formWebUiAuthenticationManager.isAuthenticationEnabled(securityContext.isSecure())) {
        return Response.seeOther(DISABLED_LOCATION_URI).build();
    }

    Optional<NewCookie> authenticationCookie = formWebUiAuthenticationManager.checkLoginCredentials(username, password, securityContext.isSecure());
    if (!authenticationCookie.isPresent()) {
        // authentication failed, redirect back to the login page
        return Response.seeOther(LOGIN_FORM_URI).build();
    }

    return redirectFromSuccessfulLoginResponse(redirectPath)
            .cookie(authenticationCookie.get())
            .build();
}
 

@GET
@Path("/rest/search/")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "", notes = "Search for any resource details", response = String.class, authorizations = {
    @io.swagger.annotations.Authorization(value = "jenkins_auth")
}, tags={ "blueOcean", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "Successfully retrieved search result", response = String.class),
    
    @io.swagger.annotations.ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    
    @io.swagger.annotations.ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class) })
public Response search( @NotNull @QueryParam("q") String q,@Context SecurityContext securityContext);
 

@POST
@Path("/roles")
@Timed
public Response addRole(Role role, @Context SecurityContext securityContext) {
    SecurityUtil.checkRole(authorizer, securityContext, ROLE_SECURITY_ADMIN);
    Role createdRole = catalogService.addRole(role);
    return WSUtils.respondEntity(createdRole, CREATED);
}
 

@GET
@Path("/rest/organizations/{organization}/scm/{scm}")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "", notes = "Retrieve SCM details for an organization", response = GithubScm.class, authorizations = {
    @io.swagger.annotations.Authorization(value = "jenkins_auth")
}, tags={ "blueOcean", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "Successfully retrieved SCM details", response = GithubScm.class),
    
    @io.swagger.annotations.ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    
    @io.swagger.annotations.ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class) })
public Response getSCM( @PathParam("organization") String organization, @PathParam("scm") String scm,@Context SecurityContext securityContext);
 

@GET
@Path("/networks/network/{networkId}/node/{nodeId}/")
@Consumes({ "application/json" })
@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "Retrieve node by ID", notes = "Retrieve operation of resource: node", response = NodeSchema.class, tags={  })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "Successful operation", response = NodeSchema.class),
    @io.swagger.annotations.ApiResponse(code = 400, message = "Internal Error", response = NodeSchema.class) })
public Response retrieveNetworksNetworkNodeNodeById(
    @ApiParam(value = "ID of networkId",required=true) @PathParam("networkId") String networkId,
    @ApiParam(value = "ID of nodeId",required=true) @PathParam("nodeId") String nodeId,
    @Context SecurityContext securityContext)
throws NotFoundException {
    return delegate.retrieveNetworksNetworkNodeNodeById(networkId,nodeId,securityContext);
}
 

@GET
@Path("/inventory")

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "Returns pet inventories by status", notes = "Returns a map of status codes to quantities", response = Integer.class, responseContainer = "Map", authorizations = {
    @io.swagger.annotations.Authorization(value = "api_key")
}, tags={ "store", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Map.class, responseContainer = "Map") })
public Response getInventory(@Context SecurityContext securityContext);
 

@DELETE
@Path("/{petId}")


@io.swagger.annotations.ApiOperation(value = "Deletes a pet", notes = "", response = Void.class, authorizations = {
    @io.swagger.annotations.Authorization(value = "petstore_auth", scopes = {
        @io.swagger.annotations.AuthorizationScope(scope = "write:pets", description = "modify pets in your account"),
        @io.swagger.annotations.AuthorizationScope(scope = "read:pets", description = "read your pets")
    })
}, tags={ "pet", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid pet value", response = Void.class) })
public Response deletePet( @PathParam("petId") Long petId,  @ApiParam(value = "" ) @HeaderParam("api_key") String apiKey,@Context SecurityContext securityContext);
 

@PUT
@Path("/acls/{id}")
@Timed
public Response addOrUpdateAcl(@PathParam("id") Long aclId, AclEntry aclEntry, @Context SecurityContext securityContext) {
    mayBeFillSidId(aclEntry);
    checkAclOp(aclEntry, securityContext, this::shouldAllowAclAddOrUpdate);
    AclEntry newAclEntry = catalogService.addOrUpdateAcl(aclId, aclEntry);
    return WSUtils.respondEntity(newAclEntry, OK);
}
 

@PATCH
    
    @Consumes({ "application/json" })
    @Produces({ "application/json" })
    @io.swagger.annotations.ApiOperation(value = "To test class name in snake case", notes = "To test class name in snake case", response = Client.class, authorizations = {
        @io.swagger.annotations.Authorization(value = "api_key_query")
    }, tags={ "fake_classname_tags 123#$%^", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Client.class) })
    public Response testClassname(@ApiParam(value = "client model", required = true) @NotNull @Valid  Client body
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.testClassname(body, securityContext);
    }
 

@PUT
@Path("/namespaces/{id}")
@Timed
public Response addOrUpdateNamespace(@PathParam("id") Long namespaceId,
    Namespace namespace, @Context SecurityContext securityContext) {
  SecurityUtil.checkRoleOrPermissions(authorizer, securityContext, Roles.ROLE_ENVIRONMENT_SUPER_ADMIN,
          Namespace.NAMESPACE, namespaceId, WRITE);
  try {
    Namespace newNamespace = environmentService.addOrUpdateNamespace(namespaceId, namespace);
    return WSUtils.respondEntity(newNamespace, OK);
  } catch (ProcessingException ex) {
    throw BadRequestException.of();
  }
}