Template-Based PDF Document Generation in Java

@Slf4j
@Service
public class LoginService {

    // restTemplate has been defined as a bean
    @Autowired
    private RestTemplate restTemplate;

    public static String urlLogin = "https://app.edocgen.com/login";
    public static String bodyLogin = "{ \"username\": \"YOUR USERNAME\", \"password\": \"YOUR PASSWORD\"}";

    public String login() {
        HttpHeaders headers = HeaderBuilder
                                .builder()
                                .accept(MediaType.APPLICATION_JSON)
                                .contentType(MediaType.APPLICATION_JSON)
                                .build();

        HttpEntity<String> requestEntity = new HttpEntity<>(bodyLogin, headers);
        String token;
        try {
            ResponseEntity<LoginResponse> responseEntity = restTemplate.exchange(urlLogin, HttpMethod.POST, requestEntity, LoginResponse.class);
            token = responseEntity.getBody().getToken();
        } catch (Exception e) {
            log.error("Failed to get the access token.", e);
            throw new LoginException("Failed to get the access token. Please check your username and password.");
        }
        return token;
    }
}

@Slf4j
@Component
@RequiredArgsConstructor
public class TokenCache {

    private static String CACHE_KEY = "x-access-token";

    private static PassiveExpiringMap<String, String> tokenCache;

    static {
        // token will be cached for 20 mins
        tokenCache = new PassiveExpiringMap<>(20 * 60 * 1000);
    }

  	@Autowired
    private final LoginService loginService;

    public String getToken() {
        String accessToken = tokenCache.get(CACHE_KEY);
        // After 20 mins, cached token will be removed from the map
        if(StringUtils.isEmpty(accessToken)) {
            synchronized (this) {
                accessToken = loginService.login();
                tokenCache.put(CACHE_KEY,accessToken);
            }
        }
        return accessToken;
    }
}

package com.api.edocgen.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;

@Component
public class HeaderUtils {

    @Autowired
    private TokenCache tokenCache;

    public HttpHeaders buildHeaders() {
        return HeaderBuilder
                .builder()
                .accept(MediaType.APPLICATION_JSON)
                .contentType(MediaType.MULTIPART_FORM_DATA)
                .accessToken(tokenCache.getToken())
                .build();
    }

}


public class HeaderBuilder {

    private MediaType accept;
    private MediaType contentType;
    private String token;
    private final HttpHeaders headers = new HttpHeaders();
    private static final String ACCESS_TOKEN = "x-access-token";

    public static HeaderBuilder builder() {
        return new HeaderBuilder();
    }

    public HeaderBuilder accept(MediaType accept) {
        this.accept = accept;
        return this;
    }

    public HeaderBuilder contentType(MediaType contentType) {
        this.contentType = contentType;
        return this;
    }

    public HeaderBuilder accessToken(String token) {
        this.token = token;
        return this;
    }

    public HttpHeaders build() {
        if(Objects.nonNull(accept))
            headers.setAccept(Collections.singletonList(accept));
        if(Objects.nonNull(contentType))
            headers.setContentType(contentType);
        if(Objects.nonNull(token))
            headers.add(ACCESS_TOKEN, token);
        return headers;
    }

}

/**
     * Gets the documentId, output format, file data as resource, email id of the recipient
     * and the mode of the document generation.
     * When the request is made for bulk generation the all the files will be zipped after generation
     * and mailed.
     * @param documentId
     * @param outputFormat
     * @param resource
     * @param email
     * @param isBulkMode
     * @throws Exception
     */
    public void getDocByApi(String documentId, String outputFormat, ByteArrayResource resource, String email, boolean isBulkMode) throws Exception {
        RestTemplate restTemplate = new RestTemplate();
        String outputFileName = UUID.randomUUID().toString();
        try {
            //create the body request
            MultiValueMap<String, Object> body = createBody(resource, documentId, outputFileName, outputFormat);
			
            //set Headers
            HttpHeaders headers = headerUtils.buildHeaders();
            //send the request to generate document
            HttpEntity requestEntity = new HttpEntity(body, headers);

            ResponseEntity<String> generateResponse = restTemplate.postForEntity(urlBulkGenerate,
                    requestEntity, String.class);
            if (HttpStatus.OK == generateResponse.getStatusCode()) {
                processOutput(outputFileName, outputFormat, !isBulkMode, email);
            }
        } catch (Exception e) {
            log.error("Error in the generating document", e);
        }
    }


   private MultiValueMap<String, Object> createBody(ByteArrayResource resource,
                                                     String documentId, String outputFileName, String outPutFormat) {
        MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
        body.add("documentId", documentId);
        body.add("inputFile", resource);

        body.add("format", outPutFormat);
        body.add("outputFileName", outputFileName);
        // to download directly the file
        body.add("sync", true);
        return body;
    }

/**
     * Collects the database parameters and submit the request to generate the document.
     * Calls processOutput that will take care of sending the document over email
     * @param documentId
     * @param outputFormat
     * @param dbparmeters
     * @param email
     * @throws Exception
     */
    public void getDocsByDatabase(String documentId, String outputFormat, DBParameters dbparmeters, String email) throws Exception {

        String outputFileName = UUID.randomUUID().toString();

        MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
        body.add("documentId", documentId);
        body.add("format", outputFormat);
        body.add("outputFileName", outputFileName);
        body.add("dbVendor", dbparmeters.getDbVendor());
        body.add("dbUrl", dbparmeters.getDbUrl());
        body.add("dbLimit", dbparmeters.getDbLimit());
        body.add("dbPassword", dbparmeters.getDbPassword());
        body.add("dbQuery", dbparmeters.getDbQuery());

        // set Headers
        HttpHeaders headers = headerUtils.buildHeaders();

        // send the request to generate document
        HttpEntity requestEntity = new HttpEntity(body, headers);
        try {
            ResponseEntity<String> generateResponse = restTemplate.postForEntity(urlBulkGenerate, requestEntity, String.class);
            log.info("Send to edocGen Response : " + generateResponse.getStatusCode());
            if (HttpStatus.OK == generateResponse.getStatusCode()) {
                processOutput(outputFileName, outputFormat, false, email);
            }
        } catch (Exception e) {
            log.error("Failed to get the file downloaded");
        }

    }

/**
     * 
     * @param outputFileName
     * @param outputFormat
     * @param isSingleGeneration
     * @param email
     */
    private void processOutput(String outputFileName, String outputFormat, boolean isSingleGeneration, String email) {
        HttpHeaders headers = headerUtils.buildHeaders();
        HttpEntity requestEntity = new HttpEntity(null, headers);

        ResponseEntity<OutputResultDto> result = restTemplate.exchange(baseURL + "output/name/" + outputFileName + "." + outputFormat, HttpMethod.GET, requestEntity, OutputResultDto.class);
        OutputDto responseOutput = null;

        if (!isSingleGeneration) {
            outputFormat = outputFormat + ".zip";
        }

        responseOutput = isFileGenerated(outputFileName, outputFormat, requestEntity, result);

        log.info("Output Document Id generated at edocgen is : " + responseOutput.get_id());
        String outputId = responseOutput.get_id();

        // output download
        try {
            emailService.sendOutputViaEmail(outputId, email);
            log.info("File has been sent over email for file : " + outputFileName + "." + outputFormat);
        } catch (Exception e) {
            log.error("Error while Sending the file over email");
            throw new FileNotGeneratedException("Error while Downloading File");
        }
    }

    private OutputDto isFileGenerated(String outputFileName, String outputFormat, HttpEntity requestEntity, ResponseEntity<OutputResultDto> result) {
        OutputDto responseOutput;
        int retryCounter = 0;
        try {
            while (result.getBody().getOutput().toString().length() <= 2 && retryCounter < 200) {
                log.info("Output file is still not available. Retrying again!!!! Counter : " + retryCounter);
                result = restTemplate.exchange(baseURL + "output/name/" + outputFileName + "." + outputFormat, HttpMethod.GET, requestEntity, OutputResultDto.class);
                retryCounter++;
                // spin lock for 500 milli secs
                Thread.sleep(5000);
            }
            responseOutput = result.getBody().getOutput().get(0);
        } catch (Exception error) {
            log.error("Error : Output file is not available after 200 tries");
            throw new FileNotGeneratedException("Error : Output file is not available after 200 tries");
        }
        return responseOutput;
    }

package com.api.edocgen.service;

import com.api.edocgen.util.HeaderUtils;
import com.api.edocgen.util.TokenCache;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

@Slf4j
@Service
public class EmailService {

    public static String urlOutputEmail = "https://app.edocgen.com/api/v1/output/email";

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private HeaderUtils headerUtils;

    public void sendOutputViaEmail(String outId, String emailId) {
        RestTemplate restTemplate = new RestTemplate();
        try {
            MultiValueMap<String, Object> body = new LinkedMultiValueMap<>();
            body.add("outId", outId);
            body.add("emailId", emailId);
            // set Headers
            HttpHeaders headers = headerUtils.buildHeaders();
            // send the request to generate document
            HttpEntity requestEntity = new HttpEntity(body, headers);

            ResponseEntity<String> generateResponse = restTemplate.postForEntity(urlOutputEmail, requestEntity, String.class);

            log.info("Send to edocGen Response : " + generateResponse.getStatusCode());
            if (HttpStatus.OK == generateResponse.getStatusCode()) {
                log.info("Email sent");
            }
        } catch (Exception e) {
            log.error("Exception During Sending Email. Check if document id is valid", e);
        }
    }

}

@RequestMapping("/document")
@RestController
@RequiredArgsConstructor
public class DocumentController {


    private final DocumentService documentService;

    /**
     * 
     * This method handles FormData with file input
     * @param documentId
     * @param email
     * @param isBulk
     * @param format
     * @param file
     * @return
     */
    @PostMapping(value = "/{document_id}/{email}",
            consumes = {
                    MediaType.MULTIPART_FORM_DATA_VALUE
            },
            produces = MediaType.APPLICATION_JSON_VALUE )
    public ResponseDto generateDocument(@PathVariable("document_id") String documentId,
                                        @PathVariable String email,
                                        @RequestParam(value = "is_bulk", required = false, defaultValue = "true") boolean isBulk,
                                        @RequestParam(value = "output_file_format", required = false, defaultValue = "pdf") String format,
                                        // Accept any type of file
                                        @RequestPart(value = "file", required = false) MultipartFile file) {
        if(Objects.isNull(file)) {
            return new ResponseDto("Input is empty");
        }
        try {
            documentService.getDocByApiAsync(documentId, format, file, isBulk, email, null);
        }catch (Exception e) {
            return new ResponseDto("Your request has been failed. Please check your input", HttpStatus.BAD_REQUEST);
        }
        return new ResponseDto("Your request has been submitted. You will receive the email with document");
    }

    /**
     * This method handles Application/json content type
     * @param documentId
     * @param email
     * @param dbParameters
     * @param isBulk
     * @param format
     * @return
     */
    @PostMapping(value = "/{document_id}/{email}",
            consumes = {
                    MediaType.APPLICATION_JSON_VALUE
            },
            produces = MediaType.APPLICATION_JSON_VALUE )
    public ResponseDto generateDocumentForDb(@PathVariable("document_id") String documentId,
                                        @PathVariable String email,
                                        // Handle dbParameters
                                        @RequestBody(required = false) DBParameters dbParameters,
                                        @RequestParam(value = "is_bulk", required = false, defaultValue = "true") boolean isBulk,
                                        @RequestParam(value = "output_file_format", required = false, defaultValue = "pdf") String format
                                        ) {
        if(Objects.isNull(dbParameters)) {
            return new ResponseDto("Input is empty");
        }
        try {
            documentService.getDocByApiAsync(documentId, format, null, isBulk, email, dbParameters);
        }catch (Exception e) {
            return new ResponseDto("Your request has been failed. Please check your input", HttpStatus.BAD_REQUEST);
        }
        return new ResponseDto("Your request has been submitted. You will receive the email with document");
    }

}

[{
    "Invoice_Number": "SBU-2053502",
    "Invoice_Date": "31-07-2020",
    "Terms_Payment": "Net 15",
    "Company_Name": "Company B",
    "Billing_Contact": "B-Contact2",
    "Address": "Seattle, United States",		  
    "Logo":"62b83ddcd406d22dc7516b53", 
    "para": "61b334ee7c00363e11da3439", 
    "Email":"test@gmail.com",
    "subtemp": "62c85b97f156ce4fbdb01bcb",
    "ITH": [{
      "Heading1":"Item Description",
      "Heading2": "Amount"

    }],
    "IT": [{	       
      "Item_Description": "Product Fees: X",
      "Amount": "5,000"

    },
           {	       
             "Item_Description": "Product Fees: Y",
             "Amount": "6,000"

           }]
		}
]