public static class OpenXmlExcelHelper
    {
        #region Append To Stylesheet

        public static uint AppendCellFormat(this SpreadsheetDocument document, CellFormat cellFormat)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (stylesheet.CellFormats == null)
                stylesheet.CellFormats = new CellFormats();

            stylesheet.CellFormats.Append(cellFormat);
            return (uint)stylesheet.CellFormats.FirstIndex(v => cellFormat == v);
        }

        public static uint AppendFont(this SpreadsheetDocument document, Font font)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (stylesheet.Fonts == null)
                stylesheet.Fonts = new Fonts();

            stylesheet.Fonts.Append(font);
            return (uint)stylesheet.Fonts.FirstIndex(v => font == v);
        }

        public static uint AppendBorder(this SpreadsheetDocument document, Border border)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (stylesheet.Borders == null)
                stylesheet.Borders = new Borders();

            stylesheet.Borders.Append(border);
            return (uint)stylesheet.Borders.FirstIndex(v => border == v);
        }        

        public static uint AppendNumberingFormat(this SpreadsheetDocument document, NumberingFormat numberingFormat)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (stylesheet.NumberingFormats == null)
                stylesheet.NumberingFormats = new NumberingFormats();

            stylesheet.NumberingFormats.Append(numberingFormat);

            if (numberingFormat.NumberFormatId == null)
            {
                var id = (uint)(stylesheet.NumberingFormats.FirstIndex(v => numberingFormat == v) + MinCustomNumberFormatId);
                numberingFormat.NumberFormatId = id;
            }

            return numberingFormat.NumberFormatId;
        }

        #endregion

        #region Stylesheet Query

        public static Font GetDefaultFont(this SpreadsheetDocument document)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;
            return (Font)stylesheet.Fonts.First();
        }

        public static Font GetCellFont(this SpreadsheetDocument document, Cell cell)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;
            var cellFormat = document.GetCellFormat(cell);

            if (cellFormat.ApplyFont != null && cellFormat.ApplyFont && cellFormat.FontId != null)
                return (Font)stylesheet.Fonts.ElementAt((int)(uint)cellFormat.FontId);

            return document.GetDefaultFont();
        }

        public static CellFormat GetDefaultCellFormat(this SpreadsheetDocument document)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;
            return (CellFormat)stylesheet.CellFormats.First();
        }

        public static CellFormat GetCellFormat(this SpreadsheetDocument document, Cell cell)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (cell.StyleIndex != null)
                return (CellFormat)stylesheet.CellFormats.ElementAt((int)(uint)cell.StyleIndex);

            return document.GetDefaultCellFormat();
        }

        public static string GetCellNumberFormatCode(this SpreadsheetDocument document, Cell cell)
        {
            var stylesheet = document.WorkbookPart.WorkbookStylesPart.Stylesheet;

            if (cell.DataType != CellValues.Number)
                return null;

            var cellStyle = document.GetCellFormat(cell);

            if (cellStyle.ApplyNumberFormat == null || cellStyle.ApplyNumberFormat == false || cellStyle.NumberFormatId == null)
                return null;

            string defaultNumberFormatCode;

            if (DefaultNumberFormats.TryGetValue(cellStyle.NumberFormatId, out defaultNumberFormatCode))
                return defaultNumberFormatCode;

            var numberFormat = stylesheet.NumberingFormats
                .Cast<NumberingFormat>()
                .FirstOrDefault(v => (uint)v.NumberFormatId == (uint)cellStyle.NumberFormatId);

            if (numberFormat != null && numberFormat.FormatCode != null)
                return numberFormat.FormatCode;

            return null;
        }

        #endregion

        #region Default Number Formats

        // http://closedxml.codeplex.com/wikipage?title=NumberFormatId%20Lookup%20Table

        const int MinCustomNumberFormatId = 1000;

        static readonly Dictionary<uint, string> DefaultNumberFormats =
            new[] 
            {
                // System.Tuple.Create(0, General),
                System.Tuple.Create(1, "0"),
                System.Tuple.Create(2, "0.00"),
                System.Tuple.Create(3, "#,##0"),
                System.Tuple.Create(4, "#,##0.00"),
                System.Tuple.Create(9, "0%"),
                System.Tuple.Create(10, "0.00%"),
                System.Tuple.Create(11, "0.00E+00"),
                System.Tuple.Create(12, "# ?/?"),
                System.Tuple.Create(13, "# ??/??"),
                System.Tuple.Create(14, "d/m/yyyy"),
                System.Tuple.Create(15, "d-mmm-yy"),
                System.Tuple.Create(16, "d-mmm"),
                System.Tuple.Create(17, "mmm-yy"),
                System.Tuple.Create(18, "h:mm tt"),
                System.Tuple.Create(19, "h:mm:ss tt"),
                System.Tuple.Create(20, "H:mm"),
                System.Tuple.Create(21, "H:mm:ss"),
                System.Tuple.Create(22, "m/d/yyyy H:mm"),
                System.Tuple.Create(37, "#,##0 ;(#,##0)"),
                System.Tuple.Create(38, "#,##0 ;[Red](#,##0)"),
                System.Tuple.Create(39, "#,##0.00;(#,##0.00)"),
                System.Tuple.Create(40, "#,##0.00;[Red](#,##0.00)"),
                System.Tuple.Create(45, "mm:ss"),
                System.Tuple.Create(46, "[h]:mm:ss"),
                System.Tuple.Create(47, "mmss.0"),
                System.Tuple.Create(48, "##0.0E+0"),
                System.Tuple.Create(49, "@")
            }
            .ToDictionary(v => (uint)v.Item1, v => v.Item2);

        #endregion
    }

namespace SspMain
{
    public class OpenXmlExcelTableExporter : IExcelTableExporter
    {
        #region IExcelTableExporter Members

        ExcelTableExporterModel Model;

        IEnumerable Data;

        SpreadsheetDocument Document;

        Worksheet Worksheet;

        SheetData SheetData;

        OpenXmlExcelTextMeasure TextMeasure;

        public Stream Execute(ExcelTableExporterModel model, IEnumerable data)
        {
            Model = model;
            Data = data;

            ResetColumnWidths();

            var result = TempFileHelper.OpenTempFile();
            try
            {
                var template = Resources.EmptyTemplate;
                result.Write(template, 0, template.Length);
                result.Seek(0, SeekOrigin.Begin);

                using (Document = SpreadsheetDocument.Open(result, true))
                using (TextMeasure = new OpenXmlExcelTextMeasure(Document))
                {
                    Worksheet = Document.WorkbookPart.WorksheetParts.First().Worksheet;
                    SheetData = Worksheet.GetFirstChild<SheetData>();

                    WriteStyles();
                    WriteDocumentHeader();
                    WriteTableHeader();
                    WriteTableData();
                    WriteTableColumns();
                }

                result.Seek(0, SeekOrigin.Begin);
                return result;
            }
            catch
            {
                result.Dispose();
                throw;
            }
        }

        #endregion

        #region Styles

        uint DocumentHeaderCellFormat;

        uint TableHeaderCellFormat;

        uint TableCommonCellFormat;

        uint TableDateCellFormat;

        uint TableDateTimeCellFormat;

        void WriteStyles()
        {
            DocumentHeaderCellFormat = Document.AppendCellFormat(new CellFormat
            {
                ApplyFont = true,
                FontId = Document.AppendFont(new Font
                {
                    FontSize = new FontSize { Val = 16 },
                    Bold = new Bold()
                })
            });

            var tableBorder = Document.AppendBorder(new Border
            {
                LeftBorder = new LeftBorder { Style = BorderStyleValues.Thin },
                RightBorder = new RightBorder { Style = BorderStyleValues.Thin },
                TopBorder = new TopBorder { Style = BorderStyleValues.Thin },
                BottomBorder = new BottomBorder { Style = BorderStyleValues.Thin }
            });

            TableHeaderCellFormat = Document.AppendCellFormat(new CellFormat
            {
                ApplyFont = true,
                FontId = Document.AppendFont(new Font { Bold = new Bold() }),
                ApplyBorder = true,
                BorderId = tableBorder
            });

            TableCommonCellFormat = Document.AppendCellFormat(new CellFormat
            {
                ApplyBorder = true,
                BorderId = tableBorder
            });

            TableDateCellFormat = Document.AppendCellFormat(new CellFormat
            {
                ApplyBorder = true,
                BorderId = tableBorder,
                ApplyNumberFormat = true,
                NumberFormatId = Document.AppendNumberingFormat(new NumberingFormat
                {
                    FormatCode = "dd/mm/yyyy"
                })
            });

            TableDateTimeCellFormat = Document.AppendCellFormat(new CellFormat
            {
                ApplyBorder = true,
                BorderId = tableBorder,
                ApplyNumberFormat = true,
                NumberFormatId = Document.AppendNumberingFormat(new NumberingFormat
                {
                    FormatCode = "dd/mm/yyyy hh:mm"
                })
            });
        }

        #endregion

        #region Cells

        void WriteDocumentHeader()
        {
            var row = new Row();

            row.Append(new Cell
            {
                StyleIndex = DocumentHeaderCellFormat,
                DataType = CellValues.String,
                CellValue = new CellValue(Model.Name)
            });

            SheetData.Append(row);
            SheetData.Append(new Row());
        }

        void WriteTableHeader()
        {
            var row = new Row();
            var columnIndex = 0;

            foreach (var column in Model.Columns)
            {
                var cell = new Cell
                {
                    StyleIndex = TableHeaderCellFormat,
                    DataType = CellValues.String,
                    CellValue = new CellValue(column.Header)
                };

                row.Append(cell);

                if (column.Width.HasValue == false)
                {
                    var width = TextMeasure.GetCellWidth(cell);
                    SetColumnWidth(columnIndex, width);
                }

                columnIndex++;
            }

            SheetData.Append(row);
        }

        void WriteTableData()
        {
            PropertyPathInfo[] valueAccessors = null;

            foreach (var dataItem in Data)
            {
                if (valueAccessors == null)
                    valueAccessors = Model.Columns
                        .Select(column => PropertyPathFactory.Create(dataItem.GetType(), column.PropertyName))
                        .ToArray();

                var row = new Row();
                var columnIndex = 0;

                foreach (var column in Model.Columns)
                {
                    var cell = new Cell();

                    try
                    {
                        var value = valueAccessors[columnIndex].GetValue(dataItem);
                        WriteCellValue(column, value, cell);
                    }
                    catch (Exception e)
                    {
                        throw new InvalidOperationException(string.Format(
                            "Excel column export error. Property name: {0}",
                            column.PropertyName
                        ), e);
                    }

                    row.Append(cell);

                    if (column.Width.HasValue == false)
                    {
                        var width = TextMeasure.GetCellWidth(cell);
                        SetColumnWidth(columnIndex, width);
                    }

                    columnIndex++;
                }

                SheetData.Append(row);
            }
        }

        // http://blogs.msdn.com/b/arvinwu/archive/2008/10/02/some-excel-2007-limitation.aspx
        const int MaxCellStringValueLength = 32767;

        void WriteCellValue(ExcelTableExporterColumn column, object value, Cell cell)
        {
            if (value == null)
            {
                cell.CellValue = new CellValue("");
                cell.DataType = CellValues.String;
                cell.StyleIndex = TableCommonCellFormat;
                return;
            }

            if (column.ValueConverter != null)
                value = column.ValueConverter(value);

            var culture = CultureInfo.InvariantCulture;

            if (column.ValueType == ExcelTableExporterValueTypes.String)
            {
                var stringValue = value.ToString();

                if (stringValue.Length > MaxCellStringValueLength)
                    stringValue = stringValue.Substring(0, MaxCellStringValueLength);

                cell.CellValue = new CellValue(stringValue);
                cell.DataType = CellValues.String;
                cell.StyleIndex = TableCommonCellFormat;
                return;
            }

            if (column.ValueType == ExcelTableExporterValueTypes.Number)
            {
                var decimalValue = Convert.ToDecimal(value);
                cell.CellValue = new CellValue(decimalValue.ToString(culture));
                cell.DataType = CellValues.Number;
                cell.StyleIndex = TableCommonCellFormat;
                return;
            }

            if (column.ValueType == ExcelTableExporterValueTypes.Boolean)
            {
                var boolValue = Convert.ToBoolean(value);
                cell.CellValue = new CellValue(boolValue ? "Да" : "");
                cell.DataType = CellValues.String;
                cell.StyleIndex = TableCommonCellFormat;
                return;
            }

            if (column.ValueType == ExcelTableExporterValueTypes.Date || column.ValueType == ExcelTableExporterValueTypes.DateTime)
            {
                var oaDateTimeValue = Convert.ToDateTime(value).ToOADate();
                cell.CellValue = new CellValue(oaDateTimeValue.ToString(culture));
                cell.DataType = CellValues.Number;
                cell.StyleIndex = column.ValueType == ExcelTableExporterValueTypes.Date ? TableDateCellFormat : TableDateTimeCellFormat;
                return;
            }

            throw new ArgumentException("column.ValueType");
        }

        #endregion

        #region Columns

        double[] ColumnWidths;

        void ResetColumnWidths()
        {
            ColumnWidths = new double[Model.Columns.Count];
        }

        void SetColumnWidth(int columnIndex, double width)
        {
            if (width > ColumnWidths[columnIndex])
                ColumnWidths[columnIndex] = width;
        }

        void WriteTableColumns()
        {
            var worksheetColumns = new Columns();
            var columnIndex = 0;

            foreach (var column in Model.Columns)
            {
                var columnNum = (uint)(columnIndex + 1);

                worksheetColumns.Append(new Column
                {
                    Min = columnNum,
                    Max = columnNum,
                    CustomWidth = true,
                    Width = column.Width ?? ColumnWidths[columnIndex]
                });

                columnIndex++;
            }

            Worksheet.InsertBefore(worksheetColumns, SheetData);
        }

        #endregion
    }
}