SOAP client

package com.vnpay.vna_ticket_redeem.service.impl;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.vna_ticket_redemption.beans.https.response.ApiResponse;
import com.vnpay.vna_ticket_redeem.common.BaseClass;
import com.vnpay.vna_ticket_redeem.service.BaseService;
import com.vnpay.vna_ticket_redeem.service.JAXBContextResponse;
import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.SneakyThrows;
import org.apache.http.HttpEntity;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.http.HttpMethod;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.Unmarshaller;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamReader;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.Objects;

/**
 * @author khoakd
 * 10/11/2023
 */
@Service
@AllArgsConstructor
public class BaseServiceImpl extends BaseClass implements BaseService {
    private final ObjectMapper objectMapper;
    private HttpServletRequest servletRequest;

    private String removeSpacesFromXML(String xml) {
        // Remove spaces, newlines, and tabs
        return xml.replaceAll("\\s+", "").replaceAll("\t", "");
    }

    @SneakyThrows
    @Override
    public <T> ApiResponse<T> callAPI(String soapMess, String resultTag, Class type, int timeout, String logString, String soapAction,
                                      String instance, String apiUrl, String keyReq) {
        CloseableHttpClient httpClient = null;
        ApiResponse<T> retDate = new ApiResponse<>();
        try {
            log.info(logString + "|START " + ", Tag=" + resultTag + ",Timeout=" + timeout + ",SoapMessage=" + removeSpacesFromXML(soapMess) + ", apiUrl:" + apiUrl + "keyReq:" + keyReq);
            httpClient = HttpClients.createDefault();
            RequestConfig cfg = RequestConfig.custom()
                    .setConnectTimeout(timeout * 1000)
                    .setSocketTimeout(timeout * 1000)
                    .setConnectionRequestTimeout(timeout * 1000).build();
            HttpPost postRequest = new HttpPost(apiUrl);
            postRequest.setConfig(cfg);
            postRequest.setHeader("Content-Type", "text/xml; charset=utf-8");
            postRequest.setHeader("SOAPAction", soapAction);
            StringEntity entity = new StringEntity(soapMess, "utf-8");
            postRequest.setEntity(entity);
            CloseableHttpResponse response = httpClient.execute(postRequest);
            HttpEntity entityReturn = response.getEntity();
            String soapXmlResult = EntityUtils.toString(entityReturn);

            // header String
            log.info(logString + "|END, " + "Rsp:" + soapXmlResult + "|keyReq:" + keyReq);
            int indexOpen = soapXmlResult.indexOf("<soapenv:Header");
            int indexClose = soapXmlResult.indexOf("</soapenv:Header>") + 17;
            if (indexOpen == -1) {
                indexOpen = soapXmlResult.indexOf("<soap:Header");
                indexClose = soapXmlResult.indexOf("</soap:Header>") + 14;
            }

            if (indexOpen != -1) {
                retDate.setHeaderInformation(soapXmlResult.substring(indexOpen, indexClose));
            }
            String xmlBody = soapXmlResult.substring(0, indexOpen) + soapXmlResult.substring(indexClose);

            log.info(logString + "|END, " + "Rsp_2:" + xmlBody + "|keyReq:" + keyReq);

            if (xmlBody.contains(resultTag)) {
                xmlBody = xmlBody.replace("¥", "");
                XMLInputFactory xif = XMLInputFactory.newFactory();
                InputStream is = new ByteArrayInputStream(xmlBody.getBytes());
                XMLStreamReader xsr = xif.createXMLStreamReader(is);
                xsr.nextTag();
                while (!xsr.getLocalName().equals(resultTag)) {
                    xsr.nextTag();
                }
                JAXBContext jaxbContext;
                switch (instance) {
                    case "SEARCH_FLIGHT": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextSearchFlight();
                        break;
                    }
                    case "SELECT_FLIGHT": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextSelectFlight();
                        break;
                    }
                    case "ADD_INFO": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextAddInfo();
                        break;
                    }
                    case "GET_PRICE": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextGetPrice();
                        break;
                    }
                    case "CREATE_TST": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextCreateTST();
                        break;
                    }
                    case "CREATE_FORM_OF_PAYMENT": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextCreateFormOfPayment();
                        break;
                    }
                    case "SAVE_RESERVATION": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextSaveReservation();
                        break;
                    }
                    case "ISSUE_TICKET": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextIssueTicket();
                        break;
                    }
                    case "DOC_ISSUANCE_ISSUE_TICKET": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextDocIssuanceIssueTicket();
                        break;
                    }
                    case "QUOTE_PLACE_PNR": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextQuotePlacePNR();
                        break;
                    }
                    case "CANCEL_PNR": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextCancelPNR();
                        break;
                    }
                    case "ADD_REDEMPTION": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextAddRedemption();
                        break;
                    }
                    case "Security_SignOutReply": {
                        jaxbContext = JAXBContextResponse.getInstance().getJAXBContextSignout();
                        break;
                    }
                    default: {
                        jaxbContext = JAXBContext.newInstance(type);
                        break;
                    }
                }
                Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
                JAXBElement<T> je = unmarshaller.unmarshal(xsr, type);
                /* convert success */
                retDate.setResponseBody(je.getValue());
            } else {
                /* response failed */
                log.info(logString + "|FAILED| keyReq:" + keyReq);
            }
        } catch (Exception ex) {
            log.error("keyReq:" + keyReq + "| " + logString + "Exception call API, Tag=" + resultTag + ",Timeout=" + timeout + ",SoapMessage=" + soapMess + ", Exception:" + ex.getMessage(), ex);
        } finally {
            if (httpClient != null) {
                httpClient.close();
            }
        }
        return retDate;
    }

    @NoArgsConstructor
    private class RestTemplateLogger {
        private String keyReq;
        private String method;
        private String function;
        private int status;
        private String url;
        private String requestBody;
        private String responseBody;
        private String responseHeader;
        private long startTime;

        public RestTemplateLogger injectRequest(String method, String url, String function, Object requestBody
        ) throws JsonProcessingException {
            this.keyReq = (String) servletRequest.getAttribute("keyReq");
            this.method = method;
            this.url = url;
            this.function = function;
            this.requestBody = convertObjectToString(requestBody);
            this.startTime = System.currentTimeMillis();
            return this;
        }

        public void injectResponse(int status, String responseBody, String responseHeader) {
            this.status = status;
            this.responseBody = responseBody;
            this.responseHeader = responseHeader;
        }

        private String convertObjectToString(Object data) throws JsonProcessingException {
            return objectMapper.writeValueAsString(data);
        }

        @Override
        public String toString() {
            StringBuilder logBuilder = new StringBuilder();
            logBuilder.append("[KeyReq] = ").append(keyReq).append(",");
            logBuilder.append("[Begin call ").append(function).append(" function, ");
            logBuilder.append("\n       [URI] = ").append(url).append(",");
            if (!HttpMethod.GET.matches(method) && !HttpMethod.DELETE.matches(method) && Objects.nonNull(requestBody)) {
                logBuilder.append("\n       [REQUEST_BODY] = ").append(requestBody);
            }
            if (Objects.nonNull(responseBody)) {
                logBuilder.append("\n       End call ").append(function).append(" function, ");
                logBuilder.append("\n[HTTP_STATUS = ").append(status).append(" ]");
                logBuilder.append("\n       [RESPONSE_TIME] = ").append(System.currentTimeMillis() - startTime);
                logBuilder.append("\n       [RESPONSE_HEADERS] = ").append(responseHeader);
                logBuilder.append("\n       [RESPONSE_BODY] = ").append(responseBody);
            }
            return logBuilder.toString();
        }
    }
}