private static string ImportPdfData(ParseOutput parseOutput, string pdfFileName)
{
var storedDocumentGuid = string.Empty;
if (parseOutput.CSVFileName != string.Empty)
{
var statementGuid = Guid.NewGuid().ToString();
var simpleFileName = FileHelper.GetFileNameFromPath(pdfFileName) + ".pdf";
// Import PDF Document
storedDocumentGuid = StorePDF(statementGuid, pdfFileName, parseOutput);
if (storedDocumentGuid != string.Empty)
{
// Import data in CSV file
CsvImporter.ImportCsvFile(storedDocumentGuid, Settings.CsvOutputFolderPath + parseOutput.CSVFileName, pdfFileName, parseOutput.IsMiscDeposit, parseOutput.IsBonusStatement);
}
// Archive CSV File
var archiveFolderPath = Settings.ImportArchiveFolderPath + simpleFileName + "\\";
FileHelper.WipeDirectory(archiveFolderPath);
FileHelper.MoveFile(Settings.CsvOutputFolderPath + parseOutput.CSVFileName, archiveFolderPath + parseOutput.CSVFileName);
}
return(storedDocumentGuid);
}
private static void InterpretParameterPrime(ParseOutput ret, ParseOutput lhs, ParseOutput pprime)
{
/* Convert LHS PPRIME to either:
*
* if PPRIME.Children == 0: LHS
* else : Expression(LHS, PPRIME.Children)
*/
if (pprime.Children.Count == 0)
{
ret.Children.Add(lhs);
}
else
{
ParseOutput expression = new ParseOutput {
Type = ParseOutput.OutputType.Expression
};
expression.Children.Add(lhs);
foreach (ParseOutput pprime_child in pprime.Children)
{
// If its a Parameter with a solitary child, use that instead
if ((pprime_child.Type == ParseOutput.OutputType.Parameter) && (pprime_child.Children.Count == 1))
{
expression.Children.Add(pprime_child.Children[0]);
}
else
{
expression.Children.Add(pprime_child);
}
}
ret.Children.Add(expression);
}
}
internal static ParseOutput ParseParameterPrime(IList <Tokenizer.TokenDefinition> input, ref int i, bool is_directive)
{
// ParameterPrime: num_op parameter | empty (empty also consumes, but does not output, ',', and if(is_directive), ':')
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.ParameterPrime
};
int start_i = i;
// Try and match numop
ParseOutput numop = ParseNumOp(input, ref i);
if (numop != null)
{
ParseOutput param = ParseParameter(input, ref i, is_directive);
if (param != null)
{
ret.Children.Add(numop);
ret.Children.Add(param);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Else, consume commas and possibly colons
while (MatchString(input, ",", ref i) || (is_directive && MatchString(input, ":", ref i)))
{
;
}
return(ret);
}
protected static string StorePDF(string statementGuid, string pdfFileName, ParseOutput parseOutput)
{
// Convert PDF to Base64 string
var bytes = File.ReadAllBytes(pdfFileName);
var base64FileContent = Convert.ToBase64String(bytes);
// Use Import Service to store the Base64 File content
var importService = new PremiumTransactionServiceSoapClient();
return(importService.StorePDF(Settings.AgencyId, parseOutput.CarrierName, statementGuid, base64FileContent, pdfFileName, false));
}
internal override bool TryParse(ParseState state, ParseOutput output)
{
output.Add(new HtmlStartTag("p"));
state.StartRun();
var ch = state.ReadInlineOrCharacter(output);
while (ch != Symbols.EndOfFile)
{
ch = state.ReadInlineOrCharacter(output);
}
output.Add(state.EndRun());
output.Add(new HtmlEndTag("p"));
return(true);
}
internal static ParseOutput ParseBlock(IList <Tokenizer.TokenDefinition> input, ref int i)
{
// Match Line*
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.Block
};
ParseOutput cur_line;
while ((cur_line = ParseLine(input, ref i)) != null)
{
ret.Children.Add(cur_line);
}
return(ret);
}
public static void WriteParseOutput(ParseOutput parseOutput)
{
var csvOutPut = new StringBuilder();
csvOutPut.Append(
$"{Settings.AgencyId}, {parseOutput.CarrierName}, {parseOutput.PdfFileName}, {parseOutput.ConverterName}, {parseOutput.StartTime}, {parseOutput.EndTime}, {parseOutput.Duration}, {parseOutput.CSVRowCount}\r\n");
lock (_myLock)
{
if (parseOutput.CSVRowCount == 0)
{
File.AppendAllText(@"c:\temp\PDFExtractEmptyFiles.csv", csvOutPut.ToString());
}
else
{
File.AppendAllText(@"c:\temp\PDFExtract.csv", csvOutPut.ToString());
}
}
}
internal override bool TryParse(ParseState state, ParseOutput output)
{
if (state.Peek() != _marker)
{
return(false);
}
var start = state.Index;
state.ReadCharacter(); // consume _marker
var ch = state.ReadCharacter();
if (ch != _marker)
{
state.Index = start;
return(false);
}
ch = state.ReadCharacter();
if (ch == _marker)
{
state.Index = start;
return(false);
}
state.StartRun(start + 2);
while (ch != Symbols.EndOfFile)
{
if (ch == _marker)
{
var next = state.ReadCharacter();
ch = next == _marker ? Symbols.EndOfFile : next;
}
else
{
ch = state.ReadInlineOrCharacter(output);
}
}
output.Add(new HtmlStartTag(_tag));
output.Add(state.EndRun(-2));
output.Add(new HtmlEndTag(_tag));
return(true);
}
internal static ParseOutput ParseDirective(IList <Tokenizer.TokenDefinition> input, ref int i)
{
// Directive: directive | '[' directive ']' | '%' directive
int start_i = i;
string str;
if (((str = MatchString(input, directives, ref i)) != null) || ((MatchString(input, "[", ref i)) &&
((str = MatchString(input, sq_bracket_directives, ref i)) != null) && (MatchString(input, "]", ref i))) ||
((MatchString(input, "%", ref i)) && ((str = MatchString(input, percent_directives, ref i)) != null)))
{
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.Directive, Name = str
};
return(ret);
}
// Rewind and fail
i = start_i;
return(null);
}
internal static ParseOutput ParseContentsOf(IList <Tokenizer.TokenDefinition> input, ref int i, bool is_directive)
{
// ContentsOf: '[' Parameter ']'
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.ContentsOf
};
int start_i = i;
// Try and match
ParseOutput param;
if (MatchString(input, "[", ref i) && ((param = ParseParameter(input, ref i, is_directive)) != null) && MatchString(input, "]", ref i))
{
ret.Children.Add(param);
return(ret);
}
// Else rewind and fail
i = start_i;
return(null);
}
internal override bool TryParse(ParseState state, ParseOutput output)
{
var start = state.Index;
var ch = state.ReadCharacter();
var inBracket = false;
if (_allowBracket && ch == '[')
{
inBracket = true;
ch = state.ReadCharacter();
}
// Bail if current character is not the marker
// -or- current character is marker and the previous character was
// neither a bracket or whitespace
if (ch != _marker ||
(!inBracket && start > 0 && !char.IsWhiteSpace(state[start - 1])))
{
return(state.Reset(start));
}
ch = state.ReadCharacter();
if (ch == _marker)
{
return(state.Reset(start));
}
state.StartRun(start + (inBracket ? 2 : 1));
while (ch != Symbols.EndOfFile)
{
if (ch == _marker)
{
if (inBracket)
{
var next = state.ReadCharacter();
ch = next == ']' ? Symbols.EndOfFile : next;
}
else
{
var next = state.ReadCharacter();
if (char.IsWhiteSpace(ch))
{
ch = Symbols.EndOfFile;
state.Index--;
}
else
{
ch = next;
}
}
}
else
{
ch = state.ReadInlineOrCharacter(output);
}
}
output.Add(new HtmlStartTag(_tag));
output.Add(state.EndRun(inBracket ? -2 : -1));
output.Add(new HtmlEndTag(_tag));
return(true);
}
private static ParseOutput ParsePdf(string pdfFileName)
{
var parseOutput = new ParseOutput();
if (pdfFileName.Contains("Protective"))
{
parseOutput = ProtectivePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Protective";
}
else if (pdfFileName.Contains("Principal"))
{
parseOutput = PrincipalPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Principal";
}
else if (pdfFileName.Contains("Prudential"))
{
parseOutput = PrudentialPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Prudential";
}
else if (pdfFileName.Contains("Genworth"))
{
parseOutput = GenworthPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Genworth";
}
else if (pdfFileName.Contains("Brighthouse"))
{
parseOutput = BrightHousePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Brighthouse";
}
else if (pdfFileName.Contains("Hancock"))
{
parseOutput = JohnHancockPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "John Hancock";
}
else if (pdfFileName.Contains("Lincoln"))
{
parseOutput = LincolnPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Lincoln";
}
else if (pdfFileName.Contains("Transamerica"))
{
parseOutput = TransamericaPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Transamerica";
}
else if (pdfFileName.Contains("Omaha"))
{
parseOutput = MutualOfOmahaPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Mutual Of Omaha";
}
else if (pdfFileName.Contains("American National"))
{
parseOutput = AmericanNationalPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "American National";
}
else if (pdfFileName.Contains("American General"))
{
parseOutput = AmericanGeneralPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "American General";
}
else if (pdfFileName.Contains("Penn Mutual"))
{
parseOutput = PennMutualPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Penn Mutual";
}
else if (pdfFileName.Contains("VOYA"))
{
parseOutput = VoyaPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Voya";
}
else if (pdfFileName.Contains("Symetra"))
{
parseOutput = SymetraPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Symetra";
}
else if (pdfFileName.Contains("Zurich"))
{
parseOutput = ZurichPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Zurich";
}
else if (pdfFileName.Contains("Reliance Standard"))
{
parseOutput = RelianceStandardPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Reliance Standard";
}
else if (pdfFileName.Contains("Nationwide"))
{
parseOutput = NationwidePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Nationwide";
}
else if (pdfFileName.Contains("North American"))
{
parseOutput = NorthAmericanPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "North American";
}
else if (pdfFileName.Contains("William Penn"))
{
parseOutput = WilliamPennPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "William Penn";
}
else if (pdfFileName.Contains("Assurity"))
{
parseOutput = AssurityPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Assurity";
}
else if (pdfFileName.Contains("Hartford"))
{
parseOutput = HartfordPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Hartford";
}
else if (pdfFileName.Contains("Mass Mutual"))
{
parseOutput = MassMutualPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Mass Mutual";
}
else if (pdfFileName.Contains("MetLife"))
{
parseOutput = MetLifePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "MetLife";
}
else if (pdfFileName.Contains("Standard -"))
{
parseOutput = StandardPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Standard";
}
else if (pdfFileName.Contains("AXA"))
{
parseOutput = AxaPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "AXA";
}
else if (pdfFileName.Contains("Banner"))
{
parseOutput = BannerPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Banner";
}
else if (pdfFileName.Contains("Minnesota"))
{
parseOutput = MinnesotaLifePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Minnesota Life";
}
else if (pdfFileName.Contains("Pacific"))
{
parseOutput = PacificLifePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Pacific Life";
}
else if (pdfFileName.Contains("Allstate"))
{
parseOutput = AllstatePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Allstate";
}
else if (pdfFileName.Contains("Athene"))
{
parseOutput = AthenePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Athene";
}
else if (pdfFileName.Contains("Foresters"))
{
parseOutput = ForestersPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Foresters";
}
else if (pdfFileName.Contains("Equitable"))
{
parseOutput = EquitablePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Equitable";
}
else if (pdfFileName.Contains("National Life"))
{
parseOutput = NationalLifePdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "National Life";
}
else if (pdfFileName.Contains("NBC National"))
{
parseOutput = NBCPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "NBC Marketing";
}
else if (pdfFileName.Contains("Legacy Marketing"))
{
parseOutput = LegacyPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Ameritas";
}
else if (pdfFileName.Contains("Guggenheim"))
{
parseOutput = GuggenheimPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Guggenheim";
}
else if (pdfFileName.Contains("Security Mutual"))
{
parseOutput = SecurityMutualPdfParser.ParsePdf(pdfFileName);
parseOutput.CarrierName = "Security Mutual";
}
return(parseOutput);
}
internal abstract bool TryParse(ParseState state, ParseOutput output);
internal static ParseOutput ParseParameter(IList <Tokenizer.TokenDefinition> input, ref int i, bool is_directive)
{
// Parameter: register P' | label P' | number P' | '[' P ']' P'
int start_i = i;
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.Parameter
};
// Try and match a register
ParseOutput reg = ParseRegister(input, ref i);
ParseOutput pprime;
if (reg != null)
{
// Match PPrime
pprime = ParseParameterPrime(input, ref i, is_directive);
if (pprime != null)
{
InterpretParameterPrime(ret, reg, pprime);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Rewind and try and match a label
i = start_i;
ParseOutput label = ParseLabel(input, ref i);
if (label != null)
{
// Match PPrime
pprime = ParseParameterPrime(input, ref i, is_directive);
if (pprime != null)
{
InterpretParameterPrime(ret, label, pprime);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Rewind and try and match a number
i = start_i;
ParseOutput number = ParseNumber(input, ref i);
if (number != null)
{
// Match PPrime
pprime = ParseParameterPrime(input, ref i, is_directive);
if (pprime != null)
{
InterpretParameterPrime(ret, number, pprime);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Rewind and try and match a 'ContentsOf'
i = start_i;
ParseOutput cof = ParseContentsOf(input, ref i, is_directive);
if (cof != null)
{
// Match PPrime
pprime = ParseParameterPrime(input, ref i, is_directive);
if (pprime != null)
{
InterpretParameterPrime(ret, cof, pprime);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Else rewind and fail
i = start_i;
return(null);
}
internal static ParseOutput ParseCommand(IList <Tokenizer.TokenDefinition> input, ref int i)
{
// Command: Directive Parameters* NewLine | Prefix* Operation Parameters* NewLine
int start_i = i;
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.OpCommand
};
ParseOutput dir;
ParseOutput param;
if ((dir = ParseDirective(input, ref i)) != null)
{
ret.Children.Add(dir);
// Match Parameters
while ((param = ParseParameter(input, ref i, true)) != null)
{
ret.Children.Add(param);
}
// Match NewLine
if (MatchNewLine(input, ref i))
{
ret.Type = ParseOutput.OutputType.DirectiveCommand;
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Else try and match prefixes
ParseOutput prefix;
while ((prefix = ParsePrefix(input, ref i)) != null)
{
ret.Children.Add(prefix);
}
// Match Operation
ParseOutput op = ParseOperation(input, ref i);
if (op == null)
{
// Rewind and fail
i = start_i;
return(null);
}
ret.Children.Add(op);
// Match parameters
while ((param = ParseParameter(input, ref i, false)) != null)
{
ret.Children.Add(param);
}
// Match NewLine
if (MatchNewLine(input, ref i))
{
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
internal static ParseOutput ParseLine(IList <Tokenizer.TokenDefinition> input, ref int i)
{
// Line : EndOfInput | NewLine | Command | Label NewLine | Label ':' NewLine | Label ':' Command
ParseOutput ret = new ParseOutput {
Type = ParseOutput.OutputType.Line
};
// Match EndOfInput
if (i >= input.Count)
{
return(null);
}
int start_i = i;
// Try and match NewLine
if (MatchNewLine(input, ref i))
{
return(ret);
}
// Try and match Command
ParseOutput cmd = ParseCommand(input, ref i);
if (cmd != null)
{
ret.Children.Add(cmd);
return(ret);
}
// Else rewind and try and match label
i = start_i;
ParseOutput label = ParseLabel(input, ref i);
if (label != null)
{
// Try and match ':'
if (MatchString(input, ":", ref i))
{
// Try and match newline
if (MatchNewLine(input, ref i))
{
ret.Children.Add(label);
return(ret);
}
else if ((cmd = ParseCommand(input, ref i)) != null)
{
ret.Children.Add(label);
ret.Children.Add(cmd);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
else if (MatchNewLine(input, ref i))
{
ret.Children.Add(label);
return(ret);
}
else
{
// Rewind and fail
i = start_i;
return(null);
}
}
// Else rewind and fail
i = start_i;
return(null);
}
