MS Office >> Open Office = Отчеты без велосипеда

using System;
using System.Data;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using Skip.DALLib.ProgramConstMngr;
using ICSharpCode.SharpZipLib.Zip;

namespace OfficeWrapperLib
{
    public static class OODocCreator
    {
        #region Consts

        const string pBookMark = @"{[\w\s;()]*}";

        private const string pDtl = @"{BeginTable}(.*?\s*?)*{EndTable}";
        private const string pWorkRow = @"<table:table-row>(.*?\s*?)*</table:table-row>";

        private const string pImage = @"<draw:frame.+?(?<ImageBookMark>{Image\((?<field_name>\w+)\)})+?[\s\S]+?</draw:frame>";

        //private const string pImage = @"<draw:frame.+?({[\w\s;()]*})+?[\s\S]+?</draw:frame>";

        private const string pImagePath = @"xlink:href=""Pictures/(?<newfile_name>[\w.]+)""";

        static readonly Regex rxBookMark = new Regex(pBookMark, RgxOptions);

        private static readonly Regex rxDtl = new Regex(pDtl, RgxOptionsMulty);
        private static readonly Regex rxWorkRow = new Regex(pWorkRow, RgxOptions);
        private static readonly Regex rxImage = new Regex(pImage, RgxOptions);
        private static readonly Regex rxImagePath = new Regex(pImagePath, RgxOptions);

        const RegexOptions RgxOptions = RegexOptions.IgnoreCase | RegexOptions.Singleline | RegexOptions.Compiled;
        const RegexOptions RgxOptionsMulty = RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.Compiled;

        #endregion

        static OODocCreator()
        {
            var programConstMngr = new ProgramConstMngr();
            StoragePath = programConstMngr.GetStoragePath();
            TemplatePathDir = programConstMngr.GetTemplatePath();
        }

        public static readonly string StoragePath;
        public static readonly string TemplatePathDir;

        public static string GetEndFileName(string Alias, int ParentViewerID, int? keyVal)
        {
            string CurPath = Path.Combine(StoragePath, ParentViewerID + @"\" + keyVal + @"\");

            return Path.Combine(CurPath, Alias + @".odt").Replace("/", "-");
        }

        static readonly FastZip fz = new FastZip();

        public static string PrepareDoc(string Alias, int ParentViewerID, int? keyVal, DataSet RPDataSet)
        {
            string endFilePath = GetEndFileName(Alias, ParentViewerID, keyVal);
            if (File.Exists(endFilePath))
            {
                endFilePath = Path.Combine(Path.GetDirectoryName(endFilePath), Path.GetFileNameWithoutExtension(endFilePath))
                    + "_" + DateTime.Now.ToString("yyyyMMddhhmm") + Path.GetExtension(endFilePath);
            }

            var TemplateFileName = Path.Combine(TemplatePathDir, Alias + @".odt");

            var directoryName = Path.GetDirectoryName(endFilePath);
            if (!Directory.Exists(directoryName))
            {
                Directory.CreateDirectory(directoryName);
            }


            string tempBaseDir = //Path.Combine(Path.GetDirectoryName(TemplateFileName), "templTemp");
                        GetTemplatePath();

            if (string.IsNullOrEmpty(tempBaseDir)) return "";

            string tempDir = Path.Combine(tempBaseDir, Guid.NewGuid().ToString());

            if (RPDataSet.Tables.Count < 1 || RPDataSet.Tables[0].Rows.Count < 1)
            {
                File.Copy(TemplateFileName, endFilePath);
                return endFilePath;
            }

            DataRow CurDataRow = RPDataSet.Tables[0].Rows[0];

            //Cursor.Current = Cursors.WaitCursor;

            try
            {
                CreateTempDir(tempDir);

                string tempContentFileName = Path.Combine(tempDir, @"content.xml");
                string str = LoadOOContent(tempDir, TemplateFileName, tempContentFileName);

                str = ProcessDetail(RPDataSet, str);

                str = FindAndReplace(str, CurDataRow);

                string ImageDir = Path.Combine(TemplatePathDir, "Pictures");
                ProcessImage(tempDir, str, CurDataRow, ImageDir);

                SaveOOContent(tempDir, tempContentFileName, str, endFilePath);
            }
            finally
            {
                Directory.Delete(tempDir, true);
                //Cursor.Current = Cursors.Default;
            }

            return endFilePath;
        }

        private static string GetTemplatePath()
        {
            return Environment.GetEnvironmentVariable("Temp");
        }

        
        private static string ProcessDetail(DataSet RPDataSet, string str)
        {
            if (RPDataSet.Tables.Count == 2)
            {
                var lastTbIndex = RPDataSet.Tables.Count - 1;
                DataTable tb = RPDataSet.Tables[lastTbIndex];
                str = FindAndReplaceDetail(str, tb);
            }

            return str;
        }

        private static void SaveOOContent(string tempDir, string tempContentFileName, string str, string endFilePath)
        {
            File.WriteAllBytes(tempContentFileName, Encoding.UTF8.GetBytes(str));

            fz.CreateEmptyDirectories = true;
            fz.CreateZip(endFilePath, tempDir, true, "");
        }

        private static string LoadOOContent(string tempDir, string TemplateName, string tempContentFileName)
        {
            fz.ExtractZip(TemplateName, tempDir, @"");

            byte[] bytes = File.ReadAllBytes(tempContentFileName);

            return Encoding.UTF8.GetString(bytes);
        }

        private static void ProcessImage(string tempDir, string str, DataRow CurDataRow, string ImageDir)
        {
            if (!IsExistImage(str)) return;

            string destImageDir = Path.Combine(tempDir, "Pictures");

            if (!Directory.Exists(destImageDir))
            {
                Directory.CreateDirectory(destImageDir);
            }

            foreach (Match mImage in rxImage.Matches(str))
            {
                string ImageClmnName = mImage.Groups["field_name"].Value;
                var ImageFile = (string)CurDataRow[ImageClmnName];

                string NewImageFile = rxImagePath.Matches(mImage.Value)[0].Groups["newfile_name"].Value;

                CopyImageToOOReport(ImageFile, NewImageFile, ImageDir, destImageDir);
            }
        }

        private static void CopyImageToOOReport(string ImageFile, string NewImageFile, string ImageDir, string destImageDir)
        {
            string sourceFileName = Path.Combine(ImageDir, ImageFile);
            string destFileName = Path.Combine(destImageDir, NewImageFile);

            File.Copy(sourceFileName, destFileName, true);
        }

        private static bool IsExistImage(string str)
        {
            return rxImage.IsMatch(str);
        }

        private static string FindAndReplaceDetail(string xml, DataTable tb)
        {
            MatchEvaluator meDtl = delegate(Match mDtl)
            {
                bool IsWorkRow = false;

                MatchEvaluator meWorkRow = delegate(Match mWorkRow)
                {
                    if (IsWorkRow) return mWorkRow.Value;

                    if (rxBookMark.IsMatch(mWorkRow.Value))
                    {
                        IsWorkRow = true;
                        string workRow = mWorkRow.Value;

                        var sb = new StringBuilder();
                        foreach (DataRow row in tb.Rows)
                        {
                            sb.AppendLine(FindAndReplace(workRow, row));
                        }
                        return sb.ToString();
                    }

                    return mWorkRow.Value;
                };

                string replace = rxWorkRow.Replace(mDtl.Value, meWorkRow);

                return replace.Replace("{BeginTable}", "").Replace("{EndTable}", "");
            };

            return rxDtl.Replace(xml, meDtl);
        }

        private static void CreateTempDir(string tempDir)
        {
            if(Directory.Exists(tempDir))
            {
                Directory.Delete(tempDir, true);
            }
            Directory.CreateDirectory(tempDir);
        }

        private static string FindAndReplace(string xml, DataRow currow)
        {
            MatchEvaluator meAll =
                delegate(Match m)
                    {
                        string resultStr = MyFuncEval.CalcFunc(m.Value, currow, currow.Table.DataSet.Tables[1]);
                        return resultStr;
                    };

            return rxBookMark.Replace(xml, meAll);
        }
        
    }
}