public static void SetCellDate(WorksheetPart worksheetPart, DateTime value, string columnName, DocumentFormat.OpenXml.Spreadsheet.Row row)
        {
            Cell cell = GetCell(worksheetPart.Worksheet, columnName, row);

            cell.CellValue = new CellValue(value.ToOADate().ToString("0"));
            cell.DataType = new EnumValue<CellValues>(CellValues.Number);
        }

        public void Start(Int32 pollingTimeInMs)
        {
            var jobDataMap = context.JobDetail.JobDataMap;
            PipelineId = new PipelineId(jobDataMap.GetString(JobKeys.PipelineId));

            InputDocumentId = new DocumentId(jobDataMap.GetString(JobKeys.DocumentId));
            InputBlobId = new BlobId(jobDataMap.GetString(JobKeys.BlobId));
            InputDocumentFormat = new DocumentFormat(jobDataMap.GetString(JobKeys.Format));

            if (TenantId == null)
                throw new Exception("tenant not set!");

            _workingFolder = Path.Combine(
                ConfigService.GetWorkingFolder(TenantId, InputBlobId),
                GetType().Name
            );

            OnExecute(context);

            try
            {
                if (Directory.Exists(_workingFolder))
                    Directory.Delete(_workingFolder, true);
            }
            catch (Exception ex)
            {
                Logger.ErrorFormat(ex, "Error deleting {0}", _workingFolder);
            }

            pollingTimer = new Timer(pollingTimeInMs);
            pollingTimer.Elapsed += pollingTimer_Elapsed;
            pollingTimer.Start();
        }

 public DeleteFormatFromDocumentDescriptor(
     DocumentDescriptorId aggregateId, 
     DocumentFormat documentFormat) : base(aggregateId)
 {
     if (aggregateId == null) throw new ArgumentNullException("aggregateId");
     DocumentFormat = documentFormat;
 }

        public static void SetCell(WorksheetPart worksheetPart, string text, string columnName, DocumentFormat.OpenXml.Spreadsheet.Row row, out Cell cell)
        {
            cell = GetCell(worksheetPart.Worksheet, columnName, row);

            cell.CellValue = new CellValue(string.IsNullOrWhiteSpace(text) ? "" : text);
            cell.DataType = new EnumValue<CellValues>(CellValues.String);
        }

        /// <summary>
        /// Stream to file
        /// </summary>
        /// <param name="inputStream"></param>
        /// <param name="outputFile"></param>
        /// <param name="fileMode"></param>
        /// <param name="sourceRectangle"></param>
        /// <returns></returns>
        public static string StreamToFile(Stream inputStream, string outputFile, FileMode fileMode, DocumentFormat.OpenXml.Drawing.SourceRectangle sourceRectangle)
        {
            try
            {
                if (inputStream == null)
                    throw new ArgumentNullException("inputStream");

                if (String.IsNullOrEmpty(outputFile))
                    throw new ArgumentException("Argument null or empty.", "outputFile");

                if (Path.GetExtension(outputFile).ToLower() == ".emf" || Path.GetExtension(outputFile).ToLower() == ".wmf")
                {
                    System.Drawing.Imaging.Metafile emf = new System.Drawing.Imaging.Metafile(inputStream);
                    System.Drawing.Rectangle cropRectangle;

                    double leftPercentage = (sourceRectangle != null && sourceRectangle.Left != null) ? ToPercentage(sourceRectangle.Left.Value) : 0;
                    double topPercentage = (sourceRectangle != null && sourceRectangle.Top != null) ? ToPercentage(sourceRectangle.Top.Value) : 0;
                    double rightPercentage = (sourceRectangle != null && sourceRectangle.Left != null) ? ToPercentage(sourceRectangle.Right.Value) : 0;
                    double bottomPercentage = (sourceRectangle != null && sourceRectangle.Left != null) ? ToPercentage(sourceRectangle.Bottom.Value) : 0;

                    cropRectangle = new System.Drawing.Rectangle(
                        (int)(emf.Width * leftPercentage),
                        (int)(emf.Height * topPercentage),
                        (int)(emf.Width - emf.Width * (leftPercentage + rightPercentage)),
                        (int)(emf.Height - emf.Height * (bottomPercentage + topPercentage)));

                    System.Drawing.Bitmap newBmp = new System.Drawing.Bitmap(cropRectangle.Width, cropRectangle.Height);
                    using (System.Drawing.Graphics graphic = System.Drawing.Graphics.FromImage(newBmp))
                    {
                        graphic.Clear(System.Drawing.Color.White);
                        graphic.DrawImage(emf, new System.Drawing.Rectangle(0, 0, cropRectangle.Width, cropRectangle.Height), cropRectangle, System.Drawing.GraphicsUnit.Pixel);
                    }
                    outputFile = outputFile.Replace(".emf", ".jpg");
                    newBmp.Save(outputFile, System.Drawing.Imaging.ImageFormat.Jpeg);
                    return outputFile;
                }
                else
                {
                    if (!File.Exists(outputFile))
                    {
                        using (FileStream outputStream = new FileStream(outputFile, fileMode, FileAccess.Write))
                        {
                            int cnt = 0;
                            const int LEN = 4096;
                            byte[] buffer = new byte[LEN];

                            while ((cnt = inputStream.Read(buffer, 0, LEN)) != 0)
                                outputStream.Write(buffer, 0, cnt);
                        }
                    }
                    return outputFile;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

 private static string GetCellValue(SharedStringTable sharedStrings, DocumentFormat.OpenXml.Spreadsheet.Cell cell)
 {
     return cell.DataType != null
                 && cell.DataType.HasValue
                 && cell.DataType == CellValues.SharedString
               ? sharedStrings.ChildElements[
                 int.Parse(cell.CellValue.InnerText)].InnerText
               : cell.CellValue.InnerText;
 }

 public void FindPluginsTest1()
 {
     DocumentFormat documentFormat = new DocumentFormat(); // TODO: Initialize to an appropriate value
     IEnumerable<IPlugin> expected = null; // TODO: Initialize to an appropriate value
     IEnumerable<IPlugin> actual;
     actual = PluginManager.FindPlugins(documentFormat);
     Assert.AreEqual(expected, actual);
     Assert.Inconclusive("Verify the correctness of this test method.");
 }

 public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
 {
     var result = new List<OpenXmlElement>();
     ForEachChild(x =>
     {
         Debug.Assert(x is ListItemFormattedElement);
         result.AddRange(x.ToOpenXmlElements(mainDocumentPart));
     });
     return result;
 }

 public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
 {
     TableRow result = new TableRow();
     ForEachChild(x =>
     {
         Debug.Assert(x is TableCellFormattedElement);
         result.Append(x.ToOpenXmlElements(mainDocumentPart));
     });
     return new List<OpenXmlElement> { result };
 }

 public AddFormatToDocumentDescriptor(
     DocumentDescriptorId aggregateId, 
     DocumentFormat documentFormat, 
     BlobId blobId,
     PipelineId createdById) : base(aggregateId)
 {
     if (aggregateId == null) throw new ArgumentNullException("aggregateId");
     DocumentFormat = documentFormat;
     BlobId = blobId;
     CreatedBy = createdById;
 }

        public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
        {
            var result = new DocumentFormat.OpenXml.Wordprocessing.Run();
            var runProperties = new DocumentFormat.OpenXml.Wordprocessing.RunProperties();
            var boldProperty = new DocumentFormat.OpenXml.Wordprocessing.Bold();

            runProperties.Append(boldProperty);
            result.Append(runProperties);

            ForEachChild(x => result.Append(x.ToOpenXmlElements(mainDocumentPart)));
            return new List<OpenXmlElement> { result };
        }

        public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
        {
            var result = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();

            var paragraphProperties = new ParagraphProperties();

            var numberingProperties = new NumberingProperties();
            var numberingLevelReference = new NumberingLevelReference() { Val = 0 };

            NumberingId numberingId;
            ParagraphStyleId paragraphStyleId;
            if (Parent is OrderedListFormattedElement)
            {
                paragraphStyleId = new ParagraphStyleId() { Val = "NumberedList" };
                numberingId = new NumberingId() { Val = ((OrderedListFormattedElement)Parent).NumberingInstanceId };

                var indentation = new Indentation() { Left = "1440", Hanging = "720" };
                paragraphProperties.Append(indentation);
            }
            else
            {
                paragraphStyleId = new ParagraphStyleId() { Val = "UnorderedListStyle" };
                numberingId = new NumberingId() { Val = 3 };
            }

            numberingProperties.Append(numberingLevelReference);
            numberingProperties.Append(numberingId);

            var spacingBetweenLines= new SpacingBetweenLines() { After = "100", AfterAutoSpacing = true };

            paragraphProperties.Append(paragraphStyleId);
            paragraphProperties.Append(numberingProperties);
            paragraphProperties.Append(spacingBetweenLines);
            result.Append(paragraphProperties);

            ForEachChild(x =>
            {
                if (x is TextFormattedElement)
                {
                    result.Append(
                        new DocumentFormat.OpenXml.Wordprocessing.Run(x.ToOpenXmlElements(mainDocumentPart))
                    );

                }
                else
                {
                    result.Append(x.ToOpenXmlElements(mainDocumentPart));
                }
            });

            return new List<OpenXmlElement> { result };
        }

        public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
        {
            var result = new List<OpenXmlElement>();
            ForEachChild(x =>
            {
                if (x is ParagraphFormattedElement)
                {
                    result.AddRange(x.ToOpenXmlElements(mainDocumentPart));
                }

            });
            return result;
        }

        public static void SetCellValue(WorksheetPart worksheetPart, decimal? value, string columnName, DocumentFormat.OpenXml.Spreadsheet.Row row, out Cell cell)
        {
            cell = GetCell(worksheetPart.Worksheet, columnName, row);

            if (value.HasValue)
            {
                cell.CellValue = new CellValue(value.ToString());
                cell.DataType = new EnumValue<CellValues>(CellValues.Number);
            }
            else
            {
                cell.CellValue = new CellValue();
                cell.DataType = new EnumValue<CellValues>(CellValues.InlineString);
            }
        }

        //Добавление комментария
        public void AddCommentOnParagraph(DocumentFormat.OpenXml.Wordprocessing.Paragraph comPar, string comment)
        {
            DocumentFormat.OpenXml.Wordprocessing.Comments comments = null;
                string id = "0";

                // Verify that the document contains a
                // WordProcessingCommentsPart part; if not, add a new one.
                if (document.MainDocumentPart.GetPartsCountOfType<WordprocessingCommentsPart>() > 0)
                {
                    comments =
                        document.MainDocumentPart.WordprocessingCommentsPart.Comments;
                    if (comments.HasChildren == true)
                    {
                        // Obtain an unused ID.
                        id = comments.Descendants<DocumentFormat.OpenXml.Wordprocessing.Comment>().Select(e => e.Id.Value).Max() + 1;
                    }
                }
                else
                {
                    // No WordprocessingCommentsPart part exists, so add one to the package.
                    WordprocessingCommentsPart commentPart = document.MainDocumentPart.AddNewPart<WordprocessingCommentsPart>();
                    commentPart.Comments = new DocumentFormat.OpenXml.Wordprocessing.Comments();
                    comments = commentPart.Comments;
                }

                // Compose a new Comment and add it to the Comments part.
                DocumentFormat.OpenXml.Wordprocessing.Paragraph p = new DocumentFormat.OpenXml.Wordprocessing.Paragraph(new DocumentFormat.OpenXml.Wordprocessing.Run(new Text(comment)));
                DocumentFormat.OpenXml.Wordprocessing.Comment cmt =
                    new DocumentFormat.OpenXml.Wordprocessing.Comment()
                    {
                        Id = id,
                        Author = "FRChecking System",
                        Date = DateTime.Now
                    };
                cmt.AppendChild(p);
                comments.AppendChild(cmt);
                comments.Save();

                // Specify the text range for the Comment.
                // Insert the new CommentRangeStart before the first run of paragraph.
                comPar.InsertBefore(new CommentRangeStart() { Id = id }, comPar.GetFirstChild<DocumentFormat.OpenXml.Wordprocessing.Run>());

                // Insert the new CommentRangeEnd after last run of paragraph.
                var cmtEnd = comPar.InsertAfter(new CommentRangeEnd() { Id = id }, comPar.Elements<DocumentFormat.OpenXml.Wordprocessing.Run>().Last());

                // Compose a run with CommentReference and insert it.
                comPar.InsertAfter(new DocumentFormat.OpenXml.Wordprocessing.Run(new CommentReference() { Id = id }), cmtEnd);
        }

 /// <summary>
 /// Get the current default file extension for a document type. The method is not aware of the MS Compatibilty pack in 2003 or below
 /// </summary>
 /// <param name="type">target document type</param>
 /// <returns>default extension for document type</returns>
 public string FileExtension(DocumentFormat type)
 {
     switch (type)
     {
         case DocumentFormat.Normal:
             return _owner.ApplicationIs2007OrHigher ? "docx" : "doc";
         case DocumentFormat.Macros:
             return _owner.ApplicationIs2007OrHigher ? "docm" : "doc";
         case DocumentFormat.Template:
             return _owner.ApplicationIs2007OrHigher ? "dotx" : "dot";
         case DocumentFormat.TemplateMacros:
             return _owner.ApplicationIs2007OrHigher ? "dotm" : "dot";
         default:
             throw new ArgumentOutOfRangeException("type");
     }
 }

 public static byte[] GetByteArrayFromDocument(RichEditControl pRichEdit, DocumentFormat pDocFormat)
 {
     byte[] resultByteArray = null;
     try
     {
         using (MemoryStream memStream = new MemoryStream())
         {
             pRichEdit.SaveDocument(memStream, pDocFormat);
             resultByteArray = memStream.ToArray();
         }
     }
     catch (Exception e)
     {
     }
     return resultByteArray;
 }

        public override IEnumerable<OpenXmlElement> ToOpenXmlElements(DocumentFormat.OpenXml.Packaging.MainDocumentPart mainDocumentPart)
        {
            var result = new DocumentFormat.OpenXml.Wordprocessing.Paragraph();
            ForEachChild(x =>
            {
                if (x is TextFormattedElement)
                {
                    result.Append(
                        new DocumentFormat.OpenXml.Wordprocessing.Run(x.ToOpenXmlElements(mainDocumentPart))
                    );

                }
                else
                {
                    result.Append(x.ToOpenXmlElements(mainDocumentPart));
                }
            });
            return new List<OpenXmlElement> { result };
        }

 /// <summary>
 /// Get the current default file extension for a document type. The method is not aware of the MS Compatibilty pack in 2003 or below
 /// </summary>
 /// <param name="type">target document type</param>
 /// <returns>default extension for document type</returns>
 public string FileExtension(DocumentFormat type)
 {
     switch (type)
     {
         case DocumentFormat.Normal:
             return _owner.ApplicationIs2007OrHigher ? "xlsx" : "xls";
         case DocumentFormat.Macros:
             return _owner.ApplicationIs2007OrHigher ? "xlsm" : "xls";
         case DocumentFormat.Template:
             return _owner.ApplicationIs2007OrHigher ? "xltx" : "xlt";
         case DocumentFormat.TemplateMacros:
             return _owner.ApplicationIs2007OrHigher ? "xltm" : "xlt";
         case DocumentFormat.Binary:
             return "xlb";
         case DocumentFormat.AddinMacros:
             return _owner.ApplicationIs2007OrHigher ? "xlam" : "xla";
         default:
             throw new ArgumentOutOfRangeException("type");
     }
 }

        /* External Service vs Internal Implementation Cross-Reference
         * Web API Architecture:
         *      ConfirmationsManager.svc.getConfirmTemplates = ConfirmDocsAPIDal.GetTemplates
         *      ConfirmationsManager.svc.getPermissionKeys = ConfirmMgrAPIDal.GetPermissionKeys
         *      ConfirmationsManager.svc.tradeConfirmationStatusChange = ConfirmMgrAPIDal...
         *      
         *      GetDocument.svc.getConfirmation = ConfirmDocsAPIDal.GetConfirm
         *      GetDocument.svc.getDealsheet = DealsheetAPIDal.GetDealsheet
         *  **********************************************************************************    
         *      CounterParty.svc.getAgreementList = CptyInfoAPIDal...
         *      CounterParty.svc.getDocumentSendTo = CptyInfoAPIDal...
         *      CounterParty.svc.storeDocumentSendTo = CptyInfoAPIDal...
         * 
         * ConfirmManager Architecture:
         *      ConfirmDocsAPIDal.GetTemplates = ConfirmationsManager.svc.getConfirmTemplates
         *      ConfirmDocsAPIDal.GetConfirm = GetDocument.svc.getConfirmation  
         *
         *      ConfirmMgrAPIDal.GetPermissionKeys = ConfirmationsManager.svc.getPermissionKeys
         *      ConfirmMgrAPIDal... = ConfirmationsManager.svc.tradeConfirmationStatusChange
         *      
         *      DealsheetAPIDal.GetDealsheet = GetDocument.svc.getDealsheet
         *  **********************************************************************************          
         *      CptyInfoAPIDal... = CounterParty.svc.getAgreementList 
         *      CptyInfoAPIDal... = CounterParty.svc.getDocumentSendTo 
         *      CptyInfoAPIDal... = CounterParty.svc.storeDocumentSendTo
         * 
        */

        public static bool SaveByteArrayAsPdfFile(byte[] pByteArray, DocumentFormat pDocFormat, string pFileName)
        {
            bool isConversionOk = false;
            RichEditControl richEdit = new RichEditControl();
            try
            {
                using (MemoryStream memStream = new MemoryStream(pByteArray))
                {
                    richEdit.LoadDocument(memStream, pDocFormat);
                    richEdit.ExportToPdf(pFileName);
                }

                isConversionOk = true;
            }
            catch (Exception e)
            {
                isConversionOk = false;
            }
            return isConversionOk;
        }