• Home
• systems.dennis
• sd-shared-web-servers-postgres
• 1.0.5
• source code
• ServerRequest.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

systems.dennis.shared.servers.beans.ServerRequest Maven / Gradle / Ivy

package systems.dennis.shared.servers.beans;

import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.client.RestTemplate;
import systems.dennis.shared.annotations.NeverNullResponse;
import systems.dennis.shared.config.WebContext;
import systems.dennis.shared.servers.model.ServerConfig;
import systems.dennis.shared.servers.service.ServerConfigService;
import systems.dennis.shared.utils.Mapper;
import systems.dennis.shared.utils.Supplier;

import java.lang.reflect.ParameterizedType;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public class ServerRequest {
    @Getter
    private RestTemplate restTemplate;
    @Getter
    private WebContext context;

    @Getter
    private Map> onError = new HashMap<>();
    @Getter
    private T result;

    @Getter
    private String url;

    public  static String AUTH_TYPE_HEADER = "AUTH_TYPE";
    public  static String AUTH_SCOPE_HEADER = "AUTH_SCOPE";
    public static final String AUTH_TYPE_DEFAULT = "DEFAULT";
    public  static String AUTH_TYPE_VIRTUAL = "VIRTUAL";

    public ServerRequest(RestTemplate restTemplate, WebContext context) {
        this.restTemplate = restTemplate;

        this.context = context;
    }


    @Getter
    private final HttpHeaders headers = new HttpHeaders();

    private ServerConfig server;

    @NeverNullResponse
    public ServerRequest virtualAuth() {
        headers.set(AUTH_TYPE_HEADER, AUTH_TYPE_VIRTUAL);
        return this;
    }

    @NeverNullResponse
    public ServerRequest uri(String uri) {

        this.url = uri;
        return this;
    }

    @NeverNullResponse
    public ServerRequest server(Long type) {
        this.server = context.getBean(ServerConfigService.class).findByType(type, true);
        return this;
    }

    @NeverNullResponse
    public ServerRequest server(ServerConfig server) {
        this.server = context.getBean(ServerConfigService.class).findByIdOrThrow(server.getId());
        return this;
    }

    @NeverNullResponse
    public ServerRequest token(String token) {
        headers.setBearerAuth(token);
        return this;
    }

    @NeverNullResponse
    public ServerRequest scope() {
        headers.set(AUTH_SCOPE_HEADER, getCurrentScope());
        return this;
    }

    @NeverNullResponse
    public ServerRequest header(Map headerMap) {
        for (Map.Entry entry : headerMap.entrySet()) {
            headers.set(entry.getKey(), entry.getValue());
        }
        return this;
    }

    @NeverNullResponse
    public ServerRequest contentType(MediaType contentType) {
        headers.setContentType(contentType);
        return this;
    }

    @NeverNullResponse
    public ServerRequest onErrorStatusError(int status, Supplier e) {
        onError.put(status, e);
        return this;
    }

    @NeverNullResponse
    public ServerRequest onAnyErrorStatusError(Supplier e) {
        onError.put(-1, e);
        return this;
    }


    /**
     * @deprecated as normally default type doesn't require this header
     */
    @Deprecated
    @NeverNullResponse
    public ServerRequest defaultAuthType() {
        headers.set(AUTH_TYPE_HEADER, AUTH_TYPE_DEFAULT);
        return this;
    }


    public  T executePost(E object, Class tClass) {
        try {
            if (!this.headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
                this.headers.setContentType(MediaType.APPLICATION_JSON);
            }
            var el = new HttpEntity<>(object, this.headers);
            var resp = restTemplate.postForEntity(server.getRoot() + url, el, tClass);
            validateExceptions(resp);

            this.result = resp.getBody();
            return this.result;
        } catch (Exception e) {
            printRequest(e);
            throw e;
        }
    }

    public  T executePut(E object, Class tClass) {
        if (!this.headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            this.headers.setContentType(MediaType.APPLICATION_JSON);
        }
        HttpEntity entity = new HttpEntity<>(object, this.headers);
        ResponseEntity response = restTemplate.exchange(server.getRoot() + url, HttpMethod.PUT, entity, tClass);
        validateExceptions(response);

        this.result = response.getBody();
        return this.result;
    }

    public  T executePatch(E object, Class tClass) {
        if (!this.headers.containsKey(HttpHeaders.CONTENT_TYPE)) {
            this.headers.setContentType(MediaType.APPLICATION_JSON);
        }
        HttpEntity entity = new HttpEntity<>(object, this.headers);
        ResponseEntity response = restTemplate.exchange(server.getRoot() + url, HttpMethod.PATCH, entity, tClass);
        validateExceptions(response);

        this.result = response.getBody();
        return this.result;
    }

    private void validateExceptions(ResponseEntity resp) {
        printResponse(resp);
        var anyError = onError.get(-1);
        if (200 != resp.getStatusCode().value()) {
            this.onError.keySet().forEach((code) -> {
                if (code != -1) {
                    if (resp.getStatusCode().value() == code) {
                        onError.get(code).onNull(resp.getStatusCode().value());
                    }
                }
            });

            if (anyError != null) {
                anyError.onNull(resp.getStatusCode().value());
            }
        }


    }

    private void printResponse(ResponseEntity resp) {
        log.debug("Url: " + this.url);
        log.debug("code: " + resp.getStatusCode());
        if (resp.getBody() != null) {
            try {
                log.debug("message: " + Mapper.mapper.writeValueAsString(resp.getBody()));
            } catch (Exception e) {
                log.debug("message: " + resp.getBody());
            }
        } else {
            log.debug("message: null");
        }
    }

    private void printRequest(Exception e) {
        log.error("Url: " + this.url);
        log.error("exception", e);
    }

    public  T executeGet(Class tClass) {
        try {
            var el = new HttpEntity<>(this.headers);
            var resp = restTemplate.exchange(server.getRoot() + url, HttpMethod.GET, el, tClass);
            validateExceptions(resp);

            this.result = resp.getBody();
            return this.result;
        } catch (Exception e) {
            printRequest(e);
            throw e;
        }
    }
    public  T executeGet(ParameterizedTypeReference respType ) {
        try {
            var el = new HttpEntity<>(this.headers);
            var resp = restTemplate.exchange(server.getRoot() + url, HttpMethod.GET, el, respType);
            validateExceptions(resp);

            this.result = resp.getBody();
            return this.result;
        } catch (Exception e) {
            printRequest(e);
            throw e;
        }
    }

    public void executeDelete(Class tClass) {
        try {
            var requestEntity = new HttpEntity<>(this.headers);
            var resp = restTemplate.exchange(server.getRoot() + url, HttpMethod.DELETE, requestEntity, tClass);
            validateExceptions(resp);
        } catch (Exception e) {
            printRequest(e);
            throw e;
        }
    }

    private String getCurrentScope() {
        return context.getEnv("dennis.systems.security.scope.id", "Default");
    }


}