Example usage for org.springframework.http ResponseEntity created

List of usage examples for org.springframework.http ResponseEntity created

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.http.*
  5. ResponseEntity
  6. created

Introduction

In this page you can find the example usage for org.springframework.http ResponseEntity created.

Prototype

public static BodyBuilder created(URI location)

Source Link

Document

Create a new builder with a HttpStatus#CREATED CREATED status and a location header set to the given URI.

Usage

From source file:capital.scalable.restdocs.example.items.ItemResource.java

/**
 * Adds new item.//from  ww w.ja v a 2s.  c o m
 *
 * @param itemUpdate item information
 */
@RequestMapping(method = POST)
public ResponseEntity<Void> addItem(@RequestBody @Valid ItemUpdateRequest itemUpdate)
        throws URISyntaxException {
    // New item with unique ID is stored and returned.
    URI location = ServletUriComponentsBuilder.fromUriString("/items").path("/{id}").buildAndExpand("2")
            .toUri();

    return ResponseEntity.created(location).body(null);
}

From source file:org.n52.restfulwpsproxy.webapp.rest.ProcessController.java

@RequestMapping(value = "/{processId:.+}/jobs", method = RequestMethod.POST)
public ResponseEntity<?> execute(@PathVariable("processId") String processId,
        @RequestParam(value = "sync-execute", required = false, defaultValue = "false") boolean syncExecute,
        @RequestBody ExecuteDocument executeDocument, HttpServletRequest request) throws URISyntaxException {

    if (!syncExecute) {
        executeDocument.getExecute().setMode(ExecuteRequestType.Mode.Enum.forString("async"));
        StatusInfoDocument asyncExecute = executeClient.asyncExecute(processId, executeDocument);

        String jobId = asyncExecute.getStatusInfo().getJobID();

        URI created = URI.create(request.getRequestURL().append("/").append(jobId).toString());

        getJobsClient.addJobId(processId, jobId);

        return ResponseEntity.created(created).build();
    } else {//from w w w . j  a v  a  2  s. c  o  m
        executeDocument.getExecute().setMode(ExecuteRequestType.Mode.Enum.forString("sync"));
        ResultDocument execute = executeClient.syncExecute(processId, executeDocument);

        return ResponseEntity.ok(execute);
    }
}

From source file:io.pivotal.strepsirrhini.chaosloris.web.ChaosController.java

@Transactional
@RequestMapping(method = POST, value = "", consumes = APPLICATION_JSON_VALUE)
public ResponseEntity create(@Valid @RequestBody ChaosCreateInput input) {
    Application application = getApplication(input.getApplication(), this.applicationRepository);
    Schedule schedule = getSchedule(input.getSchedule(), this.scheduleRepository);

    Chaos chaos = new Chaos(application, input.getProbability(), schedule);
    this.chaosRepository.saveAndFlush(chaos);

    return ResponseEntity.created(linkTo(methodOn(ChaosController.class).read(chaos.getId())).toUri()).build();
}

From source file:com.couchbase.trombi.controllers.CoworkerController.java

@RequestMapping(value = "/", method = RequestMethod.POST)
public ResponseEntity<?> createCoworker(@RequestBody Map<String, Object> body) {
    String name;//  w w w.j  a v a2 s  . c om
    String description;
    String team;
    Set<String> skills = new HashSet<>();
    Map<String, String> imHandles;
    Location mainLocation;
    try {
        if (body.containsKey("skills")) {
            skills.addAll((Collection<String>) body.get("skills"));
        }

        imHandles = (Map<String, String>) body.get("imHandles");

        Map<String, Object> mainLocationMap = (Map<String, Object>) body.get("mainLocation");
        Map<String, Object> mainLocationCoord = (Map<String, Object>) mainLocationMap.get("coordinates");
        double x = ((Number) mainLocationCoord.get("x")).doubleValue();
        double y = ((Number) mainLocationCoord.get("y")).doubleValue();
        mainLocation = new Location((String) mainLocationMap.get("name"),
                (String) mainLocationMap.get("description"), (int) mainLocationMap.get("timeZoneOffset"),
                new Point(x, y));

        name = (String) body.get("name");
        description = (String) body.get("description");
        team = (String) body.get("team");

    } catch (Exception e) {
        return ResponseEntity.badRequest().body("Malformed Coworker creation data, error: " + e.toString());
    }

    //generate an ID
    Long sequence = bucket.counter("coworkerSequence", 1, TrombinoscopeApplication.RESERVED_IDS + 1).content();
    String id = CoworkerRepository.PREFIX + sequence.longValue();

    Coworker coworker = new Coworker(id, name, description, team, skills, imHandles, mainLocation, null);

    repository.save(coworker);

    final URI location = ServletUriComponentsBuilder.fromCurrentServletMapping().path("/{id}").build()
            .expand(id).toUri();

    return ResponseEntity.created(location).body(coworker);
}

From source file:co.bluepass.web.rest.ClubResource.java

/**
 * Create response entity./*from   w w w . j  ava 2  s.co  m*/
 *
 * @param dto the dto
 * @return the response entity
 * @throws URISyntaxException the uri syntax exception
 */
@RequestMapping(value = "/clubs", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
@Timed
public ResponseEntity<Void> create(@Valid @RequestBody ClubDTO dto) throws URISyntaxException {
    log.debug("REST request to save Club Information : {}", dto);
    if (dto.getId() != null) {
        return ResponseEntity.badRequest()
                .header("Failure", "?? ? ?  .").build();
    }

    CommonCode category = dto.getCategory();

    Club club = new Club(null, dto.getName(), dto.getLicenseNumber(), dto.getPhoneNumber(), dto.getZipcode(),
            dto.getAddress1(), dto.getAddress2(), dto.getOldAddress(), dto.getAddressSimple(),
            dto.getDescription(), dto.getHomepage(), dto.getOnlyFemale(), category, dto.getManagerMobile(),
            dto.getNotificationType(), dto.getReservationClose());

    User loginUser = userRepository.findOneByEmail(SecurityUtils.getCurrentLogin());
    club.setCreator(loginUser);

    Club saved = clubRepository.save(club);

    List<CommonCode> featureCodes = null;
    if (dto.getFeatures() != null) {
        //featureCodes = commonCodeRepository.findByNameIn(dto.getFeatures());
        featureCodes = commonCodeRepository.findAll(Arrays.asList(dto.getFeatures()));
        if (featureCodes != null && !featureCodes.isEmpty()) {
            List<Feature> features = new ArrayList<Feature>();
            for (CommonCode featureCode : featureCodes) {
                features.add(new Feature(saved, featureCode));
            }
            featureRepository.save(features);
        }
    }

    try {
        if (StringUtils.isNotEmpty(saved.getOldAddress())) {
            addressIndexRepository.save(new AddressIndex(saved.getOldAddress()));
        }

    } catch (Exception e) {
        e.printStackTrace();
    }

    return ResponseEntity.created(new URI("/api/clubs/" + club.getId())).build();
}

From source file:com.leqcar.interfaces.command.ValetCommandController.java

@RequestMapping(method = RequestMethod.POST)
public ResponseEntity<ValetResponse> requestValet(@RequestBody VehicleInfoResource vehicleInfoResource) {
    LOG.log(Level.INFO, "-- requesting valet service ---");

    Validate.notNull(vehicleInfoResource, "Vehicle should not be null");
    Validate.notNull(vehicleInfoResource.getDriverInfo(), "Vehicle should have a Driver");

    ValetResponse response = valetCommandService.requestValet(new Vehicle(vehicleInfoResource.getPlateNumber(),
            toDriverModel(vehicleInfoResource.getDriverInfo())));
    URI location = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}")
            .buildAndExpand(response.getValetId()).toUri();

    response.add(linkTo(ValetCommandController.class).slash(response.getValetId()).withSelfRel());
    response.add(linkTo(methodOn(ValetCommandController.class).cancelValetRequest(response.getValetId()))
            .withRel("cancel"));
    /*response.add(linkTo(methodOn(ValetCommandController.class)
    .acceptValetRequest(response.getValetId(), new ValetAttendantInfo()))
    .withRel("accept"));*//*  ww  w. ja v a2s  . c  o m*/

    return ResponseEntity.created(location).body(response);

}

From source file:org.esupportail.publisher.web.rest.SubscriberResource.java

/**
 * POST /subscribers -> Create a new subscriber.
 *//*from w  w w  .j  av a2  s. c  om*/
@RequestMapping(value = "/subscribers", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)
@PreAuthorize(SecurityConstants.IS_ROLE_ADMIN + " || " + SecurityConstants.IS_ROLE_USER
        + " && @permissionService.canEditCtxTargets(authentication, #subscriber.subjectCtxId.context)")
@Timed
public ResponseEntity<Void> create(@Validated @RequestBody Subscriber subscriber)
        throws URISyntaxException, UnsupportedEncodingException {
    log.debug("REST request to save Subscriber : {}", subscriber);
    if (subscriberRepository.findOne(subscriber.getId()) != null) {
        return ResponseEntity.badRequest().header("Failure", "The subscriber should not already exist").build();
    }
    // TODO: check if the context can support subscribers
    EnumSet<ContextType> ctxTypes = EnumSet.of(ContextType.ORGANIZATION, ContextType.PUBLISHER);
    boolean subscribersOnCtx = false;
    switch (subscriber.getSubjectCtxId().getContext().getKeyType()) {
    case ORGANIZATION:
        subscribersOnCtx = true;
        break;
    case PUBLISHER:
        subscribersOnCtx = true;
        break;
    case CATEGORY:

    case FEED:
        AbstractClassification classif = classificationRepository
                .findOne(subscriber.getSubjectCtxId().getContext().getKeyId());
        if (classif != null
                && !WritingMode.TARGETS_ON_ITEM
                        .equals(classif.getPublisher().getContext().getRedactor().getWritingMode())
                && classif.getPublisher().isHasSubPermsManagement()) {
            subscribersOnCtx = true;
        }
        break;
    case ITEM:
        AbstractItem item = itemRepository.findOne(subscriber.getSubjectCtxId().getContext().getKeyId());
        if (item != null && WritingMode.TARGETS_ON_ITEM.equals(item.getRedactor().getWritingMode())) {
            subscribersOnCtx = true;
        }
        break;
    default:
        // non bloquant
        log.warn("ContextType unknown !");
        break;
    }
    if (!subscribersOnCtx) {
        return new ResponseEntity<>(HttpStatus.FORBIDDEN);
    }
    subscriberRepository.save(subscriber);
    String composedIdURL = new String(
            Base64.encodeBase64(subscriber.getId().getSubject().getKeyValue().getBytes(StandardCharsets.UTF_8)))
            + "/";
    composedIdURL += subscriber.getId().getSubject().getKeyType().getId() + "/";
    composedIdURL += subscriber.getId().getSubject().getKeyAttribute() + "/";
    composedIdURL += subscriber.getId().getContext().getKeyId() + "/";
    composedIdURL += subscriber.getId().getContext().getKeyType().name();
    log.debug(composedIdURL);
    return ResponseEntity
            .created(new URI(
                    "/api/subscribers/" + UriUtils.encodeQuery(composedIdURL, StandardCharsets.UTF_8.name())))
            .build();
}

From source file:org.hesperides.core.presentation.controllers.ModulesController.java

@ApiOperation("Create a working copy (possibly from a release)")
@PostMapping//from  w w w .j av a  2  s.c o m
public ResponseEntity<ModuleIO> createWorkingCopy(Authentication authentication,
        @RequestParam(value = "from_module_name", required = false) final String fromModuleName,
        @RequestParam(value = "from_module_version", required = false) final String fromModuleVersion,
        @RequestParam(value = "from_is_working_copy", required = false) final Boolean isFromWorkingCopy,
        @Valid @RequestBody final ModuleIO moduleInput) {

    log.info("createWorkingCopy {}", moduleInput.toString());

    ResponseEntity response;
    User currentUser = fromAuthentication(authentication);
    if (StringUtils.isBlank(fromModuleName) && StringUtils.isBlank(fromModuleVersion)
            && isFromWorkingCopy == null) {

        TemplateContainer.Key createdModuleKey = moduleUseCases
                .createWorkingCopy(moduleInput.toDomainInstance(), currentUser);
        ModuleIO moduleOutput = moduleUseCases.getModule(createdModuleKey).map(ModuleIO::new)
                .orElseThrow(() -> new ModuleNotFoundException(createdModuleKey));
        response = ResponseEntity.created(createdModuleKey.getURI()).body(moduleOutput);

    } else {
        checkQueryParameterNotEmpty("from_module_name", fromModuleName);
        checkQueryParameterNotEmpty("from_module_version", fromModuleVersion);
        checkQueryParameterNotEmpty("from_is_working_copy", isFromWorkingCopy);

        TemplateContainer.Key existingModuleKey = new Module.Key(fromModuleName, fromModuleVersion,
                TemplateContainer.getVersionType(isFromWorkingCopy));
        ModuleView moduleView = moduleUseCases.createWorkingCopyFrom(existingModuleKey,
                moduleInput.toDomainInstance().getKey(), currentUser);
        TemplateContainer.Key createdModuleKey = moduleView.toDomainInstance().getKey();
        ModuleIO moduleOutput = new ModuleIO(moduleView);
        response = ResponseEntity.created(createdModuleKey.getURI()).body(moduleOutput);
    }
    return response;
}

From source file:org.springframework.cloud.gateway.actuate.GatewayControllerEndpoint.java

@PostMapping("/routes/{id}")
@SuppressWarnings("unchecked")
public Mono<ResponseEntity<Void>> save(@PathVariable String id, @RequestBody Mono<RouteDefinition> route) {
    return this.routeDefinitionWriter.save(route.map(r -> {
        r.setId(id);//  ww  w .ja  v a  2 s .  com
        log.debug("Saving route: " + route);
        return r;
    })).then(Mono.defer(() -> Mono.just(ResponseEntity.created(URI.create("/routes/" + id)).build())));
}

From source file:org.springframework.cloud.gateway.actuate.GatewayEndpoint.java

@PostMapping("/routes/{id}")
public Mono<ResponseEntity<Void>> save(@PathVariable String id, @RequestBody Mono<Route> route) {
    return this.routeWriter.save(route.map(r -> {
        r.setId(id);/*from w w w . j  a v  a2s .c o m*/
        log.debug("Saving route: " + route);
        return r;
    })).then(() -> Mono.just(ResponseEntity.created(URI.create("/routes/" + id)).build()));
}