David's technobabble » PDF

OCR’ing all of the PDF files in a SharePoint Document Library using PowerShell and Solid PDF Tools

david — Thu, 28 May 2009 03:39:33 +0000

A recent review of the PDF Documents in our Document Control Library, revealed that most were “image only” PDF’s. We’ve run our document control system on different versions of SharePoint technologies since SharePoint Portal Server 2001. We are currently running SharePoint 2007. I’m surprised that someone did not previously notice that most of our PDF files were not showing up in the searches.

The question is:“How can we get all of these PDFs reprocessed to be searchable for a reasonable cost?” I spent some time reviewing various PDF tools and was surprised that few were “truly” scriptable in batch. Some tools would not run on a server or could not interface with a “HTTP Network Place”. There were some development kits that were marketed and priced for you to build your own PDF tools and they have a pretty spendy price tag. These were out of scope with this year’s budget. Some, like Acrobat, had a batching mechanism in their GUI. However, this would require us to:

Manually checkout all of the PDF’s
Download them into a folder structure
Batch them in the UI
Upload all of the OCR’ed PDFs
Manually check-in all of the PDF’s

I don’t think so! We are talking about tens of thousands of documents. This would be labor intensive and prone to human error.

I’d just about given up finding something that would fit into the current budget, when I received an email notice about Solid Converter PDF V5 being available. While reviewing the v5 features, I noticed Solid PDF Tools v5 was out and it was just $20 more the upgrade to Solid Converter PDF v5. Low and behold, Solid PDF Tools v5 claims that it has a scriptable interface. I got to looking further and discovered their script reference manual and developer blog. I downloaded the trial and verified it. The software worked, I sent them my $59 upgrade fee and viola, I had a “scriptable enough” tool that I could re-scan “image-only” pdf files to create “searchable” pdf files. I say “scriptable enough” because it gets the job done, but Solid PDF Tools v5 needs to load the GUI, load the splash screen, and display the UI for each file processed. This seems to add 10-15 seconds to the processing time of each file

Now to convert the “image-only” PDF’s in SharePoint. Once again, I decided to try PowerShell rather than write a C# program to interface with SharePoint. At the same time, I decided to give the PowerGUI Tools a try. I found the PowerGUI Script Editor to be quite useful for developing, debugging and running my script.

The “proof-of-concept” result is ~100 lines of PowerShell code that

processes all of the webs in a sharepoint site
processes all of the folders and sub-folders
processes all of the PDF documents and sends them to OCR processing

^?View Code POWERSHELL

## References
[void][System.Reflection.Assembly]::LoadWithPartialName("Microsoft.SharePoint") 
[void][System.Reflection.Assembly]::LoadWithPartialName("System.IO") 
 
$SolidPDFTools = "$env:SolidPDFTools.exe" 
$LocalFileFolder= "D:\spwork\input";
$OCRWorkFolder= "D:\spwork\output";
$OCRWorkLogFolder= "D:\spwork\logs";
$OCRScriptFile= "D:\spwork\ocr.sdscript";
 
function script:write_local_file($file, $fileFolder) {
	$fs = New-Object System.IO.FileStream($(Join-Path $fileFolder $file.Name), [System.IO.FileMode]::Create)
	$bw = New-Object System.IO.BinaryWriter($fs);
	[Byte[]] $binfile = $file.OpenBinary();    
	$bw.Write($binfile);
	$bw.Close();
	$fs.close();
}
 
function script:ocr_local_file($file, $in_fpath, $out_fpath) {
	$infile = Join-Path $in_fpath $file.Name;
	$infile = $infile -replace("\\","\\");
	$outfile = Join-Path $out_fpath $file.Name;
	$outfile = $outfile -replace("\\","\\");
        $logfile = Join-Path $OCRWorkLogFolder "debug.log";
	$logfile = $logfile -replace("\\","\\");
	$DBG='< +  $logfile +') >> Trace';
	$INP='< + $infile + ')';
	$OTP='/Output (' + $outfile + ')';
	$OCR='/OCR/Searchable';
	$CRE='>> Create';
	$XIT='EXIT';
	Write-output $DBG | Out-File $OCRScriptFile -encoding ascii;
	Write-output $INP | Out-File $OCRScriptFile -append -encoding ascii;
	Write-output $OTP | Out-File $OCRScriptFile -append -encoding ascii;
	Write-output $OCR | Out-File $OCRScriptFile -append -encoding ascii;
	Write-output $CRE | Out-File $OCRScriptFile -append -encoding ascii;
	Write-output $XIT | Out-File $OCRScriptFile -append -encoding ascii;  
 
	$sTemp = &SolidPDFTools /i $OCRScriptFile /f script 
	Write-Host $sTemp;
}
 
function script:upload_ocr_result($file, $ocr_fpath) {
	$ocrfile = Join-Path $ocr_fpath $file.Name;
	$fs = New-Object System.IO.FileStream($(Join-Path $ocr_fpath $file.Name), [System.IO.FileMode]::Open)
	$br = New-Object System.IO.BinaryReader($fs);
	[Byte[]] $binfile = $br.ReadBytes($br.BaseStream.Length);
	$file.SaveBinary($binfile);
	$br.close();
	$fs.close();
 }
 
function script:process_a_folder($folder) {
	$files = $folder.Files;
	foreach($file in $files) {
		if ($file.Name.ToLower().Contains(".pdf") ) {
			if ($file.CheckOutStatus -eq "None") {
				$file.CheckOut();
            			write_local_file $file $LocalFileFolder;
				ocr_local_file $file $LocalFileFolder $OCRWorkFolder;
				upload_ocr_result $file $OCRWorkFolder; 
				$file.CheckIn("version has had OCR processing performed");
				$file.Update();
				}
			}
		}
	$sub_folders = $folder.SubFolders;
	process_folders($sub_folders);
}
 
function script:process_folders($folders) {
	foreach($folder in $folders) {
		process_a_folder($folder);
	}
}
 
function script:append-path {
	$oldPath = get-content Env:\Path;
	$newPath = $oldPath + ";" + $args;
	set-content Env:\Path $newPath;
}
 
# MAIN
append-path (resolve-path 'D:\Program Files\SolidDocuments\Solid PDF Tools\SPDFT').Path
 
$site = new-object Microsoft.SharePoint.SPSite("http://my-sp-server");   
$siteweb = $site.OpenWeb();   
$webs = $siteweb.Webs;   
foreach($web in $webs) {   
	$folders = $web.Folders;
	process_folders($folders);
	}

I do plan to add some logging, change the hard-coded variables, and look at using streams instead of Byte[] to be more flexible and scaleable. I’ll need some error handling to deal with things like download or upload failures before I can run this in production. I’m also trying to determine if a PDF is “image only” or searchable. However, the “Proof-of-concept” does work.

A walkthrough the code to extend the HP Digital Sending Software

david — Fri, 22 May 2009 00:05:36 +0000

Recently, I wrote about extending the HP Digital Sending Software to “close the gap” and email the OCR’ed result. I received a request to release the code, so I’ve decided to do so with a bit a of documentation.

The HP digital sending software creates an XML document similar to the one below and places it in the same folder with the OCR’ed PDF. This foldername will be set set in the App.config file so this service kniows where to watch.

^?View Code XML

<--! "s2d96A4D5F15D87FB9658B0ABC53184EE0A_1.xml -->
 version="1.0" encoding="UTF-8"?>
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" Version="4.0" SentTimeStamp="2009-05-17 01:59:15 Pacific Daylight Time (GMT+08:00)" FileName="s2d96A4D5F15D87FB9658B0ABC53184EE0A_1.pdf">
 Name="my-printer" ModelName="hp LaserJet 4345 mfp" Status="0">>
 Name="GUEST">>
 FileFormat="jpeg" SendingQuality="COLOR DOCUMENT" Pages="1" Duplex="0">>
 Name="SEND PDF TO MAIL" Path="*.COMMON MFP GROUP.SEARCHABLE PDF" NumberOfPrompts="3">
 Index="0" Name="MY-FROM" Displaytext="From:">>
 Index="1" Name="MY-TO" Displaytext="To:">>
 Index="2" Name="MY-SUBJECT" Displaytext="Subject:">>
>
>

You can see above, the FileName, From Email Address, To Email Address(es) and Email Subject have been provided. Once this information was married with an SMTP Server, then all of the information required to email the resulting OCR’ed file as an attachment was available.

I wrote and built the code using Visual Studio 2008. Since the code uses .NET 2.0 you could use Visual Studio 2005 or 2008. Alternatively, you can download the full .NET 2.0 SDK and compile the code with the .NET C# compiler, csc.

In order to make the service flexible, the configuration data is in my App.config file

^?View Code XML

 version="1.0" encoding="utf-8" ?>
>
>
<--! Where HP Scanning Software places the files -->
 key="WorkFlowScanPath" value="D:\test\files" />
<--! The file type to watch for changes -->
 key="WorkFlowScanFileType" value="*.xml" />
<--! The smtp server to send the email to -->
 key="WorkFlowScanSMTPServer" value="some.smtpserver" />
<--! The text of the email body -->
 key="WorkFlowScanMailText" value='Your scanned document is attached.' />
<--! What to do after the email "delete" or "keep" -->
 key="WorkFlowScanAfterSendAction" value="delete" />
<--! If "keep", where to move the processed files -->
 key="WorkFlowScanProcessedPath" value="D:\test\processed" />
<--! The XPATH Query string to locate the from email address inside the HP produced xml file -->
 key="WorkFlowScanXPath_From" value='/Info/Destination/Prompt[@Displaytext="From:"]' />
<--! The XPATH Query string to locate the to email address inside the HP produced xml file -->
 key="WorkFlowScanXPath_To" value='/Info/Destination/Prompt[@Displaytext="To:"]' />
<--! The XPATH Query string to locate the from subject from inside the HP produced xml file -->
 key="WorkFlowScanXPath_Subject" value='/Info/Destination/Prompt[@Displaytext="Subject:"]' />
>
>

The class inherits from the .NET ServiceBase class

^?View Code CSHARP

    public class eS_HPScan_WorkFlowEXT_Service : ServiceBase

When the service is started the OnStart method is called; the configuration data is retrieved and the file watcher event handler is setup and activated.

^?View Code CSHARP

        protected override void OnStart(string[] args)
        {
            log("starting");
            WorkflowScanPath = ConfigurationSettings.AppSettings["WorkFlowScanPath"];
            WorkflowScanProcessedPath = ConfigurationSettings.AppSettings["WorkFlowScanProcessedPath"];
            WorkflowScanFileType = ConfigurationSettings.AppSettings["WorkFlowScanFileType"];
            WorkFlowScanAfterSendAction = ConfigurationSettings.AppSettings["WorkFlowScanAfterSendAction"];
            WorkflowScanSMTPServer = ConfigurationSettings.AppSettings["WorkFlowScanSMTPServer"];
            WorkFlowScanMailText = ConfigurationSettings.AppSettings["WorkFlowScanMailText"];
            WorkFlowScanXPath_From = ConfigurationSettings.AppSettings["WorkFlowScanXPath_From"];
            WorkFlowScanXPath_To = ConfigurationSettings.AppSettings["WorkFlowScanXPath_To"];
            WorkFlowScanXPath_Subject = ConfigurationSettings.AppSettings["WorkFlowScanXPath_Subject"];
            fileSystemWatcher1 = new System.IO.FileSystemWatcher();
            fileSystemWatcher1.Path = WorkflowScanPath;
            fileSystemWatcher1.Filter = WorkflowScanFileType;
            fileSystemWatcher1.IncludeSubdirectories = false;
            fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler(this.File_Changed);
            fileSystemWatcher1.NotifyFilter = (NotifyFilters.CreationTime | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName);
            fileSystemWatcher1.EnableRaisingEvents = true;
 
            log("started" + "-monitoring type(s) " + WorkflowScanFileType + " in folder " + fileSystemWatcher1.Path);
        }

The File_Changed event handler is really pretty boring. All of the real action happens in the method process_file. However, every time a file changes in the folder being watched that is of type *.xml, then this method is called with the full path of the file changed.

^?View Code CSHARP

        private void File_Changed(object sender, System.IO.FileSystemEventArgs e)
        {
             log("File_Changed: " + e.FullPath);
            // file move causes event on the original file after moved, make sure file exists
            if (System.IO.File.Exists(e.FullPath))
            {
             process_file(e.FullPath);
            }
        }

The process_file method reads the xml file for the attributes of FileName, From Email Address, To Email Address(es) and Email Subject. Afterwards, an email is sent with the OCR’ed file as an attachment. Finally, the files are moved or deleted depending on the setting in the App.config file.

^?View Code CSHARP

        private void process_file(String xml_file_withpath)
        {
            XmlNode xNode = null;
            XmlDocument xDoc = new XmlDocument();
            Attachment message_attachment = null;
            try
            {
               xDoc.Load(xml_file_withpath);
               xNode = xDoc.SelectSingleNode("/Info");
               string pdf_File_name = xNode.Attributes.GetNamedItem("FileName").Value; 
               pdf_File_name = WorkflowScanPath + pathSep + pdf_File_name;
               string scan_from = get_email_info(xDoc, WorkFlowScanXPath_From);
               string scan_to = get_email_info(xDoc, WorkFlowScanXPath_To);
               string scan_subject = get_email_info(xDoc, WorkFlowScanXPath_Subject);
                MailMessage message = new MailMessage();
               message.From = new MailAddress(scan_from);
               // allow the to address to use , ; and whitespace as separators
               if (scan_to.Contains(",") || scan_to.Contains(";") || scan_to.Contains(" "))
               {
                   string[] stringSeparators = new string[] { ",", ";", " " };
                   string[] to_addresses = scan_to.Split(stringSeparators, StringSplitOptions.None);
                   foreach (string ts in to_addresses)
                   {
                       if (ts != null && !ts.Equals("") && !ts.Equals(" "))
                       {
                           message.To.Add(new MailAddress(ts));
                       }
                   }
               }
               else
               {
                   message.To.Add(new MailAddress(scan_to));
               }
 
               message.Subject = scan_subject;
               message.Body = WorkFlowScanMailText;
               // Create  the file attachment for this e-mail message.
               message_attachment = attach_file(pdf_File_name);
               // Add the file attachment to this e-mail message.
               message.Attachments.Add(message_attachment);
               //Send the message.
               SmtpClient mclient = new SmtpClient(WorkflowScanSMTPServer);
               mclient.Send(message);
               message_attachment.Dispose(); // free the memory and files!!
               message_attachment = null;
               move_delete_file(xml_file_withpath);
               move_delete_file(pdf_File_name);
            }
            catch (Exception ex)
            {
                log("Exception caught in process_file(): " + ex.ToString(), EventLogEntryType.Error);  
            }
            if (message_attachment != null)
            {
                message_attachment.Dispose(); // free the memory!!
            }
        }

The attach_file method deserves a bit of explanation. In a few cases, the XML file arrives before the actual OCR’ed file. To handle this case there is a loop to make sure that the OCR’ed file exists.

^?View Code CSHARP

        private Attachment attach_file(string attach_file)
        {
            Attachment result = null;
            int cmax = 10;
            // Try file for 10 seconds
            for (int i=1;i <= cmax; i++)
            {
                if (!System.IO.File.Exists(attach_file))
                {
                    if (i == cmax)
                    {
                        throw new Exception("File does not exist: " + attach_file);
                    }
                    System.Threading.Thread.Sleep(1000);
                }
                else
                {
                    break;
                }
            }
 
            result = new Attachment(attach_file, MediaTypeNames.Application.Octet);
            // Add time stamp information for the file.
            ContentDisposition disposition = result.ContentDisposition;
            disposition.CreationDate = System.IO.File.GetCreationTime(attach_file);
            disposition.ModificationDate = System.IO.File.GetLastWriteTime(attach_file);
            disposition.ReadDate = System.IO.File.GetLastAccessTime(attach_file);
            return result;
        }

I think the remainder of the methods are reliatively straight forward and unless someone wants an explanation I’ll leave that as an exercise for the reader. I did note that one improvement could be to place the email address separators in the App.config file. Although “;”, “,” and ” ” are the ones commonly used in email.

The full code listing.

^?View Code CSHARP

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Net.Mail;
using System.Net.Mime;
using System.ServiceProcess;
using System.Text;
using System.Xml;
using System.Xml.XPath;
 
using eS_HPScan_Workflow_Extender;
 
namespace eS_HPScan_Workflow_Extender
{
    public class eS_HPScan_WorkFlowEXT_Service : ServiceBase
    {
        private System.ComponentModel.Container components = null;
        private System.IO.FileSystemWatcher fileSystemWatcher1 = null;
        private String WorkflowScanPath = null;
        private String WorkFlowScanAfterSendAction = null;
        private String WorkflowScanProcessedPath = null;
        private String WorkflowScanFileType = null;
        private String WorkflowScanSMTPServer = null;
        private String WorkFlowScanMailText = null;
        private String WorkFlowScanXPath_From = null;
        private String WorkFlowScanXPath_To = null;
        private String WorkFlowScanXPath_Subject = null;
        private static String pathSep = "\\";
        private static String delete_action = "delete";
        private static int default_EventID = 0;
 
	public eS_HPScan_WorkFlowEXT_Service()
	{
		// This call is required by the Windows.Forms Component Designer.
		InitializeComponent();
		// TODO: Add any initialization after the InitComponent call
	}
 
	// The main entry point for the process
	static void Main()
	{
		System.ServiceProcess.ServiceBase[] ServicesToRun;	
		ServicesToRun = new System.ServiceProcess.ServiceBase[] { new eS_HPScan_WorkFlowEXT_Service() };
		System.ServiceProcess.ServiceBase.Run(ServicesToRun);
		}
 
		///  
		/// Required method for Designer support - do not modify 
		/// the contents of this method with the code editor.
		/// 
	private void InitializeComponent()
	{
		// 
		// eS_HPScan_WorkFlowEXT_Service
		// 
		this.CanShutdown = true;
		this.ServiceName = "eS_HPScan_WorkFlowEXT_Service";
	}
	/// 
	/// Clean up any resources being used.
	/// 
	protected override void Dispose( bool disposing )
	{
		if( disposing )
		{
			if (components != null) 
			{
				components.Dispose();
			}
		}
		base.Dispose( disposing );
	}
 
 
        protected override void OnStart(string[] args)
        {
            log("starting");
            WorkflowScanPath = ConfigurationSettings.AppSettings["WorkFlowScanPath"];
            WorkflowScanProcessedPath = ConfigurationSettings.AppSettings["WorkFlowScanProcessedPath"];
            WorkflowScanFileType = ConfigurationSettings.AppSettings["WorkFlowScanFileType"];
            WorkFlowScanAfterSendAction = ConfigurationSettings.AppSettings["WorkFlowScanAfterSendAction"];
            WorkflowScanSMTPServer = ConfigurationSettings.AppSettings["WorkFlowScanSMTPServer"];
            WorkFlowScanMailText = ConfigurationSettings.AppSettings["WorkFlowScanMailText"];
            WorkFlowScanXPath_From = ConfigurationSettings.AppSettings["WorkFlowScanXPath_From"];
            WorkFlowScanXPath_To = ConfigurationSettings.AppSettings["WorkFlowScanXPath_To"];
            WorkFlowScanXPath_Subject = ConfigurationSettings.AppSettings["WorkFlowScanXPath_Subject"];
 
            fileSystemWatcher1 = new System.IO.FileSystemWatcher();
            fileSystemWatcher1.Path = WorkflowScanPath;
            fileSystemWatcher1.Filter = WorkflowScanFileType;
            fileSystemWatcher1.IncludeSubdirectories = false;
            fileSystemWatcher1.Changed += new System.IO.FileSystemEventHandler(this.File_Changed);
            fileSystemWatcher1.NotifyFilter = (NotifyFilters.CreationTime | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName);
            fileSystemWatcher1.EnableRaisingEvents = true;
 
            log("started" + "-monitoring type(s) " + WorkflowScanFileType + " in folder " + fileSystemWatcher1.Path);
        }
 
        protected override void OnStop()
        {
            log("stopping");
            log("stopped");
        }
 
        private void File_Changed(object sender, System.IO.FileSystemEventArgs e)
        {
             log("File_Changed: " + e.FullPath);
            // file move causes event on the original file after moved, make sure file exists
            if (System.IO.File.Exists(e.FullPath))
            {
             process_file(e.FullPath);
            }
        }
 
        private void process_file(String xml_file_withpath)
        {
            XmlNode xNode = null;
            XmlDocument xDoc = new XmlDocument();
            Attachment message_attachment = null;
            try
            {
               xDoc.Load(xml_file_withpath);
               xNode = xDoc.SelectSingleNode("/Info");
               string pdf_File_name = xNode.Attributes.GetNamedItem("FileName").Value; 
               pdf_File_name = WorkflowScanPath + pathSep + pdf_File_name;
 
               string scan_from = get_email_info(xDoc, WorkFlowScanXPath_From);
               string scan_to = get_email_info(xDoc, WorkFlowScanXPath_To);
               string scan_subject = get_email_info(xDoc, WorkFlowScanXPath_Subject);
                MailMessage message = new MailMessage();
               message.From = new MailAddress(scan_from);
               // allow the to address to use , ; and whitespace as separators
               if (scan_to.Contains(",") || scan_to.Contains(";") || scan_to.Contains(" "))
               {
                   string[] stringSeparators = new string[] { ",", ";", " " };
                   string[] to_addresses = scan_to.Split(stringSeparators, StringSplitOptions.None);
                   foreach (string ts in to_addresses)
                   {
                       if (ts != null && !ts.Equals("") && !ts.Equals(" "))
                       {
                           message.To.Add(new MailAddress(ts));
                       }
                   }
               }
               else
               {
                   message.To.Add(new MailAddress(scan_to));
               }
 
               message.Subject = scan_subject;
               message.Body = WorkFlowScanMailText; 
               // Create  the file attachment for this e-mail message.
               message_attachment = attach_file(pdf_File_name);
               // Add the file attachment to this e-mail message.
               message.Attachments.Add(message_attachment);
               //Send the message.
               SmtpClient mclient = new SmtpClient(WorkflowScanSMTPServer);
               mclient.Send(message);
               message_attachment.Dispose(); // free the memory and files!!
               message_attachment = null;
               move_delete_file(xml_file_withpath);
               move_delete_file(pdf_File_name);
            }
            catch (Exception ex)
            {
                log("Exception caught in process_file(): " + ex.ToString(), EventLogEntryType.Error);  
            }
            if (message_attachment != null)
            {
                message_attachment.Dispose(); // free the memory!!
            }
        }
 
        private Attachment attach_file(string attach_file)
        {
            Attachment result = null;
            int cmax = 10;
            // Try file for 10 seconds
            for (int i=1;i <= cmax; i++)
            {
                if (!System.IO.File.Exists(attach_file))
                {
                    if (i == cmax)
                    {
                        throw new Exception("File does not exist: " + attach_file);
                    }
                    System.Threading.Thread.Sleep(1000);
                }
                else
                {
                    break;
                }
            }
 
            result = new Attachment(attach_file, MediaTypeNames.Application.Octet);
            // Add time stamp information for the file.
            ContentDisposition disposition = result.ContentDisposition;
            disposition.CreationDate = System.IO.File.GetCreationTime(attach_file);
            disposition.ModificationDate = System.IO.File.GetLastWriteTime(attach_file);
            disposition.ReadDate = System.IO.File.GetLastAccessTime(attach_file);
            return result;
 
        }
 
        private void move_delete_file(string file1)
        {
            try
            {
                string destfile = WorkflowScanProcessedPath + pathSep + System.IO.Path.GetFileName(file1);
                if (WorkFlowScanAfterSendAction.ToLower().Equals(delete_action))
                {
                    System.IO.File.Delete(file1);
                }
                else
                {
                    // Move does not have over write option
                    if (System.IO.File.Exists(destfile))
                    {
                        System.IO.File.Delete(destfile);
                    }
                    System.IO.File.Move(file1, destfile);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Source: " + file1 + " - Dest: " + WorkflowScanProcessedPath + " ",ex);
            }
        }
        private string get_email_info(XmlDocument xd, string p)
        {
            string result = null;
            XmlNode xn = xd.SelectSingleNode(p);
            XmlNode cxn = xn.ChildNodes[0];
            if (cxn is XmlCDataSection)
            {
                XmlCDataSection cdataSection = cxn as XmlCDataSection;
                result = cdataSection.Value;
            }
            return result;
        }
 
        public void log(String s)
        {
            log(s, EventLogEntryType.Information, default_EventID);
        } // end method
 
        public void log(String s, EventLogEntryType logtype)
        {
            log(s, logtype, default_EventID);
        } // end method
 
        public void log(String s, EventLogEntryType logtype, int EventID)
        {
            EventLog elog = getmylog();
            elog.WriteEntry(this.ServiceName + " " + s, logtype, EventID);
        } // end method
 
        private EventLog getmylog()
        {
            EventLog elog;
            String eventsource, logName;
            //This name gets registered in the windows registry in
            //a place where the event log knows where to find it.
            eventsource = this.ServiceName;
            //Give the event log a unique name. Don't choose 
            //Application, Security or System as a name
            logName = "Application";
            if (!EventLog.SourceExists(eventsource))
            {
                EventLog.CreateEventSource(eventsource, logName);
            }
            elog = new EventLog();
            //set the log to read and write from to the new log
            elog.Log = logName;
            //set the source to this program
            elog.Source = eventsource;
            return elog;
        }
    }
}

Making OCR’ed PDF’s using the HP Digital Sending Software

david — Fri, 08 May 2009 22:18:18 +0000

We recently became aware that our fancy HP workgroup printers which can copy a document and email the result as pdf to a set of email addresses only creates image pdf’s. None of the text in the pdf is searchable. After some investigation, we discovered that we needed to install the HP Digital Sending Software and let it perform OCR post-processing on the image pdf that was created by the printer.

This works all well and good, except that the HP Digital Sending Software places the OCR’ed file in a single configurable folder on the Print Server’s local disk . You might be wondering: “What’s the problem with that? Just share the folder to all users and be done with it.” Well, my answer is: “Not so fast. Much of the material being scanned is confidential and should not be placed where an unauthorized user might be able to access it.”

After further analysis of how the HP Digital Sending Software works, we determined that for every document scanned there are 2 files being created. One is the OCR’ed pdf file and the other is an informational xml file. The xml file contains the information that the user provided during the scan. This gave us access to the “from email address”, “to email address(es)”, and the OCR’ed pdf file name.

With this information, it was pretty straight forward to write a FileWatcher service in C# that would:

Handle the file changed events events with a filter on “*.xml” files.
I initially thought that I would be processing a file created event, but the HP software creates the xml file, then updates it.
Generate an email from the “from email address” to the “to email address(es)” with the OCR’ed pdf file as an attachment.
Delete the processed xml and pdf files from the folder.

It was pretty easy to plug this gap. However, without our little “gap filler” the HP Digital Sending Software is just technology and not a solution for a Company. I wonder why HP doesn’t provide tools with their Digital Sending Software to perform this function already?