package com.megatim.fdxcommons.tools; import com.lowagie.text.Document; import com.lowagie.text.pdf.PdfContentByte; import com.lowagie.text.pdf.PdfImportedPage; import com.lowagie.text.pdf.PdfReader; import com.lowagie.text.pdf.PdfWriter; import com.opencsv.CSVReader; import com.opencsv.CSVReaderBuilder; import io.github.classgraph.ClassGraph; import io.github.classgraph.ClassInfoList; import io.github.classgraph.ScanResult; import java.io.BufferedReader; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.Reader; import java.math.BigDecimal; import java.math.BigInteger; import java.security.NoSuchAlgorithmException; import java.security.SecureRandom; import java.security.spec.InvalidKeySpecException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import java.util.Properties; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.PBEKeySpec; import java.lang.annotation.Annotation; import java.text.NumberFormat; import java.util.Calendar; import java.util.Iterator; import net.sf.jasperreports.engine.JasperExportManager; import net.sf.jasperreports.engine.JasperFillManager; import net.sf.jasperreports.engine.JasperPrint; import net.sf.jasperreports.engine.JasperReport; import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource; import net.sf.jasperreports.engine.util.JRLoader; import org.apache.poi.ss.usermodel.Sheet; import org.apache.poi.ss.usermodel.Workbook; import org.apache.poi.xssf.usermodel.XSSFWorkbook; //import org.apache.poi.hwpf.HWPFDocument; //import org.apache.poi.hwpf.extractor.WordExtractor; import org.apache.poi.xwpf.usermodel.XWPFDocument; import org.apache.poi.xwpf.usermodel.XWPFParagraph; import org.apache.poi.xwpf.usermodel.XWPFRun; //import org.dhatim.fastexcel.reader.Row; import com.megatim.export.excel.Export; import com.megatim.fdxcommons.tools.context.AppContext; import java.io.InputStream; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.format.DateTimeFormatter; import java.time.format.FormatStyle; import java.util.Locale; import java.util.stream.IntStream; import org.apache.poi.ss.usermodel.Cell; import org.apache.poi.ss.usermodel.Row; import javax.ws.rs.core.MultivaluedMap; /* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ /** * * @author ABEGA */ public class CommonsTools { /** * Methode permettant de fusionner plusieur pdf * * @param inputPdfList * @param outputStream * @throws Exception */ public static void mergePdfFiles(List inputPdfList, OutputStream outputStream) throws Exception { //Create document and pdfReader objects. Document document = new Document(); List readers = new ArrayList<>(); int totalPages = 0; //Create pdf Iterator object using inputPdfList. Iterator pdfIterator = inputPdfList.iterator(); // Create reader list for the input pdf files. while (pdfIterator.hasNext()) { InputStream pdf = pdfIterator.next(); PdfReader pdfReader = new PdfReader(pdf); readers.add(pdfReader); totalPages = totalPages + pdfReader.getNumberOfPages(); } // Create writer for the outputStream PdfWriter writer = PdfWriter.getInstance(document, outputStream); //Open document. document.open(); //Contain the pdf data. PdfContentByte pageContentByte = writer.getDirectContent(); PdfImportedPage pdfImportedPage; int currentPdfReaderPage = 1; Iterator iteratorPDFReader = readers.iterator(); // Iterate and process the reader list. while (iteratorPDFReader.hasNext()) { PdfReader pdfReader = iteratorPDFReader.next(); //Create page and add content. while (currentPdfReaderPage <= pdfReader.getNumberOfPages()) { document.newPage(); pdfImportedPage = writer.getImportedPage( pdfReader, currentPdfReaderPage); pageContentByte.addTemplate(pdfImportedPage, 0, 0); currentPdfReaderPage++; } currentPdfReaderPage = 1; } //Close document and outputStream. outputStream.flush(); document.close(); outputStream.close(); } /** * Permet de convertir un tableau de bytes en un fichier * * @param nomFichier * @param content * @return */ public static File convertBytesArrayToFile(String nomFichier, byte[] content) { //Variables FileOutputStream fileOuputStream = null; File fichier = null; try { //Variables fileOuputStream = new FileOutputStream(nomFichier); //On lit le fichier fileOuputStream.write(content); //On ferme le fichier fileOuputStream.close(); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } return new File(nomFichier); } /** * Permet de convertir un fichier en tableau de bytes * * @param fichier * @return */ public static byte[] convertFileToBytesArray(File fichier) { //Variables byte[] byteArray = new byte[(int) fichier.length()]; try { //Variables FileInputStream inputStream = new FileInputStream(fichier); //On lit le fichier inputStream.read(byteArray); //On ferme le fichier inputStream.close(); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } return byteArray; } /** * Permet d'exporter en excel dans repertoire donn� * * @param datas * @param repertoireGeneration * @return */ public static File exporterEnExcel(List datas, File fichier) { try { //On effectue l'export Export.exportExcel(datas, fichier.getAbsolutePath()); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } return fichier; } /** * Permet de verifier si une liste de valeurs est contenu dans une chaine * * @param chaine * @param tab * @return */ public static boolean contains(String chaine, List tab) { //Variables boolean bool = false; //Si non vide if (tab != null && !tab.isEmpty()) { //On parcourt la liste des valeurs for (String valeur : tab) { //Si la chaine est contenu dans la chaine if (chaine.contains(valeur)) { //On set la valeur bool = true; //On sort break; } } } return bool; } /** * Cette methode permet les donnees depuis un fichier excel * * @param file * @return */ public static List readExcelFile(File file) { //On definit de variables de reference FileInputStream inputStream = null; Workbook workbook = null; Sheet firstSheet = null; Iterator iterator = null; //Declaration List cellules = new ArrayList(); try { //Affectation inputStream = new FileInputStream(file); workbook = new XSSFWorkbook(inputStream); firstSheet = workbook.getSheetAt(0); //iterator = firstSheet.iterator(); for (int rowNumber = firstSheet.getFirstRowNum(); rowNumber <= firstSheet.getLastRowNum(); rowNumber++) { Row row = firstSheet.getRow(rowNumber); if (row == null) { // This row is completely empty } else { // The row has data for (int cellNumber = row.getFirstCellNum(); cellNumber <= row.getLastCellNum(); cellNumber++) { Cell cell = row.getCell(cellNumber, Row.MissingCellPolicy.RETURN_BLANK_AS_NULL); // if (cell == null || cell.getCellType() == Cell.CELL_TYPE_BLANK) { // // //On ajoute la cellule // cellules.add(cell); // // } else { // // // // } //On ajoute la cellule cellules.add(cell); // if(cell != null){ // System.out.println(">>>>>>>>>>>>>"+cell.getCellValue()); // }else{ // System.out.println("Cell NULLL>>>>>>>>>>>>>"); // } } } } //On parcour la feuille // while (iterator.hasNext()) { // Row nextRow = iterator.next(); // Iterator cellIterator = nextRow.cellIterator(); // // //On parcour les cellules // while (cellIterator.hasNext()) { // // //On ajoute les cellules // cellules.add(cellIterator.next()); // } // } // //On ferme le classeur workbook.close(); //On ferme le stream inputStream.close(); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } finally { try { inputStream.close(); } catch (IOException ex) { //On affiche l'erreur ex.printStackTrace(); } } return cellules; } /** * Permet de lire un fichier csv * * @param file * @return * @throws Exception */ public static List readCsvFile(File file) throws Exception { //Variables List allData = null; InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file), "UTF-8"); CSVReader csvReader = null; try { // create csvReader object and skip first Line try { //On lit le fichier csvReader = new CSVReaderBuilder(inputStreamReader) .withSkipLines(1) .build(); //On recup�re les donn�es allData = csvReader.readAll(); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } finally { //On ferme le reader csvReader.close(); } } finally { //On ferme le fichier inputStreamReader.close(); } return allData; } /** * Permet de mettre de mettre l'heure � minuit * * @param date * @return */ public static Date passerHeureAMinuit(Date date) { Calendar calendar = Calendar.getInstance(); calendar.setTime(date); calendar.set(Calendar.HOUR_OF_DAY, 0); calendar.set(Calendar.MINUTE, 0); calendar.set(Calendar.SECOND, 0); calendar.set(Calendar.MILLISECOND, 0); return calendar.getTime(); } /** * Permet de retourner la liste des codes valeurs ch�que * * @return */ public static List getCodeValeursCheque() { //Variables List liste = new ArrayList(); //On charge liste.add("30"); liste.add("33"); return liste; } /** * Permet de retourner la liste des codes valeurs virement * * @return */ public static List getCodeValeursVirement() { //Variables List liste = new ArrayList(); //On charge liste.add("10"); liste.add("13"); return liste; } /** * permet de g��nrer en pdf * * @param datas * @param pdfFile * @param reportFilePath * @param params * @return * @throws Exception */ public static File genererFichierPdf(List datas, String pdfFile, String reportFilePath, Map params) throws Exception { // Creation d'un File sur le fichier File reportFile = new File(reportFilePath); File fichierGenerer = new File(pdfFile); //On cree le fichier s'ile n'existe pas if (!fichierGenerer.exists()) { //On cree le fichier fichierGenerer.createNewFile(); } // Chargement du Rapport JasperReport report = null; // Etat rempli JasperPrint jasperPrint = null; // Chargement du report report = (JasperReport) JRLoader.loadObject(reportFile); jasperPrint = JasperFillManager.fillReport(report, params, new JRBeanCollectionDataSource(datas, false)); OutputStream output = new FileOutputStream(fichierGenerer); JasperExportManager.exportReportToPdfStream(jasperPrint, output); output.close(); return fichierGenerer; } /** * Permet de modifier un document word * * @param map * @param pathFile * @param repertoireDestination * @return * @throws Exception */ public static String updateWordFileToOtherFile(Map map, String pathFile, String fileName, String repertoireDestination) throws Exception { try { // System.out.println("---------------------------updateWordFileToOtherFile----------1111111111111--------------------------------------"+pathFile); //Variables FileInputStream fis = new FileInputStream(pathFile); XWPFDocument doc = new XWPFDocument(fis); FileOutputStream out = null; //String fileName = genererValeurAleatoire() + ".docx"; String filePathDestination = repertoireDestination + File.separator + fileName + ".docx"; //On parcourt le document for (Map.Entry entry : map.entrySet()) { for (XWPFParagraph p : doc.getParagraphs()) { List runs = p.getRuns(); if (runs != null) { for (XWPFRun r : runs) { String text = r.getText(0); //On verifie s'il elle contient la cle if (text != null && text.contains(entry.getKey())) { //Si la valeur est non vide if (entry.getValue() != null) { //On dermine le type if (entry.getValue() instanceof String) { text = text.replace(entry.getKey(), (String) entry.getValue()); r.setText(text, 0); } else { text = text.replace(entry.getKey(), entry.getValue().toString()); r.setText(text, 0); } } else { r.setText("", 0); } } } } } } //On ecrit dans le fichier out = new FileOutputStream(new File(filePathDestination)); doc.write(out); out.close(); doc.close(); return filePathDestination; } catch (Exception ex) { ex.printStackTrace(); } return null; } /** * Permet de generer des nomre aleatorement * * @return */ public static String genererValeurAleatoire() { SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); String nombre = format.format(new Date()) + String.valueOf((int) (Math.random() * 1000000000)); return nombre; } /** * Permet de charger des classes qui ont une annotation pr�cise * * @param pkgName * @param annotation * @return */ public static List getAnnotations(final String pkgName, String annotation) { //Variables List> classRefs = new ArrayList<>(); List annotations = new ArrayList<>(); try ( ScanResult scanResult = new ClassGraph().acceptPackages(pkgName).enableAllInfo().scan()) { //On recup�re les classes annot�es ClassInfoList liste = scanResult.getClassesWithAnnotation(annotation); //On charge les classes classRefs = liste.loadClasses(); //On parcourt les classes for (Class classe : classRefs) { //On parcourt les annotations for (Annotation annotationDeclaree : classe.getDeclaredAnnotations()) { //On ajoute l'annotation annotations.add(annotationDeclaree); } } } catch (Exception e) { //On affiche les traces e.printStackTrace(); } return annotations; } /** * Permet de charger des classes qui ont une annotation pr�cise * * @param pkgName * @param annotation * @return */ public static List> getAnnotatedClasses(final String pkgName, String annotation) { //Variables List> classRefs = new ArrayList<>(); try ( ScanResult scanResult = new ClassGraph().acceptPackages(pkgName).enableAllInfo().scan()) { //On recup�re les classes annot�es ClassInfoList liste = scanResult.getClassesWithAnnotation(annotation); //On charge les classes classRefs = liste.loadClasses(); } catch (Exception e) { //On affiche les traces e.printStackTrace(); } return classRefs; } /** * Permet verifier si une chaine est contenu un tableau de chaine * * @param value * @param tab * @return * @throws Exception */ public static boolean in(String value, String tab[]) { //Variables boolean bool = false; //Si non null if (tab != null && value != null) { //On parcourt la chaine for (String obj : tab) { //Si trouv� if (obj.equalsIgnoreCase(value)) { //On marque comme trouv� bool = true; //On sort break; } } } return bool; } /** * Permet verifier si une chaine est contenu un tableau de chaine * * @param value * @param tab * @return * @throws Exception */ public static boolean contains(String value, String tab[]) { //Variables boolean bool = false; //Si non null if (tab != null && value != null) { //On parcourt la chaine for (String obj : tab) { //Si trouv� if (value.contains(obj)) { //On marque comme trouv� bool = true; //On sort break; } } } return bool; } /** * Permet de charger le fichier * * @param contenuDuFichier * @return * @throws Exception */ public static List lireFichier(File fichier) throws Exception { //Variables List lignes = null; //On charge le fichier lignes = chargerLesDonnees(new FileInputStream(fichier)); return lignes; } /** * Permet de charger le fichier * * @param contenuDuFichier * @return * @throws Exception */ public static List chargerLesDonnees(Object contenuDuFichier) throws Exception { //Variables FileInputStream fichier = (FileInputStream) contenuDuFichier; InputStreamReader inputStreamReader = new InputStreamReader(fichier); BufferedReader entree; List contenuFichier; String ligne = null; //Affectation entree = new BufferedReader((Reader) inputStreamReader); contenuFichier = new ArrayList(); //On parcourt ligne par ligne le fichier while (true) { //On lie une ligne dans le fichier ligne = entree.readLine(); //Traitement si la ligne est non null if (ligne != null) { //On recupere la ligne contenuFichier.add(ligne); } else { //On sort de la boucle break; } } //On close entree.close(); return contenuFichier; } /** * Permet de decouper le traitement en plusieurs processus * * @param * @param list * @param subListNumber * @return */ public static List> splitList(List list, int subListNumber) { //Liste a retourner List> splitted = new ArrayList>(); //Si la liste est vide if (list == null || list.size() == 0) { return splitted; } //CAs sp?cifique du nombre de sous liste inf?rieur ? 1 if (subListNumber <= 1) { //Ajout de la liste courante ? la liste des sous liste splitted.add(list); //retour de la liste des sous liste return splitted; } //Taille de la liste int listSize = list.size(); //taille de la sous liste int subListSize = Math.max(listSize / (subListNumber - 1), 1); //parcours de la liste a splitter for (int i = 0; i < listSize; i += subListSize) { //Ajout de la sous-liste splitted.add(new ArrayList(list.subList(i, Math.min(listSize, i + subListSize)))); } //On retourne la liste des sous-liste return splitted; } /** * Retourn le chemin courant * * @return */ public static File getCurrentDirectory() { String fileName = (String) System.getProperties().get("user.dir"); return new File(fileName); } public static Properties loadProperties(String filename) { Properties properties = new Properties(); try { //On charge le fichier de config properties.load(new FileInputStream(filename)); } catch (Exception ex) { //On affiche l'erreur ex.printStackTrace(); } return properties; } /** * Permet d'ecrire le fichier sur el disque * * @param content * @param filename * @throws IOException */ public static void ecrireFichier(byte[] content, String filename) throws IOException { File file = new File(filename); if (!file.exists()) { file.createNewFile(); } FileOutputStream fop = new FileOutputStream(file); fop.write(content); fop.flush(); fop.close(); } /** * Permet de recup�erer le nom du fichier * * @param headers * @return */ public static String getNomFichier(MultivaluedMap headers) { String[] contentDisposition = headers.getFirst("Content-Disposition").split(";"); for (String filename : contentDisposition) { if ((filename.trim().startsWith("filename"))) { String[] name = filename.split("="); String finalFileName = name[1].trim().replaceAll("\"", ""); return finalFileName; } } return ""; } // // /** // * Permet de convertir un object java en json // * // * @param objects // * @return // */ // public static String convertirJavaToJson(List