The code sample I provided is specifically the piece that writes back to a document in the repository.

It doesn't matter if the file is in network path, a repo, etc. because you're using the stream to write; whether the source file is inside or outside the repo doesn't affect what you can do with the stream.

The document you want to write it to is "doc" in that code (i.e., doc.WriteEdoc)

So all you need to do is get a memory stream or file stream and of the PDF that can be used in the code I sent.

Based on your last statement I think part of the confusion is that you may be viewing the repo and a network folder as a 1-to-1 comparison, when in reality they are apples and oranges.

Although Laserfiche has a folder structure, that structure exists within Laserfiche so moving items into or out of a repo is not at all the same as dragging them between folders, hence the import/export methods.

I think a better question might be, why are you exporting it in the first place if you're just bringing it right back in and removing it from the external location.

I will take a look in a moment; just wanted to answer the last part though real quick: PDFSharp can not access the PDF while it is in LF Repo as far as I can tell, but if I export it first it becomes trivial to access it, so that is the option I opted for.

I'd imagine there is an overload that allows you to load the PDF into PDFSharp from a memorystream rather than only having a path option.

You can't load it from a path in Laserfiche because those are not real directory paths, but if you read it out into a stream, you should be able pass that into your PDFSharp code.

PDFSharp does allow you to open a memory stream - if I can not use a path though, how can Laserfiche provide me a memory stream of an in-repo PDF file for PDFSharp to use? 

You don't need a path. You would read the PDF from Laserfiche into a stream, then open the document directly from that stream.

For example,

PdfDocument document = PdfReader.Open(stream);

Here's an example of reading the PDF into a stream

// Read eDoc from document in repo
string mimeType = "";
MemoryStream ms = new MemoryStream();
using (LaserficheReadStream sEDocStream = sDoc.ReadEdoc(out mimeType)){
      sEDocStream.CopyTo(ms);
}

"You would read the PDF from Laserfiche into a stream" - would this not require a path? as far as I have been able to tell, all I have access to are tokens and all I get with tokens are non-existent paths and entry ids/names, if I need to read the PDF into a stream, how am I getting the 'the PDF'?
Stream ms = new MemoryStream() at minimum seems to requires a byte[] buffer, but then I am back to 'wouldn't i need a path to the PDF to specify to the byte[] buffer?'

I think you're still misunderstanding what a "path" means in Laserfiche.

A Laserfiche "path" is a logical construct; it doesn't actually exist as a folder path in the same way that you would see with network folders.

You don't read the PDF from a path, you read the PDF from the DocumentInfo object, which can be obtained in many different ways.

The same DocumentInfo object you use for the document exporter can be used with the ReadEdoc method in the code above.

You have the export working already which means you already have a viable DocumentInfo object and the only difference is that you would use it in the LaserficheReadStream instead of in the DocumentExporter.

I am completely misunderstanding what a path means in Laserfiche lol...

To be fair though, I am completely misunderstanding what the DocumentInfo object is as well - there isn't a lot of documentation so i'm kind of stumbling through this, sorry. This is what the script would look like if i adapted it to what i believe everyone here is suggesting, using a memory stream: 

            DocumentInfo docInf = (DocumentInfo)this.BoundEntryInfo;

            string mimeType = "pdf";
            MemoryStream ms = new MemoryStream();
            using (LaserficheReadStream eDocStream = docInf.ReadEdoc(out mimeType))
            {
                eDocStream.CopyTo(ms);
            }


            //a ms of the PDF
            PdfDocument inputDocument = PdfReader.Open(ms, PdfDocumentOpenMode.Modify);//PdfReader.Open(filledPDF, PdfDocumentOpenMode.Modify);

            //XGraphics object for drawing
            //this will need to know the page the signature must go on
            XGraphics gfx = XGraphics.FromPdfPage(inputDocument.Pages[2]);

            //get signature datafields (just the first)
            string sigStringPadded = this.WorkflowApi.GetTokenValueFromNameAsString("RetrieveBusinessProcessVariablesSignatureDatafields_datafield1", 1);

            //string to bytes
            byte[] imageBytes = Convert.FromBase64String(sigStringPadded);

            //bytes to stream
            Stream sigStream = new MemoryStream(imageBytes);

            //stream to image
            XImage xImg = XImage.FromStream(sigStream);

            //issue draw command
            DrawPng(gfx, xImg);

            //save outputDocument
            inputDocument.Save(ms);
            inputDocument.Close();

Looks like you're at least on the right track.

However, in the second to last step you should save to a new memory stream rather than reusing the original; either that or you'll have to reset the stream.

I'm unsure I understand the mental model of what is happening.

I have 'DocumentInfo' about the current entry.

I read the PDF Electronic Document of the current entry into a LaserficheReadStream.

I copy that PDF Stream into a 'plain' MemoryStream.

I make a PDFDocument by opening the 'plain' MemoryStream.

I make a graphics object using the PDFDocument pages.

I draw issue the draw on the graphics object - the PDFDocument in the 'plain' MemoryStream now has an image on it.

-----------

At this point I have tried:

inputDocument.Save(ms), thinking I am saving the document with the image to the 'plain' MemoryStream.

inputDocument.Save(eDocStream), thinking I am saving the document with the image to the Laserfiche entry [im certain this is wrong, but not understanding the mental model - i tried it].

docInfo.WriteEDoc(mimeType, ms.Length), thinking that if i read the EDoc then I should be writing the EDoc [though given that I can not specify the stream but only its length - this too feels wrong].

I've tried a few more things that I am forgetting, but I think I don't understand the mental model well enough. At this point I have a MemoryStream that contains a PDF document that has an image drawn on it, and I have an entry with a PDF. I am inclined to believe the next step would be taking the Document Info of the entry and writing the PDF-with-image MemoryStream to that entry; does that sound right?

So to answer the last part first, you cannot save back to the same stream you started with without extra steps. When you finish the PDFSharp portion, you either need to reset that "plain" memory stream or replace it with a new one.

The steps should be as follows

1. Get DocumentInfo object
2. Read PDF in LaserficheReadStream
3. Copy contents to first memory stream (ms)
4. Do all your PDFSharp stuff
5. Create a new Memory Stream (i.e., not ms) or Refresh ms (ms = new MemoryStream()) This step is very important.
6. Save PDFSharp document to the new/refreshed stream.
7. Now, use this final stream in the WriteEdoc code.

There's a lot you should research to really get comfortable with this level of coding, but a couple "crash course" items are as follows:

1. DocumentInfo is the document. A Laserfiche document is a complex object with pages, text, metadata, electronic files, and more, so the DocumentInfo literally is the document entry and the PDF you're working with is just a piece of that object.
2. Memory Streams are not files. Changes cannot just be saved back to the same stream because the properties of that stream, like the length and position need to change.

Thanks for your help. How is WriteEdoc supposed to be used? From what I can tell the only use is:

docInfo.WriteEdoc(mimeType, ms.Length)

I can't see how that would write anything. I've seen other posts here referencing using it like:

using (System.IO.Stream writeStream = docInfo.WriteEdoc(mimeType, ms.Length)

But doing that leaves me with a System.IO.Stream and a MemoryStream, the MemoryStream containing the PDF-with-image. So I figured I would do this:

writeStream.Write(ms.ToArray(),0,ms.ToArray().Length);

Thinking that I'm writing to the docInfo the contents of ms, but I guess I'm still misunderstanding. And it's tough because nothing is crashing and it's a little hard to 'debug' what exactly is happening. I agree that I need to research more to get comfortable with Laserfiche-coding, which is why I've been on the lookup for documentation beyond the 'SDK Documentation' PDF included with the installation; like it's wonderful to learn the mental model that DocumentInfo is the literal representation of the document from Laserfiches perspective, but I'm unsure where I would have gone to learn that.