998 lines
48 KiB
C#
998 lines
48 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using Kreta.Core.ConnectionType;
|
|
using Kreta.Resources;
|
|
using OfficeOpenXml;
|
|
using OfficeOpenXml.Style;
|
|
|
|
namespace Kreta.BusinessLogic.Helpers.Nyomtatvanyok.Excel
|
|
{
|
|
public abstract class BaseNyomtatvanyExcel : IDisposable
|
|
{
|
|
private const string ConstFontName = "Calibri";
|
|
|
|
protected class CellStyle
|
|
{
|
|
public string Name { get; set; }
|
|
|
|
/// integer (not really needed unless you need to round numbers, Excel with use default cell properties) --> "0"
|
|
/// integer without displaying the number 0 in the cell --> "#"
|
|
/// number with 1 decimal place --> "0.0"
|
|
/// number with 2 decimal places --> "0.00"
|
|
/// number with 2 decimal places and thousand separator --> "#,##0.00"
|
|
/// number with 2 decimal places and thousand separator and money symbol --> "€#,##0.00"
|
|
/// percentage (1 = 100%, 0.01 = 1%) --> "0%"
|
|
public string Numberformat { get; set; } = "0";
|
|
|
|
public string BgColorHex { get; set; } = "transparent";
|
|
|
|
public bool FontBold { get; set; }
|
|
|
|
public int FontSize { get; set; } = 11;
|
|
|
|
public string FontName { get; set; } = ConstFontName;
|
|
|
|
public string FontColorHex { get; set; } = "automatic";
|
|
|
|
public int TextRotation { get; set; }
|
|
|
|
public bool WrapText { get; set; }
|
|
|
|
public ExcelBorderStyle LeftBorder { get; set; } = ExcelBorderStyle.None;
|
|
|
|
public ExcelBorderStyle RightBorder { get; set; } = ExcelBorderStyle.None;
|
|
|
|
public ExcelBorderStyle TopBorder { get; set; } = ExcelBorderStyle.None;
|
|
|
|
public ExcelBorderStyle BottomBorder { get; set; } = ExcelBorderStyle.None;
|
|
|
|
public ExcelHorizontalAlignment HorizontalAlignment { get; set; } = ExcelHorizontalAlignment.Left;
|
|
|
|
public ExcelVerticalAlignment VerticalAlignment { get; set; } = ExcelVerticalAlignment.Center;
|
|
|
|
public CellStyle()
|
|
{ }
|
|
|
|
public CellStyle(string Name)
|
|
{
|
|
this.Name = Name;
|
|
}
|
|
|
|
public CellStyle(BaseNyomtatvanyExcel.CellStyle prevCellStyle)
|
|
{
|
|
Numberformat = prevCellStyle.Numberformat;
|
|
BgColorHex = prevCellStyle.BgColorHex;
|
|
FontBold = prevCellStyle.FontBold;
|
|
FontSize = prevCellStyle.FontSize;
|
|
FontName = prevCellStyle.FontName;
|
|
FontColorHex = prevCellStyle.FontColorHex;
|
|
TextRotation = prevCellStyle.TextRotation;
|
|
WrapText = prevCellStyle.WrapText;
|
|
LeftBorder = prevCellStyle.LeftBorder;
|
|
RightBorder = prevCellStyle.RightBorder;
|
|
TopBorder = prevCellStyle.TopBorder;
|
|
BottomBorder = prevCellStyle.BottomBorder;
|
|
HorizontalAlignment = prevCellStyle.HorizontalAlignment;
|
|
VerticalAlignment = prevCellStyle.VerticalAlignment;
|
|
}
|
|
}
|
|
|
|
protected string Author = "";
|
|
protected ExcelPackage ExcelPackage;
|
|
protected DataSet DataSet;
|
|
protected string StoredProcedure = null;
|
|
protected Dictionary<string, string> DbParameters = new Dictionary<string, string>();
|
|
|
|
protected Dictionary<string, CellStyle> NamedCellStyles = new Dictionary<string, CellStyle>();
|
|
|
|
protected CellStyle NormalStyle = null;
|
|
protected CellStyle NormalStyleWrapText = null;
|
|
protected CellStyle HeaderStyle = null;
|
|
protected CellStyle HeaderStyle90 = null;
|
|
|
|
protected CellStyle IntegerStyle = null;
|
|
protected CellStyle IntegerBoldStyle = null;
|
|
protected CellStyle Numeric2Style = null;
|
|
protected CellStyle Numeric2BoldStyle = null;
|
|
|
|
protected CellStyle NormalStyleBottomBordered = null;
|
|
protected CellStyle NormalStyleCentered = null;
|
|
protected CellStyle HeaderStyleBottomBordered = null;
|
|
protected CellStyle HeaderStyle90BottomBordered = null;
|
|
|
|
protected CellStyle IntegerStyleBottomBordered = null;
|
|
protected CellStyle IntegerBoldStyleBottomBordered = null;
|
|
protected CellStyle Numeric2StyleBottomBordered = null;
|
|
protected CellStyle Numeric2BoldStyleBottomBordered = null;
|
|
|
|
protected CellStyle HeaderStyleBottomBorderedBGGray = null;
|
|
protected CellStyle HeaderStyle90BottomBorderedBGGray = null;
|
|
|
|
protected CellStyle DocnameStyle = null;
|
|
|
|
protected CellStyle DocheaderStyle1 = null;
|
|
|
|
protected CellStyle DocheaderStyle2 = null;
|
|
protected CellStyle DocheaderStyleSideBordered = null;
|
|
|
|
protected CellStyle DocheaderStyleMergedUpperCell = null;
|
|
protected CellStyle DocheaderStyleMergedLowerCell = null;
|
|
protected CellStyle DocheaderStyleCenteredWithoutBorder = null;
|
|
|
|
protected CellStyle Numeric2BoldBigerStyleBottomBordered = null;
|
|
protected CellStyle PercentStyleBottomBordered = null;
|
|
protected CellStyle PercentBoldStyleBottomBordered = null;
|
|
|
|
protected bool isMultisheetExcel;
|
|
|
|
private IConnectionType _connectionType;
|
|
|
|
public DataSet GetSheetDataSet()
|
|
=> DataSet;
|
|
|
|
protected BaseNyomtatvanyExcel(IConnectionType connectionType, bool isMultisheetExcel = false)
|
|
{
|
|
_connectionType = connectionType;
|
|
this.isMultisheetExcel = isMultisheetExcel;
|
|
NamedCellStyles.Add("NormalStyle", NormalStyle = new CellStyle("NormalStyle"));
|
|
NamedCellStyles.Add("NormalStyleWrapText", NormalStyleWrapText = new CellStyle(NamedCellStyles["NormalStyle"]) { Name = "NormalStyleWrapText", WrapText = true });
|
|
NamedCellStyles.Add("HeaderStyle", HeaderStyle = new CellStyle("HeaderStyle") { FontBold = true, WrapText = true });
|
|
NamedCellStyles.Add("HeaderStyle90", HeaderStyle90 = new CellStyle(NamedCellStyles["HeaderStyle"]) { Name = "HeaderStyle90", TextRotation = 90, HorizontalAlignment = ExcelHorizontalAlignment.Center, VerticalAlignment = ExcelVerticalAlignment.Bottom });
|
|
|
|
NamedCellStyles.Add("IntegerStyle", IntegerStyle = new CellStyle("IntegerStyle") { Numberformat = "0", HorizontalAlignment = ExcelHorizontalAlignment.Center });
|
|
NamedCellStyles.Add("IntegerBoldStyle", IntegerBoldStyle = new CellStyle(NamedCellStyles["IntegerStyle"]) { Name = "IntegerBoldStyle", FontBold = true });
|
|
NamedCellStyles.Add("Numeric2Style", Numeric2Style = new CellStyle("Numeric2Style") { Numberformat = "0.00", HorizontalAlignment = ExcelHorizontalAlignment.Center });
|
|
NamedCellStyles.Add("Numeric2BoldStyle", Numeric2BoldStyle = new CellStyle(NamedCellStyles["Numeric2Style"]) { Name = "Numeric2BoldStyle", FontBold = true });
|
|
|
|
NamedCellStyles.Add("NormalStyleBottomBordered", NormalStyleBottomBordered = new CellStyle("NormalStyleBottomBordered")
|
|
{
|
|
TopBorder = ExcelBorderStyle.None,
|
|
LeftBorder = ExcelBorderStyle.None,
|
|
BottomBorder = ExcelBorderStyle.Thin,
|
|
RightBorder = ExcelBorderStyle.None,
|
|
});
|
|
NamedCellStyles.Add("NormalStyleCentered", NormalStyleCentered = new CellStyle("NormalStyleCentered")
|
|
{
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Center,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center,
|
|
WrapText = true
|
|
});
|
|
|
|
NamedCellStyles.Add("HeaderStyleBottomBordered", HeaderStyleBottomBordered = new CellStyle(NamedCellStyles["NormalStyleBottomBordered"]) { Name = "HeaderStyleBottomBordered", FontBold = true, WrapText = true });
|
|
NamedCellStyles.Add("HeaderStyle90BottomBordered", HeaderStyle90BottomBordered = new CellStyle(NamedCellStyles["HeaderStyleBottomBordered"]) { Name = "HeaderStyle90BottomBordered", TextRotation = 90, HorizontalAlignment = ExcelHorizontalAlignment.Center, VerticalAlignment = ExcelVerticalAlignment.Bottom });
|
|
|
|
NamedCellStyles.Add("IntegerStyleBottomBordered", IntegerStyleBottomBordered = new CellStyle(NamedCellStyles["NormalStyleBottomBordered"]) { Name = "IntegerStyleBottomBordered", Numberformat = "0", HorizontalAlignment = ExcelHorizontalAlignment.Center });
|
|
NamedCellStyles.Add("IntegerBoldStyleBottomBordered", IntegerBoldStyleBottomBordered = new CellStyle(NamedCellStyles["IntegerStyleBottomBordered"]) { Name = "IntegerBoldStyleBottomBordered", FontBold = true });
|
|
NamedCellStyles.Add("Numeric2StyleBottomBordered", Numeric2StyleBottomBordered = new CellStyle(NamedCellStyles["NormalStyleBottomBordered"]) { Name = "Numeric2StyleBottomBordered", Numberformat = "0.00", HorizontalAlignment = ExcelHorizontalAlignment.Center });
|
|
NamedCellStyles.Add("Numeric2BoldStyleBottomBordered", Numeric2BoldStyleBottomBordered = new CellStyle(NamedCellStyles["Numeric2StyleBottomBordered"]) { Name = "Numeric2BoldStyleBottomBordered", FontBold = true });
|
|
|
|
NamedCellStyles.Add("HeaderStyleBottomBorderedBGGray", HeaderStyleBottomBorderedBGGray = new CellStyle(NamedCellStyles["HeaderStyleBottomBordered"]) { Name = "HeaderStyleBottomBorderedBGGray", BgColorHex = "#AAAAAA" });
|
|
NamedCellStyles.Add("HeaderStyle90BottomBorderedBGGray", HeaderStyle90BottomBorderedBGGray = new CellStyle(NamedCellStyles["HeaderStyle90BottomBordered"]) { Name = "HeaderStyle90BottomBorderedBGGray", BgColorHex = "#AAAAAA" });
|
|
|
|
NamedCellStyles.Add("DocnameStyle", DocnameStyle = new CellStyle(NamedCellStyles["HeaderStyle"]) { Name = "DocnameStyle", FontSize = 16 });
|
|
|
|
NamedCellStyles.Add("DocheaderStyle1", DocheaderStyle1 = new CellStyle(NamedCellStyles["HeaderStyle"])
|
|
{
|
|
Name = "DocheaderStyle1",
|
|
FontColorHex = "#FFFFFF",
|
|
BgColorHex = "#18A0C8",
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Left,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center
|
|
});
|
|
|
|
NamedCellStyles.Add("DocheaderStyleSideBordered", DocheaderStyleSideBordered = new CellStyle(NamedCellStyles["HeaderStyle"])
|
|
{
|
|
Name = "DocheaderStyleSideBordered",
|
|
FontColorHex = "#FFFFFF",
|
|
BgColorHex = "#18A0C8",
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Center,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center,
|
|
LeftBorder = ExcelBorderStyle.Thin,
|
|
RightBorder = ExcelBorderStyle.Thin,
|
|
BottomBorder = ExcelBorderStyle.Thin
|
|
});
|
|
|
|
NamedCellStyles.Add("DocheaderStyleMergedUpperCell", DocheaderStyleMergedUpperCell = new CellStyle(NamedCellStyles["HeaderStyle"])
|
|
{
|
|
Name = "DocheaderStyleMergedUpperCell",
|
|
FontColorHex = "#FFFFFF",
|
|
BgColorHex = "#18A0C8",
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Left,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center,
|
|
TopBorder = ExcelBorderStyle.Thin,
|
|
LeftBorder = ExcelBorderStyle.Thin,
|
|
RightBorder = ExcelBorderStyle.Thin
|
|
});
|
|
NamedCellStyles.Add("DocheaderStyleMergedLowerCell", DocheaderStyleMergedLowerCell = new CellStyle(NamedCellStyles["HeaderStyle"])
|
|
{
|
|
Name = "DocheaderStyleMergedLowerCell",
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Left,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center,
|
|
LeftBorder = ExcelBorderStyle.Thin,
|
|
RightBorder = ExcelBorderStyle.Thin,
|
|
BottomBorder = ExcelBorderStyle.Thin
|
|
});
|
|
NamedCellStyles.Add("DocheaderStyleCenteredWithoutBorder", DocheaderStyleCenteredWithoutBorder = new CellStyle(NamedCellStyles["DocheaderStyle1"])
|
|
{
|
|
Name = "DocheaderStyleCenteredWithoutBorder",
|
|
HorizontalAlignment = ExcelHorizontalAlignment.Center,
|
|
VerticalAlignment = ExcelVerticalAlignment.Center,
|
|
LeftBorder = ExcelBorderStyle.None,
|
|
RightBorder = ExcelBorderStyle.None,
|
|
TopBorder = ExcelBorderStyle.None,
|
|
BottomBorder = ExcelBorderStyle.None
|
|
});
|
|
|
|
NamedCellStyles.Add("DocheaderStyle2", DocheaderStyle2 = new CellStyle(NamedCellStyles["DocheaderStyle1"]) { Name = "DocheaderStyle2", BgColorHex = "#5D5D5D" });
|
|
|
|
NamedCellStyles.Add("Numeric2BoldBigerStyleBottomBordered", Numeric2BoldBigerStyleBottomBordered = new CellStyle(NamedCellStyles["Numeric2BoldStyleBottomBordered"]) { Name = "Numeric2BoldBigerStyleBottomBordered", FontSize = 14 });
|
|
NamedCellStyles.Add("PercentStyleBottomBordered", PercentStyleBottomBordered = new CellStyle(NamedCellStyles["NormalStyleBottomBordered"]) { Name = "PercentStyleBottomBordered", Numberformat = "0%", HorizontalAlignment = ExcelHorizontalAlignment.Center });
|
|
NamedCellStyles.Add("PercentBoldStyleBottomBordered", PercentBoldStyleBottomBordered = new CellStyle(NamedCellStyles["PercentStyleBottomBordered"]) { Name = "PercentBoldStyleBottomBordered", FontBold = true });
|
|
}
|
|
|
|
protected DataTable CreateDataTable(List<string[]> list)
|
|
{
|
|
var dataTable = new DataTable();
|
|
var firstRow = true;
|
|
|
|
foreach (var listRow in list)
|
|
{
|
|
if (firstRow)
|
|
{
|
|
foreach (var hcol in listRow)
|
|
dataTable.Columns.Add(hcol);
|
|
firstRow = false;
|
|
}
|
|
else
|
|
{
|
|
int col = 0;
|
|
var dataRow = dataTable.NewRow();
|
|
foreach (DataColumn dataColumn in dataTable.Columns)
|
|
dataRow[dataColumn.ToString()] = listRow[col++];
|
|
|
|
dataTable.Rows.Add(dataRow);
|
|
}
|
|
}
|
|
|
|
return dataTable;
|
|
}
|
|
|
|
protected void SetExcelDataSet(DataSet ds = null)
|
|
{
|
|
if (ds == null)
|
|
{
|
|
if (DbParameters == null || StoredProcedure == null)
|
|
{
|
|
throw new NullReferenceException("DB Parameterek nincsenek beallitva");
|
|
}
|
|
|
|
DataSet = new NyomtatvanyokHelper(_connectionType).GetNyomtatvanyStoredProcedureDataSet(StoredProcedure, DbParameters);
|
|
if (DataSet == null)
|
|
{
|
|
throw new NoNullAllowedException(StoredProcedure + " SP has no result!");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DataSet = ds;
|
|
}
|
|
}
|
|
|
|
public abstract void CreateSheet(Dictionary<string, string> dbParameters, int sheetIndex = 1);
|
|
|
|
public MemoryStream ExcelNyomtatas()
|
|
{
|
|
return new MemoryStream(ExcelPackage.GetAsByteArray());
|
|
}
|
|
|
|
public MemoryStream ExcelNyomtatas(Dictionary<string, string> dbParameters)
|
|
{
|
|
if (!isMultisheetExcel)
|
|
{
|
|
if (dbParameters == null)
|
|
{
|
|
throw new ApplicationException("Egy lapos excel munkafüzet nyomtatásához az adatbázis paraméterek kötelezőek.");
|
|
}
|
|
if (ExcelPackage.Workbook.Worksheets.Count > 0)
|
|
{
|
|
GenerateNewExcelPackage();
|
|
SetWorkbookProperties();
|
|
}
|
|
CreateSheet(dbParameters);
|
|
}
|
|
return ExcelNyomtatas();
|
|
}
|
|
|
|
protected void SetWorkbookProperties()
|
|
{
|
|
ExcelPackage.Workbook.Properties.Author = "";
|
|
ExcelPackage.Workbook.Properties.Title = "";
|
|
ExcelPackage.Workbook.Properties.Company = "";
|
|
|
|
foreach (KeyValuePair<string, CellStyle> style in NamedCellStyles)
|
|
ChangeStyle(ExcelPackage.Workbook.Styles.CreateNamedStyle(style.Key), style.Value);
|
|
}
|
|
|
|
protected void AddNamedStyle(string styleName, CellStyle cellStyle)
|
|
=> ChangeStyle(ExcelPackage.Workbook.Styles.CreateNamedStyle(styleName), cellStyle);
|
|
|
|
protected ExcelWorksheet CreateSheet(string sheetName, int position = 1, eOrientation orientation = eOrientation.Portrait, bool fitToPage = false, int fitToWidth = 1, int fitToHeight = 1, int fontSize = 11, string fontName = ConstFontName)
|
|
{
|
|
if (sheetName.Length > 31)
|
|
{
|
|
sheetName = sheetName.Substring(0, 31);
|
|
}
|
|
|
|
ExcelWorksheet worksheet = ExcelPackage.Workbook.Worksheets[sheetName];
|
|
if (worksheet == null)
|
|
{
|
|
worksheet = ExcelPackage.Workbook.Worksheets.Add(sheetName);
|
|
|
|
worksheet.Cells.Style.Font.Size = fontSize;
|
|
worksheet.Cells.Style.Font.Name = fontName;
|
|
if (fitToPage)
|
|
{
|
|
worksheet.PrinterSettings.FitToPage = true;
|
|
worksheet.PrinterSettings.FitToWidth = fitToWidth;
|
|
worksheet.PrinterSettings.FitToHeight = fitToHeight;
|
|
}
|
|
worksheet.PrinterSettings.Orientation = orientation;
|
|
}
|
|
|
|
return worksheet;
|
|
}
|
|
|
|
public string ColumnLabel(int col)
|
|
{
|
|
var dividend = col;
|
|
var columnLabel = string.Empty;
|
|
|
|
while (dividend > 0)
|
|
{
|
|
var modulo = (dividend - 1) % 26;
|
|
columnLabel = Convert.ToChar(65 + modulo) + columnLabel;
|
|
dividend = (dividend - modulo) / 26;
|
|
}
|
|
|
|
return columnLabel;
|
|
}
|
|
|
|
protected void AddComment(ExcelWorksheet worksheet, int row, int col, string comment)
|
|
{
|
|
if (comment != null)
|
|
{
|
|
var commentCell = worksheet.Cells[row, col];
|
|
AddComment(commentCell, comment);
|
|
}
|
|
}
|
|
|
|
protected void AddComment(ExcelRange cell, string comment)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(comment))
|
|
{
|
|
cell.AddComment(comment, Author);
|
|
cell.Comment.AutoFit = true;
|
|
}
|
|
}
|
|
|
|
private ExcelRange AddValueCell(ExcelWorksheet worksheet, int row, int col, object value)
|
|
{
|
|
if (row < 1 || col < 1)
|
|
return null;
|
|
|
|
var cell = worksheet.Cells[row, col];
|
|
cell.Value = value;
|
|
return cell;
|
|
}
|
|
|
|
private ExcelRange AddValueRange(ExcelWorksheet worksheet, int startRow, int startCol, int endRow, int endCol, object value)
|
|
{
|
|
if (startRow < 1 || startCol < 1 || endRow < 1 || endCol < 1)
|
|
return null;
|
|
|
|
var cell = worksheet.Cells[startRow, startCol, endRow, endCol];
|
|
cell.Value = value;
|
|
worksheet.Cells[startRow, startCol, endRow, endCol].Merge = true;
|
|
|
|
return cell;
|
|
}
|
|
|
|
private ExcelRange AddFormulaCell(ExcelWorksheet worksheet, int row, int col, string value)
|
|
{
|
|
if (row < 1 || col < 1)
|
|
return null;
|
|
|
|
worksheet.Workbook.CalcMode = ExcelCalcMode.Automatic;
|
|
var cell = worksheet.Cells[row, col];
|
|
cell.Formula = value;
|
|
return cell;
|
|
}
|
|
|
|
private ExcelRange AddFormulaRange(ExcelWorksheet worksheet, int startRow, int startCol, int endRow, int endCol, string value)
|
|
{
|
|
if (startRow < 1 || startCol < 1 || endRow < 1 || endCol < 1)
|
|
return null;
|
|
|
|
worksheet.Workbook.CalcMode = ExcelCalcMode.Automatic;
|
|
var cell = worksheet.Cells[startRow, startCol, endRow, endCol];
|
|
cell.Formula = value;
|
|
worksheet.Cells[startRow, startCol, endRow, endCol].Merge = true;
|
|
|
|
return cell;
|
|
}
|
|
|
|
protected void AddTanuloAdatokFejlec(ExcelWorksheet worksheet, int fejlecRow)
|
|
{
|
|
var tanuloNevCell = worksheet.Cells[fejlecRow, 1];
|
|
tanuloNevCell.Value = TanuloResource.TanuloNeve;
|
|
ChangeStyle(tanuloNevCell, HeaderStyleBottomBordered);
|
|
|
|
var oktatasiAzonositoCell = worksheet.Cells[fejlecRow, 2];
|
|
oktatasiAzonositoCell.Value = TanuloResource.OktatasiAzonosito;
|
|
ChangeStyle(oktatasiAzonositoCell, HeaderStyleBottomBordered);
|
|
}
|
|
|
|
private void ChangeStyle(ExcelRange cell, CellStyle cellStyle)
|
|
=> cell.StyleName = cellStyle.Name;
|
|
|
|
private void ChangeStyle(OfficeOpenXml.Style.XmlAccess.ExcelNamedStyleXml excelNamedStyleXml, CellStyle cellStyle)
|
|
{
|
|
excelNamedStyleXml.Style.Numberformat.Format = cellStyle.Numberformat;
|
|
|
|
excelNamedStyleXml.Style.Font.Bold = cellStyle.FontBold;
|
|
excelNamedStyleXml.Style.TextRotation = cellStyle.TextRotation;
|
|
excelNamedStyleXml.Style.HorizontalAlignment = cellStyle.HorizontalAlignment;
|
|
excelNamedStyleXml.Style.VerticalAlignment = cellStyle.VerticalAlignment;
|
|
excelNamedStyleXml.Style.WrapText = cellStyle.WrapText;
|
|
|
|
var excelStyleBorder = excelNamedStyleXml.Style.Border;
|
|
if (cellStyle.BottomBorder != ExcelBorderStyle.None)
|
|
excelStyleBorder.Bottom.Style = cellStyle.BottomBorder;
|
|
if (cellStyle.TopBorder != ExcelBorderStyle.None)
|
|
excelStyleBorder.Top.Style = cellStyle.TopBorder;
|
|
if (cellStyle.LeftBorder != ExcelBorderStyle.None)
|
|
excelStyleBorder.Left.Style = cellStyle.LeftBorder;
|
|
if (cellStyle.RightBorder != ExcelBorderStyle.None)
|
|
excelStyleBorder.Right.Style = cellStyle.RightBorder;
|
|
ChangeFontColor(excelNamedStyleXml.Style, cellStyle.FontColorHex);
|
|
ChangeBgColor(excelNamedStyleXml.Style, cellStyle.BgColorHex);
|
|
}
|
|
|
|
private void ChangeFontColor(ExcelStyle excelStyle, string fontColorHex = "automatic")
|
|
{
|
|
if (fontColorHex?.Equals("automatic", StringComparison.OrdinalIgnoreCase) == false)
|
|
excelStyle.Font.Color.SetColor(System.Drawing.ColorTranslator.FromHtml(fontColorHex));
|
|
}
|
|
|
|
private void ChangeBgColor(ExcelStyle excelStyle, string bgColorHex = "transparent")
|
|
{
|
|
if (bgColorHex?.Equals("transparent", StringComparison.OrdinalIgnoreCase) == false)
|
|
{
|
|
excelStyle.Fill.PatternType = ExcelFillStyle.Solid;
|
|
excelStyle.Fill.BackgroundColor.SetColor(System.Drawing.ColorTranslator.FromHtml(bgColorHex));
|
|
}
|
|
}
|
|
|
|
private bool AddCellWithTypeCheck(ExcelWorksheet worksheet, int row, int col, object dtvalue, CellStyle cellStyle = null, string comment = null)
|
|
{
|
|
var aggregatedValues = true;
|
|
|
|
switch (dtvalue)
|
|
{
|
|
case int _:
|
|
case double _:
|
|
AddNumberCell(worksheet, row, col, dtvalue, cellStyle, comment);
|
|
break;
|
|
case string _ when int.TryParse((string)dtvalue, out int intDtvalue):
|
|
AddNumberCell(worksheet, row, col, intDtvalue, cellStyle, comment);
|
|
break;
|
|
case string _ when double.TryParse((string)dtvalue, out double doubleDtValue):
|
|
AddNumberCell(worksheet, row, col, doubleDtValue, cellStyle, comment);
|
|
break;
|
|
default:
|
|
AddLabelCell(worksheet, row, col, dtvalue.ToString(), cellStyle, comment);
|
|
aggregatedValues = false;
|
|
break;
|
|
}
|
|
|
|
return aggregatedValues;
|
|
}
|
|
|
|
protected void AddLabelCell(ExcelWorksheet worksheet, int row, int col, string value, CellStyle cellStyle = null, string comment = null)
|
|
{
|
|
var cell = AddValueCell(worksheet, row, col, value);
|
|
ChangeStyle(cell, cellStyle ?? new CellStyle("NormalStyle"));
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected void AddNumberCell(ExcelWorksheet worksheet, int row, int col, object value, CellStyle cellStyle = null, string comment = null)
|
|
{
|
|
var cell = AddValueCell(worksheet, row, col, value);
|
|
ChangeStyle(cell, cellStyle ?? NamedCellStyles["IntegerStyle"]);
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected void AddFormulaCell(ExcelWorksheet worksheet, int row, int col, string value, CellStyle cellStyle, string comment = null)
|
|
{
|
|
var cell = AddFormulaCell(worksheet, row, col, value);
|
|
ChangeStyle(cell, cellStyle ?? NamedCellStyles["IntegerStyle"]);
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected void AddAggregateFormulaCell(ExcelWorksheet worksheet, int row, int col, string aggrfunctionname, int startRow, int startCol, int endRow, int endCol, bool errorCheck = false, CellStyle cellStyle = null)
|
|
{
|
|
var aggregateCondition = "";
|
|
if (aggrfunctionname.StartsWith("COUNTIF"))
|
|
{
|
|
var rx = new System.Text.RegularExpressions.Regex("[,]");
|
|
var array = rx.Split(aggrfunctionname);
|
|
aggrfunctionname = array[0];
|
|
aggregateCondition = "," + array[1];
|
|
}
|
|
if (aggrfunctionname.StartsWith("IF"))
|
|
{
|
|
//IF,#<offset a pillanatnyi oszloptól>=<feltétel értéke>,#<offset a pillanatnyi oszloptól>,<hamis érték>
|
|
var rx = new System.Text.RegularExpressions.Regex("[,]");
|
|
var array = rx.Split(aggrfunctionname);
|
|
rx = new System.Text.RegularExpressions.Regex("=");
|
|
var condarray = rx.Split(array[1]);
|
|
var form = string.Format("{0}({1}{2}{3},{4}{5},{6})", array[0], ColumnLabel(col + int.Parse(condarray[0].Substring(1))), row, "=" + condarray[1], ColumnLabel(col + int.Parse(array[2].Substring(1))), row, array[3]);
|
|
if (errorCheck)
|
|
form = "IF(ISERROR(" + form + "),\"\"," + form + ")";
|
|
|
|
AddFormulaCell(worksheet, row, col, "=" + form, cellStyle);
|
|
return;
|
|
}
|
|
|
|
string value = null;
|
|
if (startCol <= endCol)
|
|
{
|
|
string formula = aggrfunctionname + "(" + ColumnLabel(startCol) + startRow + ":" + ColumnLabel(endCol) + endRow + aggregateCondition + ")";
|
|
if (errorCheck)
|
|
{
|
|
formula = "IF(ISERROR(" + formula + "),\"\"," + formula + ")";
|
|
}
|
|
value = "=" + formula;
|
|
}
|
|
|
|
AddFormulaCell(worksheet, row, col, value, cellStyle);
|
|
}
|
|
|
|
protected void AddLabelRange(ExcelWorksheet worksheet, int startRow, int startCol, int endRow, int endCol, string value, CellStyle cellStyle = null, string comment = null)
|
|
{
|
|
var cell = AddValueRange(worksheet, startRow, startCol, endRow, endCol, value);
|
|
ChangeStyle(cell, cellStyle ?? new CellStyle());
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected void AddNumberRange(ExcelWorksheet worksheet, int startRow, int startCol, int endRow, int endCol, object value, CellStyle cellStyle = null, string comment = null)
|
|
{
|
|
var cell = AddValueRange(worksheet, startRow, startCol, endRow, endCol, value);
|
|
ChangeStyle(cell, cellStyle ?? NamedCellStyles["IntegerStyle"]);
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected void AddFormulaRange(ExcelWorksheet worksheet, int startRow, int startCol, int endRow, int endCol, string value, CellStyle cellStyle, string comment = null)
|
|
{
|
|
var cell = AddFormulaRange(worksheet, startRow, startCol, endRow, endCol, value);
|
|
ChangeStyle(cell, cellStyle ?? NamedCellStyles["IntegerStyle"]);
|
|
AddComment(cell, comment);
|
|
}
|
|
|
|
protected int AddDataTableCol(ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, int dtCol, CellStyle cellStyle, string customheader = null, CellStyle headerCellStyle = null, string aggregateFunc = null, CellStyle formulaCellStyle = null)
|
|
{
|
|
return AddDataTableCol(worksheet, trow, tcol, dataTable, dataTable.Columns[dtCol].ToString(), cellStyle, customheader, headerCellStyle, aggregateFunc, formulaCellStyle);
|
|
}
|
|
|
|
protected int AddDataTableCol(ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, string dtCol, CellStyle cellStyle, string customHeader = null, CellStyle headerCellStyle = null, string aggregateFunc = null, CellStyle formulaCellStyle = null)
|
|
{
|
|
if (trow < 1 || tcol < 1)
|
|
return 0;
|
|
|
|
var row = 0;
|
|
var rowOffset = 0;
|
|
|
|
DataColumnCollection columns = dataTable.Columns;
|
|
if (columns.Contains(dtCol))
|
|
{
|
|
bool aggregatedValues = false;
|
|
if (customHeader != null)
|
|
{
|
|
AddLabelCell(worksheet, trow, tcol, customHeader, headerCellStyle);
|
|
rowOffset++;
|
|
}
|
|
|
|
for (; row < dataTable.Rows.Count; row++)
|
|
aggregatedValues = AddCellWithTypeCheck(worksheet, trow + rowOffset + row, tcol, dataTable.Rows[row][dtCol], cellStyle);
|
|
|
|
if (aggregatedValues && row > 0 && aggregateFunc != null)
|
|
AddFormulaCell(worksheet, trow + rowOffset + row++, tcol, "=" + aggregateFunc + "(" + ColumnLabel(tcol) + (trow + rowOffset) + ":" + ColumnLabel(tcol) + (trow + rowOffset + row - 2) + ")", formulaCellStyle);
|
|
else if (!aggregatedValues && row > 0 && aggregateFunc != null)
|
|
row++;
|
|
}
|
|
return row + rowOffset;
|
|
}
|
|
|
|
protected int AddDataTableColTransponalt(ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, string dtCol, CellStyle cellStyle, string customHeader = null, CellStyle headerCellStyle = null, string aggregateFunc = null, CellStyle formulaCellStyle = null)
|
|
{
|
|
if (trow < 1 || tcol < 1)
|
|
return 0;
|
|
|
|
var rowColl = 0;
|
|
var collOffset = 0;
|
|
|
|
DataColumnCollection columns = dataTable.Columns;
|
|
if (columns.Contains(dtCol))
|
|
{
|
|
bool aggregatedValues = false;
|
|
if (customHeader != null)
|
|
{
|
|
AddLabelCell(worksheet, trow, tcol, customHeader, headerCellStyle);
|
|
collOffset++;
|
|
}
|
|
|
|
for (; rowColl < dataTable.Rows.Count; rowColl++)
|
|
aggregatedValues = AddCellWithTypeCheck(worksheet, trow, tcol + collOffset + rowColl, dataTable.Rows[rowColl][dtCol], cellStyle);
|
|
|
|
if (aggregatedValues && rowColl > 0 && aggregateFunc != null)
|
|
AddFormulaCell(worksheet, trow, tcol + collOffset + rowColl++, "=" + aggregateFunc + "(" + ColumnLabel(tcol + collOffset) + trow + ":" + ColumnLabel(tcol + collOffset + rowColl - 2) + trow + ")", formulaCellStyle);
|
|
else if (!aggregatedValues && rowColl > 0 && aggregateFunc != null)
|
|
rowColl++;
|
|
}
|
|
return rowColl + collOffset;
|
|
}
|
|
|
|
protected int[] AddDataTableRow(ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, string criteria, CellStyle cellStyle, string[] dtCols = null, string aggregateFunc = null, CellStyle formulaCellStyle = null)
|
|
{
|
|
int[] insertDim = { 0/*rows*/, 0 /*cols*/};
|
|
|
|
if (trow < 1 || tcol < 1)
|
|
return insertDim;
|
|
|
|
DataRow[] filteredRows = dataTable.Select(criteria);
|
|
DataColumnCollection columns = dataTable.Columns;
|
|
if (dtCols == null)
|
|
dtCols = columns.Cast<DataColumn>().Select(x => x.ColumnName).ToArray();
|
|
|
|
if (filteredRows.Length > 0)
|
|
{
|
|
bool aggregatedValues = false;
|
|
insertDim[0] = filteredRows.Length;
|
|
|
|
var col = 0;
|
|
for (int row = 0; row < filteredRows.Length; row++)
|
|
{
|
|
col = 0;
|
|
foreach (string dtCol in dtCols)
|
|
{
|
|
if (columns.Contains(dtCol))
|
|
{
|
|
aggregatedValues = AddCellWithTypeCheck(worksheet, trow + row, tcol + col, filteredRows[row][dtCol], cellStyle);
|
|
col++;
|
|
}
|
|
}
|
|
if (aggregatedValues && aggregateFunc != null)
|
|
{
|
|
AddFormulaCell(worksheet, trow + row, tcol + dtCols.Length, "=" + aggregateFunc + "(" + ColumnLabel(tcol) + (trow + row) + ":" + ColumnLabel(tcol + dtCols.Length - 1) + (trow + row) + ")", formulaCellStyle);
|
|
insertDim[1]++;
|
|
}
|
|
}
|
|
insertDim[1] = col;
|
|
}
|
|
|
|
return insertDim;
|
|
}
|
|
|
|
protected int[] AddDataTable
|
|
(
|
|
ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, string criteria,
|
|
CellStyle cellDefaultStyle, CellStyle headerDefaultStyle, CellStyle[] cellStyles = null, CellStyle[] headerStyles = null,
|
|
string[] dtCols = null,
|
|
string rowAggregateFunc = null, CellStyle rowFormulaCellStyle = null,
|
|
int rowHeaderOffset = 0, string[] columnAggregateFuncs = null, string[] columnAggregateFuncHeaderCol = null, CellStyle[] columnFormulaCellStyles = null, CellStyle columnFormulaCellHeaderStyles = null //ColumnAggregates
|
|
)
|
|
{
|
|
int[] insertDim = { 0/*rows*/, 0 /*cols*/};
|
|
|
|
if (trow < 1 || tcol < 1)
|
|
return insertDim;
|
|
|
|
DataRow[] filteredRows = dataTable.Select(criteria);
|
|
DataColumnCollection columns = dataTable.Columns;
|
|
|
|
int headerCount = 0;
|
|
if (dtCols == null)
|
|
{
|
|
dtCols = columns.Cast<DataColumn>().Select(x => x.ColumnName).ToArray();
|
|
|
|
headerCount = 1;
|
|
int tHeaderColNum = tcol;
|
|
foreach (var col in dtCols)
|
|
{
|
|
AddLabelCell(worksheet, trow, tHeaderColNum, col.IndexOf("COLUMN", StringComparison.OrdinalIgnoreCase) >= 0 ? Resources.ExcelNyomtatvanyResource.ResourceManager.GetString(col.ToUpper()) : col, (headerStyles?.Length ?? 0) > (tHeaderColNum - tcol) ? headerStyles[tHeaderColNum - tcol] : headerDefaultStyle);
|
|
tHeaderColNum++;
|
|
}
|
|
}
|
|
|
|
if (filteredRows.Length > 0)
|
|
{
|
|
bool aggregatedValues = false;
|
|
insertDim[0] = headerCount + filteredRows.Length + (columnAggregateFuncs?.Length ?? 0);
|
|
|
|
var col = 0;
|
|
int row = 0;
|
|
for (; row < filteredRows.Length; row++)
|
|
{
|
|
col = 0;
|
|
int currentRowNum = trow + headerCount + row;
|
|
foreach (string dtCol in dtCols)
|
|
{
|
|
if (columns.Contains(dtCol))
|
|
{
|
|
aggregatedValues = AddCellWithTypeCheck(worksheet, currentRowNum, tcol + col, filteredRows[row][dtCol], (cellStyles?.Length ?? 0) > col ? cellStyles[col] : cellDefaultStyle);
|
|
col++;
|
|
}
|
|
}
|
|
if (aggregatedValues && rowAggregateFunc != null)
|
|
{
|
|
AddFormulaCell(worksheet, currentRowNum, tcol + dtCols.Length, "=" + rowAggregateFunc + "(" + ColumnLabel(tcol) + currentRowNum + ":" + ColumnLabel(tcol + dtCols.Length - 1) + currentRowNum + ")", rowFormulaCellStyle);
|
|
insertDim[1]++;
|
|
}
|
|
}
|
|
insertDim[1] = col;
|
|
|
|
if (columnAggregateFuncs != null)
|
|
{
|
|
for (var funcrow = 0; funcrow < columnAggregateFuncs.Length; funcrow++)
|
|
{
|
|
var formularow = trow + headerCount + row + funcrow;
|
|
|
|
var vaggregateFuncHeader = columnAggregateFuncHeaderCol != null && columnAggregateFuncHeaderCol.Length > funcrow ? columnAggregateFuncHeaderCol[funcrow] : null;
|
|
if (vaggregateFuncHeader != null)
|
|
AddLabelCell(worksheet, formularow, tcol, vaggregateFuncHeader, columnFormulaCellHeaderStyles ?? ((cellStyles?.Length ?? 0) > col ? cellStyles[col] : cellDefaultStyle));
|
|
|
|
var vaggregateFunc = columnAggregateFuncs[funcrow];
|
|
CellStyle colFormulaCellStyle = columnFormulaCellStyles != null && columnFormulaCellStyles.Length > funcrow ? columnFormulaCellStyles[funcrow] : cellDefaultStyle;
|
|
|
|
for (col = rowHeaderOffset; col < dtCols.Length; col++)
|
|
{
|
|
int formulacol = tcol + col;
|
|
AddAggregateFormulaCell(worksheet, formularow, formulacol, vaggregateFunc, trow + headerCount, formulacol, trow + headerCount + row - 1, formulacol, true, colFormulaCellStyle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return insertDim;
|
|
}
|
|
|
|
protected bool AddDataTablePivotTableCell(ExcelWorksheet worksheet, int trow, int tcol, DataTable dataTable, string criteria, CellStyle cellStyle, string[] dtCols = null, string[] dtCommentCols = null)
|
|
{
|
|
bool aggregatedValue = false;
|
|
if (trow < 1 || tcol < 1)
|
|
return aggregatedValue;
|
|
|
|
DataRow[] filteredRows = dataTable.Select(criteria);
|
|
|
|
if (filteredRows.Length > 0)
|
|
{
|
|
DataColumnCollection columns = dataTable.Columns;
|
|
if (dtCols == null)
|
|
dtCols = columns.Cast<DataColumn>().Select(x => x.ColumnName).ToArray();
|
|
|
|
for (int row = 0; row < filteredRows.Length; row++)
|
|
{
|
|
var col = 0;
|
|
foreach (string dtCol in dtCols)
|
|
{
|
|
if (columns.Contains(dtCol))
|
|
{
|
|
string comment = null;
|
|
if (dtCommentCols != null)
|
|
{
|
|
foreach (string dtCommentCol in dtCommentCols)
|
|
{
|
|
object commentValue = filteredRows[row][dtCommentCol];
|
|
if (columns.Contains(dtCommentCol) && !(commentValue is DBNull))
|
|
comment = (string)commentValue;
|
|
}
|
|
}
|
|
|
|
aggregatedValue = AddCellWithTypeCheck(worksheet, trow + row, tcol + col, filteredRows[row][dtCol], cellStyle, comment);
|
|
col++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
aggregatedValue = AddCellWithTypeCheck(worksheet, trow, tcol, "", cellStyle);
|
|
}
|
|
|
|
return aggregatedValue;
|
|
}
|
|
|
|
protected int[] AddDataTablePivotTable
|
|
(
|
|
ExcelWorksheet worksheet, int trow, int tcol, //Worksheet
|
|
DataTable dataTableHeader, string headerFilterDtCols, string headershowDtCol, //TableHeader
|
|
DataTable dataTableRowHeader, string rowHeadersFilteDtCols, string[] rowHeaderDtCols, //RowHeader
|
|
DataTable dataTable, //DataTable
|
|
CellStyle cellStyle, CellStyle headerCellStyle = null, CellStyle rowHeaderCellStyle = null, //Styles
|
|
string[] dtCols = null, string[] dtCommentCols = null, //DataTableFields
|
|
string[] rowAggregateFuncs = null, string[] rowAggregateFuncHeaderCol = null, CellStyle[] rowFormulaCellStyles = null, //RowAggregates
|
|
string[] columnAggregateFuncs = null, string[] columnAggregateFuncHeaderCol = null, CellStyle[] columnFormulaCellStyles = null //ColumnAggregates
|
|
)
|
|
{
|
|
return AddDataTablePivotTable
|
|
(
|
|
worksheet, trow, tcol,
|
|
dataTableHeader, headerFilterDtCols != null ? new[] { headerFilterDtCols } : null, headershowDtCol,
|
|
dataTableRowHeader, rowHeadersFilteDtCols != null ? new[] { rowHeadersFilteDtCols } : null, rowHeaderDtCols,
|
|
dataTable,
|
|
cellStyle, headerCellStyle, rowHeaderCellStyle,
|
|
dtCols, dtCommentCols,
|
|
rowAggregateFuncs, rowAggregateFuncHeaderCol, rowFormulaCellStyles,
|
|
columnAggregateFuncs, columnAggregateFuncHeaderCol, columnFormulaCellStyles
|
|
);
|
|
}
|
|
|
|
protected int[] AddDataTablePivotTable
|
|
(
|
|
ExcelWorksheet worksheet, int trow, int tcol, //Worksheet
|
|
DataTable dataTableHeader, string[] headerFilterDtCols, string headershowDtCol, //TableHeader
|
|
DataTable dataTableRowHeader, string[] rowHeadersFilteDtCols, string[] rowHeaderDtCols, //RowHeader
|
|
DataTable dataTable, //DataTable
|
|
CellStyle cellStyle, CellStyle headerCellStyle = null, CellStyle rowHeaderCellStyle = null, //Styles
|
|
string[] dtCols = null, string[] dtCommentCols = null, //DataTableFields
|
|
string[] rowAggregateFuncs = null, string[] rowAggregateFuncHeaderCol = null, CellStyle[] rowFormulaCellStyles = null, //RowAggregates
|
|
string[] columnAggregateFuncs = null, string[] columnAggregateFuncHeaderCol = null, CellStyle[] columnFormulaCellStyles = null //ColumnAggregates
|
|
)
|
|
{
|
|
int[] insertDim = { 0/*rows*/, 0 /*cols*/};
|
|
if (trow < 1 || tcol < 1)
|
|
return insertDim;
|
|
|
|
var rowHeaderOffset = rowHeaderDtCols?.Length ?? 0;
|
|
if (headershowDtCol != null)
|
|
AddDataTableColTransponalt(worksheet, trow, tcol + rowHeaderOffset, dataTableHeader, headershowDtCol, headerCellStyle ?? cellStyle);
|
|
if (rowHeaderOffset > 0)
|
|
AddDataTableRow(worksheet, trow + 1, tcol, dataTableRowHeader, "", rowHeaderCellStyle ?? cellStyle, rowHeaderDtCols);
|
|
|
|
const int headerCount = 1;
|
|
var row = 0;
|
|
List<string> colFilters = new List<string>();
|
|
/*Fejléc filterek összeállítása*/
|
|
foreach (DataRow dtRow in dataTableHeader.Rows)
|
|
{
|
|
var colFilter = "";
|
|
foreach (var headerFilterDtCol in headerFilterDtCols)
|
|
{
|
|
object dtvalue = dtRow[headerFilterDtCol];
|
|
|
|
switch (dtvalue)
|
|
{
|
|
case int _:
|
|
case double _:
|
|
case string _ when int.TryParse((string)dtvalue, out int intDtvalue):
|
|
case string _ when double.TryParse((string)dtvalue, out double doubleDtValue):
|
|
break;
|
|
default:
|
|
dtvalue = "'" + dtvalue + "'";
|
|
break;
|
|
}
|
|
|
|
colFilter += (colFilter.Length > 0 ? " AND " : "") + headerFilterDtCol + "=" + dtvalue;
|
|
}
|
|
colFilters.Add(colFilter);
|
|
}
|
|
/*Sorok feldolgozása*/
|
|
for (; row < dataTableRowHeader.Rows.Count; row++)
|
|
{
|
|
var rowFilter = "";
|
|
foreach (var rowHeadersFilteDtCol in rowHeadersFilteDtCols)
|
|
{
|
|
object dtvalue = dataTableRowHeader.Rows[row][rowHeadersFilteDtCol];
|
|
|
|
switch (dtvalue)
|
|
{
|
|
case int _:
|
|
case double _:
|
|
case string _ when int.TryParse((string)dtvalue, out int intDtvalue):
|
|
case string _ when double.TryParse((string)dtvalue, out double doubleDtValue):
|
|
break;
|
|
default:
|
|
dtvalue = "'" + dtvalue + "'";
|
|
break;
|
|
}
|
|
|
|
rowFilter += (rowFilter.Length > 0 ? " AND " : "") + rowHeadersFilteDtCol + "=" + dtvalue;
|
|
}
|
|
/*Sor adataival szűrt adattábla ellenőrzés, szűrés*/
|
|
DataRow[] filteredRows = dataTable.Select(rowFilter);
|
|
if (filteredRows.Length > 0)
|
|
{
|
|
DataTable rowFilteredTable = filteredRows.AsEnumerable().CopyToDataTable();
|
|
/*Oszlopok összeállítása*/
|
|
var col = 0;
|
|
foreach (string colFilter in colFilters)
|
|
{
|
|
AddDataTablePivotTableCell(worksheet, trow + headerCount + row, tcol + rowHeaderOffset + col, rowFilteredTable, colFilter, cellStyle, dtCols, dtCommentCols);
|
|
col++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var col = 0;
|
|
foreach (string colFilter in colFilters)
|
|
{
|
|
AddCellWithTypeCheck(worksheet, trow + headerCount + row, tcol + rowHeaderOffset + col, "", cellStyle);
|
|
col++;
|
|
}
|
|
}
|
|
|
|
if (rowAggregateFuncs != null)
|
|
{
|
|
var formularow = trow + headerCount + row;
|
|
var formulacol = tcol + rowHeaderOffset + colFilters.Count;
|
|
|
|
for (int funccol = 0; funccol < rowAggregateFuncs.Length; funccol++)
|
|
{
|
|
if (rowAggregateFuncs[funccol] == null)
|
|
{
|
|
continue;
|
|
}
|
|
string aggregateFuncHeader = (rowAggregateFuncHeaderCol != null && rowAggregateFuncHeaderCol.Length > funccol ? rowAggregateFuncHeaderCol[funccol] : "");
|
|
CellStyle formulaCellStyle = (rowFormulaCellStyles != null && rowFormulaCellStyles.Length > funccol ? rowFormulaCellStyles[funccol] : cellStyle);
|
|
AddLabelCell(worksheet, trow, formulacol + funccol, aggregateFuncHeader, headerCellStyle ?? cellStyle);
|
|
|
|
AddAggregateFormulaCell(worksheet, formularow, formulacol + funccol, rowAggregateFuncs[funccol], formularow, tcol + rowHeaderOffset, formularow, formulacol - 1, true, formulaCellStyle);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (columnAggregateFuncs != null)
|
|
{
|
|
for (var funcrow = 0; funcrow < columnAggregateFuncs.Length; funcrow++)
|
|
{
|
|
var formularow = trow + headerCount + row + funcrow;
|
|
|
|
var vaggregateFuncHeader = columnAggregateFuncHeaderCol != null && columnAggregateFuncHeaderCol.Length > funcrow ? columnAggregateFuncHeaderCol[funcrow] : "";
|
|
CellStyle formulaCellStyle = columnFormulaCellStyles != null && columnFormulaCellStyles.Length > funcrow ? columnFormulaCellStyles[funcrow] : cellStyle;
|
|
|
|
AddLabelCell(worksheet, formularow, tcol, vaggregateFuncHeader, rowHeaderCellStyle ?? cellStyle);
|
|
|
|
for (var col = 0; col < dataTableHeader.Rows.Count; col++)
|
|
{
|
|
int formulacol = tcol + rowHeaderOffset + col;
|
|
AddAggregateFormulaCell(worksheet, formularow, formulacol, columnAggregateFuncs[funcrow], trow + headerCount, formulacol, trow + headerCount + row - 1, formulacol, true, formulaCellStyle);
|
|
}
|
|
}
|
|
}
|
|
|
|
insertDim[0] = row + headerCount + (columnAggregateFuncs?.Length ?? 0);
|
|
insertDim[1] = rowHeaderOffset + dataTableHeader.Rows.Count + (rowAggregateFuncs?.Length ?? 0);
|
|
|
|
return insertDim;
|
|
}
|
|
|
|
public void GenerateNewExcelPackage(string templateFilename = null)
|
|
{
|
|
FileInfo exFile = null;
|
|
if (templateFilename != null)
|
|
{
|
|
exFile = new FileInfo(templateFilename);
|
|
}
|
|
ExcelPackage = (exFile == null) ? new ExcelPackage() : new ExcelPackage(exFile);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
ExcelPackage?.Dispose();
|
|
DataSet?.Dispose();
|
|
}
|
|
}
|
|
}
|