org.openapitools.model.User Java Examples

@GET
    @Path("/{username}")
    
    @Produces({ "application/xml", "application/json" })
    @io.swagger.annotations.ApiOperation(value = "Get user by user name", notes = "", response = User.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = User.class),
        
        @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid username supplied", response = Void.class),
        
        @io.swagger.annotations.ApiResponse(code = 404, message = "User not found", response = Void.class) })
    public Response getUserByName(@ApiParam(value = "The name that needs to be fetched. Use user1 for testing.", required = true) @PathParam("username") @NotNull  String username
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.getUserByName(username, securityContext);
    }
 

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

@Produces({ "application/json" })
@io.swagger.annotations.ApiOperation(value = "", notes = "Retrieve authenticated user details for an organization", response = User.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 authenticated user details", response = User.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 getAuthenticatedUser( @PathParam("organization") String organization,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.getAuthenticatedUser(organization,securityContext);
}
 

@GET
    @Path("/{username}")
    
    @Produces({ "application/xml", "application/json" })
    @io.swagger.annotations.ApiOperation(value = "Get user by user name", notes = "", response = User.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = User.class),
        
        @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid username supplied", response = Void.class),
        
        @io.swagger.annotations.ApiResponse(code = 404, message = "User not found", response = Void.class) })
    public Response getUserByName(@ApiParam(value = "The name that needs to be fetched. Use user1 for testing.", required = true) @PathParam("username") @NotNull  String username
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.getUserByName(username, securityContext);
    }
 

/**
 * Creates list of users with given input array
 *
 */
@POST
@Path("/user/createWithArray")
@ApiOperation(value = "Creates list of users with given input array", tags={ "user",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
public void createUsersWithArrayInput(@Valid List<User> body);
 

/**
 * POST /user/createWithList : Creates list of users with given input array
 *
 * @param body List of user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Creates list of users with given input array", nickname = "createUsersWithListInput", notes = "", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@RequestMapping(value = "/user/createWithList",
    method = RequestMethod.POST)
ResponseEntity<Void> createUsersWithListInput(@ApiParam(value = "List of user object" ,required=true )  @Valid @RequestBody List<User> body);
 

@POST
@Path("/createWithArray")


@io.swagger.annotations.ApiOperation(value = "Creates list of users with given input array", notes = "", response = Void.class, tags={ "user", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Void.class) })
public Response createUsersWithArrayInput(@ApiParam(value = "List of user object" ,required=true) @NotNull @Valid List<User> body,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.createUsersWithArrayInput(body,securityContext);
}
 

@POST
    @Path("/createWithArray")
    
    
    @io.swagger.annotations.ApiOperation(value = "Creates list of users with given input array", notes = "", response = Void.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Void.class) })
    public Response createUsersWithArrayInput(@ApiParam(value = "List of user object", required = true) @NotNull @Valid  List<User> body
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.createUsersWithArrayInput(body, securityContext);
    }
 

/**
 * POST /user/createWithArray : Creates list of users with given input array
 *
 * @param body List of user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Creates list of users with given input array", nickname = "createUsersWithArrayInput", notes = "", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@RequestMapping(value = "/user/createWithArray",
    method = RequestMethod.POST)
default Mono<ResponseEntity<Void>> createUsersWithArrayInput(@ApiParam(value = "List of user object" ,required=true )  @Valid @RequestBody Flux<User> body, ServerWebExchange exchange) {
    return getDelegate().createUsersWithArrayInput(body, exchange);
}
 

@GET
@Path("/{username}")

@Produces({ "application/xml", "application/json" })
@io.swagger.annotations.ApiOperation(value = "Get user by user name", notes = "", response = User.class, tags={ "user", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = User.class),
    
    @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid username supplied", response = Void.class),
    
    @io.swagger.annotations.ApiResponse(code = 404, message = "User not found", response = Void.class) })
public Response getUserByName( @PathParam("username") String username,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.getUserByName(username,securityContext);
}
 

/**
 * POST /user : Create user
 * This can only be done by the logged in user.
 *
 * @param body Created user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Create user", nickname = "createUser", notes = "This can only be done by the logged in user.", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@RequestMapping(value = "/user",
    method = RequestMethod.POST)
default ResponseEntity<Void> createUser(@ApiParam(value = "Created user object" ,required=true )  @Valid @RequestBody User body) {
    return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

}
 

@GET
@Path("/rest/organizations/{organization}/users/")
@Produces({ "application/json" })
@ApiOperation(value = "", notes = "Retrieve users details for an organization", response = User.class, authorizations = {
    @Authorization(value = "jenkins_auth")
}, tags={ "blueOcean",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Successfully retrieved users details", response = User.class),
    @ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    @ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class)
})
public Response getUsers(@PathParam("organization") @ApiParam("Name of the organization") String organization) {
    return Response.ok().entity("magic!").build();
}
 

/**
 * POST /user/createWithList : Creates list of users with given input array
 *
 * @param body List of user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Creates list of users with given input array", nickname = "createUsersWithListInput", notes = "", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@RequestMapping(value = "/user/createWithList",
    method = RequestMethod.POST)
default CompletableFuture<ResponseEntity<Void>> createUsersWithListInput(@ApiParam(value = "List of user object" ,required=true )  @Valid @RequestBody List<User> body) {
    return CompletableFuture.completedFuture(new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED));

}
 

@GET
@Path("/rest/organizations/{organization}/users/{user}")
@Produces({ "application/json" })
@ApiOperation(value = "", notes = "Retrieve user details for an organization", response = User.class, authorizations = {
    @Authorization(value = "jenkins_auth")
}, tags={ "blueOcean",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Successfully retrieved users details", response = User.class),
    @ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password", response = Void.class),
    @ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password", response = Void.class)
})
public Response getUser(@PathParam("organization") @ApiParam("Name of the organization") String organization,@PathParam("user") @ApiParam("Name of the user") String user) {
    return Response.ok().entity("magic!").build();
}
 

@PUT
    @Path("/{username}")
    @Consumes({ "application/json" })
    
    @io.swagger.annotations.ApiOperation(value = "Updated user", notes = "This can only be done by the logged in user.", response = Void.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid user supplied", response = Void.class),
        
        @io.swagger.annotations.ApiResponse(code = 404, message = "User not found", response = Void.class) })
    public Response updateUser(@ApiParam(value = "name that need to be deleted", required = true) @PathParam("username") @NotNull  String username
,@ApiParam(value = "Updated user object", required = true) @NotNull @Valid  User user
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.updateUser(username, user, securityContext);
    }
 

/**
 * Updated user
 *
 * This can only be done by the logged in user.
 *
 * @throws ApiException
 *          if the Api call fails
 */
@Test
public void updateUserTest() {
    String username = null;
    User body = null;
    //api.updateUser(username, body);
    
    // TODO: test validations
    
    
}
 

/**
 * POST /user/createWithList : Creates list of users with given input array
 *
 * @param body List of user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Creates list of users with given input array", nickname = "createUsersWithListInput", notes = "", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@RequestMapping(value = "/user/createWithList",
    method = RequestMethod.POST)
default ResponseEntity<Void> createUsersWithListInput(@ApiParam(value = "List of user object" ,required=true )  @Valid @RequestBody List<User> body) {
    return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

}
 

@GET
@Path("/blue/rest/organizations/{organization}/users/{user}")
@Produces({ "application/json" })
@ApiOperation(value = "", tags={ "blueOcean",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Successfully retrieved users details", response = User.class),
    @ApiResponse(code = 401, message = "Authentication failed - incorrect username and/or password"),
    @ApiResponse(code = 403, message = "Jenkins requires authentication - please set username and password") })
public User getUser(@PathParam("organization") String organization, @PathParam("user") String user);
 

@POST
@Path("/createWithArray")


@io.swagger.annotations.ApiOperation(value = "Creates list of users with given input array", notes = "", response = Void.class, tags={ "user", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Void.class) })
public Response createUsersWithArrayInput(@ApiParam(value = "List of user object" ,required=true) @NotNull @Valid List<User> body,@Context SecurityContext securityContext);
 

@POST
@Path("/createWithArray")


@io.swagger.annotations.ApiOperation(value = "Creates list of users with given input array", notes = "", response = Void.class, tags={ "user",  })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Void.class) })
public Response createUsersWithArrayInput(
    @ApiParam(value = "List of user object", required = true) @NotNull @Valid  List<User> body,
    @Context SecurityContext securityContext)
throws NotFoundException {
    return delegate.createUsersWithArrayInput(body,securityContext);
}
 

@POST
@Path("/createWithList")


@ApiOperation(value = "Creates list of users with given input array", notes = "", response = Void.class, tags={ "user",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation", response = Void.class) })
public Response createUsersWithListInput(@ApiParam(value = "List of user object" ,required=true) List<User> body) {
    return delegate.createUsersWithListInput(body, securityContext);
}
 

/**
 * POST /user/createWithArray : Creates list of users with given input array
 *
 * @param body List of user object (required)
 * @return successful operation (status code 200)
 */
@ApiOperation(value = "Creates list of users with given input array", nickname = "createUsersWithArrayInput", notes = "", tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
@ApiImplicitParams({
})
@RequestMapping(value = "/user/createWithArray",
    method = RequestMethod.POST)
default ResponseEntity<Void> createUsersWithArrayInput(@ApiParam(value = "List of user object" ,required=true )  @Valid @RequestBody List<User> body) {
    return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

}
 

@GET
@Path("/{username}")
@Produces({ "application/xml", "application/json" })
@ApiOperation(value = "Get user by user name", notes = "", tags={ "user",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation", response = User.class),
    @ApiResponse(code = 400, message = "Invalid username supplied", response = Void.class),
    @ApiResponse(code = 404, message = "User not found", response = Void.class) })
Response getUserByName(@PathParam("username") @ApiParam("The name that needs to be fetched. Use user1 for testing.") String username);
 

@PUT
@Path("/{username}")
@ApiOperation(value = "Updated user", notes = "This can only be done by the logged in user.", tags={ "user" })
@ApiResponses(value = { 
    @ApiResponse(code = 400, message = "Invalid user supplied", response = Void.class),
    @ApiResponse(code = 404, message = "User not found", response = Void.class) })
Response updateUser(@PathParam("username") @ApiParam("name that need to be deleted") String username,@Valid User body);
 

@PUT
@Path("/body-with-query-params")
@Consumes({ "application/json" })
@ApiOperation(value = "", notes = "", tags={ "fake",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Success", response = Void.class) })
Response testBodyWithQueryParams(@QueryParam("query") @NotNull    String query,@Valid User body);
 

/**
 * PUT /fake/body-with-query-params
 *
 * @param query  (required)
 * @param body  (required)
 * @return Success (status code 200)
 */
@ApiOperation(value = "", nickname = "testBodyWithQueryParams", notes = "", tags={ "fake", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "Success") })
@RequestMapping(value = "/fake/body-with-query-params",
    consumes = { "application/json" },
    method = RequestMethod.PUT)
default ResponseEntity<Void> testBodyWithQueryParams(@NotNull @ApiParam(value = "", required = true) @Valid @RequestParam(value = "query", required = true) String query,@ApiParam(value = "" ,required=true )  @Valid @RequestBody User body) {
    return new ResponseEntity<>(HttpStatus.NOT_IMPLEMENTED);

}
 

/**
 * GET /user/{username} : Get user by user name
 *
 * @param username The name that needs to be fetched. Use user1 for testing. (required)
 * @return successful operation (status code 200)
 *         or Invalid username supplied (status code 400)
 *         or User not found (status code 404)
 */
@ApiOperation(value = "Get user by user name", nickname = "getUserByName", notes = "", response = User.class, tags={ "user", })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation", response = User.class),
    @ApiResponse(code = 400, message = "Invalid username supplied"),
    @ApiResponse(code = 404, message = "User not found") })
@RequestMapping(value = "/user/{username}",
    produces = { "application/xml", "application/json" }, 
    method = RequestMethod.GET)
ResponseEntity<User> getUserByName(@ApiParam(value = "The name that needs to be fetched. Use user1 for testing.",required=true) @PathVariable("username") String username);
 

@POST
@ApiOperation(value = "Create user", notes = "This can only be done by the logged in user.", response = Void.class, tags={ "user",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation", response = Void.class)
})
public Response createUser(@Valid User body) {
    return Response.ok().entity("magic!").build();
}
 

/**
 * Creates list of users with given input array
 *
 */
@POST
@Path("/user/createWithList")
@Consumes({ "application/json" })
@ApiOperation(value = "Creates list of users with given input array", tags={ "user",  })
@ApiResponses(value = { 
    @ApiResponse(code = 200, message = "successful operation") })
public void createUsersWithListInput(@Valid List<User> body);
 

@POST



@io.swagger.annotations.ApiOperation(value = "Create user", notes = "This can only be done by the logged in user.", response = Void.class, tags={ "user", })
@io.swagger.annotations.ApiResponses(value = { 
    @io.swagger.annotations.ApiResponse(code = 200, message = "successful operation", response = Void.class) })
public Response createUser(@ApiParam(value = "Created user object" ,required=true) @NotNull @Valid User body,@Context SecurityContext securityContext)
throws NotFoundException {
    return service.createUser(body,securityContext);
}
 

@PUT
    @Path("/{username}")
    
    
    @io.swagger.annotations.ApiOperation(value = "Updated user", notes = "This can only be done by the logged in user.", response = Void.class, tags={ "user", })
    @io.swagger.annotations.ApiResponses(value = { 
        @io.swagger.annotations.ApiResponse(code = 400, message = "Invalid user supplied", response = Void.class),
        
        @io.swagger.annotations.ApiResponse(code = 404, message = "User not found", response = Void.class) })
    public Response updateUser(@ApiParam(value = "name that need to be deleted", required = true) @PathParam("username") @NotNull  String username
,@ApiParam(value = "Updated user object", required = true) @NotNull @Valid  User body
,@Context SecurityContext securityContext)
    throws NotFoundException {
        return delegate.updateUser(username, body, securityContext);
    }