private void CalcPackage(FilePackageContent filePackage)
{
// The package must ALWAYS exist at this point!
EM_TemplateCalculator calculator = calculators[filePackage.Key];
ResultsPackage resultsPackage = resultsPackages.Find(x => x.packageKey == filePackage.Key);
try
{
bool success = calculator.CalculateStatistics(resultsPackage.microData);
lock (resultsPackages)
{
resultsPackage.displayResults = calculator.GetDisplayResults();
resultsPackage.error = calculator.GetErrorMessage(); // this may also just be warnings
if (!success)
{
resultsPackage.displayResults.calculated = true; // if did not succeed, declare this done
}
// cleanup
calculators.Remove(filePackage.Key);
resultsPackage.microData = null;
filePackage = null;
}
}
catch (Exception exception)
{
lock (resultsPackages)
{
resultsPackage.error = exception.Message;
}
}
}
private void PrepareAndStartCalculatingResults()
{
foreach (FilePackageContent filePackage in filePackages) // tested multi-threading this, but there was no noticeable gain!
{
List <string> filenames = new List <string>();
// Prepare the filenames and microdata
List <StringBuilder> microData = new List <StringBuilder>();
if (template.info.templateType != HardDefinitions.TemplateType.Multi)
{
if (filePackage.MicroDataBase != null)
{
filenames.Add(string.Empty); microData.Add(filePackage.MicroDataBase);
}
else
{
filenames.Add(filePackage.PathBase); microData.Add(null);
}
}
for (int f = 0; f < Math.Max(filePackage.PathsAlt.Count, filePackage.MicroDataAlt.Count); ++f)
{
filenames.Add(f < filePackage.PathsAlt.Count ? filePackage.PathsAlt[f] : string.Empty);
microData.Add(f < filePackage.MicroDataAlt.Count ? filePackage.MicroDataAlt[f] : null);
}
if (filePackage.MicroDataBase == null && filePackage.MicroDataAlt.Count == 0)
{
microData = null;
}
// Prepare the resultsPackage
ResultsPackage resultsPackage = new ResultsPackage();
EM_TemplateCalculator calculator = new EM_TemplateCalculator(template, filePackage.Key);
bool prepared = calculator.Prepare(filenames, out ErrorCollector errorCollector);
calculators.Add(filePackage.Key, calculator);
resultsPackage.displayResults = calculator.GetDisplayResults();
if (!prepared)
{
resultsPackage.displayResults.calculated = true; // if preperation went wrong, there will not be any results comming later!
}
resultsPackage.packageKey = filePackage.Key;
resultsPackage.error = errorCollector.GetErrorMessage();
resultsPackage.microData = microData;
resultsPackages.Add(resultsPackage);
}
new System.Threading.Thread(() =>
{
Parallel.ForEach <FilePackageContent>(filePackages, filePackage =>
{
CalcPackage(filePackage);
});
}).Start();
}
internal override string ReplaceText(string origText, PrettyInfoResources resources)
{
string newText = origText;
while (newText.IndexOf("[@") > -1)
{
int start = newText.IndexOf("[@");
int end = newText.IndexOf("]", start) + 1;
string userVar = newText.Substring(start, end - start);
int oneBasedRefNo = resources.refNo < 0 ? -1 : resources.refNo + 1; // GetRealVariableName requires 1-based reference-number
newText = newText.Substring(0, start) +
EM_TemplateCalculator.GetRealVariableName(userVar, resources.templateInfo, true, resources.packageKey, oneBasedRefNo) +
newText.Substring(end);
}
return(newText);
}
public override void Run(Dictionary<string, object> arguments = null)
{
try
{
EM_TemplateCalculator.WarmUp(); // warms up the library in a parallel thread to avoid a 2 second delay when running the first dynamic calculation
string templateName = null;
Template template = null;
List<FilePackageContent> filePackages = null;
List<Template.TemplateInfo.UserVariable> userInput = null;
if (arguments != null)
{
string errors = string.Empty;
foreach (var argument in arguments)
{
if (argument.Key.ToLower() == "templatename") templateName = GetArgument<string>(argument, ref errors);
else if (argument.Key.ToLower() == "template") template = GetArgument<Template>(argument, ref errors);
else if (argument.Key.ToLower() == "filepackages") filePackages = GetArgument<List<FilePackageContent>>(argument, ref errors);
else if (argument.Key.ToLower() == "userinput") userInput = GetArgument<List<Template.TemplateInfo.UserVariable>>(argument, ref errors);
else errors += "Unknown argument: " + argument.Key + Environment.NewLine;
}
if (errors != string.Empty)
{
MessageBox.Show(GetTitle() + " was called with invalid argument(s):" + Environment.NewLine +
"Valid arguments are:" + Environment.NewLine +
"TemplateName (string)" + Environment.NewLine +
"Template (EMS_Template)" + Environment.NewLine +
"FilePackages (List<EMS_FilePackageContent>)" + Environment.NewLine +
"UserInput (List<EMS_UserInput>)" + Environment.NewLine +
"RunTimeCaptions (List<EMS_RunTimeCaption>)" + Environment.NewLine +
Environment.NewLine + "Error(s):" + Environment.NewLine + errors);
return;
}
}
else
{
// if there is only one template in the UserSelectableTemplates folder then open this by default, otherwise let user chose
var templates = Directory.EnumerateFiles(EnvironmentInfo.GetUserSelectableTemplateFolder(), "*.xml");
if (templates.Count() == 1) templateName = templates.First();
}
SelectDefaultTemplateComboForm form = new SelectDefaultTemplateComboForm(templateName, template, filePackages, userInput);
if (form.ShowDialog() == DialogResult.Cancel) return;
PresenterForm presenter = new PresenterForm(form.template, form.filePackages, form.userInput);
presenter.Show();
}
catch (Exception exception)
{
MessageBox.Show($"Failed to run plug-in '{GetTitle()}':{Environment.NewLine}{exception.Message}");
}
T GetArgument<T>(KeyValuePair<string, object> argument, ref string errors)
{
if (argument.Value is T == true) return (T)argument.Value;
errors += "Type of argument '" + argument.Key + "' is invalid." + Environment.NewLine;
return default(T);
}
}
