private void exportToHtml(ExportOption option, DisplayAndPrintSettings settings)
{
if (option == ExportOption.All)
{
foreach (var song in Song.listOfAllSongs())
{
Song.loadSong(song).ExportToHtml(settings);
}
if (settings.settingsType == DisplayAndPrintSettingsType.PrintSettings)
{
UiHelper.ShowInFileManager(Settings.GlobalApplicationSettings.PrintFolder);
}
else if (settings.settingsType == DisplayAndPrintSettingsType.TabletSettings)
{
UiHelper.ShowInFileManager(Settings.GlobalApplicationSettings.TabletFolder);
}
}
else if (option == ExportOption.Set)
{
ucSetListPanel.ExportToHtml(settings);
}
else if (option == ExportOption.Song)
{
ucSongMetaDataPanel.ExportToHtml(settings);
}
}
private void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
#region [ Initalization UI ]
lvLog.Items.Clear();
lvTask.Items.Clear();
_detailsOption = (DetailsOption)frOption.Content;
_vertManager = (VertificationManager)frVertManager.Content;
_exportOption = (ExportOption)frExportOption.Content;
_taskReport = (TaskReport)frTaskReport.Content;
_taskReport.ExportRequest += _taskReport_ExportRequest;
if (!AccessDBFormat <ISearchResult> .AccessConnectorInstalled())
{
AddLog("Access DB에 올바르게 접근 할 수 없습니다. 내보내기 옵션의 Access DB에서 문제를 해결하세요.", TaskLogType.System);
}
else
{
_exportOption.HiddenInstall();
}
#endregion
this.Activate();
}
public byte[] Export <T>(ExportOption <T> exportOption)
where T : class, new()
{
IWorkbook workbook = null;
if (exportOption.ExportType == ExportType.XLS)
{
workbook = new HSSFWorkbook();
}
else
{
workbook = new XSSFWorkbook();
}
ISheet sheet = workbook.CreateSheet(exportOption.SheetName);
var headerDict = ExportMappingDictFactory.CreateInstance(typeof(T));
SetHeader <T>(sheet, exportOption.HeaderRowIndex, headerDict);
if (exportOption.Data != null && exportOption.Data.Count > 0)
{
SetDataRows(sheet, exportOption.DataRowStartIndex, exportOption.Data, headerDict);
}
return(workbook?.ToBytes());
}
public byte[] WrapText <T>(byte[] workbookBytes, ExportOption <T> exportOption, DecoratorContext context)
where T : class, new()
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var attr = context.TypeDecoratorInfo.GetDecorateAttr <WrapTextAttribute>();
if (attr == null)
{
return(workbookBytes);
}
IWorkbook workbook = workbookBytes.ToWorkbook();
ISheet sheet = workbook.GetSheet(exportOption.SheetName);
IRow row;
if (sheet.PhysicalNumberOfRows > 0)
{
for (int i = 0; i < sheet.PhysicalNumberOfRows; i++)
{
row = sheet.GetRow(i);
for (int colIndex = 0; colIndex < row.PhysicalNumberOfCells; colIndex++)
{
row.GetCell(colIndex).CellStyle.WrapText = true;
}
}
}
return(workbook.ToBytes());
}
// Methods
public PrintItem(ISelectPresentationsInformation selectPresentation, CultureInfo cultureInfo)
{
_rectangle = selectPresentation.DisplayRectangle;
_mode = selectPresentation.PresentationMode;
_presentationImage = selectPresentation.Image;
_exportOption = DicomPrintSession.GetPresentationMode(_mode);
_cultureInfo = cultureInfo;
}
public byte[] Export <T>(ExportOption <T> exportOption) where T : class, new()
{
//var dt = ToDataTable(exportOption.Data);
//DataSet ds = new DataSet();
//ds.Tables.Add(dt);
var headerDict = ExportMappingDictFactory.CreateInstance(typeof(T));
return(Export(exportOption.Data, headerDict));
}
public Task <byte[]> ExportAsync <T>(ExportOption <T> exportOption)
where T : class, new()
{
var workbookBytes = _excelExportProvider.Export(exportOption);
//设置样式
workbookBytes = Decorate(workbookBytes, exportOption);
//返回byte数组
return(Task.FromResult(workbookBytes));
}
private void MergeCols <T>(ISheet sheet, int colIndex, ExportOption <T> exportOption)
where T : class, new()
{
string currentCellValue;
int startRowIndex = exportOption.DataRowStartIndex;
CellRangeAddress mergeRangeAddress;
var startRow = sheet.GetRow(startRowIndex);
if (startRow == null)
{
return;
}
var startCell = startRow.GetCell(colIndex);
if (startCell == null)
{
return;
}
string startCellValue = startCell.StringCellValue;
if (string.IsNullOrWhiteSpace(startCellValue))
{
return;
}
for (int rowIndex = exportOption.DataRowStartIndex; rowIndex < sheet.PhysicalNumberOfRows; rowIndex++)
{
var cell = sheet.GetRow(rowIndex)?.GetCell(colIndex);
currentCellValue = cell == null ? string.Empty : cell.StringCellValue;
if (currentCellValue.Trim() != startCellValue.Trim())
{
mergeRangeAddress = new CellRangeAddress(startRowIndex, rowIndex - 1, colIndex, colIndex);
sheet.AddMergedRegion(mergeRangeAddress);
startRow.GetCell(colIndex).CellStyle.VerticalAlignment = VerticalAlignment.Center;
startRowIndex = rowIndex;
startCellValue = currentCellValue;
}
if (rowIndex == sheet.PhysicalNumberOfRows - 1 && startRowIndex != rowIndex)
{
mergeRangeAddress = new CellRangeAddress(startRowIndex, rowIndex, colIndex, colIndex);
sheet.AddMergedRegion(mergeRangeAddress);
startRow.GetCell(colIndex).CellStyle.VerticalAlignment = VerticalAlignment.Center;
}
}
}
public byte[] ExportExcel <TExport>(ExportOption exportOption, List <TExport> datas) where TExport : class, new()
{
var provider = this._exportProvider;
if (exportOption.ExcelExportProvider != null)
{
provider = exportOption.ExcelExportProvider;
}
IWorkbook workbook = null;
if (exportOption.ExcelType == Core.ExcelExport.Enums.ExcelType.XLS)
{
workbook = new HSSFWorkbook();
if (datas.Count > 65536)
{
throw new NotSupportedException("xls文档最大长度是65536行");
}
}
else if (exportOption.ExcelType == Core.ExcelExport.Enums.ExcelType.XLSX)
{
workbook = new XSSFWorkbook();
if (datas.Count > 1048576)
{
throw new NotSupportedException("xlsx文档最大长度是1048576行");
}
}
if (workbook == null)
{
throw new NotSupportedException($"{nameof(workbook)}不能是null");
}
DataSet dataSet = this.FindDataSource <TExport>(datas, exportOption.PropertyNames);
byte[] workbookBytes = this.Export(exportOption, workbook, dataSet);
DecorationContext context = new DecorationContext {
TypeDecoInfo = TypeDecoInfoFactory.CreateTypeDecoInfo <TExport>()
};
List <IFilter> filters = FiltersFactory.CreateFilters(context);
filters.ForEach(f =>
{
workbookBytes = f.Filter(workbookBytes, context, exportOption, provider);
});
return(workbookBytes);
}
private void InitializeOptions()
{
ImageExportSettings settings = ImageExportSettings.Default;
_exportOption = (ExportOption)settings.SelectedImageExportOption;
_selectedExporterInfo = GetExporterInfo(settings.SelectedImageExporterId);
if (_selectedExporterInfo == null)
{
_selectedExporterInfo = _exporterInfoList[0];
}
_sizeMode = settings.SizeMode;
_backgroundColor = settings.BackgroundColor;
}
private byte[] Decorate <T>(byte[] workbookBytes, ExportOption <T> exportOption)
where T : class, new()
{
DecoratorContext context = new DecoratorContext()
{
TypeDecoratorInfo = TypeDecoratorInfoFactory.CreateInstance(typeof(T))
};
GetDecorators <T>().ForEach(d =>
{
workbookBytes = d.Decorate(workbookBytes, exportOption, context, _excelExportProvider);
});
return(workbookBytes);
}
public byte[] Export<T>(List<T> data,ExportOption<T> exportOption) where T : class, new()
{
string url = Path.Combine(Environment.CurrentDirectory, DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".xlsx");
using (var writer = new StreamWriter(url))
using (var csv = new CsvWriter(writer, new CultureInfo("zh-CN", false)))
{
csv.WriteRecords(data);
}
var bytes = File.ReadAllBytes(url);
File.Delete(url);
return bytes;
}
public Task <byte[]> ExportAsync <T>(ExportOption <T> exportOption) where T : class, new()
{
if (exportOption.ExportType == Enums.ExportType.XLS && exportOption.Data.Count > 65535)
{
throw new InvalidOperationException("xls格式文件最多支持65536行数据");
}
if (exportOption.ExportType == Enums.ExportType.XLSX && exportOption.Data.Count > 1048575)
{
throw new InvalidOperationException("xlsx格式文件最多支持1048575行数据");
}
NPOIExcelHelper helper = new NPOIExcelHelper();
var workbookBytes = helper.Export(exportOption);
//返回byte数组
return(Task.FromResult(workbookBytes));
}
public byte[] DecorateHeader <T>(byte[] workbookBytes, ExportOption <T> exportOption, DecoratorContext context)
where T : class, new()
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var attr = (HeaderAttribute)context.TypeDecoratorInfo?.TypeDecoratorAttrs?.SingleOrDefault(a => a.GetType() == typeof(HeaderAttribute));
if (attr == null)
{
return(workbookBytes);
}
IWorkbook workbook = workbookBytes.ToWorkbook();
IRow headerRow = workbook?.GetSheet(exportOption.SheetName)?.GetRow(exportOption.HeaderRowIndex);
if (headerRow == null)
{
return(workbookBytes);
}
ICellStyle style = workbook.CreateCellStyle();
IFont font = workbook.CreateFont();
font.FontName = attr.FontName;
font.Color = (short)attr.Color.GetHashCode();
font.FontHeightInPoints = (short)attr.FontSize;
if (attr.IsBold)
{
font.Boldweight = short.MaxValue;
}
style.SetFont(font);
for (int i = 0; i < headerRow.PhysicalNumberOfCells; i++)
{
headerRow.GetCell(i).CellStyle = style;
}
return(workbook.ToBytes());
}
public Task <byte[]> ExportAsync <T>(List <T> data, ExportOption <T> exportOption = null)
where T : class, new()
{
exportOption = exportOption ?? new ExportOption <T>();
var provider = _excelExportProvider;
switch (exportOption.ExportType)
{
case Enums.ExportType.FastXLSX:
provider = new OpenXmlExcelExportProvider();
break;
case Enums.ExportType.CSV:
provider = new CSVExcelExportProvider();
break;
}
if (exportOption.CustomExcelExportProvider != null)
{
provider = exportOption.CustomExcelExportProvider;
}
//if (exportOption.ExcelType == Enums.ExcelTypeEnum.XLS
// && exportOption.Data.Count > 65535)
//{
// throw new InvalidOperationException("xls格式文件最多支持65536行数据");
//}
//if (exportOption.ExcelType == Enums.ExcelTypeEnum.XLSX
// && exportOption.Data.Count > 1048575)
//{
// throw new InvalidOperationException("xlsx格式文件最多支持1048575行数据");
//}
var workbookBytes = provider.Export(data, exportOption);
//设置样式
workbookBytes = Decorate(workbookBytes, exportOption);
//返回byte数组
return(Task.FromResult(workbookBytes));
}
private void LoadSettings()
{
AviExportSettings settings = AviExportSettings.Default;
_exportOption = (ExportOption)settings.ExportOption;
_frameRate = settings.FrameRate;
_selectedCodec = Avi.Codec.GetInstalledCodec(settings.PreferredCodecFccCode);
_availableCodecs.AddRange(GetAvailiableCodecs());
if (!_availableCodecs.Contains(_selectedCodec))
{
_selectedCodec = Avi.Codec.Find(GetInputFormat(), null); //use whatever the OS provides.
}
_quality = settings.Quality;
UseDefaultQuality = settings.UseDefaultQuality;
_sizeMode = settings.SizeMode;
_backgroundColor = settings.BackgroundColor;
}
public byte[] MergeCols <T>(byte[] workbookBytes, ExportOption <T> exportOption, DecoratorContext context)
where T : class, new()
{
if (context == null)
{
throw new ArgumentNullException("context");
}
var propertyDecoratorInfos = context.TypeDecoratorInfo.PropertyDecoratorInfos;
var workbook = workbookBytes.ToWorkbook();
ISheet sheet = workbook.GetSheet(exportOption.SheetName);
foreach (var item in propertyDecoratorInfos)
{
if (item.DecoratorAttrs.SingleOrDefault(a => a.GetType() == typeof(MergeColsAttribute)) != null)
{
MergeCols(sheet, item.ColIndex, exportOption);
}
}
return(workbook.ToBytes());
}
/// <summary>
/// 导出Excel
/// </summary>
private byte[] Export(ExportOption exportOption, IWorkbook workbook, DataSet dataSet)
{
string[] tableHeaders = exportOption.Header.SplitTextBySemicolonChar();
string[] sheetNames = exportOption.SheetName.SplitTextBySemicolonChar();
string[] titles = exportOption.Title.SplitTextBySemicolonChar();
ICellStyle titleStyle = this.titleStyleFunc(workbook);
ICellStyle headerStyle = this.headerStyleFunc(workbook);
ICellStyle contentStyle = this.styleFunc(workbook);
for (int sheetIndex = 0; sheetIndex < sheetNames.Length; sheetIndex++)
{
ISheet sheet = workbook.CreateSheet(sheetNames[sheetIndex]);
var rowInfo = this.CreateTitleAndHeader(tableHeaders, titles, sheetIndex, sheet, titleStyle, headerStyle);
int rowIndex = rowInfo.headerRowCount + rowInfo.titleRowCount;
this.CreateDataContent(sheetIndex, rowIndex, sheet, contentStyle, dataSet);
}
return(workbook.ConvertWorkBookToBytes());
}
public ExportOptionDialog(ExportType exporyType, MapType mapType)
{
InitializeComponent();
DataContext = new ExportOption(exporyType, mapType);
}
public bool DownloadChapter(Chapter downloadChapter, Source specificSource = null)
{
if (downloadChapter == null || !downloadChapter.Valid)
{
SetUpdateProgress(0, 0, UpdateStates.Error);
return(false);
}
if (UpdateState == UpdateStates.Syncing || UpdateState == UpdateStates.Checking)
{
return(false);
}
var result = downloadChapter.ChapterUrls;
if (!result.Any())
{
SetUpdateProgress(0, 0, UpdateStates.Error);
return(false);
}
if (specificSource != null)
{
if (!Sources.Contains(specificSource))
{
return(false);
}
var urlResult = (from url in downloadChapter.ChapterUrls
where url.Source.ID == specificSource.ID
select url);
if (!urlResult.Any())
{
return(false);
}
ChapterUrl specificUrl = urlResult.First <ChapterUrl>();
string[] novelContent = specificSource.GetChapterContent(downloadChapter.ChapterTitle, specificUrl.Url);
if (novelContent == null)
{
return(false);
}
System.IO.File.WriteAllLines(downloadChapter.GetTextFileLocation(), novelContent);
return(true);
}
ChapterUrl[] urls = (from url in result
where url.Vip == false
orderby url.Source.Priority ascending
select url).ToArray <ChapterUrl>();
foreach (ChapterUrl url in urls)
{
//Console.WriteLine("Download chapter " + downloadChapter.ChapterTitle + " " + (url.Vip));
if (url == null || url.Vip)
{
continue;
}
Source source = url.Source;
if (source == null || !source.Valid)
{
continue;
}
string[] novelContent = source.GetChapterContent(downloadChapter.ChapterTitle, url.Url);
if (novelContent == null)
{
continue;
}
System.IO.File.WriteAllLines(downloadChapter.GetTextFileLocation(), novelContent);
if (Configuration.Instance.TextExportLocation != null)
{
string exportFolderLocation = Path.Combine(Configuration.Instance.TextExportLocation, NovelTitle);
if (!Directory.Exists(exportFolderLocation))
{
Directory.CreateDirectory(exportFolderLocation);
}
if (Configuration.Instance.NovelExport.ContainsKey(NovelTitle))
{
ExportOption exportOption = Configuration.Instance.NovelExport[NovelTitle];
if (exportOption == ExportOption.Both || exportOption == ExportOption.Text)
{
downloadChapter.ExportText(exportFolderLocation);
}
}
}
return(true);
}
return(false);
}
private void ExportOptionDialogOnExportOptionSelected(object sender, ExportOptionSelectedEventArgs e)
{
try
{
var exportType = e.ExportOption.ExportType;
var mapType = e.ExportOption.MapType;
IExportJob exist = null;
#if DEBUG
foreach (var exportJob in RootMap.ExportJobs)
{
var exportOption = new ExportOption(exportJob.ExportProperties, exportJob.Type, exportJob.MapType);
if (exportOption.Equals(e.ExportOption))
{
exist = exportJob;
break;
}
}
//exist = RootMap.ExportJobs.FirstOrDefault(q => new ExportOption(q.ExportProperties, q.Type, q.MapType).Equals(e.ExportOption));
#else
exist = RootMap.ExportJobs.FirstOrDefault(q => new ExportOption(q.ExportProperties, q.Type, q.MapType).Equals(e.ExportOption) && q.IsCurrent);
#endif
if (exist != null)
{
switch (exist.Status)
{
case ExportStatus.Completed:
SuperMessageBoxService.ShowInformation("Export Exists",
"An existing export that matches is up-to-date and ready for download already");
break;
case ExportStatus.Error:
SuperMessageBoxService.ShowInformation("Export Exists",
"An existing export that matches did not complete successfully, delete the failed export and try again");
break;
case ExportStatus.Processing:
case ExportStatus.Scheduled:
SuperMessageBoxService.ShowInformation("Export Exists",
string.Format("An existing export that matches is already {0}, please wait until it has completed", exist.Status.ToString().ToLower()));
break;
default:
break;
}
IsBusy = false;
}
else
{
ExportServiceManager.CreateExportJobCompleted.RegisterEvent(RootMap.Id, OnCreateExportJobCompleted);
ExportServiceManager.CreateExportJobAsync(RootMap.ParentId, RootMap.Id, e.ExportOption.Value, mapType, exportType);
DebugLogger.Instance.LogMsg("Submitted export job details, Domain: {0}, RootMap: {1}, MapType: {2}, ExportType: {3}", RootMap.ParentId, RootMap.Id, mapType, exportType);
}
}
catch (Exception ex)
{
DebugLogger.Instance.LogMsg("An error occurred processing the Export Options dialog. {0}.", ex.ToString());
SuperMessageBoxService.ShowError("Error Occurred",
"You cannot export the map at the moment, please try again later.");
}
}
public override void OnInspectorGUI(NodeGUI node, AssetReferenceStreamManager streamManager, NodeGUIEditor editor, Action onValueChanged)
{
if (m_exportPath == null)
{
return;
}
var currentEditingGroup = editor.CurrentEditingGroup;
EditorGUILayout.HelpBox("Export To Directory: Export given files to output directory.", MessageType.Info);
editor.UpdateNodeName(node);
GUILayout.Space(10f);
//Show target configuration tab
editor.DrawPlatformSelector(node);
using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
var disabledScope = editor.DrawOverrideTargetToggle(node, m_exportPath.ContainsValueOf(currentEditingGroup), (bool enabled) => {
using (new RecordUndoScope("Remove Target Export Settings", node, true)){
if (enabled)
{
m_exportPath[currentEditingGroup] = m_exportPath.DefaultValue;
m_exportOption[currentEditingGroup] = m_exportOption.DefaultValue;
m_flattenDir[currentEditingGroup] = m_flattenDir.DefaultValue;
}
else
{
m_exportPath.Remove(currentEditingGroup);
m_exportOption.Remove(currentEditingGroup);
m_flattenDir.Remove(currentEditingGroup);
}
onValueChanged();
}
});
EditorGUI.BeginDisabledGroup(disabledScope);
#region DisableGroup
//using (disabledScope) {
ExportOption opt = (ExportOption)m_exportOption[currentEditingGroup];
var newOption = (ExportOption)EditorGUILayout.EnumPopup("Export Option", opt);
if (newOption != opt)
{
using (new RecordUndoScope("Change Export Option", node, true)){
m_exportOption[currentEditingGroup] = (int)newOption;
onValueChanged();
}
}
EditorGUILayout.LabelField("Export Path:");
string newExportPath = null;
newExportPath = editor.DrawFolderSelector("", "Select Export Folder",
m_exportPath[currentEditingGroup],
GetExportPath(m_exportPath[currentEditingGroup]),
(string folderSelected) => {
var projectPath = Directory.GetParent(Application.dataPath).ToString();
if (projectPath == folderSelected)
{
folderSelected = string.Empty;
}
else
{
var index = folderSelected.IndexOf(projectPath);
if (index >= 0)
{
folderSelected = folderSelected.Substring(projectPath.Length + index);
if (folderSelected.IndexOf('/') == 0)
{
folderSelected = folderSelected.Substring(1);
}
}
}
return(folderSelected);
}
);
if (newExportPath != m_exportPath[currentEditingGroup])
{
using (new RecordUndoScope("Change Export Path", node, true)){
m_exportPath[currentEditingGroup] = newExportPath;
onValueChanged();
}
}
int flat = m_flattenDir[currentEditingGroup];
var newFlat = EditorGUILayout.ToggleLeft("Flatten Directory", flat == 1) ? 1:0;
if (newFlat != flat)
{
using (new RecordUndoScope("Change Flatten Directory", node, true)){
m_flattenDir[currentEditingGroup] = newFlat;
onValueChanged();
}
}
var exporterNodePath = GetExportPath(newExportPath);
if (ValidateExportPath(
newExportPath,
exporterNodePath,
() => {
},
() => {
using (new EditorGUILayout.HorizontalScope()) {
EditorGUILayout.LabelField(exporterNodePath + " does not exist.");
if (GUILayout.Button("Create directory"))
{
Directory.CreateDirectory(exporterNodePath);
}
onValueChanged();
}
EditorGUILayout.Space();
string parentDir = Path.GetDirectoryName(exporterNodePath);
if (Directory.Exists(parentDir))
{
EditorGUILayout.LabelField("Available Directories:");
string[] dirs = Directory.GetDirectories(parentDir);
foreach (string s in dirs)
{
EditorGUILayout.LabelField(s);
}
}
}
))
{
GUILayout.Space(10f);
using (new EditorGUILayout.HorizontalScope()) {
GUILayout.FlexibleSpace();
#if UNITY_EDITOR_OSX
string buttonName = "Reveal in Finder";
#else
string buttonName = "Show in Explorer";
#endif
if (GUILayout.Button(buttonName))
{
EditorUtility.RevealInFinder(exporterNodePath);
}
}
}
#endregion
EditorGUI.EndDisabledGroup();
}
}
public byte[] SetTitleDecoration(byte[] workBookBytes, DecorationContext context, ExportOption exportOption)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (exportOption == null)
{
return(workBookBytes);
}
if (string.IsNullOrWhiteSpace(exportOption.Title))
{
return(workBookBytes);
}
List <BaseDecorationAttribute> basesList = new List <BaseDecorationAttribute>();
basesList.AddRange(context.TypeDecoInfo.TypeDecoAttrs);
basesList.AddRange(context.TypeDecoInfo.propertyDecoInfos.SelectMany(pd => pd.PropertyAttrs));
IWorkbook workbook = workBookBytes.ConvertBytesToWorkBook();
var titleAttr = (TitleAttribute)basesList.FirstOrDefault(bd => bd.GetType() == typeof(TitleAttribute));
ICellStyle cellStyle = workbook.CreateCellStyle();
cellStyle.Alignment = titleAttr.HorizontalAlignment;
cellStyle.VerticalAlignment = titleAttr.VerticalAlignment;
cellStyle.FillForegroundColor = titleAttr.FillForegroundColor;
cellStyle.FillPattern = titleAttr.FillPattern;
cellStyle.BorderBottom = titleAttr.BorderBottom;
cellStyle.BorderLeft = titleAttr.BorderLeft;
cellStyle.BorderRight = titleAttr.BorderRight;
IFont font = workbook.CreateFont();
font.Color = (short)titleAttr.FontColor.GetHashCode();
font.FontName = titleAttr.FontName;
font.FontHeightInPoints = titleAttr.FontSize;
if (titleAttr.IsBold)
{
font.IsBold = true;
}
cellStyle.SetFont(font);
ISheet sheet = workbook.GetSheet(exportOption.SheetName);
IRow row = sheet.GetRow(0);
for (int i = 0; i < row.PhysicalNumberOfCells; i++)
{
row.GetCell(i).CellStyle = cellStyle;
}
return(workbook.ConvertWorkBookToBytes());
}
public byte[] Decorate <T>(byte[] workbookBytes, ExportOption <T> exportOption, DecoratorContext context, IExcelExportProvider exportProvider)
where T : class, new()
{
return(exportProvider.MergeCols(workbookBytes, exportOption, context));
}
public byte[] WrapText <T>(byte[] workbookBytes, ExportOption <T> exportOption, DecoratorContext context) where T : class, new()
{
throw new NotImplementedException();
}
private static void ToLocal(Post post, ExportOption option)
{
string text = "";
try
{
text = new Markdown().Transform(post.body_md);
}
catch (Exception)
{
return;
}
var html = new HtmlAgilityPack.HtmlDocument();
html.LoadHtml(text);
var images = html.DocumentNode
.SelectNodes(@"//img");
var anchors = html.DocumentNode
.SelectNodes(@"//a");
var tite = new String(post.full_name.Replace("/", "_").Where(x => !System.IO.Path.GetInvalidFileNameChars().Contains(x)).ToArray());
var path = $@"{filePath}\{post.number}";
if (images != null)
{
DownloadImages(images, path);
}
if (option == ExportOption.Json)
{
var jsonData = JsonSerializer.Serialize(post);
System.IO.File.WriteAllBytes($@"{path}.json", jsonData);
}
else
{
var md = post.body_md;
if (images != null)
{
var files = System.IO.Directory.GetFiles(path)
.Select(x => System.IO.Path.GetFileName(x))
.ToArray();
foreach (var item in images)
{
string url = "";
try
{
url = item.Attributes["src"].Value;
}
catch (Exception)
{
continue;
}
var fileName = files.FirstOrDefault(x => item.Attributes["src"].Value.Contains(x));
if (!string.IsNullOrEmpty(fileName))
{
md = md.Replace(url, $@"./{post.number}/{fileName}");
}
}
}
if (anchors != null)
{
foreach (var item in anchors)
{
string url = "";
try
{
url = item.Attributes["href"].Value;
}
catch (Exception)
{
continue;
}
if (url.IndexOf(teamPostUrl) < 0)
{
continue;
}
md = md.Replace(url, $"./{post.number}.md");
}
}
System.IO.File.WriteAllText($@"{path}.md", md);
}
}
public byte[] Filter(byte[] workBookBytes, DecorationContext context, ExportOption exportOption, IExcelExportProvider exportProvider)
{
return(exportProvider.SetTitleDecoration(workBookBytes, context, exportOption));
}
