public override void Init(ExportBase export)
{
base.Init(export);
PDFExport pdfExport = Export as PDFExport;
cbCompressed.Checked = pdfExport.Compressed;
cbEmbedded.Checked = pdfExport.EmbeddingFonts;
cbBackground.Checked = pdfExport.Background;
cbPrintOptimized.Checked = pdfExport.PrintOptimized;
tbTitle.Text = pdfExport.Title;
tbAuthor.Text = pdfExport.Author;
tbSubject.Text = pdfExport.Subject;
tbKeywords.Text = pdfExport.Keywords;
tbCreator.Text = pdfExport.Creator;
tbProducer.Text = pdfExport.Producer;
tbOwnerPassword.Text = pdfExport.OwnerPassword;
tbUserPassword.Text = pdfExport.UserPassword;
cbPrintTheDocument.Checked = pdfExport.AllowPrint;
cbModifyTheDocument.Checked = pdfExport.AllowModify;
cbCopyOfTextAndGraphics.Checked = pdfExport.AllowCopy;
cbAnnotations.Checked = pdfExport.AllowAnnotate;
cbHideToolbar.Checked = pdfExport.HideToolbar;
cbHideMenubar.Checked = pdfExport.HideMenubar;
cbHideUI.Checked = pdfExport.HideWindowUI;
cbFitWindow.Checked = pdfExport.FitWindow;
cbCenterWindow.Checked = pdfExport.CenterWindow;
cbPrintScaling.Checked = pdfExport.PrintScaling;
cbOutline.Checked = pdfExport.Outline;
// not implemented yet
//pageControlSecurity.Parent = null;
cbOutline.Visible = false;
}
public override void GenerateConversionMetadataFile(
ExportBase export,
IExportNastaveni settings,
string documentType,
string finalOutputFileFullPath,
string finalOutputFileName,
string finalOutputMetadataFileName)
{
var fiFinalOutputFilename = new FileInfo(finalOutputFileFullPath);
var step = 0;
var outputFileWithoutExtension = fiFinalOutputFilename.Name.Substring(0, fiFinalOutputFilename.Name.LastIndexOf(".", StringComparison.Ordinal));
var fileTransformationSource = finalOutputFileFullPath;
var parameters = new NameValueCollection
{
{ "accessories", finalOutputFileName }
};
foreach (var transformationFile in XsltTransformerFactory.GetTransformationFromTransformationsFile(settings.SouborTransformaci, "jgslov-xmd-step"))
{
var fileTransformationTarget = GetTempFile(settings.DocasnaSlozka, outputFileWithoutExtension, step++);
export.ApplyTransformations(fileTransformationSource, fileTransformationTarget, XsltTransformerFactory.GetXsltTransformers(
settings.SouborTransformaci,
transformationFile,
settings.SlozkaXslt, true), settings.DocasnaSlozka, parameters);
fileTransformationSource = fileTransformationTarget;
}
File.Copy(fileTransformationSource, finalOutputMetadataFileName);
}
public override void Init(ExportBase export)
{
base.Init(export);
PowerPoint2007Export pptExport = Export as PowerPoint2007Export;
comboBox1.SelectedIndex = (int)pptExport.ImageFormat;
}
private void btnSettings_Click(object sender, EventArgs e)
{
ExportBase export = FExports[cbxAttachment.SelectedIndex];
export.SetReport(FExport.Report);
export.ShowDialog();
}
public string ExportToFile(Report report)
{
ExportBase export = null;
string fileName = Path.GetTempPath() + @"\_rpt" + DateTime.Now.ToString("yyyyMMddhhmmss") + "_" + Loginer.CurrentUser.Account;
if (ExportType.IMG == _exportType)
{
fileName = fileName + ".png";
export = new ImageExport();
(export as ImageExport).ImageFormat = ImageExportFormat.Png;
}
else if (ExportType.PDF == _exportType)
{
fileName = fileName + ".pdf";
export = new PDFExport();
}
else if (ExportType.XLS == _exportType)
{
fileName = fileName + ".xls";
export = new XMLExport();
}
else if (ExportType.HTML == _exportType)
{
fileName = fileName + ".html";
export = new HTMLExport();
}
export.AllowOpenAfter = false;
report.Export(export, fileName);
return(fileName);
}
public ExportBase ExportFactoryInit(ExportInfo exportInfo)
{
try
{
if (exportInfo != null)
{
if (exportInfo.ReportDetails.ExportFormat == ReportingInterfaces.EnumHelper.ExportFormat.EXCEL.ToString())
{
export = new ExcelExport(exportInfo);
}
else if (exportInfo.ReportDetails.ExportFormat == ReportingInterfaces.EnumHelper.ExportFormat.CSV.ToString())
{
export = new CSVExport(exportInfo);
}
else if (exportInfo.ReportDetails.ExportFormat == ReportingInterfaces.EnumHelper.ExportFormat.HTML.ToString())
{
export = new HtmLExport(exportInfo);
}
}
else
{
AMTLogger.WriteToLog("Export Info is null", MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Info);
}
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(export);
}
public override void Init(ExportBase export)
{
base.Init(export);
MHTExport MHTExport = Export as MHTExport;
cbWysiwyg.Checked = MHTExport.Wysiwyg;
cbPictures.Checked = MHTExport.Pictures;
}
public override void Init(ExportBase export)
{
base.Init(export);
TextExport textExport = Export as TextExport;
report = textExport.Report;
ProfessionalColorTable vs2005ColorTable = new ProfessionalColorTable();
vs2005ColorTable.UseSystemColors = true;
toolStrip.Renderer = new ToolStripProfessionalRenderer(vs2005ColorTable);
cbPageBreaks.Checked = textExport.PageBreaks;
cbEmptyLines.Checked = textExport.EmptyLines;
if (textExport.Frames && textExport.TextFrames)
{
cbbFrames.SelectedIndex = 1;
}
else if (textExport.Frames && !textExport.TextFrames)
{
cbbFrames.SelectedIndex = 2;
}
else
{
cbbFrames.SelectedIndex = 0;
}
cbDataOnly.Checked = textExport.DataOnly;
if (textExport.Encoding == Encoding.Default)
{
cbbCodepage.SelectedIndex = 0;
}
else if (textExport.Encoding == Encoding.UTF8)
{
cbbCodepage.SelectedIndex = 1;
}
else if (textExport.Encoding == Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage))
{
cbbCodepage.SelectedIndex = 2;
}
udX.Value = (decimal)textExport.ScaleX;
udY.Value = (decimal)textExport.ScaleY;
udX.ValueChanged += new EventHandler(udX_ValueChanged);
udY.ValueChanged += new EventHandler(udX_ValueChanged);
cbbFrames.SelectedIndexChanged += new EventHandler(cbbFrames_SelectedIndexChanged);
MyRes res = new MyRes("Preview");
tbPage.Text = "1";
prevPage = 1;
lblTotalPages.Text = String.Format(Res.Get("Misc,ofM"), report.PreparedPages.Count);
cbFontSize.SelectedIndex = 4;
previewExport = new TextExport();
previewExport.PreviewMode = true;
CalcScale();
}
public override void Init(ExportBase export)
{
base.Init(export);
XMLExport xmlExport = Export as XMLExport;
cbWysiwyg.Checked = xmlExport.Wysiwyg;
cbPageBreaks.Checked = xmlExport.PageBreaks;
cbDataOnly.Checked = xmlExport.DataOnly;
}
public override void Init(ExportBase export)
{
base.Init(export);
MyRes res = new MyRes("Export,Docx");
Text = res.Get("");
Word2007Export ooxmlExport = Export as Word2007Export;
this.radioButtonTable.Checked = (ooxmlExport.MatrixBased == true);
}
public JobItem(ExportBase expBase, int JobType, string Default, string INISection, string INIItem, string FileItem)
{
this.expBase = expBase;
this.JobType = JobType;
this.DefaultDir = Default.Replace("//", "/");
this.INISection = INISection;
this.INIItem = INIItem;
this.FileItem = FileItem.Replace("//", "/");
files = new List <string>();
}
public static void GenereteReport(ReportParams reportParams)
{
if (reportParams == null)
{
throw new ArgumentNullException($"{nameof(reportParams)} cannot be null.");
}
// create report instance
using (FastReport.Report report = new FastReport.Report())
{
// load the existing report
report.Load(reportParams.FrxPath);
// register datasource's
if (reportParams.DataSource != null)
{
foreach (var pair in reportParams.DataSource)
{
report.RegisterData(pair.Value, pair.Key);
}
}
if (reportParams.Parameters != null)
{
foreach (var pair in reportParams.Parameters)
{
report.SetParameterValue(pair.Key, pair.Value);
}
}
// prepare the report
report.Prepare();
ExportBase export = null;
switch (reportParams.OutputType)
{
case 0: // export to html
export = new HTMLExport();
(export as HTMLExport).Format = HTMLExportFormat.HTML;
break;
case 1:
export = new ImageExport();
(export as ImageExport).ImageFormat = ImageExportFormat.Png;
break;
default:
throw new ArgumentException($"O parametro {reportParams.OutputType} é inválido");
}
report.Export(export, reportParams.OutStream);
}
reportParams.OutStream.Position = 0;
}
public override void Init(ExportBase export)
{
base.Init(export);
MyRes res = new MyRes("Export," + ((export is ODSExport) ? "Ods" : "Odt"));
Text = res.Get("");
ODFExport odfExport = Export as ODFExport;
cbWysiwyg.Checked = odfExport.Wysiwyg;
cbPageBreaks.Checked = odfExport.PageBreaks;
}
public override void Init(ExportBase export)
{
base.Init(export);
MyRes res = new MyRes("Export,Xlsx");
Text = res.Get("");
Excel2007Export ooxmlExport = Export as Excel2007Export;
// cbWysiwyg.Checked = ooxmlExport.Wysiwyg;
cbPageBreaks.Checked = ooxmlExport.PageBreaks;
}
public virtual ActionResult ExportTo(int id)
{
List <Electronics> list = Electronics.GetData();
ExportList <Electronics> exp = new ExportList <Electronics>();
exp.PathTemplateFolder = Server.MapPath("~/ExportTemplates/electronics");
string filePathExport = Server.MapPath("~/exports/a" + ExportBase.GetFileExtension((ExportToFormat)id));
exp.ExportTo(list, (ExportToFormat)id, filePathExport);
return(this.File(filePathExport, "application/octet-stream", System.IO.Path.GetFileName(filePathExport)));
}
public override void Init(ExportBase export)
{
base.Init(export);
HTMLExport htmlExport = Export as HTMLExport;
cbWysiwyg.Checked = htmlExport.Wysiwyg;
cbPictures.Checked = htmlExport.Pictures;
cbSinglePage.Checked = htmlExport.SinglePage;
cbSubFolder.Checked = htmlExport.SubFolder;
cbNavigator.Checked = htmlExport.Navigator;
cbLayers.Checked = htmlExport.Layers;
}
private Stream GetFile(string xml)
{
MessageList mes_list = new MessageList();
MessageLog logs = new MessageLog(MessageLog.INFO, "GetFile", "Создание потока");
mes_list.Add_Message(logs);
XDocument doc = XDocument.Parse(xml);
FRDataForm form = new FRDataForm();
ConverterClass convert_class = new ConverterClass();
List <DataTable> list = convert_class.Converter(doc, out form);
using (Report report = new Report())
{
//conf.GetValue("FolderFR") "\\Report\\"
String name_file = conf.GetValue("PathService") + "\\" + conf.GetValue("FolderFR") + "\\" + form.product + "\\" + form.form + ".frx";
MemoryStream mem = new MemoryStream();
logs = new MessageLog(MessageLog.INFO, "GetFile", "Отчет " + name_file);
mes_list.Add_Message(logs);
ExportBase export = Format(form);
report.Load(name_file);
EnvironmentSettings s = new EnvironmentSettings();
s.ReportSettings.ShowProgress = false;
foreach (DataTable st in list)
{
report.RegisterData(st, st.TableName);
}
//report.Show();
//report.Design();
report.Prepare();
//FileStream fl = new FileStream("555.pdf", FileMode.Create);
//report.Export(export, fl);
//fl.Close();
//report.SavePrepared(fl);
report.Export(export, mem);
// }
// nt.Flush();
mem.Position = 0;
//byte[] file = mem.ToArray();
logs = new MessageLog(MessageLog.INFO, "GetFile", "Отчет сформирован и отправлен");
mes_list.Add_Message(logs);
Logger.getInstance().Write(mes_list);
return(mem);
}
}
/// <summary>
/// Initializes controls with initial values.
/// </summary>
/// <param name="export">The export filter to edit.</param>
/// <remarks>
/// Override this method to pass values from the export filter to the dialog controls.
/// </remarks>
/// <example>See the example of this method implementation that is used in the <b>ImageExport</b>.
/// <code>
/// public override void Init(ExportBase export)
/// {
/// base.Init(export);
/// ImageExport imageExport = Export as ImageExport;
/// cbxImageFormat.SelectedIndex = (int)imageExport.ImageFormat;
/// udResolution.Value = imageExport.Resolution;
/// udQuality.Value = imageExport.JpegQuality;
/// cbSeparateFiles.Checked = imageExport.SeparateFiles;
/// }
/// </code>
/// </example>
public virtual void Init(ExportBase export)
{
FExport = export;
Localize();
rbAll.Checked = Export.PageRange == PageRange.All;
rbCurrent.Checked = Export.PageRange == PageRange.Current;
rbNumbers.Checked = Export.PageRange == PageRange.PageNumbers;
tbNumbers.Text = Export.PageNumbers;
cbOpenAfter.Checked = Export.OpenAfterExport;
cbOpenAfter.Enabled = export.AllowOpenAfter;
}
public override void Init(ExportBase export)
{
base.Init(export);
ImageExport imageExport = Export as ImageExport;
cbxImageFormat.SelectedIndex = (int)imageExport.ImageFormat;
udResolution.Value = imageExport.ResolutionX;
udResolutionY.Value = imageExport.ResolutionY;
udQuality.Value = imageExport.JpegQuality;
cbSeparateFiles.Checked = imageExport.SeparateFiles;
cbMultiFrameTiff.Checked = imageExport.MultiFrameTiff;
cbMonochrome.Checked = imageExport.MonochromeTiff;
cbMultiFrameTiff_CheckedChanged(null, EventArgs.Empty);
}
private void item_Click(object sender, EventArgs e)
{
ObjectInfo info = (sender as ToolStripMenuItem).Tag as ObjectInfo;
if (info == null)
{
preview.Save();
}
else
{
ExportBase export = Activator.CreateInstance(info.Object) as ExportBase;
export.CurPage = preview.PageNo;
export.Export(preview.Report);
}
}
public override void Init(ExportBase export)
{
base.Init(export);
RTFExport rtfExport = Export as RTFExport;
cbWysiwyg.Checked = rtfExport.Wysiwyg;
cbPageBreaks.Checked = rtfExport.PageBreaks;
if (rtfExport.Pictures)
{
cbbPictures.SelectedIndex = rtfExport.ImageFormat == RTFImageFormat.Metafile ? 1 : (rtfExport.ImageFormat == RTFImageFormat.Jpeg ? 2 : 3);
}
else
{
cbbPictures.SelectedIndex = 0;
}
}
public override void Init(ExportBase export)
{
base.Init(export);
DBFExport dbfExport = Export as DBFExport;
if (dbfExport.Encoding == Encoding.Default)
{
cbbCodepage.SelectedIndex = 0;
}
else if (dbfExport.Encoding == Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage))
{
cbbCodepage.SelectedIndex = 1;
}
tbFieldNames.Text = dbfExport.FieldNames;
cbDataOnly.Checked = dbfExport.DataOnly;
}
private void Email_Click(object sender, EventArgs e)
{
if (IsPreviewEmpty)
{
return;
}
List <string> fileNames = new List <string>();
ObjectInfo info = (sender as ButtonItem).Tag as ObjectInfo;
if (info == null)
{
using (SaveFileDialog dialog = new SaveFileDialog())
{
dialog.Filter = Res.Get("FileFilters,PreparedReport");
dialog.DefaultExt = "*.fpx";
if (dialog.ShowDialog() == DialogResult.OK)
{
Save(dialog.FileName);
fileNames.Add(dialog.FileName);
}
}
}
else
{
ExportBase export = Activator.CreateInstance(info.Object) as ExportBase;
export.CurPage = CurrentPreview.PageNo;
export.AllowOpenAfter = false;
export.ShowProgress = true;
export.Export(Report);
fileNames = export.GeneratedFiles;
}
if (fileNames.Count > 0)
{
Form form = FindForm();
string[] recipientAddresses = Report.EmailSettings.Recipients == null ?
new string[] { } : Report.EmailSettings.Recipients;
int error = MAPI.SendMail(form == null ? IntPtr.Zero : form.Handle, fileNames.ToArray(),
Report.EmailSettings.Subject, Report.EmailSettings.Message, new string[] {}, recipientAddresses);
if (error > 1)
{
MessageBox.Show("MAPISendMail failed! " + MAPI.GetErrorText(error));
}
}
}
public override bool ExportReportData()
{
Boolean result = false;
try
{
objExportbase = new ExportFactory().ExportFactoryInit(ReportExportInfo);
BuildDataReader();
objExportbase.SaveReport();
}
catch (Exception ex)
{
AMTLogger.WriteToLog(ex.Message, MethodBase.GetCurrentMethod().Name, 0, AMTLogger.LogInfo.Error);
}
return(result);
}
public override void Init(ExportBase export)
{
base.Init(export);
CSVExport csvExport = Export as CSVExport;
tbSeparator.Text = csvExport.Separator;
if (csvExport.Encoding == Encoding.Default)
{
cbbCodepage.SelectedIndex = 0;
}
else if (csvExport.Encoding == Encoding.UTF8)
{
cbbCodepage.SelectedIndex = 1;
}
else if (csvExport.Encoding == Encoding.GetEncoding(CultureInfo.CurrentCulture.TextInfo.OEMCodePage))
{
cbbCodepage.SelectedIndex = 2;
}
cbDataOnly.Checked = csvExport.DataOnly;
}
private void Export_Click(object sender, EventArgs e)
{
if (IsPreviewEmpty)
{
return;
}
ObjectInfo info = (sender as ButtonItem).Tag as ObjectInfo;
if (info == null)
{
Save();
}
else
{
ExportBase export = Activator.CreateInstance(info.Object) as ExportBase;
export.CurPage = CurrentPreview.PageNo;
export.AllowSaveSettings = true;
export.ShowProgress = true;
try
{
export.Export(Report);
}
#if !DEBUG
catch (Exception ex)
{
using (ExceptionForm form = new ExceptionForm(ex))
{
form.ShowDialog();
}
}
#endif
finally
{
}
}
}
public ExportTypeClass(string name, ExportBase exportclass)
{
Name = name;
export = exportclass;
}
public JobExportData(ExportBase expBase, int JobType, string Default, string INISection, string INIItem, string FileItem)
: base(expBase, JobType, Default, INISection, INIItem, FileItem)
{
}
/// <summary>Creates service definition that can be registered with a server</summary>
/// <param name="serviceImpl">An object implementing the server-side handling logic.</param>
public static grpc::ServerServiceDefinition BindService(ExportBase serviceImpl)
{
return(grpc::ServerServiceDefinition.CreateBuilder()
.AddMethod(__Method_ExportSpan, serviceImpl.ExportSpan).Build());
}
public ConversionResult Convert(DocxToTeiConverterSettings settings)
{
ConverterSettings = settings;
CheckIfDirectoryPathsExists(ConverterSettings);
_result = new ConversionResult();
string documentType = null;
//get metadata only for first (by alphabet) uploaded file
var inputFileName = ConverterSettings.InputFilesPath.Select(filePath => new FileInfo(filePath)).Select(fileInfo => fileInfo.Name).First();
ResolveDefaultSettingsValues(ConverterSettings);
var prepis = GetPrepisy(ConverterSettings, inputFileName);
if (prepis == null)
{
//dokument v evidenci neexistuje, nabídnout zanesení dokumentu do evidence
// mělo by stačit přiřazení typu dokumentu
_result.Errors.Add(new DocumentNotInEvidenceException(String.Format("Dokument s uvedeným jménem souboru '{0}' neexistuje v evidenci.", inputFileName)));
return(_result);
}
if (prepis.FazeZpracovani < FazeZpracovani.Exportovat)
{
_result.Errors.Add(new DocumentNotInRequredStateException("Dokument s uvedeným jménem souboru není připraven pro export."));
return(_result);
}
documentType = GetDocumentType(prepis.TypPrepisu);
_documentId = prepis.GUID;
if (documentType == null)
{
//dokument má v evidenci přiřazen typ dokumentu, který není podporován
_result.Errors.Add(new NotSupportedFileFormatException("Dokument má v evidenci přiřazen typ dokumentu, který není podporován."));
return(_result);
}
string tempDirectoryPath = ConverterSettings.TempDirectoryPath;
//vytvoří se adresářová struktura, pokud neexistuje, pro ukládání výsledných a dočasných souborů
AdresarovaStruktura ads = new AdresarovaStruktura(tempDirectoryPath, documentType);
ads.VytvorStrukturu();
string docxToXmlFilePath = Path.Combine(GetDataDirectoryPath(), "AllStylesConvert.2xml");
string xsltTemplatesPath = GetXsltTemplatesPath();
string xsltTransformationsPath = GetXsltTransformationsPath();
string fileNameWithoutExtension = prepis.Soubor.NazevBezPripony;
string xmlOutpuFileName = fileNameWithoutExtension + XmlExtension;
string finalOutputDirectory = ads.DejVystup; // Path.Combine(ads.DejVystup, fileNameWithoutExtension);
string finalOutputFileName = Path.Combine(finalOutputDirectory, xmlOutpuFileName);
//Zatím pouze konverze z DOCX do základního XML
IList <string> xmlOutputFiles = new List <string>();
try
{
var filePart = 0;
foreach (var inputFilePath in ConverterSettings.InputFilesPath)
{
xmlOutputFiles.Add(GetDocxToXmlOutput(ads, prepis.Soubor.NazevBezPripony, filePart, ConverterSettings.InputFilesPath.Length > 1));
ConvertDocxToXml(inputFilePath, docxToXmlFilePath, xmlOutputFiles.Last());
filePart++;
}
}
catch (Exception exception)
{
_result.Errors.Add(exception);
return(_result);
}
if (!Directory.Exists(finalOutputDirectory))
{
Directory.CreateDirectory(finalOutputDirectory);
}
IExportNastaveni exportSettings = GetExportSettings(documentType, ConverterSettings, xsltTransformationsPath, xsltTemplatesPath, ads, prepis);
ExportBase export = GetExportModule(documentType, exportSettings);
if (export == null || exportSettings == null)
{
//Objekt pro export se nepodažřilo vytvořit, není podporován.
return(_result);
}
try
{
export.Exportuj(exportSettings.Prepis, xmlOutputFiles, ConverterSettings.UploadedFilesPath);
_result.IsConverted = true;
}
catch (Exception exception)
{
_result.Errors.Add(exception);
return(_result);
}
if (!settings.Debug)
{
foreach (var xmlOutputFile in xmlOutputFiles.Where(File.Exists))
{
File.Delete(xmlOutputFile);
}
}
var versions = settings.GetVersionList(_documentId);
_currentVersionInfoSkeleton = versions.Last();
WriteListChange(finalOutputFileName, versions, _currentVersionInfoSkeleton);
var xmlFinalOutputPath = Path.Combine(settings.OutputDirectoryPath, xmlOutpuFileName);
File.Copy(finalOutputFileName, xmlFinalOutputPath, true);
_result.MetadataFilePath = settings.OutputMetadataFilePath;
//GetConversionMetadataFileFullPath(settings.OutputFilePath);
if (export.UsePersonalizedXmdGenerator)
{
export.GenerateConversionMetadataFile(documentType, xmlFinalOutputPath, xmlOutpuFileName, settings.OutputMetadataFilePath);
}
else
{
SplittingResult splittingResult = null;
if (settings.SplitDocumentByPageBreaks)
{
splittingResult = SplitDocumentByPageBreaks(xmlFinalOutputPath, fileNameWithoutExtension);
if (!splittingResult.IsSplitted)
{
_result.IsConverted = false;
_result.Errors.Add(new DocumentSplittingException("Vyskytla se chyba při rozdělení souboru podle hranice stran."));
}
}
TableOfContentResult tocResult = null;
ContentInfoBuilder tocBuilder = new ContentInfoBuilder();
tocResult = tocBuilder.MakeTableOfContent(xmlFinalOutputPath, "body");
GenerateConversionMetadataFile(splittingResult, tocResult, documentType, xmlFinalOutputPath, xmlOutpuFileName, settings.OutputMetadataFilePath);
}
if (!settings.Debug)
{
try
{
Directory.Delete(settings.TempDirectoryPath, true);
}
catch (IOException exception)
{
Directory.Delete(settings.TempDirectoryPath, true);
}
}
return(_result);
}
