Added Excel Fromula to the openXMLwriter + added Builder pattern to t…

src/DoddleReport.Builder/DoddleExporter.cs

@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace DoddleReport.Builder
+{
+    public static class DoddleExporter
+    {
+        /// <summary>
+        ///     Converts an enumerable of dictionaries to a report source
+        /// </summary>
+        /// <typeparam name="TValue">
+        ///     The type of values in the dictionaries
+        /// </typeparam>
+        /// <param name="elements">
+        ///     An enumerable of elements
+        /// </param>
+        /// <param name="select"></param>
+        /// <returns>The report source that was created from the elements</returns>
+        public static IReportSource ToReportSource<TValue>(IEnumerable<IDictionary<string, TValue>> elements)
+        {
+            var elementsArray = elements.ToArray();
+            if (!elementsArray.Any())
+                throw new ArgumentException("Can't export empty list of elements");
+            return ToReportSource(elementsArray, elementsArray.First().Keys.ToArray(),
+                (element, key) => element.ContainsKey(key) ? element[key] : default(TValue));
+        }
+
+        /// <summary>
+        /// Converts an enumerable of XElement to a report source
+        /// </summary>
+        /// <param name="rootElements">
+        ///     The xml root elements that contain the values
+        /// </param>
+        /// <param name="keys">
+        ///     They keys that can be used to fetch values from each root element
+        /// </param>
+        /// <returns>The report source that was created from the elements</returns>
+        public static IReportSource ToReportSource(IEnumerable<XElement> rootElements, string[] keys)
+        {
+            return ToReportSource(rootElements, keys, delegate (XElement element, string key)
+            {
+                var value = element.Element(XmlConvert.EncodeLocalName(key));
+                return value != null ? value.Value : null;
+            });
+        }
+
+        /// <summary>
+        ///     Converts a list of elements to a report source
+        /// </summary>
+        /// <param name="elements">
+        ///     An enumerable of elements
+        /// </param>
+        /// <param name="keys">
+        ///     They keys with which the values can be fetched from one element
+        /// </param>
+        /// <param name="valueSelector">
+        ///     The function with which one value can be fetched given one key and one element
+        /// </param>
+        /// <returns>The report source that was created from the elements</returns>
+        public static IReportSource ToReportSource<T>(IEnumerable<T> elements, string[] keys,
+            Func<T, string, object> valueSelector)
+        {
+            var expandos = new List<ExpandoObject>();
+            foreach (var element in elements)
+            {
+                var expando = new ExpandoObject();
+                var expandoDictionary = (IDictionary<string, object>)expando;
+                foreach (var key in keys)
+                {
+                    var value = valueSelector(element, key);
+                    expandoDictionary[key] = value;
+                }
+                expandos.Add(expando);
+            }
+            return expandos.ToReportSource();
+        }
+    }
+}

src/DoddleReport.Builder/DoddleReport.Builder.csproj

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{10FAE193-E8EB-4239-8579-97E2ADC28F9D}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>DoddleReport.Builder</RootNamespace>
+    <AssemblyName>DoddleReport.Builder</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Net.Http" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="ExportBuilder.cs" />
+    <Compile Include="ExportColumn.cs" />
+    <Compile Include="Extentions\ExtensionsForIEnumerable.cs" />
+    <Compile Include="Extentions\ExtensionsForMemberInfo.cs" />
+    <Compile Include="IExportColumn.cs" />
+    <Compile Include="DoddleExporter.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DoddleReport\DoddleReport.csproj">
+      <Project>{F08B2994-4D05-423E-A8FE-7D1E8A63472B}</Project>
+      <Name>DoddleReport</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+</Project>

src/DoddleReport.Builder/ExportBuilder.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Linq.Expressions;
+using DoddleReport.Builder.Extentions;
+
+namespace DoddleReport.Builder
+{
+    public class ExportBuilder<TModel> where TModel : class
+    {
+        private readonly IEnumerable<TModel> _models;
+        private readonly ICollection<IExportColumn<TModel>> _columns;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:System.Object"/> class.
+        /// </summary>
+        private ExportBuilder(IEnumerable<TModel> models)
+        {
+            _models = models;
+            _columns = new List<IExportColumn<TModel>>();
+        }
+
+        public static ExportBuilder<TModel> Create(IEnumerable<TModel> models)
+        {
+            return new ExportBuilder<TModel>(models);
+        }
+
+        public ExportBuilder<TModel> Column<TProperty>(Expression<Func<TModel, TProperty>> display)
+        {
+            if (!(display.Body is MemberExpression))
+                throw new ArgumentException(display + " is not a property!");
+
+            var memberInfo = ((MemberExpression)display.Body).Member;
+            if (!memberInfo.HasAttribute<DisplayNameAttribute>())
+                throw new ArgumentException(display + " does not have a [Display] attribute");
+            var displayAttribute = ExtensionsForMemberInfo.GetAttribute<DisplayNameAttribute>(memberInfo);
+
+            _columns.Add(new ExportColumn<TModel, TProperty>(displayAttribute.DisplayName, display));
+            return this;
+        }
+
+        public ExportBuilder<TModel> Column<TProperty>(string header, Expression<Func<TModel, TProperty>> property)
+        {
+            _columns.Add(new ExportColumn<TModel, TProperty>(header, property));
+            return this;
+
+        }
+
+
+        public IReportSource ToReportSource()
+        {
+            if (_models.Any())
+            {
+                return DoddleExporter.ToReportSource(_models.Select(model => _columns.ToDictionary(c => c.Header, c => c.Display(model))));
+            }
+            var result = _columns
+                    .ToDictionary(a => a.Header, a => string.Empty);
+            return DoddleExporter.ToReportSource(new[] { result });
+        }
+
+        public Report ToReport(IEnumerable<KeyValuePair<string, string>> headers, IReportWriter writer = null)
+        {
+            headers = headers ?? Enumerable.Empty<KeyValuePair<string, string>>();
+            var report = new Report(ToReportSource(), writer);
+            //report.TextFields.Footer = string.Format(@"Aangemaakt op: {0}", DateTime.Now.ToString(DataFormatStrings.Date));
+            var headersArray = headers as KeyValuePair<string, string>[] ?? headers.ToArray();
+            if (headersArray.Any())
+            {
+                report.TextFields.Header = headersArray.Aggregate(string.Empty,
+                                             (currentHeaders, header) => string.Format("{0}{3}{1} : {2}", currentHeaders, header.Key, header.Value, Environment.NewLine));
+            }
+
+            return report;
+        }
+    }
+
+}

src/DoddleReport.Builder/ExportColumn.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Linq.Expressions;
+
+namespace DoddleReport.Builder
+{
+    public class ExportColumn<TModel, TProperty> : IExportColumn<TModel> where TModel : class
+    {
+        private readonly string _header;
+        private readonly Expression<Func<TModel, TProperty>> _display;
+        private string _formula;
+
+        public string Header => _header;
+        public string Formula => _formula;
+        public Func<TModel, object> Display { get { return model => _display.Compile().Invoke(model); } }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="T:System.Object"/> class.
+        /// </summary>
+        public ExportColumn(string header, Expression<Func<TModel, TProperty>> display)
+        {
+            _header = header;
+            _display = display; ;
+        }
+
+        public ExportColumn(string header, Expression<Func<TModel, TProperty>> property, string formula)
+        {
+            _header = header;
+            _display = property;
+            _formula = formula;
+        }
+
+        /// <summary>
+        /// Returns a string that represents the current object.
+        /// </summary>
+        /// <returns>
+        /// A string that represents the current object.
+        /// </returns>
+        public override string ToString()
+        {
+            return $"Header: {_header}, Display: {_display}";
+        }
+    }
+}

src/DoddleReport.Builder/Extentions/ExtensionsForIEnumerable.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace DoddleReport.Builder.Extentions
+{
+    public static class ExtensionsForIEnumerable
+    {
+        public static ExportBuilder<TModel> Export<TModel>(this IEnumerable<TModel> models) where TModel : class
+        {
+            return ExportBuilder<TModel>.Create(models);
+        }
+    }
+}

src/DoddleReport.Builder/Extentions/ExtensionsForMemberInfo.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Linq;
+using System.Reflection;
+
+namespace DoddleReport.Builder.Extentions
+{
+    public static class ExtensionsForMemberInfo
+    {
+        public static bool HasAttribute<TAttribute>(this MemberInfo @this)
+        {
+            return HasAttribute(@this, typeof(TAttribute));
+        }
+
+        public static bool HasAttribute(this MemberInfo @this, Type attributeType)
+        {
+            return Attribute.GetCustomAttributes(@this, attributeType).Any();
+        }
+
+        public static TAttribute GetAttribute<TAttribute>(this MemberInfo @this) where TAttribute : Attribute
+        {
+            if ([email protected](typeof(TAttribute)))
+                throw new InvalidOperationException($"Member {@this} has no attribute of type {typeof(TAttribute)}");
+            return (TAttribute)@this.GetCustomAttribute(typeof(TAttribute));
+        }
+
+
+    }
+}

src/DoddleReport.Builder/IExportColumn.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace DoddleReport.Builder
+{
+    public interface IExportColumn<in TModel> where TModel : class
+    {
+        string Header { get; }
+        string Formula { get; }
+        Func<TModel, object> Display { get; }
+    }
+}

src/DoddleReport.Builder/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DoddleReport.Builder")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DoddleReport.Builder")]
+[assembly: AssemblyCopyright("Copyright ©  2017")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components.  If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("10fae193-e8eb-4239-8579-97e2adc28f9d")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]