How to use

Rendering

in

org.springframework.web.reactive.result.view

@Test
public void defaultValues() {
  Rendering rendering = Rendering.view("abc").build();
  assertEquals("abc", rendering.view());
  assertEquals(Collections.emptyMap(), rendering.modelAttributes());
  assertNull(rendering.status());
  assertEquals(0, rendering.headers().size());
}

@Test
public void redirectWithAbsoluteUrl() throws Exception {
  Rendering rendering = Rendering.redirectTo("foo").contextRelative(false).build();
  Object view = rendering.view();
  assertEquals(RedirectView.class, view.getClass());
  assertFalse(((RedirectView) view).isContextRelative());
}

@Test
public void httpHeaders() throws Exception {
  HttpHeaders headers = new HttpHeaders();
  headers.add("foo", "bar");
  Rendering rendering = Rendering.view("foo").headers(headers).build();
  assertEquals(headers, rendering.headers());
}

@Test
public void modelAttributes() throws Exception {
  Foo foo = new Foo();
  Bar bar = new Bar();
  Rendering rendering = Rendering.view("foo").modelAttributes(foo, bar).build();
  Map<String, Object> map = new LinkedHashMap<>(2);
  map.put("foo", foo);
  map.put("bar", bar);
  assertEquals(map, rendering.modelAttributes());
}

@Test
public void viewName() {
  Rendering rendering = Rendering.view("foo").build();
  assertEquals("foo", rendering.view());
}

@Test
public void model() throws Exception {
  Map<String, Object> map = new LinkedHashMap<>();
  map.put("foo", new Foo());
  map.put("bar", new Bar());
  Rendering rendering = Rendering.view("foo").model(map).build();
  assertEquals(map, rendering.modelAttributes());
}

returnValue = Rendering.view("account").modelAttribute("a", "a1").status(status).header("h", "h1").build();
String expected = "account: {a=a1, id=123}";
ServerWebExchange exchange = testHandle("/path", returnType, returnValue, expected, resolver);

@Test
public void header() throws Exception {
  Rendering rendering = Rendering.view("foo").header("foo", "bar").build();
  assertEquals(1, rendering.headers().size());
  assertEquals(Collections.singletonList("bar"), rendering.headers().get("foo"));
}

HttpStatus status = render.status();
if (status != null) {
  exchange.getResponse().setStatusCode(status);
exchange.getResponse().getHeaders().putAll(render.headers());
model.addAllAttributes(render.modelAttributes());
Object view = render.view();
if (view == null) {
  view = getDefaultViewName(exchange);

@Test
public void modelAttribute() throws Exception {
  Foo foo = new Foo();
  Rendering rendering = Rendering.view("foo").modelAttribute(foo).build();
  assertEquals(Collections.singletonMap("foo", foo), rendering.modelAttributes());
}

 @PostMapping({ "/", "/404" })
 public Rendering post(@RequestParam(required = false, name = "name") final Optional<String> name) {

  final String result = name.orElse("World");

  return Rendering.view("index")
          .modelAttribute("name", result)
          .build();
 }
}

@Test
public void redirectWithPropagateQuery() throws Exception {
  Rendering rendering = Rendering.redirectTo("foo").propagateQuery(true).build();
  Object view = rendering.view();
  assertEquals(RedirectView.class, view.getClass());
  assertTrue(((RedirectView) view).isPropagateQuery());
}

@Bean
RouterFunction<ServerResponse> routes() {
 return
   route(GET("/api/v1/messages"),
      request -> ok().contentType(request.headers()
                        .accept()
                        .contains(TEXT_EVENT_STREAM)
                      ? TEXT_EVENT_STREAM : APPLICATION_STREAM_JSON)
              .body(Flux.zip(
                Flux.interval(Duration.ofSeconds(1)),
                messages.findAll())
                   .map(Tuple2::getT2)
                   .share(), Message.class))
     .andRoute(POST("/api/v1/messages"),
          request -> ok().contentType(APPLICATION_JSON)
                  .body(request.bodyToMono(Message.class)
                        .flatMap(messages::save), Message.class))
     .andRoute(GET("/"),
          request -> ok().render("index",
                      Rendering.view("index")
                          .modelAttribute("name", "Max")
                          .build()
                          .modelAttributes())
     );
}

@GetMapping({ "/", "/404" })
public Rendering index(@RequestParam(required = false, name = "name") final Optional<String> name) {
 final String result = name.orElse("World");
 return Rendering.view("index")
         .modelAttribute("name", result)
         .build();
}

@Test
public void defaultValuesForRedirect() throws Exception {
  Rendering rendering = Rendering.redirectTo("abc").build();
  Object view = rendering.view();
  assertEquals(RedirectView.class, view.getClass());
  assertEquals("abc", ((RedirectView) view).getUrl());
  assertTrue(((RedirectView) view).isContextRelative());
  assertFalse(((RedirectView) view).isPropagateQuery());
}

@GetMapping("/")
public Rendering home() {
  return Rendering
      .view("index")
      .modelAttribute("zones", this.zoneDescriptorRepository.findAll())
      .build();
}

@GetMapping(path = "/zones/events", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Rendering streamZoneEvents() {
  Flux<ElectricityMeasure> events = this.measuresCollector
      .getElectricityMeasures()
      .filter(measure -> measure.getPower() == 0);
  ReactiveDataDriverContextVariable eventsDataDriver =
      new ReactiveDataDriverContextVariable(events, 1);
  return Rendering.view("zone :: #events")
      .modelAttribute("eventStream", eventsDataDriver)
      .build();
}

@GetMapping("/zones/{zoneId}")
public Mono<Rendering> displayZone(@PathVariable String zoneId) {
  PageRequest pageRequest = PageRequest.of(0, this.historySize,
      Sort.by("timestamp").descending());
  Flux<PowerGridSample> latestSamples = this.powerGridSampleRepository
      .findAllByZoneId(zoneId, pageRequest);
  return this.zoneDescriptorRepository.findById(zoneId)
      .switchIfEmpty(Mono.error(new MissingDataException(zoneId)))
      .map(zoneDescriptor -> Rendering
          .view("zone")
          .modelAttribute("zone", zoneDescriptor)
          .modelAttribute("samples", latestSamples)
          .build());
}

 @GetMapping
 Rendering index() {
  return Rendering.view("index")
          .modelAttribute("message", Message.of("hello, la-la!"))
          .modelAttribute("messages", new ReactiveDataDriverContextVariable(
            Flux.zip(
              Flux.interval(Duration.ofSeconds(1)),
              Flux.just(
                Message.of("and one"),
                Message.of("and two"),
                Message.of("and three"),
                Message.of("and four!"))
            ).map(Tuple2::getT2),
            1
          ))
          .build();
 }
}