Add files via upload

src/main/java/stirling/software/SPDF/SPdfApplication.java

@@ -0,0 +1,13 @@
+package stirling.software.SPDF;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+@SpringBootApplication
+public class SPdfApplication {
+
+	public static void main(String[] args) {
+		SpringApplication.run(SPdfApplication.class, args);
+	}
+
+}

src/main/java/stirling/software/SPDF/controller/FromPDFController.java

@@ -0,0 +1,32 @@
+package stirling.software.SPDF.controller;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+import stirling.software.SPDF.utils.PdfUtils;
+
+@Controller
+public class FromPDFController {
+
+	private static final Logger logger = LoggerFactory.getLogger(FromPDFController.class);
+
+	@GetMapping("/convert-from-pdf")
+	public String convertFromPdfForm() {
+		return "convert-from-pdf";
+	}
+
+	@PostMapping("/convert-from-pdf")
+	public byte[] convertToImage(@RequestParam("fileInput") MultipartFile file,
+			@RequestParam("imageFormat") String imageFormat) throws IOException {
+		byte[] pdfBytes = file.getBytes();
+		return PdfUtils.convertFromPdf(pdfBytes, imageFormat);
+	}
+
+}

src/main/java/stirling/software/SPDF/controller/OverlayImageController.java

@@ -0,0 +1,47 @@
+package stirling.software.SPDF.controller;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+import stirling.software.SPDF.utils.PdfUtils;
+
+@Controller
+public class OverlayImageController {
+
+	private static final Logger logger = LoggerFactory.getLogger(OverlayImageController.class);
+
+	@GetMapping("/add-image")
+	public String overlayImage() {
+		return "add-image";
+	}
+
+	@PostMapping("/add-image")
+	public ResponseEntity<byte[]> overlayImage(@RequestParam("fileInput") MultipartFile pdfFile,
+			@RequestParam("fileInput2") MultipartFile imageFile, @RequestParam("x") float x,
+			@RequestParam("y") float y) {
+		try {
+			byte[] pdfBytes = pdfFile.getBytes();
+			byte[] imageBytes = imageFile.getBytes();
+			byte[] result = PdfUtils.overlayImage(pdfBytes, imageBytes, x, y);
+			HttpHeaders headers = new HttpHeaders();
+			headers.setContentType(MediaType.APPLICATION_PDF);
+			headers.setContentDispositionFormData("attachment", "overlayed.pdf");
+			headers.setCacheControl("must-revalidate, post-check=0, pre-check=0");
+			return new ResponseEntity<>(result, headers, HttpStatus.OK);
+		} catch (IOException e) {
+			logger.error("Failed to add image to PDF", e);
+			return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
+		}
+	}
+}

src/main/java/stirling/software/SPDF/controller/PdfController.java

@@ -0,0 +1,88 @@
+package stirling.software.SPDF.controller;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDPageTree;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+@Controller
+public class PdfController {
+
+	private static final Logger logger = LoggerFactory.getLogger(PdfController.class);
+
+	@GetMapping("/")
+	public String root(Model model) {
+		return "redirect:/home";
+	}
+
+	@GetMapping("/merge-pdfs")
+	public String hello(Model model) {
+		model.addAttribute("message", "Hello, World!");
+		return "merge-pdfs";
+	}
+
+	@GetMapping("/home")
+	public String home(Model model) {
+		model.addAttribute("message", "Hello, World!");
+		return "home";
+	}
+
+	@PostMapping("/merge-pdfs")
+	public ResponseEntity<InputStreamResource> mergePdfs(@RequestParam("fileInput") MultipartFile[] files)
+			throws IOException {
+		// Read the input PDF files into PDDocument objects
+		List<PDDocument> documents = new ArrayList<>();
+
+		// Loop through the files array and read each file into a PDDocument
+		for (MultipartFile file : files) {
+			documents.add(PDDocument.load(file.getInputStream()));
+		}
+
+		PDDocument mergedDoc = mergeDocuments(documents);
+		ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+		mergedDoc.save(byteArrayOutputStream);
+		mergedDoc.close();
+
+		// Create an InputStreamResource from the merged PDF
+		InputStreamResource resource = new InputStreamResource(
+				new ByteArrayInputStream(byteArrayOutputStream.toByteArray()));
+
+		// Return the merged PDF as a response
+		return ResponseEntity.ok().contentType(MediaType.APPLICATION_PDF).body(resource);
+	}
+
+	private PDDocument mergeDocuments(List<PDDocument> documents) throws IOException {
+		// Create a new empty document
+		PDDocument mergedDoc = new PDDocument();
+
+		// Iterate over the list of documents and add their pages to the merged document
+		for (PDDocument doc : documents) {
+			// Get all pages from the current document
+			PDPageTree pages = doc.getPages();
+			// Iterate over the pages and add them to the merged document
+			for (PDPage page : pages) {
+				mergedDoc.addPage(page);
+			}
+		}
+
+		// Return the merged document
+		return mergedDoc;
+	}
+
+}

src/main/java/stirling/software/SPDF/controller/RearrangePagesPDFController.java

@@ -0,0 +1,107 @@
+package stirling.software.SPDF.controller;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+@Controller
+public class RearrangePagesPDFController {
+
+	private static final Logger logger = LoggerFactory.getLogger(RearrangePagesPDFController.class);
+
+	@GetMapping("/pdf-organizer")
+	public String pageOrganizer(Model model) {
+		return "pdf-organizer";
+	}
+
+	@PostMapping("/rearrange-pages")
+	public ResponseEntity<byte[]> rearrangePages(@RequestParam("fileInput") MultipartFile pdfFile,
+			@RequestParam("pageOrder") String pageOrder) {
+		try {
+			// Load the input PDF
+			PDDocument document = PDDocument.load(pdfFile.getInputStream());
+
+			// Split the page order string into an array of page numbers or range of numbers
+			String[] pageOrderArr = pageOrder.split(",");
+			List<Integer> newPageOrder = new ArrayList<Integer>();
+			//int[] newPageOrder = new int[pageOrderArr.length];
+			int totalPages = document.getNumberOfPages();
+
+			// loop through the page order array
+			for (String element : pageOrderArr) {
+				// check if the element contains a range of pages
+				if (element.contains("-")) {
+					// split the range into start and end page
+					String[] range = element.split("-");
+					int start = Integer.parseInt(range[0]);
+					int end = Integer.parseInt(range[1]);
+					// check if the end page is greater than total pages
+					if (end > totalPages) {
+						end = totalPages;
+					}
+					// loop through the range of pages
+					for (int j = start; j <= end; j++) {
+						// print the current index
+						newPageOrder.add( j - 1);
+					}
+				} else {
+					// if the element is a single page
+					newPageOrder.add( Integer.parseInt(element) - 1);
+				}
+			}
+
+			// Create a new list to hold the pages in the new order
+			List<PDPage> newPages = new ArrayList<>();
+			for (int i = 0; i < newPageOrder.size(); i++) {
+				newPages.add(document.getPage(newPageOrder.get(i)));
+			}
+
+			// Remove all the pages from the original document
+			for (int i = document.getNumberOfPages() - 1; i >= 0; i--) {
+				document.removePage(i);
+			}
+
+			// Add the pages in the new order
+			for (PDPage page : newPages) {
+				document.addPage(page);
+			}
+
+			// Save the rearranged PDF to a ByteArrayOutputStream
+			ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+			document.save(outputStream);
+
+			// Close the original document
+			document.close();
+
+			// Prepare the response headers
+			HttpHeaders headers = new HttpHeaders();
+			headers.setContentType(MediaType.APPLICATION_PDF);
+			headers.setContentDispositionFormData("attachment", "rearranged.pdf");
+			headers.setContentLength(outputStream.size());
+
+			// Return the response with the PDF data and headers
+			return new ResponseEntity<>(outputStream.toByteArray(), headers, HttpStatus.OK);
+		} catch (IOException e) {
+
+			logger.error("Failed rearranging documents", e);
+			return null;
+		}
+	}
+
+}

src/main/java/stirling/software/SPDF/controller/SplitPDFController.java

@@ -0,0 +1,140 @@
+package stirling.software.SPDF.controller;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.ByteArrayResource;
+import org.springframework.core.io.Resource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+@Controller
+public class SplitPDFController {
+
+	private static final Logger logger = LoggerFactory.getLogger(SplitPDFController.class);
+
+	@GetMapping("/split-pdfs")
+	public String splitPdfForm() {
+		return "split-pdfs";
+	}
+
+	@PostMapping("/split-pages")
+	public ResponseEntity<Resource> splitPdf(@RequestParam("fileInput") MultipartFile file,
+			@RequestParam("pages") String pages) throws IOException {
+		// parse user input
+
+		// open the pdf document
+		InputStream inputStream = file.getInputStream();
+		PDDocument document = PDDocument.load(inputStream);
+
+		List<Integer> pageNumbers = new ArrayList<>();
+		pages = pages.replaceAll("\\s+", ""); // remove whitespaces
+		if (pages.toLowerCase().equals("all")) {
+			for (int i = 0; i < document.getNumberOfPages(); i++) {
+				pageNumbers.add(i);
+			}
+		} else {
+			List<String> pageNumbersStr = new ArrayList<>(Arrays.asList(pages.split(",")));
+			if (!pageNumbersStr.contains(String.valueOf(document.getNumberOfPages()))) {
+				String lastpage = String.valueOf(document.getNumberOfPages());
+				pageNumbersStr.add(lastpage);
+			}
+			for (String page : pageNumbersStr) {
+				if (page.contains("-")) {
+					String[] range = page.split("-");
+					int start = Integer.parseInt(range[0]);
+					int end = Integer.parseInt(range[1]);
+					for (int i = start; i <= end; i++) {
+						pageNumbers.add(i);
+					}
+				} else {
+					pageNumbers.add(Integer.parseInt(page));
+				}
+			}
+		}
+
+		logger.info("Splitting PDF into pages: {}",
+				pageNumbers.stream().map(String::valueOf).collect(Collectors.joining(",")));
+
+		// split the document
+		List<ByteArrayOutputStream> splitDocumentsBoas = new ArrayList<>();
+		int currentPage = 0;
+		for (int pageNumber : pageNumbers) {
+			try (PDDocument splitDocument = new PDDocument()) {
+				for (int i = currentPage; i < pageNumber; i++) {
+					PDPage page = document.getPage(i);
+					splitDocument.addPage(page);
+					logger.debug("Adding page {} to split document", i);
+				}
+				currentPage = pageNumber;
+				logger.debug("Setting current page to {}", currentPage);
+
+				ByteArrayOutputStream baos = new ByteArrayOutputStream();
+				splitDocument.save(baos);
+
+				splitDocumentsBoas.add(baos);
+			} catch (Exception e) {
+				logger.error("Failed splitting documents and saving them", e);
+				throw e;
+			}
+		}
+
+		// closing the original document
+		document.close();
+
+		// create the zip file
+		Path zipFile = Paths.get("split_documents.zip");
+		URI uri = URI.create("jar:file:" + zipFile.toUri().getPath());
+		Map<String, String> env = new HashMap<>();
+		env.put("create", "true");
+		FileSystem zipfs = FileSystems.newFileSystem(uri, env);
+
+		// loop through the split documents and write them to the zip file
+		for (int i = 0; i < splitDocumentsBoas.size(); i++) {
+			String fileName = "split_document_" + (i + 1) + ".pdf";
+			ByteArrayOutputStream baos = splitDocumentsBoas.get(i);
+			byte[] pdf = baos.toByteArray();
+			Path pathInZipfile = zipfs.getPath(fileName);
+			try (OutputStream os = Files.newOutputStream(pathInZipfile)) {
+				os.write(pdf);
+				logger.info("Wrote split document {} to zip file", fileName);
+			} catch (Exception e) {
+				logger.error("Failed writing to zip", e);
+				throw e;
+			}
+		}
+		zipfs.close();
+		logger.info("Successfully created zip file with split documents: {}", zipFile.toString());
+		byte[] data = Files.readAllBytes(zipFile);
+		ByteArrayResource resource = new ByteArrayResource(data);
+		new File("split_documents.zip").delete();
+		// return the Resource in the response
+		return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=split_documents.zip")
+				.contentType(MediaType.APPLICATION_OCTET_STREAM).contentLength(resource.contentLength()).body(resource);
+	}
+}

src/main/java/stirling/software/SPDF/controller/ToPDFController.java

@@ -0,0 +1,43 @@
+package stirling.software.SPDF.controller;
+
+import java.io.IOException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+import stirling.software.SPDF.utils.PdfUtils;
+
+@Controller
+public class ToPDFController {
+
+	private static final Logger logger = LoggerFactory.getLogger(ToPDFController.class);
+
+	@GetMapping("/convert-to-pdf")
+	public String convertToPdfForm() {
+		return "convert-to-pdf";
+	}
+
+	@PostMapping("/convert-to-pdf")
+	public ResponseEntity<byte[]> convertToPdf(@RequestParam("fileInput") MultipartFile file) throws IOException {
+		// Convert the file to PDF and get the resulting bytes
+		byte[] bytes = PdfUtils.convertToPdf(file.getInputStream());
+		logger.info("File {} successfully converted to pdf", file.getOriginalFilename());
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.setContentType(MediaType.APPLICATION_PDF);
+		String filename = "converted.pdf";
+		headers.setContentDispositionFormData(filename, filename);
+		headers.setCacheControl("must-revalidate, post-check=0, pre-check=0");
+		ResponseEntity<byte[]> response = new ResponseEntity<>(bytes, headers, HttpStatus.OK);
+		return response;
+	}
+}

src/main/java/stirling/software/SPDF/utils/PdfUtils.java

@@ -0,0 +1,124 @@
+package stirling.software.SPDF.utils;
+
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Iterator;
+
+import javax.imageio.IIOImage;
+import javax.imageio.ImageIO;
+import javax.imageio.ImageWriter;
+import javax.imageio.stream.ImageOutputStream;
+
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.pdmodel.PDPage;
+import org.apache.pdfbox.pdmodel.PDPageContentStream;
+import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
+import org.apache.pdfbox.rendering.ImageType;
+import org.apache.pdfbox.rendering.PDFRenderer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PdfUtils {
+
+	private static final Logger logger = LoggerFactory.getLogger(PdfUtils.class);
+
+	public static byte[] convertToPdf(InputStream imageStream) throws IOException {
+
+		// Create a File object for the image
+		File imageFile = new File("image.jpg");
+
+		try (FileOutputStream fos = new FileOutputStream(imageFile); InputStream input = imageStream) {
+			byte[] buffer = new byte[1024];
+			int len;
+			// Read from the input stream and write to the file
+			while ((len = input.read(buffer)) != -1) {
+				fos.write(buffer, 0, len);
+			}
+			logger.info("Image successfully written to file: {}", imageFile.getAbsolutePath());
+		} catch (IOException e) {
+			logger.error("Error writing image to file: {}", imageFile.getAbsolutePath(), e);
+			throw e;
+		}
+
+		try (PDDocument doc = new PDDocument()) {
+			// Create a new PDF page
+			PDPage page = new PDPage();
+			doc.addPage(page);
+
+			// Create an image object from the image file
+			PDImageXObject image = PDImageXObject.createFromFileByContent(imageFile, doc);
+
+			try (PDPageContentStream contentStream = new PDPageContentStream(doc, page)) {
+				// Draw the image onto the page
+				contentStream.drawImage(image, 0, 0);
+				logger.info("Image successfully added to PDF");
+			} catch (IOException e) {
+				logger.error("Error adding image to PDF", e);
+				throw e;
+			}
+
+			// Create a ByteArrayOutputStream to save the PDF to
+			ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+			doc.save(byteArrayOutputStream);
+			logger.info("PDF successfully saved to byte array");
+			return byteArrayOutputStream.toByteArray();
+		}
+	}
+
+	public static byte[] convertFromPdf(byte[] inputStream, String imageType) throws IOException {
+		try (PDDocument document = PDDocument.load(new ByteArrayInputStream(inputStream))) {
+			// Create a PDFRenderer to convert the PDF to an image
+			PDFRenderer pdfRenderer = new PDFRenderer(document);
+			BufferedImage bim = pdfRenderer.renderImageWithDPI(0, 300, ImageType.RGB);
+
+			// Get an ImageWriter for the specified image type
+			Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(imageType);
+			ImageWriter writer = writers.next();
+
+			// Create a ByteArrayOutputStream to save the image to
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			try (ImageOutputStream ios = ImageIO.createImageOutputStream(baos)) {
+				writer.setOutput(ios);
+				// Write the image to the output stream
+				writer.write(new IIOImage(bim, null, null));
+				// Log that the image was successfully written to the byte array
+				logger.info("Image successfully written to byte array");
+			}
+			return baos.toByteArray();
+		} catch (IOException e) {
+			// Log an error message if there is an issue converting the PDF to an image
+			logger.error("Error converting PDF to image", e);
+			throw e;
+		}
+	}
+
+	public static byte[] overlayImage(byte[] pdfBytes, byte[] imageBytes, float x, float y) throws IOException {
+
+		try (PDDocument document = PDDocument.load(new ByteArrayInputStream(pdfBytes))) {
+			// Get the first page of the PDF
+			PDPage page = document.getPage(0);
+			try (PDPageContentStream contentStream = new PDPageContentStream(document, page,
+					PDPageContentStream.AppendMode.APPEND, true)) {
+				// Create an image object from the image bytes
+				PDImageXObject image = PDImageXObject.createFromByteArray(document, imageBytes, "");
+				// Draw the image onto the page at the specified x and y coordinates
+				contentStream.drawImage(image, x, y);
+				logger.info("Image successfully overlayed onto PDF");
+			}
+			// Create a ByteArrayOutputStream to save the PDF to
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			document.save(baos);
+			logger.info("PDF successfully saved to byte array");
+			return baos.toByteArray();
+		} catch (IOException e) {
+			// Log an error message if there is an issue overlaying the image onto the PDF
+			logger.error("Error overlaying image onto PDF", e);
+			throw e;
+		}
+	}
+}