public void PdfTextExtractorTestMethod1()
{
string text = new PdfTextExtractor().GetTextByCommandLine(@"D:\DHL\A.pdf");
int textlength = text.Length;
}
public virtual string GetText()
{
var output = new StringBuilder();
using (var pdfReader = GetPdfReader())
{
if (!IsPdf)
{
return(null);
}
for (var i = 1; i <= pdfReader.NumberOfPages; i++)
{
var text = PdfTextExtractor.GetTextFromPage(pdfReader, i, new SimpleTextExtractionStrategy());
output.AppendLine(text);
}
}
return(output.ToString());
}
public string Parse()
{
if (!File.Exists(Context.Path))
{
throw new FileNotFoundException("File " + Context.Path + " is not found");
}
using (PdfReader reader = new PdfReader(this.Context.Path))
{
StringBuilder text = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
ITextExtractionStrategy its = new iTextSharp.text.pdf.parser.LocationTextExtractionStrategy();
string thePage = PdfTextExtractor.GetTextFromPage(reader, i, its);
text.AppendLine(thePage);
}
return(text.ToString());
}
}
public static string GetPdfText(string filename)
{
StringBuilder text = new StringBuilder();
if (File.Exists(filename))
{
PdfReader pdfReader = new PdfReader(filename);
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
currentText = Encoding.UTF8.GetString(Encoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
text.Append(currentText);
}
pdfReader.Close();
}
return(text.ToString());
}
public static void ExtractTextFromPdfToTxt(string path, string directoryPath)
{
using (PdfReader reader = new PdfReader(path))
{
StringBuilder text = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
text.Append(PdfTextExtractor.GetTextFromPage(reader, i));
}
string fileName = directoryPath + Path.GetFileName(path) + ".txt";
fileName = fileName.Replace(".pdf", "");
if (!File.Exists(fileName))
{
File.WriteAllText(fileName, text.ToString());
}
}
}
/// <summary>
/// Get PDF content from a metnioned URL
/// </summary>
/// <param name="url"></param>
/// <returns></returns>
public string GetPDFContentFromURL(string url)
{
string filepath = GetTempPDFFilePath();
StringBuilder text = new StringBuilder();
Console.WriteLine("Filepath : " + filepath);
Report.Pass("Getting PDF content ... " + filepath);
log.Info("Getting PDF content ...");
if (File.Exists(filepath))
{
//string[] lines;
(new WebClient()).DownloadFile(url, filepath);
Report.Pass("PDf File : " + filepath + " exists");
log.Info("PDf File : " + filepath + " exists");
PdfReader reader = new PdfReader(filepath);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
ITextExtractionStrategy strategy = new LocationTextExtractionStrategy();
string page = PdfTextExtractor.GetTextFromPage(reader, i, strategy);
string[] lines = page.Split('\n');
for (int j = 0; j < lines.Length; j++)
{
string line = Encoding.UTF8.GetString(Encoding.UTF8.GetBytes(lines[j]));
text.Append(line);
}
}
reader.Close();
RemoveTempFile(filepath);
}
else
{
Report.Fail("PDf File :" + filepath + " does not exists");
log.Error(TestContext.CurrentContext.Test.MethodName + "PDf File :" + filepath + " does not exists");
}
return(text.ToString());
}
private void button1_Click(object sender, EventArgs e)
{
// Start Reading eBook //
if (textBox1.Text == "")
{
MessageBox.Show(" Please Enter a location", "PDF to TEXT Converter");
}
else if (File.Exists(filename))
{
try
{
StringBuilder text = new StringBuilder();
PdfReader pdfReader = new PdfReader(filename);
progressBar1.Maximum = pdfReader.NumberOfPages;
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
text.Append(System.Environment.NewLine);
text.Append("\n Page Number:" + page);
text.Append(System.Environment.NewLine);
currentText = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
text.Append(currentText);
pdfReader.Close();
progressBar1.Value++;
}
pdftext.Text += text.ToString();
progressBar1.Value = 0;
}
catch (Exception ex)
{
MessageBox.Show("Error: " + ex.Message, "Error");
}
}
else
{
pdftext.Text = "Error: eBook does not exist at the specified location";
}
// End Reading eBook //
}
public static string ParsePdf(string filename)
//public static int ParsePdf(string filename)
{
if (!File.Exists(filename))
{
throw new FileNotFoundException("fileName");
}
using (PdfReader textreader = new PdfReader(filename))
{
StringBuilder sb = new StringBuilder();
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
for (int page = 0; page < textreader.NumberOfPages; page++)
{
string text = PdfTextExtractor.GetTextFromPage(textreader, page + 1, strategy);
if (!string.IsNullOrWhiteSpace(text))
{
sb.Append(Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(text))));
}
}
string sb_final = sb.ToString();
int new_file_name_index = sb_final.IndexOf("Number");
int startValue = new_file_name_index + 8;
string new_file_name = sb_final.Substring(startValue, 6);
return(new_file_name);
// Code adjustment
/*if (new_file_name == "201363")
*
* {
* return new_file_name;
* }
* else
* {
* return "";
* }*/
}
}
private bool isGoodChart(PdfDocument document)
{
int numPages = document.GetNumberOfPages();
for (int pageNumber = 1; pageNumber <= numPages; pageNumber++)
{
PdfPage currentPage = document.GetPage(pageNumber);
string pageContent = PdfTextExtractor.GetTextFromPage(currentPage);
foreach (string doc in physicianList)
{
// checks for a completed chart
string physicianString = "ED Provider Notes by " + doc;
string dischargeNote = "ED Discharge Summary Note";
if (pageContent.Contains(physicianString) && pageContent.Contains("Physical Exam"))
{
// LOGGING
global_log_file_sw.Write(physicianString + " " + "Physical Exam" + " on page " +
pageNumber.ToString() + " - GOOD");
return(true);
}
// checks for cosign needed charts
// these will be SC eventually, but should be sent to coding
else if (pageContent.Contains(dischargeNote) &&
pageContent.Contains(doc) &&
pageContent.Contains("Status: Cosign Needed"))
{
// LOGGING
global_log_file_sw.Write(dischargeNote + " " + doc + " Status: Cosign Needed" +
" on page " + pageNumber.ToString() + " - COSIGN NEEDED");
return(true);
}
}
}
// LOGGING
global_log_file_sw.Write(" - BAD");
return(false);
}
public string GetColumnWiseTextFromPDFFile(string filepath)
{
StringBuilder text = new StringBuilder();
if (File.Exists(filepath))
{
PdfReader reader = new PdfReader(filepath);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currenttext = PdfTextExtractor.GetTextFromPage(reader, i, strategy);
currenttext = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currenttext)));
text.Append(currenttext);
}
reader.Close();
}
return(text.ToString());
}
public string ReadData(string PdfFilePath)
{
if (!File.Exists(PdfFilePath))
{
throw new FileNotFoundException(PdfFilePath);
}
using (PdfReader reader = new PdfReader(PdfFilePath))
{
StringBuilder sb = new StringBuilder();
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
for (int page = 0; page < reader.NumberOfPages; page++)
{
string text = PdfTextExtractor.GetTextFromPage(reader, page + 1, strategy);
if (!string.IsNullOrWhiteSpace(text))
{
sb.Append(Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(text))));
}
}
return(sb.ToString());
}
}
public static string ProcessPDF(string path)
{
string input = "";
PdfReader reader = new PdfReader(path);
LocationTextExtractionStrategy strategy = new LocationTextExtractionStrategy();
for (int p = 1; p < reader.NumberOfPages; p++)
{
string page = PdfTextExtractor.GetTextFromPage(reader, p, strategy);
string[] lines = page.Split('\n');
foreach (string line in lines)
{
input += "|" + line;
}
}
reader.Close();
return(input);
}
/// <summary>
/// ////////////////////////// Для сохранения при выходе ...КОНЕЦ
/// </summary>
///
/// <summary>
/// ////////////////////////// Для экстрактора pdf файлов НАЧАЛО...
/// </summary>
public void ParsePdf(string fileName)
{
string text = "";
if (!File.Exists(fileName))
{
throw new FileNotFoundException(fileName);
}
PdfReader reader = new PdfReader(fileName);
StringBuilder sb = new StringBuilder();
//ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
for (int page = 0; page < reader.NumberOfPages; page++)
{
richTextBox1.Text += PdfTextExtractor.GetTextFromPage(reader, page + 1);
}
//richTextBox1.Text = text;
}
private List <int> ReadPdfFile(string fileName, String searthText)
{
List <int> pages = new List <int>();
if (File.Exists(fileName))
{
PdfReader pdfReader = new PdfReader(fileName);
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentPageText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
if (currentPageText.Contains(searthText))
{
pages.Add(page);
}
}
pdfReader.Close();
}
return(pages);
}
protected override void GetData()
{
string lPath = System.IO.Path.Combine(_analizerData.Settings.Directory, $"{_analizerData.Settings.SourceFileName}{_format}");
try
{
using (PdfDocument pdfDoc = new PdfDocument(new PdfReader(lPath)))
{
for (int i = 1; i <= pdfDoc.GetNumberOfPages(); i++)
{
PdfPage page = pdfDoc.GetPage(i);
_analizerData.Data.Append(PdfTextExtractor.GetTextFromPage(page));
}
}
}
catch (Exception)
{
//Log here
_analizerData.Success = false;
}
}
private async static Task <StringBuilder> ReadPdfFile(string filePath)
{
var pdfText = new StringBuilder();
using (var pdfReader = new PdfReader(filePath))
{
for (int page = 1; page < pdfReader.NumberOfPages; page++)
{
try
{
ITextExtractionStrategy pdfExtractor = new SimpleTextExtractionStrategy();
var text = PdfTextExtractor.GetTextFromPage(pdfReader, page, pdfExtractor);
pdfText.Append(text);
}
catch (Exception ex)
{
}
}
}
return(await Task.FromResult(pdfText));
}
/// <summary>
/// Get all page numbers that contains a string
/// </summary>
/// <param name="fileName"></param>
/// <param name="searchText"></param>
/// <param name="garetelistPages"></param>
/// <returns>List of page numbers</returns>
private static List <int> GetPagesByString(string fileName, String searchText, List <int> garetelistPages)
{
List <int> pages = new List <int>();
if (File.Exists(fileName))
{
PdfReader pdfReader = new PdfReader(fileName);
foreach (int page in garetelistPages)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentPageText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
if (currentPageText.Contains(searchText))
{
pages.Add(page);
}
}
pdfReader.Close();
}
return(pages);
}
//pathToFile should be the absolute or relative path to the pdf file with Filename.pdf
//for example - D://test//Test.pdf
public static string GetAllTextFromPDF(string pathToFile)
{
try
{
StringBuilder text = new StringBuilder();
using (PdfReader reader = new PdfReader(pathToFile))
{
for (int i = 1; i <= reader.NumberOfPages; i++)
{
text.Append(PdfTextExtractor.GetTextFromPage(reader, i));
}
}
return(text.ToString());
}
catch (Exception e)
{
LogHelper.LogException(e);
throw;
}
}
private bool Serach(string pdfData, string searchtext)
{
byte[] bytes = Convert.FromBase64String(pdfData);
PdfReader reader = new PdfReader(bytes);
string text = string.Empty;
for (int page = 1; page <= reader.NumberOfPages; page++)
{
text += PdfTextExtractor.GetTextFromPage(reader, page);
}
reader.Close();
if (text.Contains(searchtext))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Get all page numbers that contains Geräteliste
/// </summary>
/// <param name="fileName"></param>
/// <returns>List of page numbers</returns>
public static List <int> GetGaretelistePages(string fileName)
{
List <int> pages = new List <int>();
if (File.Exists(fileName))
{
PdfReader pdfReader = new PdfReader(fileName);
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentPageText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
if (currentPageText.Contains("Geräteliste"))
{
pages.Add(page);
}
}
pdfReader.Close();
}
return(pages);
}
public static string ReadPdfFile(string fileName)
{
StringBuilder text = new StringBuilder();
if (File.Exists(fileName))
{
PdfReader pdfReader = new PdfReader(fileName);
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
// Todo: Try LocationTextExtractionStrategy instead, or see about overriding SimpleTextExtractionStrategy() with different space between characters.
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
currentText = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
text.Append(currentText);
}
pdfReader.Close();
}
return(text.ToString());
}
static private string GetTextFromPDF(string fname)
{
StringBuilder text = new StringBuilder();
try {
using (PdfReader reader = new PdfReader(fname))
{
for (int i = 1; i <= reader.NumberOfPages; i++)
{
text.Append(PdfTextExtractor.GetTextFromPage(reader, i));
}
}
}
catch (Exception e)
{
Console.WriteLine("Error on pdf open {0}", e);
fileopen = false;
}
return(text.ToString());
}
private static string ConvertPDFToText(byte[] bytes)
{
var sb = new StringBuilder();
try
{
var reader = new PdfReader(bytes);
var numberOfPages = reader.NumberOfPages;
for (var currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
sb.Append(PdfTextExtractor.GetTextFromPage(reader, currentPageIndex));
}
}
catch (Exception exception)
{
Console.WriteLine(exception.Message);
}
return(sb.ToString());
}
public static string ExtractTextFromPdf(string path)
{
ITextExtractionStrategy its = new iTextSharp.text.pdf.parser.LocationTextExtractionStrategy();
using (PdfReader reader = new PdfReader(path))
{
StringBuilder text = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
string thePage = PdfTextExtractor.GetTextFromPage(reader, i, its);
string[] theLines = thePage.Split('\n');
foreach (var theLine in theLines)
{
text.AppendLine(theLine);
}
}
return(text.ToString());
}
}
public void iTextSharp(BackgroundWorker backgroundWorker, string path)
{
using (PdfReader reader = new PdfReader(path))
{
mpath = path;
StringBuilder builder = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
if (!backgroundWorker.CancellationPending)
{
backgroundWorker.ReportProgress((i * 100) / reader.NumberOfPages);
//bulider.Append(PdfTextExtractor.GetTextFromPage(reader, i));
ITextExtractionStrategy its = new iTextSharp.text.pdf.parser.LocationTextExtractionStrategy();
string s = PdfTextExtractor.GetTextFromPage(reader, i, its);
//s = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(s)));
builder.Append(s);
}
}
MainForm.finaltext = builder.ToString();
}
}
/// <summary>
/// Parse pdf to text string
/// </summary>
/// <param name="data">pdf data stream</param>
public void ParsePdf(byte[] data)
{
this.pacNetBalanceRows = new List <PacNetBalanceRow>();
var reader = new PdfReader(data);
for (int page = 1; page <= reader.NumberOfPages; page++)
{
string text = PdfTextExtractor.GetTextFromPage(reader, page);
string[] lines = text.Split(new[] { "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string line in lines)
{
HandleLine(line);
}
} // for
reader.Close();
PacNetBalance.PopulateList(date, openingBalance, closingBalance, credits, debits, this.pacNetBalanceRows, this.loginAddress, this.loginPassword);
} // ParsePdf
public static UserData ClasifySheet(string PdfSheetPath, IEnumerable <UserData> Users)
{
PdfReader pdfReader = new PdfReader(PdfSheetPath);
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string pdf_text = PdfTextExtractor.GetTextFromPage(pdfReader, 1, strategy);
pdf_text = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(pdf_text)));
Match match = expression_regular.Match(pdf_text);
if (match.Success)
{
foreach (UserData currentUser in Users)
{
if (currentUser.Pattern == match.Groups[1].Value)
{
return(currentUser);
}
}
}
return(null);
}
//static degiskeni ile ayrilastirilmis sayfalar metodu sadece tek bir sefer cagirarak bulunur
static String extractText(string path)
{
StringBuilder text = new StringBuilder();
using (PdfReader reader = new PdfReader(path))
{
pages = new string[reader.NumberOfPages];
StringBuilder page = new StringBuilder();
for (int i = 1; i <= reader.NumberOfPages; i++)
{
page.Clear();
page.Append(PdfTextExtractor.GetTextFromPage(reader, i));
text.Append(page.ToString());
pages[i - 1] = page.ToString();
}
}
return(text.ToString());
}
public static string ReadDATAFromPDF(string fileName, string path)
{
StringBuilder sb = new StringBuilder();
if (File.Exists(fileName))
{
PdfReader reader = new PdfReader(fileName);
Rectangle rect = new Rectangle(0, 0, 415, 775);
RenderFilter[] filter = { new RegionTextRenderFilter(rect) };
ITextExtractionStrategy strategy;
for (int i = 1; i <= reader.NumberOfPages; i++)
{
strategy = new FilteredTextRenderListener(new LocationTextExtractionStrategy(), filter);
sb.AppendLine(PdfTextExtractor.GetTextFromPage(reader, i, strategy));
}
}
MakeTempFile(sb, path);
return(sb.ToString());
}
public static string[] OpenPDFFile(string path)
{
try
{
using (PdfReader reader = new PdfReader(path))
{
string[] page = new string[reader.NumberOfPages + 1];
for (int i = 1; i <= reader.NumberOfPages; i++)
{
//парсим книгу постранично
page[i] = PdfTextExtractor.GetTextFromPage(reader, i);
}
return(page);
}
}
catch (Exception ex)
{
Console.WriteLine("The file could not be read\n" + ex.Message);
return(new string[] {});
}
}
public string ReadPdfFile(string fileName)
{
StringBuilder text = new StringBuilder();
if (File.Exists(fileName))
{
Label1.Text = "Continúa desde donde lo dejaste...";
PdfReader pdfReader = new PdfReader(fileName);
for (int page = 1; page <= pdfReader.NumberOfPages; page++)
{
ITextExtractionStrategy strategy = new SimpleTextExtractionStrategy();
string currentText = PdfTextExtractor.GetTextFromPage(pdfReader, page, strategy);
currentText = Encoding.UTF8.GetString(ASCIIEncoding.Convert(Encoding.Default, Encoding.UTF8, Encoding.Default.GetBytes(currentText)));
text.Append(currentText);
}
pdfReader.Close();
}
return(text.ToString());
}
public static string GetExtract(BinaryData binaryData, Node node)
{
if (binaryData == null)
return string.Empty;
var fname = binaryData.FileName;
if (fname == null)
return string.Empty;
var ext = fname.Extension;
if (String.IsNullOrEmpty(ext))
return string.Empty;
ITextExtractor extractor = null;
var result = string.Empty;
switch (ext.ToLower())
{
case "contenttype":
case "xml": extractor = new XmlTextExtractor(); break;
case "doc": extractor = new DocTextExtractor(); break;
case "xls": extractor = new XlsTextExtractor(); break;
case "pdf": extractor = new PdfTextExtractor(); break;
case "docx": extractor = new DocxTextExtractor(); break;
case "xlsx": extractor = new XlsxTextExtractor(); break;
case "pptx": extractor = new PptxTextExtractor(); break;
case "txt": extractor = new PlainTextExtractor(); break;
default:
return String.Empty;
}
var stream = binaryData.GetStream();
if (stream == null)
return String.Empty;
if (stream.Length == 0)
return String.Empty;
try
{
////-- sync
//result = extractor.Extract(stream);
//-- async
Action<TimeboxedActivity> timeboxedFunctionCall = activity =>
{
var x = (Stream)activity.InArgument;
var extract = extractor.Extract(x);
activity.OutArgument = extract;
};
var act = new TimeboxedActivity();
act.InArgument = stream;
act.Activity = timeboxedFunctionCall;
act.Context = HttpContext.Current;
var finishedWithinTime = act.ExecuteAndWait(Repository.TextExtractTimeout * 1000);
if (!finishedWithinTime)
{
act.Abort();
var msg = String.Format("Text extracting timeout. Version: {0}, path: {1}", node.Version, node.Path);
Logger.WriteWarning(msg);
return String.Empty;
}
else if (act.ExecutionException != null)
{
WriteError(act.ExecutionException, node);
}
else
{
result = (string)act.OutArgument;
}
}
catch (Exception e)
{
WriteError(e, node);
}
if (String.IsNullOrEmpty(result))
{
var format = @"Couldn't extract text. VersionId: {0}, path: '{1}' ";
var inf = String.Format(CultureInfo.InvariantCulture, format, node.VersionId, node.Path);
Logger.WriteWarning(inf);
}
result = result.Replace('\0', '.');
return result;
}
public static string GetExtract(Stream stream, string fileName, out string errorMessage)
{
if (stream == null)
{
errorMessage = null;
return String.Empty;
}
if (stream.Length == 0)
{
errorMessage = null;
return String.Empty;
}
if (String.IsNullOrEmpty(fileName))
{
errorMessage = "Cannot resolve a TextExtractor if FileName is null or empty";
return String.Empty;
}
var extension = Path.GetExtension(fileName);
if (String.IsNullOrEmpty(extension))
{
errorMessage = "Cannot resolve a TextExtractor if FileName's extension is null or empty";
return string.Empty;
}
extension = extension.TrimStart('.');
if (extension.Length == 0)
{
errorMessage = "Cannot resolve a TextExtractor if FileName's extension is empty";
return string.Empty;
}
extension = extension.ToLower();
if (extension == "txt")
{
errorMessage = null;
return SenseNet.ContentRepository.Tools.GetStreamString(stream);
}
ITextExtractor extractor = null;
var result = string.Empty;
switch (extension)
{
case "contenttype":
case "xml": extractor = new XmlTextExtractor(); break;
case "doc": extractor = new DocTextExtractor(); break;
case "xls": extractor = new XlsTextExtractor(); break;
case "pdf": extractor = new PdfTextExtractor(); break;
case "docx": extractor = new DocxTextExtractor(); break;
case "xlsx": extractor = new XlsxTextExtractor(); break;
case "pptx": extractor = new PptxTextExtractor(); break;
case "txt": extractor = new PlainTextExtractor(); break;
default:
errorMessage = String.Format("Cannot resolve a TextExtractor for this extension: '{0}'", extension);
return String.Empty;
}
try
{
//-- sync
result = extractor.Extract(stream);
errorMessage = null;
////-- async
/*
Action<TimeboxedActivity> timeboxedFunctionCall = activity =>
{
var x = (Stream)activity.InArgument;
var extract = extractor.Extract(x);
activity.OutArgument = extract;
};
var act = new TimeboxedActivity();
act.InArgument = stream;
act.Activity = timeboxedFunctionCall;
var finishedWithinTime = act.ExecuteAndWait(5000);
if (!finishedWithinTime)
{
act.Abort();
errorMessage = String.Format("Text extracting timeout. path: {0}", fileName);
return String.Empty;
}
else if (act.ExecutionException != null)
{
errorMessage = String.Format("An error occured during extracting text. Path: {0}. Message: {1}", fileName, act.ExecutionException.Message);
}
else
{
result = (string)act.OutArgument;
errorMessage = null;
}
*/
}
catch (Exception e)
{
errorMessage = String.Format("An error occured during extracting text. Path: {0}. Message: {1}", fileName, e.Message);
}
if (String.IsNullOrEmpty(result))
{
var format = @"Couldn't extract text. FileName: '{0}' ";
errorMessage = String.Format(CultureInfo.InvariantCulture, format, fileName);
}
result = result.Replace('\0', '.');
return result;
}
