private void butSaveTemplate_Click(object sender, EventArgs e)
{
this.selectedClassTemplate = ucSingleTemplateEditor1.GetDocumentClassTemplateWithChangedGeneralProperties();
var classTemplateWithChangedDataFields = ucSingleTemplateEditor1.GetDocumentClassTemplateWithChangedFields();
this.selectedClassTemplate.DataFields = classTemplateWithChangedDataFields.DataFields;
//var oldTemplate = this.classTemplates.Where(x => x.TemplateClassName == this.selectedClassTemplate.TemplateClassName).FirstOrDefault();
//if (oldTemplate != null)
//{
// this.classTemplates.Remove(oldTemplate);
// this.classTemplates.Add(this.selectedClassTemplate);
//}
var templateProcessor = new TemplateProcessor(Directories.AppRootPath);
if (Directories.AllowSaveTemplatesToFiles)
{
this.selectedClassTemplate.TemplateClassName = System.Text.RegularExpressions.Regex.Replace(this.selectedClassTemplate.TemplateClassName, @"[^0-9a-zA-Z]", string.Empty);
var saved = templateProcessor.SaveTemplateToFile(this.selectedClassTemplate);
if (saved == true)
{
ClassTemplateSavedInClassTemplateEditor?.Invoke(this.selectedClassTemplate);
}
}
else
{
this.selectedClassTemplate.TemplateClassName = System.Text.RegularExpressions.Regex.Replace(this.selectedClassTemplate.TemplateClassName, @"[^0-9a-zA-Z]", string.Empty);
templateProcessor.CleanClassTemplateBeforeSave(this.selectedClassTemplate);
ClassTemplateSavedInClassTemplateEditor?.Invoke(this.selectedClassTemplate);
}
}
/// <summary>
/// Shows the general properties of a class template
/// </summary>
public void ShowGeneralProperties(DocumentClassTemplate classTemplate)
{
this.classTemplate = classTemplate;
if (this.classTemplate != null)
{
txtClassName.Text = this.classTemplate.TemplateClassName;
txtGroupName.Text = this.classTemplate.TemplateGroupName;
txtIban.Text = string.Empty;
if (this.classTemplate.PreSelectionCondition.IBANs != null)
{
foreach (var item in this.classTemplate.PreSelectionCondition.IBANs)
{
txtIban.Text = txtIban.Text + item + Environment.NewLine;
}
}
txtKeyWords.Text = string.Empty;
if (this.classTemplate.KeyWords != null)
{
foreach (var item in this.classTemplate.KeyWords)
{
txtKeyWords.Text = txtKeyWords.Text + item + Environment.NewLine;
}
}
}
}
/// <summary>
/// Can be called to prepare modified class templates for being saved externally. Takes care removing double blank spaces in <see cref="DocumentBaseTemplate.KeyWords"/>.
/// Will be called automatically if the template is saved by the internally provided methods. (<see cref="SaveTemplateToFile(DocumentClassTemplate, string)"/>) and its derivates.
/// </summary>
/// <param name="template"></param>
/// <returns></returns>
public DocumentClassTemplate CleanClassTemplateBeforeSave(DocumentClassTemplate template)
{
// Clean KeyWords of excessive blank spaces to match a cleaned document text when
template.KeyWords = template.KeyWords.Select(x => Regex.Replace(x, " +", " ")).ToList();
return(template);
}
private void UcTemplateSelector1_SelectionChanged(string templateName)
{
if (this.selectedClassTemplate.TemplateClassName != templateName)
{
this.selectedClassTemplate = this.classTemplates.Where(x => x.TemplateClassName == templateName).FirstOrDefault();
ucSingleTemplateEditor1.ShowPropertiesAndDataFields(this.selectedClassTemplate);
}
}
private void TemplateEditor_ClassTemplateSavedInClassTemplateEditor(DocumentClassTemplate savedClassTemplate)
{
var template = this.classTemplates.Where(x => x.TemplateClassName == savedClassTemplate.TemplateClassName).FirstOrDefault();
if (template != null)
{
template = savedClassTemplate;
}
MessageBox.Show(Translation.LanguageStrings.MsgClassTemplateSaved + ": " + savedClassTemplate.TemplateClassName, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
/// <summary>
/// Returns the class (changed) class template, which is shown within ucSingleTemplateEditor
/// </summary>
public DocumentClassTemplate GetChangedDocumentClassTemplate()
{
var retVal = new DocumentClassTemplate();
retVal = ucSingleTemplateEditor1.GetDocumentClassTemplateWithChangedGeneralProperties();
var classTemplateWithChangedDataFields = ucSingleTemplateEditor1.GetDocumentClassTemplateWithChangedFields();
retVal.DataFields = classTemplateWithChangedDataFields.DataFields;
return(retVal);
}
/// <summary>
/// Deletes class template from directory
/// </summary>
/// <param name="template"></param>
/// <returns></returns>
public bool DeleteTemplateFile(DocumentClassTemplate template)
{
var filePath = Path.Combine(TemplateClassDirectory, template.TemplateClassName + ".json.txt");
try
{
File.Delete(filePath);
return(true);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(false);
}
}
/// <summary>
/// Saves class template to the specified directory.
/// </summary>
/// <param name="template">Class template</param>
/// <param name="templateDirectory">Template directory</param>
public bool SaveTemplateToFile(DocumentClassTemplate template, string templateDirectory)
{
var retVal = false;
template = CleanClassTemplateBeforeSave(template);
if (string.IsNullOrWhiteSpace(template.TemplateClassName) == false)
{
var templateJson = JsonConvert.SerializeObject(template, Formatting.Indented);
var filePath = Path.Combine(templateDirectory, template.TemplateClassName + ".json.txt");
File.WriteAllText(filePath, templateJson);
retVal = true;
}
return(retVal);
}
/// <summary>
/// Shows the data fields of a class template
/// </summary>
public void ShowDataFields(DocumentClassTemplate classTemplate)
{
this.classTemplate = classTemplate;
var controlList = new List <Control>();
foreach (Control control in flowLayoutPanel1.Controls)
{
controlList.Add(control);
}
foreach (Control control in controlList)
{
flowLayoutPanel1.Controls.Remove(control);
control.Dispose();
}
if (this.classTemplate != null && this.classTemplate.DataFields != null)
{
foreach (var item in this.classTemplate.DataFields)
{
var newDataField = (ucDataFieldClassTemplate)Activator.CreateInstance(UserControlSelector.DataFieldClassTemplateUserControl, item);
newDataField.Tag = Guid.NewGuid();
newDataField.IsInTemplateEditor = this.IsInClassTemplateEditor;
newDataField.RegexOrPositionHelper += FireRegexOrPositionHelper;
newDataField.DataFieldEraser += DeleteDataFieldClassTemplate;
flowLayoutPanel1.Controls.Add(newDataField);
}
}
if (this.classTemplate != null && this.classTemplate.ConditionalFields != null)
{
foreach (var item in this.classTemplate.ConditionalFields)
{
if (item.OnlyStoreInGroupTemplate == false)
{
var newConditionalField = (ucConditionalFieldTemplate)Activator.CreateInstance(UserControlSelector.ConditionalFieldTemplateUserControl, item);
newConditionalField.HideGroupTemplateSpecificComponents();
newConditionalField.Tag = Guid.NewGuid();
newConditionalField.ConditionalFieldEraser += DeleteConditionalField;
flowLayoutPanel1.Controls.Add(newConditionalField);
}
}
}
}
/// <summary>
/// Shows the content of the extraction result
/// </summary>
/// <param name="extractionResult">Extraction result of type FieldExtractionResult</param>
public void ShowExtractedData(FieldExtractionResult extractionResult, DocumentClassTemplate classTemplate, DocumentGroupTemplate groupTemplate)
{
txtClassName.Text = extractionResult.TemplateClassName;
txtGroupName.Text = extractionResult.TemplateGroupName;
ucExtractedDataFields1.ShowExtractedDataFields(extractionResult.DataFields);
ucExtractedCalculationFields1.ShowExtractedCalculationFields(extractionResult.CalculationFields);
var conditionalFields = classTemplate.ConditionalFields;
foreach (var item in groupTemplate.ConditionalFields)
{
if (item.OnlyStoreInGroupTemplate)
{
conditionalFields.Add(item);
}
}
ucExtractedConditionalFields1.ShowExtractedConditionalFields(extractionResult.ConditionalFields, conditionalFields);
}
/// <summary>
/// Creates a class template for the input text with the given template name. Datafields will be generated based on the group template. Working regex expression for the data fields will be generated based on their text anchors (if possible).
/// </summary>
/// <param name="templateName"></param>
/// <param name="inputText"></param>
/// <param name="baseGroupTemplate"></param>
/// <returns></returns>
public DocumentClassTemplate AutoCreateClassTemplate(string templateName, string inputText, DocumentGroupTemplate baseGroupTemplate)
{
// var genericRechnung = JsonConvert.DeserializeObject<DocumentGroupTemplate>(File.ReadAllText(Path.Combine(appRootPath, "GenericTemplates", "GenericTemplateRechnungen.json.txt")));
//var genericRechnung = GetDocumentGroupTemplateByName("Rechnung", baseGroupTemplate);
var retVal = new DocumentClassTemplate();
if (baseGroupTemplate != null)
{
retVal.TemplateClassName = templateName;
retVal.TemplateGroupName = baseGroupTemplate.TemplateGroupName;
RegexExpressionFinderResult regexResult;
if (TryFindRegexMatchExpress(inputText, string.Empty, string.Empty, DataFieldType.AnchorLessIBAN, false, out regexResult))
{
// retVal.PreSelectionCondition.IBANs = regexResult.MatchingValue.Replace(" ", string.Empty).ToUpper();
foreach (var item in regexResult.AllMatchingValues)
{
var cleaned = item.Replace(" ", string.Empty).ToUpper();
retVal.PreSelectionCondition.IBANs.Add(cleaned);
}
}
foreach (var item in baseGroupTemplate.DataFields.ToList())
{
var newDataField = AutoCreateDataFieldClassTemplateFromDataFieldGroupTemplate(item, inputText);
retVal.DataFields.Add(newDataField);
}
//It's important to create a clone of the List<ConditionalFieldTemplate> to make the reference to the baseGroupTemplate.ConditionalFields disappear
var baseConditionalFields = baseGroupTemplate.ConditionalFields.Where(x => x.OnlyStoreInGroupTemplate == false).ToList();
var objectClone = HelperExtensions.JsonDeepClone(baseConditionalFields);
retVal.ConditionalFields.AddRange(objectClone);
}
return(retVal);
}
public void LoadTemplate(DocumentClassTemplate template)
{
tbTemplateBox.Text = JsonConvert.SerializeObject(template, Formatting.Indented);
}
/// <summary>
/// Checks if a group template has datafields that are still missing in the class template. If a data field is missing, it will be added to the class template (including eg. automatic regexExpressionFinder magic).
/// Added datafields are also returned to indicate which fields were added.
/// </summary>
/// <param name="groupTemplate"></param>
/// <param name="classTemplate"></param>
/// <param name="inputText"></param>
/// <returns></returns>
public List <FieldTemplateBase> UpdateFieldsFromGroupTemplate(DocumentGroupTemplate groupTemplate, DocumentClassTemplate classTemplate, string inputText)
{
var retVal = new List <FieldTemplateBase>();
var fieldSet = classTemplate.DataFields.Select(x => x.Name).ToHashSet();
foreach (var item in groupTemplate.DataFields.ToList())
{
if (fieldSet.Contains(item.Name) == false)
{
var newDataField = AutoCreateDataFieldClassTemplateFromDataFieldGroupTemplate(item, inputText);
classTemplate.DataFields.Add(newDataField);
retVal.Add(newDataField);
}
}
fieldSet = classTemplate.ConditionalFields.Select(x => x.Name).ToHashSet();
foreach (var item in groupTemplate.ConditionalFields.ToList())
{
if (item.OnlyStoreInGroupTemplate == false && fieldSet.Contains(item.Name) == false)
{
classTemplate.ConditionalFields.Add(item);
retVal.Add(item);
}
}
return(retVal);
}
/// <summary>
/// Returns extracted data from <see cref=" ExtractData(DocumentClassTemplate, List{DocumentGroupTemplate}, string, string)"/> as JSON text.
/// </summary>
/// <param name="template"></param>
/// <param name="groupTemplates"></param>
/// <param name="inputText"></param>
/// <param name="pdfFilePath"></param>
/// <returns></returns>
public async Task <string> ExtractDataAsJson(DocumentClassTemplate template, List <DocumentGroupTemplate> groupTemplates, string inputText, string pdfFilePath)
{
var json = JsonConvert.SerializeObject(await ExtractData(template, groupTemplates, inputText, pdfFilePath), Formatting.Indented);
return(json);
}
/// <summary>
/// Extracts data from input text based on the given class template and matching group template.
/// </summary>
/// <param name="template">The class template to be used</param>
/// <param name="groupTemplates">Available group templates. The correct group template for the given class template will be selected automatically. If it is the correct one, it's okay if only one group template is in the list.</param>
/// <param name="inputText"></param>
/// <param name="pdfFilePath"></param>
/// <returns></returns>
public async Task <FieldExtractionResult> ExtractData(DocumentClassTemplate template, List <DocumentGroupTemplate> groupTemplates, string inputText, string pdfFilePath)
{
var retVal = new FieldExtractionResult()
{
TemplateClassName = template.TemplateClassName, TemplateGroupName = template.TemplateGroupName
};
foreach (var item in template.DataFields)
{
var resultItem = new DataFieldResult()
{
FieldType = item.FieldType, Name = item.Name
};
if (item.FieldMode == DataFieldMode.Regex)
{
resultItem.Value = ExecuteRegexExpression(inputText, item.RegexExpressions);
}
retVal.DataFields.Add(resultItem);
}
var dataFieldsPosition = await TextLoader.GetTextFromPdfForPositionalDataFields(pdfFilePath, template.DataFields.Where(x => x.FieldMode == DataFieldMode.Position).ToList());
foreach (var dataFieldPos in dataFieldsPosition)
{
var retValDataField = retVal.DataFields.Where(x => x.Name == dataFieldPos.Name).FirstOrDefault();
if (retValDataField != null)
{
retValDataField.Value = dataFieldPos.Value;
}
}
//var groupTemplate = GetDocumentGroupTemplateByName(template.TemplateGroupName);
var groupTemplate = groupTemplates.Where(x => x.TemplateGroupName == template.TemplateGroupName).FirstOrDefault();
if (groupTemplate != null)
{
var fieldCalculator = new FieldCalculator();
foreach (var item in groupTemplate.CalculationFields)
{
retVal.CalculationFields.Add(fieldCalculator.CompareExpressionResults(item, retVal.DataFields));
}
}
var conditionProcessor = new ConditionalFieldProcessor();
var allConditionalClassFields = template.ConditionalFields;
// Add conditional fields to class template if necessary.
if (groupTemplate != null)
{
var conditionalFieldsHash = allConditionalClassFields.Select(x => x.Name.ToLower()).ToHashSet();
foreach (var item in groupTemplate.ConditionalFields.Where(x => x.OnlyStoreInGroupTemplate == false))
{
var lowerName = item.Name.ToLower();
if (conditionalFieldsHash.Contains(lowerName) == false)
{
allConditionalClassFields.Add(item);
}
}
//allConditionalFields.AddRange(groupTemplate.ConditionalFields.Where(x => x.OnlyStoreInGroupTemplate));
}
foreach (var item in allConditionalClassFields)
{
var conditionalFieldResult = conditionProcessor.ProcessConditions(inputText, item);
if (retVal.ConditionalFields.Where(x => x.Name == conditionalFieldResult.Name).Count() == 0)
{
retVal.ConditionalFields.Add(conditionalFieldResult);
}
}
if (groupTemplate != null)
{
foreach (var item in groupTemplate?.ConditionalFields.Where(x => x.OnlyStoreInGroupTemplate == true))
{
var conditionalFieldResult = conditionProcessor.ProcessConditions(inputText, item);
if (retVal.ConditionalFields.Where(x => x.Name == conditionalFieldResult.Name).Count() == 0)
{
retVal.ConditionalFields.Add(conditionalFieldResult);
}
}
}
return(retVal);
}
private void TemplateEditor_ClassTemplateDeletedInClassTemplateEditor(DocumentClassTemplate deletedClassTemplate)
{
this.classTemplates.Remove(deletedClassTemplate);
MessageBox.Show(Translation.LanguageStrings.MsgClassTemplateDeleted + ": " + deletedClassTemplate.TemplateClassName, string.Empty, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void UcClassTemplateEditor1_ClassTemplateSavedInClassTemplateEditor(DocumentClassTemplate savedClassTemplate)
{
ClassTemplateSavedInClassTemplateEditor?.Invoke(savedClassTemplate);
}
/// <summary>
/// Saves class template to the TemplateClassDirectory.
/// </summary>
/// <param name="template">Class template</param>
public bool SaveTemplateToFile(DocumentClassTemplate template)
{
return(SaveTemplateToFile(template, TemplateClassDirectory));
}
private void UcClassTemplateEditor1_ClassTemplateDeletedInClassTemplateEditor(DocumentClassTemplate deletedClassTemplate)
{
ClassTemplateDeletedInClassTemplateEditor?.Invoke(deletedClassTemplate);
}
/// <summary>
/// Shows a class template (general properties and data fields) within ucSingleTemplateEditor
/// </summary>
/// <param name="classTemplate">Class template</param>
public void ShowPropertiesAndDataFields(DocumentClassTemplate classTemplate, DocumentGroupTemplate groupTemplate)
{
ucSingleTemplateEditor1.ShowPropertiesAndDataFields(classTemplate);
ucExtractedData1.ShowExtractedData(new FieldExtractionResult(), classTemplate, groupTemplate);
ucSingleTemplateEditor1.ActivateRegexAndPositionHelper();
}
/// <summary>
/// Shows general properties and data fields of a class template
/// </summary>
/// <param name="classTemplate">Class template</param>
public void ShowPropertiesAndDataFields(DocumentClassTemplate classTemplate)
{
ShowGeneralProperties(classTemplate);
ShowDataFields(classTemplate);
}
/// <summary>
/// Shows the data fields of a class template
/// </summary>
private void ShowDataFields(DocumentClassTemplate classTemplate)
{
ucDataFieldEditor1.ShowDataFields(classTemplate);
}
/// <summary>
/// Shows the general properties of a class template
/// </summary>
private void ShowGeneralProperties(DocumentClassTemplate classTemplate)
{
ucGeneralPropertyEditor1.ShowGeneralProperties(classTemplate);
}
