io.rocketbase.commons.resource.AbstractBaseCrudRestResource Maven / Gradle / Ivy

Go to download
package io.rocketbase.commons.resource;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.rocketbase.commons.dto.PageableResult;
import lombok.Getter;
import lombok.Setter;
import lombok.SneakyThrows;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.util.UriComponentsBuilder;

import java.lang.reflect.ParameterizedType;

public abstract class AbstractBaseCrudRestResource extends AbstractRestResource {

    @Getter
    protected Class responseClass;

    @Setter
    private RestTemplate restTemplate;

    @SuppressWarnings("unchecked")
    public AbstractBaseCrudRestResource(ObjectMapper objectMapper) {
        super(objectMapper);
        responseClass = (Class) ((ParameterizedType) getClass()
                .getGenericSuperclass()).getActualTypeArguments()[0];
    }

    protected RestTemplate getRestTemplate() {
        if (restTemplate == null) {
            restTemplate = new RestTemplate();
            restTemplate.setErrorHandler(new NoopResponseErrorHandler());
        }
        return restTemplate;
    }

    @SneakyThrows
    protected PageableResult find(UriComponentsBuilder uriBuilder) {
        ResponseEntity response = getRestTemplate().exchange(uriBuilder.toUriString(),
                HttpMethod.GET,
                new HttpEntity<>(createHeaderWithLanguage()),
                String.class);
        return renderResponse(response, createPagedTypeReference());
    }

    @SneakyThrows
    protected Read getById(UriComponentsBuilder uriBuilder) {
        ResponseEntity response = getRestTemplate().exchange(uriBuilder.toUriString(),
                HttpMethod.GET,
                new HttpEntity<>(createHeaderWithLanguage()),
                String.class);
        return renderResponse(response, responseClass);
    }

    @SneakyThrows
    protected Read create(UriComponentsBuilder uriBuilder, Write write) {
        ResponseEntity response = getRestTemplate().exchange(uriBuilder.toUriString(),
                HttpMethod.POST,
                createHttpEntity(write),
                String.class);
        return renderResponse(response, responseClass);
    }

    @SneakyThrows
    protected Read update(UriComponentsBuilder uriBuilder, Write write) {
        ResponseEntity response = restTemplate.exchange(uriBuilder.toUriString(),
                HttpMethod.PUT,
                createHttpEntity(write),
                String.class);
        return renderResponse(response, responseClass);
    }

    protected void delete(UriComponentsBuilder uriBuilder) {
        ResponseEntity response = getRestTemplate().exchange(uriBuilder.toUriString(),
                HttpMethod.DELETE,
                null, Void.class);
    }

    protected HttpEntity createHttpEntity(Write write) {
        HttpEntity entity = new HttpEntity<>(write, createHeaderWithLanguage());
        return entity;
    }

    protected abstract TypeReference> createPagedTypeReference();

}