Exemple #1
0
        internal static bool EmbedPDFAttachment(List <PDFAttachmentItem> attachments, PDDocument doc)
        {
            bool flag;

            try
            {
                PDEmbeddedFilesNameTreeNode pDEmbeddedFilesNameTreeNode = new PDEmbeddedFilesNameTreeNode();
                List arrayList = new ArrayList();
                foreach (PDFAttachmentItem attachment in attachments)
                {
                    PDComplexFileSpecification pDComplexFileSpecification = new PDComplexFileSpecification();
                    pDComplexFileSpecification.setFile(System.IO.Path.GetFileName(attachment.filePath));
                    java.io.File   file           = new java.io.File(attachment.filePath);
                    byte[]         numArray       = Files.readAllBytes(file.toPath());
                    PDEmbeddedFile pDEmbeddedFile = new PDEmbeddedFile(doc, new ByteArrayInputStream(numArray));
                    pDEmbeddedFile.setSize((int)numArray.Length);
                    pDEmbeddedFile.setCreationDate(new GregorianCalendar());
                    pDComplexFileSpecification.setEmbeddedFile(pDEmbeddedFile);
                    PDEmbeddedFilesNameTreeNode pDEmbeddedFilesNameTreeNode1 = new PDEmbeddedFilesNameTreeNode();
                    pDEmbeddedFilesNameTreeNode1.setNames(Collections.singletonMap(attachment.filePath, pDComplexFileSpecification));
                    arrayList.@add(pDEmbeddedFilesNameTreeNode1);
                }
                pDEmbeddedFilesNameTreeNode.setKids(arrayList);
                PDDocumentNameDictionary pDDocumentNameDictionary = new PDDocumentNameDictionary(doc.getDocumentCatalog());
                pDDocumentNameDictionary.setEmbeddedFiles(pDEmbeddedFilesNameTreeNode);
                doc.getDocumentCatalog().setNames(pDDocumentNameDictionary);
                flag = true;
            }
            catch (Exception exception1)
            {
                Exception exception = exception1;
                throw new PDFToolkitException(exception.Message, exception);
            }
            return(flag);
        }
        private static PDEmbeddedFile getEmbeddedFile(PDComplexFileSpecification fileSpec)
        {
            PDEmbeddedFile embeddedFileUnicode = null;

            if (fileSpec != null)
            {
                embeddedFileUnicode = fileSpec.getEmbeddedFileUnicode() ?? fileSpec.getEmbeddedFileDos() ?? fileSpec.getEmbeddedFileMac() ?? fileSpec.getEmbeddedFileUnix() ?? fileSpec.getEmbeddedFile();
            }
            return(embeddedFileUnicode);
        }
 private static void extractFiles(Map names, string filePath)
 {
     object[] objArray = names.entrySet().toArray();
     for (int i = 0; i < (int)objArray.Length; i++)
     {
         PDComplexFileSpecification value = (PDComplexFileSpecification)((Map.Entry)objArray[i]).getValue();
         string filename = value.getFilename();
         PDFExtractEmbeddedFiles.extractFile(filePath, filename, PDFExtractEmbeddedFiles.getEmbeddedFile(value));
     }
 }
 internal static void ExtractAttachment(PDFDocument pdfDoc, string OutputPath)
 {
     try
     {
         string     filePath       = pdfDoc.FilePath;
         PDDocument pDFBoxDocument = pdfDoc.PDFBoxDocument;
         PDEmbeddedFilesNameTreeNode embeddedFiles = (new PDDocumentNameDictionary(pDFBoxDocument.getDocumentCatalog())).getEmbeddedFiles();
         if (embeddedFiles != null)
         {
             Map names = embeddedFiles.getNames();
             if (names == null)
             {
                 object[] objArray = embeddedFiles.getKids().toArray();
                 for (int i = 0; i < (int)objArray.Length; i++)
                 {
                     names = ((PDNameTreeNode)objArray[i]).getNames();
                     PDFExtractEmbeddedFiles.extractFiles(names, OutputPath);
                 }
             }
             else
             {
                 PDFExtractEmbeddedFiles.extractFiles(names, OutputPath);
             }
         }
         foreach (PDPage page in pDFBoxDocument.getPages())
         {
             object[] objArray1 = page.getAnnotations().toArray();
             for (int j = 0; j < (int)objArray1.Length; j++)
             {
                 PDAnnotation pDAnnotation = (PDAnnotation)objArray1[j];
                 if (pDAnnotation is PDAnnotationFileAttachment)
                 {
                     PDComplexFileSpecification file         = (PDComplexFileSpecification)((PDAnnotationFileAttachment)pDAnnotation).getFile();
                     PDEmbeddedFile             embeddedFile = PDFExtractEmbeddedFiles.getEmbeddedFile(file);
                     PDFExtractEmbeddedFiles.extractFile(filePath, file.getFilename(), embeddedFile);
                 }
             }
         }
     }
     finally
     {
     }
 }
        /**
         * Extracts a ZUGFeRD invoice from a PDF document represented by an input stream.
         * Errors are reported via exception handling.
         */
        public void extractLowLevel(InputStream pdfStream)
        {
            PDDocument doc = null;

            try
            {
                doc = PDDocument.load(pdfStream);
                // PDDocumentInformation info = doc.getDocumentInformation();
                PDDocumentNameDictionary names = new PDDocumentNameDictionary(
                    doc.getDocumentCatalog());
                PDEmbeddedFilesNameTreeNode etn;
                etn = names.getEmbeddedFiles();
                if (etn == null)
                {
                    doc.close();
                    return;
                }
                //Set efMap = etn.getNames().keySet();
                Object[] efMap = etn.getNames().keySet().toArray();
                //Map<String, COSObjectable> efMap = etn.getNames();
                // String filePath = "/tmp/";
                //for (String filename : efMap.keySet()) {
                foreach (String filename in efMap)
                {
                    ///**
                    //* currently (in the release candidate of version 1) only one
                    //* attached file with the name ZUGFeRD-invoice.xml is allowed
                    //* */
                    if (filename.Equals("ZUGFeRD-invoice.xml"))
                    { //$NON-NLS-1$
                        containsMeta = true;
                        PDComplexFileSpecification fileSpec     = (PDComplexFileSpecification)etn.getNames().get(filename);
                        PDEmbeddedFile             embeddedFile = fileSpec.getEmbeddedFile();
                        // String embeddedFilename = filePath + filename;
                        // File file = new File(filePath + filename);
                        // System.out.println("Writing " + embeddedFilename);
                        // ByteArrayOutputStream fileBytes=new
                        // ByteArrayOutputStream();
                        // FileOutputStream fos = new FileOutputStream(file);
                        rawXML = embeddedFile.getByteArray();
                        setMeta(Encoding.UTF8.GetString(rawXML));
                        // fos.write(embeddedFile.getByteArray());
                        // fos.close();
                    }
                }
            }
            catch (IOException e1)
            {
                throw e1;
            }
            finally
            {
                try
                {
                    if (doc != null)
                    {
                        doc.close();
                    }
                }
                catch (IOException e) { }
            }
        }
        // Decent example here -- https://github.com/Aiybe/PDFData/blob/master/od-reader/src/main/java/im/abe/pdfdata/AttachmentDataStorage.java

        private void AttachmentZone_Drop(object sender, DragEventArgs e)
        {
            // reset UI
            AttachmentZoneBorder.BorderThickness = new Thickness(1);
            AttachmentZone.Background            = new SolidColorBrush(System.Windows.Media.Color.FromRgb(255, 255, 255));
            deselectAllAttachmentPanels();

            // attach files to PDF
            if (e.Data.GetDataPresent(DataFormats.FileDrop))
            {
                // Note that you can have more than one file.
                string[]      files     = (string[])e.Data.GetData(DataFormats.FileDrop);
                List <string> filesList = files.ToList();

                if (pd != null)
                {
                    foreach (string file in filesList)
                    {
                        byte[] fileBytes;
                        try
                        {
                            fileBytes = System.IO.File.ReadAllBytes(file);
                        }
                        catch
                        {
                            // couldn't read file
                            MessageBox.Show("Can't open " + file + " make sure it is not open in another application.", "Can't open file.");
                            continue;
                        }
                        FileStream _filestream        = System.IO.File.Open(file, FileMode.Open);
                        string     nameOfFileToAttach = _filestream.Name;
                        _filestream.Close();

                        PDComplexFileSpecification fs = new PDComplexFileSpecification();
                        fs.setFile(nameOfFileToAttach);

                        ByteArrayInputStream inputStream = new ByteArrayInputStream(fileBytes, 0, fileBytes.Length);
                        //ByteArrayInputStream inputStream = new ByteArrayInputStream(fileBytes);
                        PDEmbeddedFile embeddedFile = new PDEmbeddedFile(pd, inputStream);
                        embeddedFile.setModDate(java.util.Calendar.getInstance());
                        embeddedFile.setSize(fileBytes.Length);
                        fs.setEmbeddedFile(embeddedFile);

                        PDDocumentCatalog        catalog = pd.getDocumentCatalog();
                        PDDocumentNameDictionary names   = catalog.getNames();

                        Map TomsNewMap = new HashMap();
                        if (names != null)
                        {
                            // there are already some attached files
                            PDEmbeddedFilesNameTreeNode embeddedFiles = names.getEmbeddedFiles();
                            Map embeddedFileNames = embeddedFiles.getNames();
                            Dictionary <String, PDComplexFileSpecification> embeddedFileNamesNet = embeddedFileNames.ToDictionary <String, PDComplexFileSpecification>();


                            // Attach all the existing files
                            foreach (KeyValuePair <String, PDComplexFileSpecification> entry in embeddedFileNamesNet)
                            {
                                TomsNewMap.put(entry.Key, entry.Value);
                            }
                        }
                        else
                        {
                            // there are no files already attached -- so create a new name dictionary
                            names = new PDDocumentNameDictionary(catalog);
                        }

                        // Attach the new file
                        TomsNewMap.put(System.IO.Path.GetFileName(nameOfFileToAttach), fs);
                        PDEmbeddedFilesNameTreeNode TomsEmbeddedFiles = new PDEmbeddedFilesNameTreeNode();
                        TomsEmbeddedFiles.setNames(TomsNewMap);
                        names.setEmbeddedFiles(TomsEmbeddedFiles);
                        catalog.setNames(names);

                        pd.save(pathToCurrentPDF);
                        pd.close();
                    }
                }
                else
                {
                    MessageBoxResult result = MessageBox.Show("No PDF file loaded.");
                }
            }

            // reload the PDF
            LoadPDFAndLookForAttachments(pathToCurrentPDF);
        }
        /**
         * Embeds an external file (generic - any type allowed) in the PDF.
         *
         * @param doc
         *            PDDocument to attach the file to.
         * @param filename
         *            name of the file that will become attachment name in the PDF
         * @param relationship
         *            how the file relates to the content, e.g. "Alternative"
         * @param description
         *            Human-readable description of the file content
         * @param subType
         *            type of the data e.g. could be "text/xml" - mime like
         * @param data
         *            the binary data of the file/attachment
         */
        public void PDFAttachGenericFile(PDDocument doc, String filename,
                                         String relationship, String description, String subType, byte[] data)
        {
            PDComplexFileSpecification fs = new PDComplexFileSpecification();

            fs.setFile(filename);

            COSDictionary dict = fs.getCOSDictionary();

            dict.setName("AFRelationship", relationship);
            dict.setString("UF", filename);
            dict.setString("Desc", description);

            ByteArrayInputStream fakeFile = new ByteArrayInputStream(data);
            PDEmbeddedFile       ef       = new PDEmbeddedFile(doc, fakeFile);

            ef.setSubtype(subType);
            ef.setSize(data.Length);
            ef.setCreationDate(new GregorianCalendar());

            ef.setModDate(GregorianCalendar.getInstance());

            fs.setEmbeddedFile(ef);

            // In addition make sure the embedded file is set under /UF
            dict = fs.getCOSDictionary();
            COSDictionary efDict = (COSDictionary)dict
                                   .getDictionaryObject(COSName.EF);
            COSBase lowerLevelFile = efDict.getItem(COSName.F);

            efDict.setItem(COSName.UF, lowerLevelFile);

            // now add the entry to the embedded file tree and set in the document.
            PDDocumentNameDictionary names = new PDDocumentNameDictionary(
                doc.getDocumentCatalog());
            PDEmbeddedFilesNameTreeNode efTree = names.getEmbeddedFiles();

            if (efTree == null)
            {
                efTree = new PDEmbeddedFilesNameTreeNode();
            }

            //Map<String, COSObjectable> namesMap = new HashMap<String, COSObjectable>();
            //      Map<String, COSObjectable> oldNamesMap = efTree.getNames();
            //if (oldNamesMap != null) {
            // for (String key : oldNamesMap.keySet()) {
            //  namesMap.put(key, oldNamesMap.get(key));
            // }
            //}
            //efTree.setNames(namesMap);
            //should be ported more exactly...
            efTree.setNames(Collections.singletonMap(filename, fs));

            names.setEmbeddedFiles(efTree);
            doc.getDocumentCatalog().setNames(names);

            // AF entry (Array) in catalog with the FileSpec
            COSArray cosArray = (COSArray)doc.getDocumentCatalog()
                                .getCOSDictionary().getItem("AF");

            if (cosArray == null)
            {
                cosArray = new COSArray();
            }
            cosArray.add(fs);
            COSDictionary dict2 = doc.getDocumentCatalog().getCOSDictionary();
            COSArray      array = new COSArray();

            array.add(fs.getCOSDictionary()); // see below
            dict2.setItem("AF", array);
            doc.getDocumentCatalog().getCOSDictionary().setItem("AF", cosArray);
        }