Support for cells with rich text formatting

traf72 · traf72 · commit ade35d258ac8 · 2024-02-16T15:41:57.000+03:00
diff --git a/ExcelReportGenerator.Tests/CustomAsserts/ExcelAssert.cs b/ExcelReportGenerator.Tests/CustomAsserts/ExcelAssert.cs
@@ -37,7 +37,62 @@ public static void AreWorksheetsContentEquals(IXLWorksheet expected, IXLWorkshee
             }
             else
             {
-                Assert.AreEqual(expectedCell.Value, actualCell.Value, $"Cell {expectedCell.Address} Value failed.");
+                if (!expectedCell.HasRichText && !actualCell.HasRichText)
+                {
+                    Assert.AreEqual(expectedCell.Value, actualCell.Value, $"Cell {expectedCell.Address} Value failed.");
+                }
+                else if (expectedCell.HasRichText && actualCell.HasRichText)
+                {
+                    AreRichTextEqual(expectedCell.GetRichText(), actualCell.GetRichText());
+                }
+                else
+                {
+                    Assert.Fail(
+                        $"Expected cell {expectedCell.Address} {nameof(IXLCell.HasRichText)} is {expectedCell.HasRichText}, but actual cell {nameof(IXLCell.HasRichText)} is {actualCell.HasRichText}");
+                }
+
+                void AreRichTextEqual(IXLRichText expectedRichText, IXLRichText actualRichText)
+                {
+                    Assert.AreEqual(expectedRichText.Count, actualRichText.Count,
+                        GetErrorMessage(nameof(IXLRichText.Count)));
+                    for (var i = 0; i < expectedRichText.Count; i++)
+                    {
+                        var expectedRichString = expectedRichText.ElementAt(i);
+                        var actualRichString = actualRichText.ElementAt(i);
+
+                        Assert.AreEqual(expectedRichString.Text, actualRichString.Text,
+                            GetErrorMessage(nameof(IXLRichString.Text)));
+                        Assert.AreEqual(expectedRichString.FontScheme, actualRichString.FontScheme,
+                            GetErrorMessage(nameof(IXLRichString.FontScheme)));
+                        Assert.AreEqual(expectedRichString.Bold, actualRichString.Bold,
+                            GetErrorMessage(nameof(IXLRichString.Bold)));
+                        Assert.AreEqual(expectedRichString.Italic, actualRichString.Italic,
+                            GetErrorMessage(nameof(IXLRichString.Italic)));
+                        Assert.AreEqual(expectedRichString.Shadow, actualRichString.Shadow,
+                            GetErrorMessage(nameof(IXLRichString.Shadow)));
+                        Assert.AreEqual(expectedRichString.Strikethrough, actualRichString.Strikethrough,
+                            GetErrorMessage(nameof(IXLRichString.Strikethrough)));
+                        Assert.AreEqual(expectedRichString.Underline, actualRichString.Underline,
+                            GetErrorMessage(nameof(IXLRichString.Underline)));
+                        Assert.AreEqual(expectedRichString.FontColor, actualRichString.FontColor,
+                            GetErrorMessage(nameof(IXLRichString.FontColor)));
+                        Assert.AreEqual(expectedRichString.FontName, actualRichString.FontName,
+                            GetErrorMessage(nameof(IXLRichString.FontName)));
+                        Assert.AreEqual(expectedRichString.FontSize, actualRichString.FontSize,
+                            GetErrorMessage(nameof(IXLRichString.FontSize)));
+                        Assert.AreEqual(expectedRichString.VerticalAlignment, actualRichString.VerticalAlignment,
+                            GetErrorMessage(nameof(IXLRichString.VerticalAlignment)));
+                        Assert.AreEqual(expectedRichString.FontCharSet, actualRichString.FontCharSet,
+                            GetErrorMessage(nameof(IXLRichString.FontCharSet)));
+                        Assert.AreEqual(expectedRichString.FontFamilyNumbering, actualRichString.FontFamilyNumbering,
+                            GetErrorMessage(nameof(IXLRichString.FontFamilyNumbering)));
+                    }
+
+                    return;
+
+                    string GetErrorMessage(string propName) =>
+                        $"Cell {expectedCell.Address} RichTextValue '{propName}' failed.";
+                }
             }
 
             Assert.AreEqual(expectedCell.DataType, actualCell.DataType,
diff --git a/ExcelReportGenerator.Tests/ExcelReportGenerator.Tests.csproj b/ExcelReportGenerator.Tests/ExcelReportGenerator.Tests.csproj
@@ -349,6 +349,9 @@
         <None Update="TestData\ExcelDataSourcePanelTest\TestGroupResultVertical_WithoutGroupingBlankValues.xlsx">
           <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         </None>
+        <None Update="TestData\DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test\ParentCellsShiftChildCellsShift_WithRichText.xlsx">
+          <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </None>
     </ItemGroup>
 
 </Project>
diff --git a/ExcelReportGenerator.Tests/Rendering/Panels/ExcelPanels/PanelRenderTests/DataSourcePanelRenderTests/DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test.cs b/ExcelReportGenerator.Tests/Rendering/Panels/ExcelPanels/PanelRenderTests/DataSourcePanelRenderTests/DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test.cs
@@ -64,6 +64,128 @@ public void Test_HorizontalPanelsGrouping_ChildLeft_ParentCellsShiftChildCellsSh
         //report.Workbook.SaveAs("test.xlsx");
     }
 
+    [Test]
+    public void Test_HorizontalPanelsGrouping_ChildLeft_ParentCellsShiftChildCellsShift_WithRichText()
+    {
+        var report = new TestReport();
+        var ws = report.Workbook.AddWorksheet("Test");
+        var parentRange = ws.Range(2, 2, 5, 3);
+        parentRange.AddToNamed("ParentRange", XLScope.Worksheet);
+
+        var child = ws.Range(2, 2, 5, 2);
+        child.AddToNamed("ChildRange", XLScope.Worksheet);
+
+        child.Range(2, 1, 4, 1).Style.Border.OutsideBorder = XLBorderStyleValues.Thin;
+        child.Range(2, 1, 4, 1).Style.Border.OutsideBorderColor = XLColor.Red;
+
+        parentRange.Style.Border.OutsideBorder = XLBorderStyleValues.Thin;
+        parentRange.Style.Border.OutsideBorderColor = XLColor.Black;
+
+        ws.Cell(2, 3).CreateRichText()
+            .AddText("Name - {di:Name} - {di:Name} - Name")
+            .SetItalic();
+
+        ws.Cell(2, 3)
+            .GetRichText()
+            .Substring(0, 4)
+            .SetFontColor(XLColor.Green);
+        
+        ws.Cell(2, 3)
+            .GetRichText()
+            .Substring(6, 23)
+            .SetFontColor(XLColor.Red);
+        
+        ws.Cell(2, 3)
+            .GetRichText()
+            .Substring(31, 4)
+            .SetFontColor(XLColor.Blue);
+
+        ws.Cell(3, 3).CreateRichText()
+            .AddText("Date: {di:Date}");
+
+        ws.Cell(3, 3)
+            .GetRichText()
+            .Substring(0, 4)
+            .SetFontColor(XLColor.Apricot);
+        
+        ws.Cell(3, 3)
+            .GetRichText()
+            .Substring(6, 9)
+            .SetBold()
+            .SetStrikethrough();
+
+        ws.Cell(3, 2).CreateRichText()
+            .AddText("{di:Field1}");
+
+        ws.Cell(3, 2)
+            .GetRichText()
+            .Substring(0, 4)
+            .SetStrikethrough();
+        
+        ws.Cell(4, 2).CreateRichText()
+            .AddText("Field1/Field2: {di:Field1}/{di:Field2}");
+        
+        ws.Cell(4, 2)
+            .GetRichText()
+            .Substring(15, 11)
+            .SetStrikethrough();
+        
+        ws.Cell(4, 2)
+            .GetRichText()
+            .Substring(27, 11)
+            .SetUnderline();
+        
+        ws.Cell(5, 2).CreateRichText()
+            .AddText("Sum: {di:parent:Sum} = {di:parent:Sum}");
+        
+        ws.Cell(5, 2)
+            .GetRichText()
+            .Substring(0, 21)
+            .SetFontColor(XLColor.Green);
+        
+        ws.Cell(5, 2)
+            .GetRichText()
+            .Substring(20, 6)
+            .SetUnderline();
+
+        ws.Cell(1, 1).CreateRichText()
+            .AddText("{di:Name}")
+            .SetBold();
+        
+        ws.Cell(1, 3).CreateRichText()
+            .AddText("Name: {di:Name}")
+            .SetItalic();
+        
+        ws.Cell(1, 4).Value = "{di:Name}";
+        ws.Cell(3, 1).Value = "{di:Name}";
+        ws.Cell(3, 4).Value = "{di:Name}";
+        ws.Cell(6, 1).Value = "{di:Name}";
+        ws.Cell(6, 3).Value = "{di:Name}";
+        ws.Cell(6, 4).Value = "{di:Name}";
+
+        var parentPanel = new ExcelDataSourcePanel("m:DataProvider:GetIEnumerable()", ws.NamedRange("ParentRange"),
+            report, report.TemplateProcessor)
+        {
+            Type = PanelType.Horizontal
+        };
+        var childPanel = new ExcelDataSourcePanel("m:DataProvider:GetChildIEnumerable(di:Name)",
+            ws.NamedRange("ChildRange"), report, report.TemplateProcessor)
+        {
+            Parent = parentPanel,
+            Type = PanelType.Horizontal
+        };
+        parentPanel.Children = new[] {childPanel};
+        parentPanel.Render();
+
+        Assert.AreEqual(ws.Range(2, 2, 5, 9), parentPanel.ResultRange);
+        
+        ExcelAssert.AreWorkbooksContentEquals(TestHelper.GetExpectedWorkbook(
+            nameof(DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test),
+            "ParentCellsShiftChildCellsShift_WithRichText"), ws.Workbook);
+
+        //report.Workbook.SaveAs("test.xlsx");
+    }
+
     [Test]
     public void Test_HorizontalPanelsGrouping_ChildLeft_ParentRowShiftChildCellsShift()
     {
diff --git a/ExcelReportGenerator.Tests/Rendering/Panels/ExcelPanels/PanelRenderTests/PanelRenderTest.cs b/ExcelReportGenerator.Tests/Rendering/Panels/ExcelPanels/PanelRenderTests/PanelRenderTest.cs
@@ -13,7 +13,7 @@ public void TestPanelRender()
     {
         var report = new TestReport();
         var ws = report.Workbook.AddWorksheet("Test");
-        var range = ws.Range(1, 1, 5, 5);
+        var range = ws.Range(1, 1, 6, 6);
 
         ws.Cell(1, 1).Value = "{p:StrParam}";
         ws.Cell(1, 2).Value = "{p:IntParam}";
@@ -38,16 +38,49 @@ public void TestPanelRender()
         ws.Cell(5, 1).Value = "{p:ExpandoObj.StrProp}";
         ws.Cell(5, 2).Value = "{p:ExpandoObj.DecimalProp}";
         ws.Cell(5, 3).Value = "{p:NullProp}";
-        ws.Cell(6, 1).Value = "{p:StrParam}";
-        ws.Cell(6, 2).Value = "{m:Counter()}";
-        ws.Cell(7, 1).Value = "Plain text outside range";
+
+        ws.Cell(6, 1)
+            .CreateRichText()
+            .AddText("Rich expando")
+            .SetItalic()
+            .AddText(" {p:ExpandoObj.StrProp}")
+            .SetBold();
+
+        ws.Cell(6, 2)
+            .CreateRichText()
+            .AddText("Rich decimal before")
+            .SetItalic()
+            .AddText(" {p:ExpandoObj.DecimalProp} ")
+            .SetBold()
+            .AddText("Rich decimal after")
+            .SetStrikethrough();
+
+        ws.Cell(6, 3)
+            .CreateRichText()
+            .AddText("{p:ExpandoObj.StrProp}");
+        
+        ws.Cell(6, 3)
+            .GetRichText()
+            .Substring(0, 13)
+            .SetFontColor(XLColor.Green);
+
+        ws.Cell(10, 1).Value = "{p:StrParam}";
+        ws.Cell(10, 2).Value = "{m:Counter()}";
+        ws.Cell(11, 1).Value = "Plain text outside range";
+
+        ws.Cell(11, 2)
+            .CreateRichText()
+            .AddText("Rich outside first")
+            .SetItalic()
+            .AddText(" Rich outside second")
+            .SetFontColor(XLColor.Red);
 
         var panel = new ExcelPanel(range, report, report.TemplateProcessor);
         panel.Render();
 
         Assert.AreEqual(range, panel.ResultRange);
 
-        Assert.AreEqual(24, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
+        Assert.AreEqual(28, ws.CellsUsed(XLCellsUsedOptions.Contents).Count());
         Assert.AreEqual("String parameter", ws.Cell(1, 1).Value);
         Assert.AreEqual(10d, ws.Cell(1, 2).Value);
         Assert.AreEqual(new DateTime(2017, 10, 25), ws.Cell(1, 3).Value);
@@ -74,17 +107,47 @@ public void TestPanelRender()
         Assert.AreEqual("ExpandoStr", ws.Cell(5, 1).Value);
         Assert.AreEqual(5.56d, ws.Cell(5, 2).Value);
         Assert.AreEqual(Blank.Value, ws.Cell(5, 3).Value);
-
-        Assert.AreEqual("{p:StrParam}", ws.Cell(6, 1).Value);
-        Assert.AreEqual("{m:Counter()}", ws.Cell(6, 2).Value);
-        Assert.AreEqual("Plain text outside range", ws.Cell(7, 1).Value);
+        
+        Assert.True(ws.Cell(6, 1).HasRichText);
+        Assert.AreEqual(ws.Cell(6, 1).GetRichText().Count, 2);
+        Assert.AreEqual(ws.Cell(6, 1).GetRichText().First().Text, "Rich expando");
+        Assert.True(ws.Cell(6, 1).GetRichText().First().Italic);
+        Assert.AreEqual(ws.Cell(6, 1).GetRichText().Last().Text, " ExpandoStr");
+        Assert.True(ws.Cell(6, 1).GetRichText().Last().Bold);
+        
+        Assert.True(ws.Cell(6, 2).HasRichText);
+        Assert.AreEqual(ws.Cell(6, 2).GetRichText().Count, 3);
+        Assert.AreEqual(ws.Cell(6, 2).GetRichText().First().Text, "Rich decimal before");
+        Assert.True(ws.Cell(6, 2).GetRichText().First().Italic);
+        Assert.AreEqual(ws.Cell(6, 2).GetRichText().ElementAt(1).Text, $" {5.56d.ToString()} ");
+        Assert.True(ws.Cell(6, 2).GetRichText().ElementAt(1).Bold);
+        Assert.AreEqual(ws.Cell(6, 2).GetRichText().Last().Text, "Rich decimal after");
+        Assert.True(ws.Cell(6, 2).GetRichText().Last().Strikethrough);
+
+        Assert.AreEqual("{p:ExpandoObj.StrProp}", ws.Cell(6, 3).Value);
+        Assert.True(ws.Cell(6, 3).HasRichText);
+        Assert.AreEqual(ws.Cell(6, 3).GetRichText().Count, 2);
+        Assert.AreEqual(ws.Cell(6, 3).GetRichText().First().Text, "{p:ExpandoObj");
+        Assert.AreEqual(ws.Cell(6, 3).GetRichText().First().FontColor, XLColor.Green);
+        Assert.AreEqual(ws.Cell(6, 3).GetRichText().Last().Text, ".StrProp}");
+        
+        Assert.AreEqual("{p:StrParam}", ws.Cell(10, 1).Value);
+        Assert.AreEqual("{m:Counter()}", ws.Cell(10, 2).Value);
+        Assert.AreEqual("Plain text outside range", ws.Cell(11, 1).Value);
+        Assert.AreEqual("Rich outside first Rich outside second", ws.Cell(11, 2).Value);
+        Assert.True(ws.Cell(11, 2).HasRichText);
+        Assert.AreEqual(ws.Cell(11, 2).GetRichText().Count, 2);
+        Assert.AreEqual(ws.Cell(11, 2).GetRichText().First().Text, "Rich outside first");
+        Assert.True(ws.Cell(11, 2).GetRichText().First().Italic);
+        Assert.AreEqual(ws.Cell(11, 2).GetRichText().Last().Text, " Rich outside second");
+        Assert.AreEqual(ws.Cell(11, 2).GetRichText().Last().FontColor, XLColor.Red);
 
         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");
+        // report.Workbook.SaveAs("test.xlsx");
     }
 
     [Test]
diff --git a/ExcelReportGenerator.Tests/TestData/DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test/ParentCellsShiftChildCellsShift_WithRichText.xlsx b/ExcelReportGenerator.Tests/TestData/DataSourcePanelRender_WithGrouping_HorizontalPanels_ChildLeft_Test/ParentCellsShiftChildCellsShift_WithRichText.xlsx
diff --git a/ExcelReportGenerator/Rendering/Panels/ExcelPanels/ExcelPanel.cs b/ExcelReportGenerator/Rendering/Panels/ExcelPanels/ExcelPanel.cs
