public void TestGetNearestNamedPanelTest()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
var excelReport = Substitute.For <object>();
var templateProcessor = Substitute.For <ITemplateProcessor>();
IXLRange range = ws.Range(1, 1, 3, 4);
range.AddToNamed("Parent", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("Parent");
IXLRange childRange = ws.Range(2, 1, 3, 4);
IXLRange childOfChildRange = ws.Range(3, 1, 3, 4);
childOfChildRange.AddToNamed("ChildOfChild", XLScope.Worksheet);
IXLNamedRange childOfChildNamedRange = ws.NamedRange("ChildOfChild");
IExcelPanel childOfChildPanel = new ExcelNamedPanel(childOfChildNamedRange, excelReport, templateProcessor);
IExcelPanel childPanel = new ExcelPanel(childRange, excelReport, templateProcessor);
IExcelPanel parentPanel = new ExcelNamedPanel(namedRange, excelReport, templateProcessor);
MethodInfo method = typeof(ExcelNamedPanel).GetMethod("GetNearestNamedParent", BindingFlags.Instance | BindingFlags.NonPublic);
Assert.IsNull(method.Invoke(childOfChildPanel, null));
childOfChildPanel.Parent = childPanel;
Assert.IsNull(method.Invoke(childOfChildPanel, null));
childPanel.Parent = parentPanel;
Assert.AreSame(parentPanel, method.Invoke(childOfChildPanel, null));
}
public void TestRemoveAllNamesRecursive()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
var excelReport = Substitute.For <object>();
var templateProcessor = Substitute.For <ITemplateProcessor>();
IXLRange range = ws.Range(1, 1, 3, 4);
range.AddToNamed("Parent", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("Parent");
IExcelNamedPanel parentPanel = new ExcelNamedPanel(namedRange, excelReport, templateProcessor);
IXLRange childRange1 = ws.Range(1, 1, 1, 4);
childRange1.AddToNamed("Child", XLScope.Worksheet);
IXLNamedRange namedChildRange = ws.NamedRange("Child");
IExcelNamedPanel childPanel1 = new ExcelNamedPanel(namedChildRange, excelReport, templateProcessor);
childPanel1.Parent = parentPanel;
IXLRange childRange2 = ws.Range(2, 1, 3, 4);
IExcelPanel childPanel2 = new ExcelPanel(childRange2, excelReport, templateProcessor);
childPanel2.Parent = parentPanel;
parentPanel.Children = new List <IExcelPanel> {
childPanel1, childPanel2
};
IXLRange childOfChild1Range = ws.Range(1, 1, 1, 4);
childOfChild1Range.AddToNamed("ChildOfChild1", XLScope.Worksheet);
IXLNamedRange namedChildOfChild1RangeRange = ws.NamedRange("ChildOfChild1");
IExcelNamedPanel childOfChild1Panel = new ExcelNamedPanel(namedChildOfChild1RangeRange, excelReport, templateProcessor);
childOfChild1Panel.Parent = childPanel1;
childPanel1.Children = new List <IExcelPanel> {
childOfChild1Panel
};
IXLRange childOfChild2Range = ws.Range(3, 1, 3, 4);
childOfChild2Range.AddToNamed("ChildOfChild2", XLScope.Worksheet);
IXLNamedRange namedChildOfChild2RangeRange = ws.NamedRange("ChildOfChild2");
IExcelNamedPanel childOfChild2Panel = new ExcelNamedPanel(namedChildOfChild2RangeRange, excelReport, templateProcessor);
childOfChild2Panel.Parent = childPanel2;
childPanel2.Children = new List <IExcelPanel> {
childOfChild2Panel
};
ExcelNamedPanel.RemoveAllNamesRecursive(parentPanel);
Assert.AreEqual(0, ws.NamedRanges.Count());
//wb.SaveAs("test.xlsx");
}
public void TestPanelWithNoData()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(1, 1, 1, 5);
range.AddToNamed("Test", XLScope.Worksheet);
ws.Cell(1, 1).Value = "Plain text";
ws.Cell(1, 2).Value = "{Sum(di:Sum)}";
ws.Cell(1, 3).Value = "{ Custom(DI:Sum, CustomAggregation, PostAggregation) }";
ws.Cell(1, 4).Value = "{Min(di:Sum)}";
ws.Cell(1, 5).Value = "Text1 {count(di:Name)} Text2 {avg(di:Sum, , PostAggregationRound)} Text3 {Max(di:Sum)}";
var panel = new ExcelTotalsPanel("m:DataProvider:GetEmptyIEnumerable()", ws.NamedRange("Test"), report, report.TemplateProcessor);
panel.Render();
Assert.AreEqual(range, panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(TotalsPanelRenderTest),
nameof(TestPanelWithNoData)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestParseTotalCellsErrors()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange range = ws.Range(1, 1, 1, 1);
range.AddToNamed("Test", XLScope.Worksheet);
var templateProcessor = Substitute.For <ITemplateProcessor>();
templateProcessor.LeftTemplateBorder.Returns("<");
templateProcessor.RightTemplateBorder.Returns(">");
templateProcessor.MemberLabelSeparator.Returns("-");
templateProcessor.DataItemMemberLabel.Returns("d");
var report = new TestReport
{
TemplateProcessor = templateProcessor,
Workbook = wb
};
var panel = new ExcelTotalsPanel("Stub", ws.NamedRange("Test"), report, report.TemplateProcessor);
MethodInfo method = panel.GetType().GetMethod("ParseTotalCells", BindingFlags.Instance | BindingFlags.NonPublic);
ws.Cell(1, 1).Value = "<Sum(d-Val, fn1, fn2, fn3)>";
ExceptionAssert.ThrowsBaseException <InvalidOperationException>(() => method.Invoke(panel, null), "Aggregation function must have at least one but no more than 3 parameters");
}
public void TestPanelRenderEvents()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 3);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(2, 3).Value = "{di:Date}";
var panel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("TestRange"), report, report.TemplateProcessor)
{
BeforeRenderMethodName = "TestExcelDataSourcePanelBeforeRender",
AfterRenderMethodName = "TestExcelDataSourcePanelAfterRender",
BeforeDataItemRenderMethodName = "TestExcelDataItemPanelBeforeRender",
AfterDataItemRenderMethodName = "TestExcelDataItemPanelAfterRender",
};
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 4, 2), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelIEnumerableRenderTest),
nameof(TestPanelRenderEvents)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderEmptyDataSet()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 6);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Id}";
ws.Cell(2, 3).Value = "{di:Name}";
ws.Cell(2, 4).Value = "{di:IsVip}";
ws.Cell(2, 5).Value = "{di:Description}";
ws.Cell(2, 6).Value = "{di:Type}";
var panel = new ExcelDataSourcePanel("m:DataProvider:GetEmptyDataSet()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel.Render();
Assert.IsNull(panel.ResultRange);
Assert.AreEqual(0, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
Assert.AreEqual(0, ws.NamedRanges.Count());
Assert.AreEqual(0, ws.Workbook.NamedRanges.Count());
Assert.AreEqual(1, ws.Workbook.Worksheets.Count);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderIEnumerableVerticalNoShift()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 3, 5);
range.AddToNamed("TestRange", XLScope.Worksheet);
range.FirstCell().Style.Border.SetTopBorder(XLBorderStyleValues.Thin);
range.FirstCell().Style.Border.SetBottomBorder(XLBorderStyleValues.Thin);
range.FirstCell().Style.Border.SetLeftBorder(XLBorderStyleValues.Thin);
ws.Cell(3, 5).Style.Border.SetBottomBorder(XLBorderStyleValues.Thin);
ws.Cell(2, 4).DataType = XLDataType.Number;
//ws.Cell(2, 4).DataType = XLCellValues.Number;
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(2, 3).Value = "{di:Date}";
ws.Cell(2, 4).Value = "{di:Sum}";
ws.Cell(2, 5).Value = "{di:Contacts}";
ws.Cell(3, 2).Value = "{di:Contacts.Phone}";
ws.Cell(3, 3).Value = "{di:Contacts.Fax}";
ws.Cell(3, 4).Value = "{p:StrParam}";
ws.Cell(1, 1).Value = "{di:Name}";
ws.Cell(4, 1).Value = "{di:Name}";
ws.Cell(1, 6).Value = "{di:Name}";
ws.Cell(4, 6).Value = "{di:Name}";
ws.Cell(3, 1).Value = "{di:Name}";
ws.Cell(3, 6).Value = "{di:Name}";
ws.Cell(1, 4).Value = "{di:Name}";
ws.Cell(4, 4).Value = "{di:Name}";
ws.Cell(8, 5).Value = "{di:Date}";
ws.Cell(8, 5).Style.Border.SetTopBorder(XLBorderStyleValues.Thin);
ws.Cell(8, 5).Style.Border.SetRightBorder(XLBorderStyleValues.Thin);
ws.Cell(8, 5).Style.Border.SetBottomBorder(XLBorderStyleValues.Thin);
ws.Cell(8, 5).Style.Border.SetLeftBorder(XLBorderStyleValues.Thin);
ws.Cell(8, 5).Style.Border.SetTopBorderColor(XLColor.Red);
ws.Cell(8, 5).Style.Border.SetRightBorderColor(XLColor.Red);
ws.Cell(8, 5).Style.Border.SetBottomBorderColor(XLColor.Red);
ws.Cell(8, 5).Style.Border.SetLeftBorderColor(XLColor.Red);
var panel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("TestRange"), report, report.TemplateProcessor)
{
ShiftType = ShiftType.NoShift,
};
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 7, 5), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelIEnumerableRenderTest),
nameof(TestRenderIEnumerableVerticalNoShift)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestCreateSimplePanel()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange range = ws.Range(ws.Cell(1, 1), ws.Cell(2, 2));
range.AddToNamed("s_Test", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("s_Test");
var report = new object();
var templateProcessor = Substitute.For <ITemplateProcessor>();
var parseSettings = new PanelParsingSettings
{
SimplePanelPrefix = "s",
PanelPrefixSeparator = "_",
};
var factory = new ExcelPanelFactory(report, templateProcessor, parseSettings);
var panel = (ExcelPanel)factory.Create(namedRange, new Dictionary <string, string>
{
[nameof(ExcelPanel.Type)] = PanelType.Horizontal.ToString(),
[nameof(ExcelPanel.ShiftType)] = ShiftType.Row.ToString(),
[nameof(ExcelPanel.RenderPriority)] = "5",
[nameof(ExcelPanel.BeforeRenderMethodName)] = "BeforeRenderMethodName",
[nameof(ExcelPanel.AfterRenderMethodName)] = "AfterRenderMethodName",
});
Assert.AreEqual(PanelType.Horizontal, panel.Type);
Assert.AreEqual(ShiftType.Row, panel.ShiftType);
Assert.AreEqual(5, panel.RenderPriority);
Assert.AreEqual("BeforeRenderMethodName", panel.BeforeRenderMethodName);
Assert.AreEqual("AfterRenderMethodName", panel.AfterRenderMethodName);
Assert.AreEqual(0, panel.Children.Count);
Assert.IsNull(panel.Parent);
Assert.AreEqual(namedRange.Ranges.First(), panel.Range);
Assert.AreSame(report, panel.GetType().GetField("_report", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
Assert.AreSame(templateProcessor, panel.GetType().GetField("_templateProcessor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
namedRange.Delete();
range.AddToNamed("SS--Test", XLScope.Workbook);
namedRange = wb.NamedRange("SS--Test");
parseSettings.SimplePanelPrefix = "ss";
parseSettings.PanelPrefixSeparator = "--";
factory = new ExcelPanelFactory(report, templateProcessor, parseSettings);
panel = (ExcelPanel)factory.Create(namedRange, null);
Assert.IsInstanceOf <ExcelPanel>(panel);
Assert.AreEqual(PanelType.Vertical, panel.Type);
Assert.AreEqual(ShiftType.Cells, panel.ShiftType);
Assert.AreEqual(0, panel.RenderPriority);
Assert.AreEqual(0, panel.Children.Count);
Assert.IsNull(panel.BeforeRenderMethodName);
Assert.IsNull(panel.AfterRenderMethodName);
Assert.IsNull(panel.Parent);
Assert.AreEqual(namedRange.Ranges.First(), panel.Range);
Assert.AreSame(report, panel.GetType().GetField("_report", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
Assert.AreSame(templateProcessor, panel.GetType().GetField("_templateProcessor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
}
public void TestRenderEmptyDictionary()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range1 = ws.Range(2, 2, 4, 2);
range1.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{Headers}";
ws.Cell(3, 2).Value = "{Data}";
ws.Cell(4, 2).Value = "{Totals}";
IXLRange range2 = ws.Range(7, 2, 9, 2);
range2.AddToNamed("TestRange2", XLScope.Worksheet);
ws.Cell(7, 2).Value = "{Headers}";
ws.Cell(8, 2).Value = "{Data}";
ws.Cell(9, 2).Value = "{Totals}";
IDictionary <string, object> data1 = new Dictionary <string, object>();
var panel1 = new ExcelDataSourceDynamicPanel(data1, ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel1.Render();
Assert.AreEqual(ws.Range(2, 2, 3, 3), panel1.ResultRange);
IEnumerable <KeyValuePair <string, object> > data2 = new List <KeyValuePair <string, object> >();
var panel2 = new ExcelDataSourceDynamicPanel(data2, ws.NamedRange("TestRange2"), report, report.TemplateProcessor);
panel2.Render();
Assert.AreEqual(ws.Range(6, 2, 7, 3), panel2.ResultRange);
Assert.AreEqual(4, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
Assert.AreEqual("Key", ws.Cell(2, 2).Value);
Assert.AreEqual("Value", ws.Cell(2, 3).Value);
Assert.AreEqual("Key", ws.Cell(6, 2).Value);
Assert.AreEqual("Value", ws.Cell(6, 3).Value);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderDictionary()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range1 = ws.Range(2, 2, 2, 3);
range1.AddToNamed("TestRange", XLScope.Worksheet);
IXLRange range2 = ws.Range(2, 5, 2, 6);
range2.AddToNamed("TestRange2", XLScope.Worksheet);
ws.Cell(1, 2).Value = "Key";
ws.Cell(1, 3).Value = "Value";
ws.Cell(2, 2).Value = "{di:Key}";
ws.Cell(2, 3).Value = "{di:Value}";
ws.Cell(1, 5).Value = "Key";
ws.Cell(1, 6).Value = "Value";
ws.Cell(2, 5).Value = "{di:Key}";
ws.Cell(2, 6).Value = "{di:Value}";
IDictionary <string, object> data1 = new DataProvider().GetDictionaryEnumerable().First();
var panel1 = new ExcelDataSourcePanel(data1, ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel1.Render();
IEnumerable <KeyValuePair <string, object> > data2 = new DataProvider().GetDictionaryEnumerable().First()
.Select(x => new KeyValuePair <string, object>(x.Key, x.Value));
var panel2 = new ExcelDataSourcePanel(data2, ws.NamedRange("TestRange2"), report, report.TemplateProcessor);
panel2.Render();
Assert.AreEqual(ws.Range(2, 2, 4, 3), panel1.ResultRange);
Assert.AreEqual(ws.Range(2, 5, 4, 6), panel2.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelDictionaryRenderTest),
nameof(TestRenderDictionary)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void Test_VerticalPageBreaks_WithSimplePanel_RowShift()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange parentRange = ws.Range(2, 2, 5, 4);
parentRange.AddToNamed("ParentRange", XLScope.Worksheet);
parentRange.Style.Border.OutsideBorder = XLBorderStyleValues.Thin;
IXLRange child1 = ws.Range(2, 3, 5, 3);
child1.AddToNamed("ChildRange1", XLScope.Worksheet);
IXLRange child2 = ws.Range(2, 4, 5, 4);
child2.AddToNamed("ChildRange2", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(3, 2).Value = "{di:Date}";
ws.Cell(3, 3).Value = "{di:Field1}";
ws.Cell(4, 3).Value = "{di:Field2}";
ws.Cell(5, 3).Value = "{di:parent:Sum}";
ws.Cell(2, 4).Value = "{VertPageBreak}";
var parentPanel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("ParentRange"), report, report.TemplateProcessor)
{
Type = PanelType.Horizontal,
ShiftType = ShiftType.Row,
};
var childPanel1 = new ExcelDataSourcePanel("m:DataProvider:GetChildIEnumerable(di:Name)", ws.NamedRange("ChildRange1"), report, report.TemplateProcessor)
{
Parent = parentPanel,
Type = PanelType.Horizontal,
ShiftType = ShiftType.Row,
};
var childPanel2 = new ExcelNamedPanel(ws.NamedRange("ChildRange2"), report, report.TemplateProcessor)
{
Parent = parentPanel,
};
parentPanel.Children = new[] { childPanel1, childPanel2 };
parentPanel.Render();
Assert.AreEqual(ws.Range(2, 2, 5, 12), parentPanel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelRender_WithGrouping_PageBreaks_Test),
"Test_VerticalPageBreaks"), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public override void Render()
{
// Receive parent data item context
HierarchicalDataItem parentDataItem = GetDataContext();
_data = _isDataReceivedDirectly ? _data : _templateProcessor.GetValue(_dataSourceTemplate, parentDataItem);
bool isCanceled = CallBeforeRenderMethod();
if (isCanceled)
{
ResultRange = ExcelHelper.CloneRange(Range);
return;
}
ICustomEnumerator enumerator = null;
try
{
enumerator = EnumeratorFactory.Create(_data) ?? new EnumerableEnumerator(new object[] { });
IDictionary <IXLCell, IList <ParsedAggregationFunc> > totalCells = ParseTotalCells();
DoAggregation(enumerator, totalCells.SelectMany(t => t.Value).ToArray(), parentDataItem);
IXLWorksheet ws = Range.Worksheet;
dynamic dataSource = new ExpandoObject();
var dataSourceAsDict = (IDictionary <string, object>)dataSource;
foreach (KeyValuePair <IXLCell, IList <ParsedAggregationFunc> > totalCell in totalCells)
{
IList <ParsedAggregationFunc> aggFuncs = totalCell.Value;
foreach (ParsedAggregationFunc f in aggFuncs)
{
dataSourceAsDict[$"AggFunc_{f.UniqueName}"] = f.Result;
}
}
string rangeName = $"AggFuncs_{Guid.NewGuid():N}";
Range.AddToNamed(rangeName, XLScope.Worksheet);
var dataPanel = new ExcelDataSourcePanel(new[] { dataSource }, ws.NamedRange(rangeName), _report, _templateProcessor)
{
Parent = Parent
};
dataPanel.Render();
ResultRange = ExcelHelper.MergeRanges(Range, dataPanel.ResultRange);
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
RemoveName();
CallAfterRenderMethod();
}
private IXLRange RenderTotalsTemplates(IList <ExcelDynamicColumn> columns)
{
string template = _templateProcessor.WrapTemplate("Totals");
IXLCell cell = Range.CellsUsedWithoutFormulas().SingleOrDefault(c => Regex.IsMatch(c.Value.ToString(), $@"^{template}$", RegexOptions.IgnoreCase));
if (cell == null)
{
return(null);
}
IXLWorksheet ws = Range.Worksheet;
IXLRange range = ws.Range(cell, cell);
bool isCanceled = CallBeforeRenderMethod(BeforeTotalsTemplatesRenderMethodName, range, columns);
if (isCanceled)
{
return(range);
}
cell.Value = _templateProcessor.BuildDataItemTemplate(nameof(TotalsTemplatesHelper.Totals));
string rangeName = $"Totals_{Guid.NewGuid():N}";
range.AddToNamed(rangeName, XLScope.Worksheet);
IList <string> totalsTemplates = new List <string>();
foreach (ExcelDynamicColumn column in columns)
{
totalsTemplates.Add(column.AggregateFunction != AggregateFunction.NoAggregation
? _templateProcessor.BuildAggregationFuncTemplate(column.AggregateFunction, column.Name)
: null);
}
var panel = new ExcelDataSourcePanel(totalsTemplates.Select(t => new TotalsTemplatesHelper {
Totals = t
}), ws.NamedRange(rangeName), _report, _templateProcessor)
{
ShiftType = ShiftType.Cells,
Type = Type == PanelType.Vertical ? PanelType.Horizontal : PanelType.Vertical,
};
panel.Render();
SetColumnsWidth(panel.ResultRange, columns);
SetCellsDisplayFormat(panel.ResultRange, columns);
CallAfterRenderMethod(AfterTotalsTemplatesRenderMethodName, panel.ResultRange, columns);
return(panel.ResultRange);
}
public void TestRenderDictionaryEnumerable()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range1 = ws.Range(2, 2, 4, 2);
range1.AddToNamed("TestRange1", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{Headers}";
ws.Cell(3, 2).Value = "{Data}";
ws.Cell(4, 2).Value = "{Totals}";
var panel1 = new ExcelDataSourceDynamicPanel("m:DataProvider:GetDictionaryEnumerable()", ws.NamedRange("TestRange1"), report, report.TemplateProcessor);
panel1.Render();
Assert.AreEqual(ws.Range(2, 2, 6, 4), panel1.ResultRange);
var dictWithDecimalValues = new List <IDictionary <string, decimal> >
{
new Dictionary <string, decimal> {
["Value"] = 25.7m
},
new Dictionary <string, decimal> {
["Value"] = 250.7m
},
new Dictionary <string, decimal> {
["Value"] = 2500.7m
},
};
IXLRange range2 = ws.Range(7, 2, 9, 2);
range2.AddToNamed("TestRange2", XLScope.Worksheet);
ws.Cell(7, 2).Value = "{Headers}";
ws.Cell(8, 2).Value = "{Data}";
ws.Cell(9, 2).Value = "{Totals}";
var panel2 = new ExcelDataSourceDynamicPanel(dictWithDecimalValues, ws.NamedRange("TestRange2"), report, report.TemplateProcessor);
panel2.Render();
Assert.AreEqual(ws.Range(7, 2, 11, 2), panel2.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourceDynamicPanelDictionaryRenderTest),
nameof(TestRenderDictionaryEnumerable)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void Test_TwoChildren_Horizontal()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange parentRange = ws.Range(2, 2, 5, 6);
parentRange.AddToNamed("ParentRange", XLScope.Worksheet);
IXLRange child1 = ws.Range(2, 4, 5, 4);
child1.AddToNamed("ChildRange1", XLScope.Worksheet);
IXLRange child2 = ws.Range(2, 6, 5, 6);
child2.AddToNamed("ChildRange2", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(3, 3).Value = "Field1";
ws.Cell(3, 3).Style.Font.Bold = true;
ws.Cell(4, 3).Value = "Field2";
ws.Cell(4, 3).Style.Font.Bold = true;
ws.Cell(3, 4).Value = "{di:Field1}";
ws.Cell(4, 4).Value = "{di:Field2}";
ws.Cell(5, 5).Value = "Number";
ws.Cell(5, 5).Style.Font.Bold = true;
ws.Cell(5, 6).Value = "{di:di}";
var parentPanel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("ParentRange"), report, report.TemplateProcessor);
var childPanel1 = new ExcelDataSourcePanel("m:DataProvider:GetChildIEnumerable(di:Name)", ws.NamedRange("ChildRange1"), report, report.TemplateProcessor)
{
Parent = parentPanel,
Type = PanelType.Horizontal,
};
var childPanel2 = new ExcelDataSourcePanel("di:ChildrenPrimitive", ws.NamedRange("ChildRange2"), report, report.TemplateProcessor)
{
Parent = parentPanel,
Type = PanelType.Horizontal,
};
parentPanel.Children = new[] { childPanel1, childPanel2 };
parentPanel.Render();
Assert.AreEqual(ws.Range(2, 2, 13, 8), parentPanel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelRender_WithGrouping_MultipleChildrenInOneParent),
nameof(Test_TwoChildren_Horizontal)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestMakePanelsHierarchy()
{
var wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange panel1Range = ws.Range(1, 1, 4, 4);
IXLRange panel2Range = ws.Range(1, 1, 2, 4);
panel2Range.AddToNamed("Panel2", XLScope.Worksheet);
IXLRange panel3Range = ws.Range(2, 1, 2, 4);
panel3Range.AddToNamed("Panel3", XLScope.Workbook);
IXLRange panel4Range = ws.Range(5, 1, 6, 5);
IXLRange panel5Range = ws.Range(6, 1, 6, 5);
panel5Range.AddToNamed("Panel5", XLScope.Worksheet);
IXLRange panel6Range = ws.Range(3, 1, 4, 4);
IXLRange panel7Range = ws.Range(10, 10, 10, 10);
IXLRange panel8Range = ws.Range(8, 9, 9, 10);
panel8Range.AddToNamed("Panel8", XLScope.Worksheet);
var panel1 = new ExcelPanel(panel1Range, new object(), Substitute.For <ITemplateProcessor>());
var panel2 = new ExcelDataSourcePanel("Stub", ws.NamedRange("Panel2"), new object(),
Substitute.For <ITemplateProcessor>());
var panel3 = new ExcelDataSourcePanel("Stub", wb.NamedRange("Panel3"), new object(),
Substitute.For <ITemplateProcessor>());
var panel4 = new ExcelPanel(panel4Range, new object(), Substitute.For <ITemplateProcessor>());
var panel5 = new ExcelDataSourceDynamicPanel("Stub", ws.NamedRange("Panel5"), new object(),
Substitute.For <ITemplateProcessor>());
var panel6 = new ExcelPanel(panel6Range, new object(), Substitute.For <ITemplateProcessor>());
var panel7 = new ExcelPanel(panel7Range, new object(), Substitute.For <ITemplateProcessor>());
var panel8 = new ExcelTotalsPanel("Stub", ws.NamedRange("Panel8"), new object(),
Substitute.For <ITemplateProcessor>());
IDictionary <string, (IExcelPanel, string)> panelsFlatView = new Dictionary <string, (IExcelPanel, string)>
{
private IXLRange RenderColumnNumbers(IList <ExcelDynamicColumn> columns)
{
string template = _templateProcessor.WrapTemplate(@"Numbers(\((?<start>\d+)\))?");
IXLCell cell = Range.CellsUsedWithoutFormulas().SingleOrDefault(c => Regex.IsMatch(c.Value.ToString(), $@"^{template}$", RegexOptions.IgnoreCase));
if (cell == null)
{
return(null);
}
IXLWorksheet ws = Range.Worksheet;
IXLRange range = ws.Range(cell, cell);
bool isCanceled = CallBeforeRenderMethod(BeforeNumbersRenderMethodName, range, columns);
if (isCanceled)
{
return(range);
}
Match match = Regex.Match(cell.Value.ToString(), $@"^{template}$", RegexOptions.IgnoreCase);
if (!int.TryParse(match.Groups["start"]?.Value, out int startNumber))
{
startNumber = 1;
}
cell.Value = _templateProcessor.BuildDataItemTemplate(nameof(ColumnNumbersHelper.Number));
string rangeName = $"ColumnNumbers_{Guid.NewGuid():N}";
range.AddToNamed(rangeName, XLScope.Worksheet);
var panel = new ExcelDataSourcePanel(columns.Select((c, i) => new ColumnNumbersHelper {
Number = i + startNumber
}).ToList(),
ws.NamedRange(rangeName), _report, _templateProcessor)
{
ShiftType = ShiftType.Cells,
Type = Type == PanelType.Vertical ? PanelType.Horizontal : PanelType.Vertical,
};
panel.Render();
SetColumnsWidth(panel.ResultRange, columns);
CallAfterRenderMethod(AfterNumbersRenderMethodName, panel.ResultRange, columns);
return(panel.ResultRange);
}
public void TestCreateDataSourcePanel()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange range = ws.Range(ws.Cell(1, 1), ws.Cell(2, 2));
range.AddToNamed("d_Test", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("d_Test");
var report = new object();
var templateProcessor = Substitute.For <ITemplateProcessor>();
var parseSettings = new PanelParsingSettings
{
DataSourcePanelPrefix = "d",
PanelPrefixSeparator = "_",
};
var factory = new ExcelPanelFactory(report, templateProcessor, parseSettings);
var panel = (ExcelDataSourcePanel)factory.Create(namedRange, new Dictionary <string, string>
{
[nameof(ExcelDataSourcePanel.Type)] = PanelType.Horizontal.ToString(),
[nameof(ExcelDataSourcePanel.ShiftType)] = ShiftType.Row.ToString(),
[nameof(ExcelDataSourcePanel.RenderPriority)] = "5",
[nameof(ExcelDataSourcePanel.BeforeRenderMethodName)] = "BeforeRenderMethodName",
[nameof(ExcelDataSourcePanel.AfterRenderMethodName)] = "AfterRenderMethodName",
[nameof(ExcelDataSourcePanel.BeforeDataItemRenderMethodName)] = "BeforeDataItemRenderMethodName",
[nameof(ExcelDataSourcePanel.AfterDataItemRenderMethodName)] = "AfterDataItemRenderMethodName",
["DataSource"] = "DS",
});
Assert.AreEqual(PanelType.Horizontal, panel.Type);
Assert.AreEqual(ShiftType.Row, panel.ShiftType);
Assert.AreEqual(5, panel.RenderPriority);
Assert.AreEqual("BeforeRenderMethodName", panel.BeforeRenderMethodName);
Assert.AreEqual("AfterRenderMethodName", panel.AfterRenderMethodName);
Assert.AreEqual("BeforeDataItemRenderMethodName", panel.BeforeDataItemRenderMethodName);
Assert.AreEqual("AfterDataItemRenderMethodName", panel.AfterDataItemRenderMethodName);
Assert.AreEqual(0, panel.Children.Count);
Assert.IsNull(panel.Parent);
Assert.AreEqual(namedRange.Ranges.First(), panel.Range);
Assert.AreSame("DS", panel.GetType().GetField("_dataSourceTemplate", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
Assert.AreSame(report, panel.GetType().GetField("_report", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
Assert.AreSame(templateProcessor, panel.GetType().GetField("_templateProcessor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(panel));
ExceptionAssert.Throws <InvalidOperationException>(() => factory.Create(namedRange, null), "Data source panel must have the property \"DataSource\"");
}
public void TestCopyIfDataIsSet()
{
var wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
var excelReport = Substitute.For <object>();
var templateProcessor = Substitute.For <ITemplateProcessor>();
IXLRange range = ws.Range(1, 1, 2, 4);
range.AddToNamed("DataPanel", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("DataPanel");
object[] data = { 1, "One" };
var panel = new ExcelDataSourcePanel(data, namedRange, excelReport, templateProcessor)
{
RenderPriority = 10,
Type = PanelType.Horizontal,
ShiftType = ShiftType.NoShift,
BeforeRenderMethodName = "BeforeRenderMethod",
AfterRenderMethodName = "AfterRenderMethod",
BeforeDataItemRenderMethodName = "BeforeDataItemRenderMethodName",
AfterDataItemRenderMethodName = "AfterDataItemRenderMethodName",
GroupBy = "2,4",
};
ExcelDataSourcePanel copiedPanel = (ExcelDataSourcePanel)panel.Copy(ws.Cell(5, 5));
Assert.AreSame(excelReport, copiedPanel.GetType().GetField("_report", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(copiedPanel));
Assert.AreSame(templateProcessor, copiedPanel.GetType().GetField("_templateProcessor", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(copiedPanel));
Assert.IsNull(copiedPanel.GetType().GetField("_dataSourceTemplate", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(copiedPanel));
Assert.AreSame(data, copiedPanel.GetType().GetField("_data", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(copiedPanel));
Assert.AreEqual(ws.Cell(5, 5), copiedPanel.Range.FirstCell());
Assert.AreEqual(ws.Cell(6, 8), copiedPanel.Range.LastCell());
Assert.AreEqual(10, copiedPanel.RenderPriority);
Assert.AreEqual(PanelType.Horizontal, copiedPanel.Type);
Assert.AreEqual(ShiftType.NoShift, copiedPanel.ShiftType);
Assert.AreEqual("BeforeRenderMethod", copiedPanel.BeforeRenderMethodName);
Assert.AreEqual("AfterRenderMethod", copiedPanel.AfterRenderMethodName);
Assert.AreEqual("BeforeDataItemRenderMethodName", copiedPanel.BeforeDataItemRenderMethodName);
Assert.AreEqual("AfterDataItemRenderMethodName", copiedPanel.AfterDataItemRenderMethodName);
Assert.AreEqual("2,4", copiedPanel.GroupBy);
Assert.IsNull(copiedPanel.Parent);
//wb.SaveAs("test.xlsx");
}
public void TestCreatePanelWithBadName()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange range = ws.Range(ws.Cell(1, 1), ws.Cell(2, 2));
range.AddToNamed("b_Test", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("b_Test");
var report = new object();
var templateProcessor = Substitute.For <ITemplateProcessor>();
var parseSettings = new PanelParsingSettings {
PanelPrefixSeparator = "-"
};
var factory = new ExcelPanelFactory(report, templateProcessor, parseSettings);
ExceptionAssert.Throws <InvalidOperationException>(() => factory.Create(namedRange, null), "Panel name \"b_Test\" does not contain prefix separator \"-\"");
}
public void TestCreateUnsupportedPanelType()
{
XLWorkbook wb = new XLWorkbook();
IXLWorksheet ws = wb.AddWorksheet("Test");
IXLRange range = ws.Range(ws.Cell(1, 1), ws.Cell(2, 2));
range.AddToNamed("b_Test", XLScope.Worksheet);
IXLNamedRange namedRange = ws.NamedRange("b_Test");
var report = new object();
var templateProcessor = Substitute.For <ITemplateProcessor>();
var parseSettings = new PanelParsingSettings {
PanelPrefixSeparator = "_"
};
var factory = new ExcelPanelFactory(report, templateProcessor, parseSettings);
ExceptionAssert.Throws <NotSupportedException>(() => factory.Create(namedRange, null), "Panel type with prefix \"b\" is not supported");
}
public void TestRenderIEnumerableOfInt()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 2);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:di}";
var panel = new ExcelDataSourcePanel(new[] { 1, 2, 3, 4 }, ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 5, 2), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelIEnumerableRenderTest),
nameof(TestRenderIEnumerableOfInt)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderNullItemHorizontalNoShift()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 3, 5);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(2, 3).Value = "{di:Date}";
ws.Cell(2, 4).Value = "{m:Multiply(di:Sum, 5)}";
ws.Cell(2, 5).Value = "{di:Contacts}";
ws.Cell(3, 2).Value = "{di:Contacts.Phone}";
ws.Cell(3, 3).Value = "{di:Contacts.Fax}";
ws.Cell(3, 4).Value = "{p:StrParam}";
ws.Cell(1, 1).Value = "{di:Name}";
ws.Cell(4, 1).Value = "{di:Name}";
ws.Cell(1, 6).Value = "{di:Name}";
ws.Cell(4, 6).Value = "{di:Name}";
ws.Cell(3, 1).Value = "{di:Name}";
ws.Cell(3, 6).Value = "{di:Name}";
ws.Cell(1, 4).Value = "{di:Name}";
ws.Cell(4, 4).Value = "{di:Name}";
var panel = new ExcelDataSourcePanel("m:DataProvider:GetNullItem()", ws.NamedRange("TestRange"), report, report.TemplateProcessor)
{
Type = PanelType.Horizontal,
ShiftType = ShiftType.NoShift,
};
panel.Render();
Assert.IsNull(panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelNullItemRenderTest),
nameof(TestRenderNullItemHorizontalNoShift)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
// Rendering speed test
//[Test]
public void TestPanelRenderSpeed()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 6);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Name}";
ws.Cell(2, 3).Value = "{di:Date}";
ws.Cell(2, 4).Value = "{di:Sum}";
ws.Cell(2, 5).Value = "{di:Contacts.Phone}";
ws.Cell(2, 6).Value = "{di:Contacts.Fax}";
const int dataCount = 6000;
IList <TestItem> data = new List <TestItem>(dataCount);
for (int i = 0; i < dataCount; i++)
{
data.Add(new TestItem($"Name_{i}", DateTime.Now.AddHours(1), i + 10, new Contacts($"Phone_{i}", $"Fax_{i}")));
}
var panel = new ExcelDataSourcePanel(data, ws.NamedRange("TestRange"), report, report.TemplateProcessor)
{
//ShiftType = ShiftType.Row,
//ShiftType = ShiftType.NoShift,
};
Stopwatch sw = Stopwatch.StartNew();
panel.Render();
sw.Stop();
//Stopwatch sw2 = Stopwatch.StartNew();
//report.Workbook.SaveAs("test.xlsx");
//sw2.Stop();
}
private IXLRange RenderHeaders(IList <ExcelDynamicColumn> columns)
{
string template = _templateProcessor.WrapTemplate("Headers");
IXLCell cell = Range.CellsUsedWithoutFormulas().SingleOrDefault(c => Regex.IsMatch(c.Value.ToString(), $@"^{template}$", RegexOptions.IgnoreCase));
if (cell == null)
{
return(null);
}
IXLWorksheet ws = Range.Worksheet;
IXLRange range = ws.Range(cell, cell);
bool isCanceled = CallBeforeRenderMethod(BeforeHeadersRenderMethodName, range, columns);
if (isCanceled)
{
return(range);
}
cell.Value = _templateProcessor.BuildDataItemTemplate(nameof(ExcelDynamicColumn.Caption));
string rangeName = $"Headers_{Guid.NewGuid():N}";
range.AddToNamed(rangeName, XLScope.Worksheet);
var panel = new ExcelDataSourcePanel(columns, ws.NamedRange(rangeName), _report, _templateProcessor)
{
ShiftType = ShiftType.Cells,
Type = Type == PanelType.Vertical ? PanelType.Horizontal : PanelType.Vertical,
};
panel.Render();
SetColumnsWidth(panel.ResultRange, columns);
CallAfterRenderMethod(AfterHeadersRenderMethodName, panel.ResultRange, columns);
return(panel.ResultRange);
}
public void TestPanelRender()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(1, 1, 1, 12);
range.AddToNamed("Test", XLScope.Worksheet);
ws.Cell(1, 1).Value = "Plain text";
ws.Cell(1, 2).Value = "{Sum(di:Sum)}";
ws.Cell(1, 3).Value = "{ Custom(DI:Sum, CustomAggregation, PostAggregation) }";
ws.Cell(1, 4).Value = "{Min(di:Sum)}";
ws.Cell(1, 5).Value = "Text1 {count(di:Name)} Text2 {avg(di:Sum, , PostAggregationRound)} {p:StrParam} {Max(di:Sum)} {Max(di:Sum)}";
ws.Cell(1, 6).Value = "{Mix(di:Sum)}";
ws.Cell(1, 7).FormulaA1 = "=SUM(B1:D1)";
ws.Cell(1, 8).FormulaA1 = "=ROW()";
ws.Cell(1, 9).Value = "{sf:Format(p:DateParam, yyyyMMdd)}";
ws.Cell(1, 10).Value = "{p:IntParam}";
ws.Cell(1, 11).Value = "{sf:Format(m:TestClassForTotals:Round(Min(di:Sum), 1), #,,0.0000)}";
ws.Cell(1, 12).Value = "Aggregation: {m:TestClassForTotals:Meth(avg(di:Sum, , PostAggregationRound), Max( di : Sum ))}. Date: {sf:Format(p:DateParam, dd.MM.yyyy)}";
ws.Cell(1, 13).Value = "{Sum(di:Sum)}";
var panel = new ExcelTotalsPanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("Test"), report, report.TemplateProcessor)
{
BeforeRenderMethodName = "TestExcelTotalsPanelBeforeRender",
AfterRenderMethodName = "TestExcelTotalsPanelAfterRender",
};
panel.Render();
Assert.AreEqual(range, panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(TotalsPanelRenderTest),
nameof(TestPanelRender)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestCancelPanelRender()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 2);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:di}";
var panel = new ExcelDataSourcePanel(new[] { 1, 2, 3, 4 }, ws.NamedRange("TestRange"), report, report.TemplateProcessor)
{
BeforeRenderMethodName = "CancelPanelRender",
};
panel.Render();
Assert.AreEqual(range, panel.ResultRange);
Assert.AreEqual(1, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
Assert.AreEqual("{di:di}", ws.Cell(2, 2).Value);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderEmptyDataReader()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 4, 2);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{Headers}";
ws.Cell(2, 2).Style.Border.OutsideBorder = XLBorderStyleValues.Medium;
ws.Cell(2, 2).Style.Border.OutsideBorderColor = XLColor.Red;
ws.Cell(2, 2).Style.Font.Bold = true;
ws.Cell(3, 2).Value = "{Data}";
ws.Cell(3, 2).Style.Border.OutsideBorder = XLBorderStyleValues.Thin;
ws.Cell(3, 2).Style.Border.OutsideBorderColor = XLColor.Black;
ws.Cell(4, 2).Value = "{Totals}";
ws.Cell(4, 2).Style.Border.OutsideBorder = XLBorderStyleValues.Dotted;
ws.Cell(4, 2).Style.Border.OutsideBorderColor = XLColor.Green;
var panel = new ExcelDataSourceDynamicPanel("m:DataProvider:GetEmptyDataReader()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 3, 7), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourceDynamicPanelDataReaderRenderTest),
nameof(TestRenderEmptyDataReader)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderDataSet()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range = ws.Range(2, 2, 2, 6);
range.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{di:Id}";
ws.Cell(2, 3).Value = "{di:Name}";
ws.Cell(2, 4).Value = "{di:IsVip}";
ws.Cell(2, 5).Value = "{di:Description}";
ws.Cell(2, 6).Value = "{di:Type}";
var panel = new ExcelDataSourcePanel("m:DataProvider:GetAllCustomersDataSet()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 4, 6), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourcePanelDataSetRenderTest),
nameof(TestRenderDataSet)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
public void TestRenderEmptyEnumerable()
{
var report = new TestReport();
IXLWorksheet ws = report.Workbook.AddWorksheet("Test");
IXLRange range1 = ws.Range(2, 2, 4, 2);
range1.AddToNamed("TestRange", XLScope.Worksheet);
ws.Cell(2, 2).Value = "{Headers}";
ws.Cell(3, 2).Value = "{Data}";
ws.Cell(4, 2).Value = "{Totals}";
var panel = new ExcelDataSourceDynamicPanel("m:DataProvider:GetEmptyIEnumerable()", ws.NamedRange("TestRange"), report, report.TemplateProcessor);
panel.Render();
Assert.AreEqual(ws.Range(2, 2, 3, 5), panel.ResultRange);
ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(nameof(DataSourceDynamicPanelEnumerableRenderTest),
nameof(TestRenderEmptyEnumerable)), ws.Workbook);
//report.Workbook.SaveAs("test.xlsx");
}
