HiTeachCC/HiTeachCC.Service/PowerPoint/Implement/PowerPointService.cs

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Drawing;
using DocumentFormat.OpenXml.Office2010.Drawing;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Presentation;
using HiTeachCC.Model.PowerPoint;
using HiTeachCC.Service.Core.Implement;
using HiTeachCC.Service.PowerPoint.Interface;
using Microsoft.AspNetCore.Http;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Xml;
using TEAMModelOS.SDK.Context.Constant.Common;
using TEAMModelOS.SDK.Context.Exception;
using TEAMModelOS.SDK.Helper.Common.CollectionHelper;
using TEAMModelOS.SDK.Helper.Common.JsonHelper;
using TEAMModelOS.SDK.Helper.Common.XmlHelper;
using TEAMModelOS.SDK.Helper.Security.ShaHash;
using TEAMModelOS.SDK.Module.AzureBlob.Container;
using TEAMModelOS.SDK.Module.AzureBlob.Interfaces;
using BlipFill = DocumentFormat.OpenXml.Presentation.BlipFill;
using ColorMap = DocumentFormat.OpenXml.Presentation.ColorMap;
using Paragraph = HiTeachCC.Model.PowerPoint.Paragraph;
using Point = HiTeachCC.Model.PowerPoint.Point;
using Shape = HiTeachCC.Model.PowerPoint.Shape;
using Text = HiTeachCC.Model.PowerPoint.Text;
using Theme = DocumentFormat.OpenXml.Drawing.Theme;
using Transform2D = DocumentFormat.OpenXml.Drawing.Transform2D;

namespace HiTeachCC.Service.PowerPoint.Implement
{
    public class PowerPointService : BaseService, IPowerPointService
    {
        private readonly IAzureBlobDBRepository azureBlobDBRepository;

        public PowerPointService(IAzureBlobDBRepository _azureBlobDBRepository)
        {
            azureBlobDBRepository = _azureBlobDBRepository;
        }

        const double inchpixel = 96.00, inchpt = 72.00, pxBase = 914400.00, ptBase = 12700;
        const double rotBase = 60000.00;
        public Dictionary<string, Dictionary<string, string>> styleTable = new Dictionary<string, Dictionary<string, string>>();
        public async Task<Dictionary<string, object>> LoadPresentation(IFormFile file)
        {
            Dictionary<string, object> resdict = new Dictionary<string, object>();

            if (FileType.GetExtention(file.FileName).ToLower().Equals("pptx"))
            {
                await ProcessPPT(file, resdict);
                return resdict;
            }
            else if (FileType.GetExtention(file.FileName).ToLower().Equals("pdf"))
            {
                await ProcessPDF(file, resdict);
                return resdict;
            }
            else
            {
                throw new BizException(500, "file type does not support!");
            }
        }
        /// <summary>
        /// 加载PPTX文件
        /// </summary>
        /// <param name="presentationFile"></param>
        /// <returns></returns>
        public async Task<Dictionary<string, object>> ProcessPPT(IFormFile file, Dictionary<string, object> resdict)
        {
            string shaCode = ShaHashHelper.GetSHA1(file.OpenReadStream());
            using (PresentationDocument presentationDocument = PresentationDocument.Open(file.OpenReadStream(), false))
            {
                if (presentationDocument == null)
                {
                    throw new ArgumentNullException("presentationDocument");
                }
                var thumbnailPart = presentationDocument.ThumbnailPart;
               
                string base64 = "";
                if (thumbnailPart != null) {
                    var contentType = thumbnailPart.ContentType;
                    using (var stream = thumbnailPart.GetStream())
                    {
                        byte[] buffer = new byte[stream.Length];
                        stream.Read(buffer, 0, buffer.Length);
                        stream.Close();
                        base64 = System.Convert.ToBase64String(buffer);
                        base64 = "data:" + contentType + ";base64," + base64;
                    }
                }
                PresentationPart presentationPart = presentationDocument.PresentationPart;
                if (presentationPart != null && presentationPart.Presentation != null)
                {
                    // Get a Presentation object from the PresentationPart object.
                    Presentation presentation = presentationPart.Presentation;
                    int pageSize = 0;
                    var slideMasterParts = presentationPart.SlideMasterParts;
                    ColorMap colorMap = null;
                    SlideMaster slideMaster = null;
                    Theme theme = null;
                    foreach (var slideMasterPart in slideMasterParts)
                    {
                        if (colorMap != null && theme != null)
                        {
                            break;
                        }
                        slideMaster = slideMasterPart.SlideMaster;
                        colorMap = slideMasterPart.SlideMaster.ColorMap;
                        theme = slideMasterPart.ThemePart.Theme;
                        var imgpart = slideMasterPart.ImageParts;
                        if (imgpart != null)
                        {
                            imgpart.ToList().ForEach(yy =>
                            {
                                var bgct = yy.ContentType;
                                string bg64 = "";
                                using (var stream = yy.GetStream())
                                {
                                    byte[] buffer = new byte[stream.Length];
                                    stream.Read(buffer, 0, buffer.Length);
                                    stream.Close();
                                    bg64 = System.Convert.ToBase64String(buffer);
                                    bg64 = "data:" + bgct + ";base64," + bg64;
                                }
                            });
                            //  slideMaster.CommonSlideData.Background.BackgroundProperties;

                            //blipfill blipfill = element.blipfill;
                            //var imagerid = blipfill.blip.embed.value;
                            //idpartpair idparie = slidepart.parts.where(x => x.relationshipid == imagerid).firstordefault();
                            //imagepart imagepart = (imagepart)idparie.openxmlpart;
                            //var contenttype = imagepart.contenttype;
                            //string base64 = "";
                            //using (var stream = imagepart.getstream())
                            //{
                            //    byte[] buffer = new byte[stream.length];
                            //    stream.read(buffer, 0, buffer.length);
                            //    stream.close();
                            //    base64 = system.convert.tobase64string(buffer);
                            //    base64 = "data:" + contenttype + ";base64," + base64;
                            //}

                        }
                    }
                    Dictionary<string, string> slideMasterColors = PowerPointHelper.DoColorMap(null, colorMap, theme);
                    //获取PPT 一页大小
                    double x = presentation.SlideSize.Cx * inchpixel / pxBase;
                    double y = presentation.SlideSize.Cy * inchpixel / pxBase;
                    List<string> slides = new List<string>();
                    string slideMasterXml = slideMaster.OuterXml;
                    Style slideMasterTables = PowerPointHelper.IndexNodes(slideMasterXml);

                    XmlDocument SlideMasterTextStyles = PowerPointHelper.GetSlideMasterTextStyles(slideMasterXml);
                    if (presentation.SlideIdList != null)
                    {

                        //  presentation.SlideIdList.OrderBy(x=>x.);
                        // Get the title of each slide in the slide order.
                        // 获取的是几页PPT数量
                        foreach (var slideId in presentation.SlideIdList.Elements<SlideId>())
                        {

                            // HiTeachCC.Model.PowerPoint.Slide slide = new HiTeachCC.Model.PowerPoint.Slide();
                            // 获取这一页 PPT 的id 
                            string id = slideId.RelationshipId;
                            SlidePart slidePart = presentationPart.GetPartById(slideId.RelationshipId) as SlidePart;
                            //获取当前页 PPT 的所有元素
                            // slide.Items = GetSlideElement(slidePart, theme, colorMap);
                            //slide.Xml = slidePart.Slide.OuterXml;
                            var slide10 = slidePart.Slide;
                            HiTeachCC.Model.PowerPoint.Slide slide = GetSlideElement(slidePart, slideMaster, slideMasterColors, theme, slideMasterTables, SlideMasterTextStyles, pageSize);
                            slide.Width = x;
                            slide.Height = y;

                            XmlDocument xml = Newtonsoft.Json.JsonConvert.DeserializeXmlNode(slide.ToJson(), "Slide");
                            string result = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>" +
                                @"<?xml-stylesheet type=""text/xsl"" href=""hixml2html.xsl""?>" +
                                xml.OuterXml;
                            AzureBlobModel amodel = await azureBlobDBRepository.UploadTextByFolder(result, shaCode, (pageSize + 1) + ".xml", "pptx", false);
                            slides.Add(amodel.BlobUrl);
                            pageSize++;
                        }
                    }
                    Pptx info = new Pptx { HiXmls = slides, Width = x, Height = y, PageSize = pageSize, Thumbnail = base64, Sha1Code = shaCode };
                    AzureBlobModel model = await azureBlobDBRepository.UploadFileByFolder(file.OpenReadStream(), shaCode, shaCode + ".pptx", "pptx", false);
                    info.PptUrl = model.BlobUrl;
                    resdict.Add("pptx", info);
                    resdict.Add("type", "pptx");
                    return resdict;
                }
                return null;
            }
        }
        /// <summary>
        /// 处理图形非可视化信息
        /// </summary>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="slideMasterColors"></param>
        /// <param name="theme"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public HiTeachCC.Model.PowerPoint.Slide GetSlideElement(SlidePart slidePart, SlideMaster slideMaster,
            Dictionary<string, string> slideMasterColors, Theme theme,
            Style slideMasterTables, XmlDocument SlideMasterTextStyles, int pageSize)
        {

            Model.PowerPoint.Slide slide = new Model.PowerPoint.Slide() { Index = pageSize };
            //用Layout colorMap覆盖 master ColorMap 
            slideMasterColors = PowerPointHelper.GetLayoutOrMasterColors(slidePart, slideMasterColors, theme);
            //slidePart.SlideLayoutPart;
            HiTeachCC.Model.PowerPoint.Fill bgFill = PowerPointHelper.GetSlideBackgroundFill(slidePart, slideMaster, slideMasterColors, theme);
            string slideLayoutXml = slidePart.SlideLayoutPart.SlideLayout.OuterXml;

            var slideLayoutTables = PowerPointHelper.IndexNodes(slideLayoutXml);

            var shapeTrees = from shap in slidePart.Slide.Descendants<ShapeTree>() select shap;
            if (shapeTrees.Count() > 0 && shapeTrees.First().ChildElements.Count > 0)
            {
                OpenXmlElementList openXmlElements = shapeTrees.First().ChildElements;
                //TransformGroup transformGroup = shapeTrees.First().GroupShapeProperties.TransformGroup;
                //HiTeachCC.Model.PowerPoint.Position position = new
                //HiTeachCC.Model.PowerPoint.Position();
                //position.Rot = transformGroup.Rotation == null ? 0 : transformGroup.Rotation.Value;
                //position.FlipH = transformGroup.HorizontalFlip == null ? 0 : transformGroup.HorizontalFlip.Value == true ? 1 : 0;
                //position.FlipV = transformGroup.VerticalFlip == null ? 0 : transformGroup.VerticalFlip.Value == true ? 1 : 0;
                //position.X = transformGroup.Offset.X == null ? 0 : transformGroup.Offset.X.Value;
                //position.Y = transformGroup.Offset.Y == null ? 0 : transformGroup.Offset.Y.Value;
                //position.Cx = transformGroup.Extents.Cx == null ? 0 : transformGroup.Extents.Cx.Value;
                //position.Cy = transformGroup.Extents.Cy == null ? 0 : transformGroup.Extents.Cy.Value;
                //position.ChX = transformGroup.ChildOffset.X == null ? 0 : transformGroup.ChildOffset.X.Value;
                //position.ChY = transformGroup.ChildOffset.Y == null ? 0 : transformGroup.ChildOffset.Y.Value;
                //position.ChCX = transformGroup.ChildExtents.Cx == null ? 0 : transformGroup.ChildExtents.Cx.Value;
                //position.ChCY = transformGroup.ChildExtents.Cy == null ? 0 : transformGroup.ChildExtents.Cy.Value;
                int index = 0;
                foreach (OpenXmlElement element in openXmlElements)
                {
                    if (element is DocumentFormat.OpenXml.Presentation.NonVisualGroupShapeProperties np || element is DocumentFormat.OpenXml.Presentation.GroupShapeProperties gp)
                    {
                        continue;
                    }

                    List<Item> list = new List<Item>();
                    ProcessNodesInSlide(list, element, slidePart.Parts, slideMaster, slideMasterColors, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme, slidePart, false);
                    slide.Items.AddRange(list);

                    index++;
                }
            }
            var layOutshapeTrees = from shap in slidePart.SlideLayoutPart.SlideLayout.Descendants<ShapeTree>() select shap;
            if (layOutshapeTrees.Count() > 0 && layOutshapeTrees.First().ChildElements.Count > 0)
            {
                OpenXmlElementList openXmlElements = layOutshapeTrees.First().ChildElements;
                //TransformGroup transformGroup = shapeTrees.First().GroupShapeProperties.TransformGroup;
                //HiTeachCC.Model.PowerPoint.Position position = new
                //HiTeachCC.Model.PowerPoint.Position();
                //position.Rot = transformGroup.Rotation == null ? 0 : transformGroup.Rotation.Value;
                //position.FlipH = transformGroup.HorizontalFlip == null ? 0 : transformGroup.HorizontalFlip.Value == true ? 1 : 0;
                //position.FlipV = transformGroup.VerticalFlip == null ? 0 : transformGroup.VerticalFlip.Value == true ? 1 : 0;
                //position.X = transformGroup.Offset.X == null ? 0 : transformGroup.Offset.X.Value;
                //position.Y = transformGroup.Offset.Y == null ? 0 : transformGroup.Offset.Y.Value;
                //position.Cx = transformGroup.Extents.Cx == null ? 0 : transformGroup.Extents.Cx.Value;
                //position.Cy = transformGroup.Extents.Cy == null ? 0 : transformGroup.Extents.Cy.Value;
                //position.ChX = transformGroup.ChildOffset.X == null ? 0 : transformGroup.ChildOffset.X.Value;
                //position.ChY = transformGroup.ChildOffset.Y == null ? 0 : transformGroup.ChildOffset.Y.Value;
                //position.ChCX = transformGroup.ChildExtents.Cx == null ? 0 : transformGroup.ChildExtents.Cx.Value;
                //position.ChCY = transformGroup.ChildExtents.Cy == null ? 0 : transformGroup.ChildExtents.Cy.Value;
                int index = 0;
                foreach (OpenXmlElement element in openXmlElements)
                {
                    if (element is DocumentFormat.OpenXml.Presentation.NonVisualGroupShapeProperties np || element is DocumentFormat.OpenXml.Presentation.GroupShapeProperties gp)
                    {
                        continue;
                    }

                    List<Item> list = new List<Item>();
                    ProcessNodesInSlide(list, element, slidePart.SlideLayoutPart.Parts, slideMaster, slideMasterColors, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme, slidePart, true);
                    slide.Items.AddRange(list);
                    index++;
                }
            }
            slide.Fill = bgFill;
            return slide;
        }
        /// <summary>
        /// 单个元素分类
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="slideMasterColors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public void ProcessNodesInSlide(List<Item> list, OpenXmlElement element,
            IEnumerable<IdPartPair> idPartPairs,
            SlideMaster slideMaster,
            Dictionary<string, string> colorMaps,
            int index,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument SlideMasterTextStyles, Theme theme, SlidePart slidePart, bool isLayOut)
        {

            if (element is DocumentFormat.OpenXml.Presentation.Picture pic)//p:pic  图片
            {
                list.Add(ProcessPicNode(pic, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme));
            }
            else if (element is DocumentFormat.OpenXml.AlternateContent mc)//mc:alternatecontent   公式等 
            {
                list.Add(ProcessMcNode(mc, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme));
            }
            else if (element is DocumentFormat.OpenXml.Presentation.GraphicFrame graphicFrame)//p:graphicFrame   Chart, Diagram, Table
            {
                list.Add(ProcessGraphicFrameNode(graphicFrame, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme));
            }
            else if (element is DocumentFormat.OpenXml.Presentation.GroupShape grpSp)//p:grpSp  组合图形
            {
                ProcessGrpSpNode(list, grpSp, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme, slidePart);
            }
            else if (element is DocumentFormat.OpenXml.Presentation.ConnectionShape cxnSp) // p:cxnSp  连接线
            {
                list.Add(ProcessCxnSpNode(cxnSp, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme));
            }
            else if (element is DocumentFormat.OpenXml.Presentation.Shape sp)//p:sp  形状
            {
                if (isLayOut)
                {
                    XmlDocument doc = new XmlDocument();
                    doc.LoadXml(element.OuterXml);
                    XmlNode userDrawnNode = doc.SelectSingleNode("//p:nvPr//@userDrawn", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    //处理模板中有无背编辑过的元素
                    if (userDrawnNode != null && userDrawnNode.Value.Equals("1"))
                    {
                        list.Add(ProcessSpNode(sp, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme, slidePart));
                    }
                }
                else
                {
                    list.Add(ProcessSpNode(sp, idPartPairs, slideMaster, colorMaps, index, slideLayoutTables, slideMasterTables, SlideMasterTextStyles, theme, slidePart));
                }

            }
        }


        /// <summary>
        /// 处理Shape的样式 位置信息
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public HiTeachCC.Model.PowerPoint.Shape ProcessSpNode(DocumentFormat.OpenXml.Presentation.Shape element, IEnumerable<IdPartPair> idPartPairs, SlideMaster slideMaster,
            Dictionary<string, string> colors, int index,
            //HiTeachCC.Model.PowerPoint.Position position,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme, SlidePart slidePart)
        {

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(element.OuterXml);
            //获取当前节点的相关样式属性
            XmlNode idNode = doc.SelectSingleNode("//p:nvSpPr/p:cNvPr/@id", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            XmlNode nameNode = doc.SelectSingleNode("//p:nvSpPr/p:cNvPr/@name", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            XmlNode idxNode = doc.SelectSingleNode("//p:nvSpPr/p:nvPr/p:ph/@idx", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            XmlNode typeNode = doc.SelectSingleNode("//p:nvSpPr/p:nvPr/p:ph/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            XmlDocument slideLayoutSpNode = null;
            XmlDocument slideMasterSpNode = null;
            if (typeNode != null)
            {

                //  检查 slideLayoutSpNode slideMasterSpNode 为空时产生的位置 横竖排版 空指针问题


                //slideLayoutSpNode = slideLayoutTables.TypeTable;
                //slideMasterSpNode = slideMasterTables.TypeTable;


                doc.LoadXml(slideLayoutTables.TypeTable.OuterXml);
                XmlNodeList types = doc.SelectNodes("//xmlDatas/xmlData", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                if (types != null)
                {
                    int size = types.Count;
                    for (int i = 0; i < size; i++)
                    {
                        XmlNode node = types.Item(i);
                        doc.LoadXml(node.OuterXml);
                        XmlNode id = doc.SelectSingleNode("./xmlData/@id", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                        if (id.Value.Equals(typeNode.Value))
                        {
                            XmlDocument nodeDoc = new XmlDocument();
                            nodeDoc.LoadXml(types.Item(i).OuterXml);
                            slideLayoutSpNode = nodeDoc;
                            break;
                        }
                    }
                }
                doc.LoadXml(slideMasterTables.TypeTable.OuterXml);
                types = doc.SelectNodes("//xmlDatas/xmlData", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                if (types != null)
                {
                    int size = types.Count;
                    for (int i = 0; i < size; i++)
                    {
                        XmlNode node = types.Item(i);
                        doc.LoadXml(node.OuterXml);
                        XmlNode id = doc.SelectSingleNode("./xmlData/@id", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                        if (id.Value.Equals(typeNode.Value))
                        {
                            XmlDocument nodeDoc = new XmlDocument();
                            nodeDoc.LoadXml(types.Item(i).OuterXml);
                            slideMasterSpNode = nodeDoc;
                            break;
                        }
                    }
                }
            }
            else
            {
                if (idxNode != null)
                {
                    //slideLayoutSpNode = slideLayoutTables.IdxTable;
                    //slideMasterSpNode = slideMasterTables.IdxTable;
                    doc.LoadXml(slideLayoutTables.IdxTable.OuterXml);
                    XmlNodeList types = doc.SelectNodes("//xmlDatas/xmlData", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    if (types != null)
                    {
                        int size = types.Count;
                        for (int i = 0; i < size; i++)
                        {
                            XmlNode node = types.Item(i);
                            doc.LoadXml(node.OuterXml);
                            XmlNode id = doc.SelectSingleNode("./xmlData/@id", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                            if (id.Value.Equals(idxNode.Value))
                            {
                                XmlDocument nodeDoc = new XmlDocument();
                                nodeDoc.LoadXml(types.Item(i).OuterXml);
                                slideLayoutSpNode = nodeDoc;
                                break;
                            }
                        }
                    }
                    doc.LoadXml(slideMasterTables.IdxTable.OuterXml);
                    types = doc.SelectNodes("//xmlDatas/xmlData", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    if (types != null)
                    {
                        int size = types.Count;
                        for (int i = 0; i < size; i++)
                        {
                            XmlNode node = types.Item(i);
                            doc.LoadXml(node.OuterXml);
                            XmlNode id = doc.SelectSingleNode("./xmlData/@id", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                            if (id.Value.Equals(idxNode.Value))
                            {
                                XmlDocument nodeDoc = new XmlDocument();
                                nodeDoc.LoadXml(types.Item(i).OuterXml);
                                slideMasterSpNode = nodeDoc;
                                break;
                            }
                        }
                    }
                }
            }
            if (typeNode == null)
            {
                if (slideLayoutSpNode != null)
                {
                    typeNode = slideLayoutSpNode.SelectSingleNode("//p:nvSpPr/p:nvPr/p:ph/@type", PowerPointHelper.GetXmlnsManager(slideLayoutSpNode.NameTable));
                }
                //getTextByPathList(slideLayoutSpNode, ["p:nvSpPr", "p:nvPr", "p:ph", "attrs", "type"]);
                if (typeNode == null)
                {
                    if (slideMasterSpNode != null)
                    {
                        typeNode = slideMasterSpNode.SelectSingleNode("//p:nvSpPr/p:nvPr/p:ph/@type", PowerPointHelper.GetXmlnsManager(slideMasterSpNode.NameTable));
                    }
                    // typeNode = getTextByPathList(slideMasterSpNode, ["p:nvSpPr", "p:nvPr", "p:ph", "attrs", "type"]);
                }
            }
            HiTeachCC.Model.PowerPoint.Shape s = GenShape(element, idPartPairs, slideMaster, colors, index, slideLayoutTables,
                slideMasterTables, idNode, nameNode, idxNode, typeNode, slideLayoutSpNode, slideMasterSpNode, slideMasterTextStyles, theme, slidePart);
            return s;
        }
        /// <summary>
        /// 处理图形的具体信息
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <param name="idNode"></param>
        /// <param name="nameNode"></param>
        /// <param name="idxNode"></param>
        /// <param name="typeNode"></param>
        /// <param name="slideLayoutSpNode"></param>
        /// <param name="slideMasterSpNode"></param>
        /// <returns></returns>
        public HiTeachCC.Model.PowerPoint.Shape GenShape(DocumentFormat.OpenXml.Presentation.Shape element, IEnumerable<IdPartPair> idPartPairs, SlideMaster slideMaster,
           Dictionary<string, string> colors, int index,
           //HiTeachCC.Model.PowerPoint.Position position,
           Style slideLayoutTables,
           Style slideMasterTables, XmlNode idNode, XmlNode nameNode, XmlNode idxNode, XmlNode typeNode,
           XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode, XmlDocument slideMasterTextStyles, Theme theme, SlidePart slidePart)
        {

            HiTeachCC.Model.PowerPoint.Shape shape = new HiTeachCC.Model.PowerPoint.Shape();
            HiTeachCC.Model.PowerPoint.Position spPosition = null;
            if (element.ShapeProperties != null)
            {
                Transform2D transform2D = element.ShapeProperties.Transform2D;
                if (transform2D != null)
                {
                    spPosition = PowerPointHelper.GetPositionByTransform2D(transform2D);
                }
            }
            DocumentFormat.OpenXml.Presentation.NonVisualShapeProperties nonVisualShapeProperties = element.NonVisualShapeProperties;

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(element.OuterXml);
            XmlNode shapeType = doc.SelectSingleNode("//p:spPr/a:prstGeom/@prst", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            if (shapeType != null)
            {
                //常规图形
                HiTeachCC.Model.PowerPoint.Position shapePosition = PowerPointHelper.GetPosition(element.OuterXml, slideLayoutSpNode, slideMasterSpNode);
                Border border = PowerPointHelper.GetBorder(element.OuterXml, false, colors);
                HiTeachCC.Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(element.OuterXml, colors);
                //var headEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:headEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                // var tailEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:tailEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                PowerPointHelper.GenPPTXShape(shapeType);
                // shapePosition.Index = index;
                shape.Position = shapePosition;
                shape.Paragraph = GenTextBody(element.OuterXml, slideLayoutSpNode, slideMasterSpNode, typeNode, slideLayoutTables, slideMasterTables, slideMasterTextStyles, theme, idPartPairs, colors, slidePart);
                shape.Fill = fill;
                shape.Border = border;
                shape.Type = "Sp";
                shape.ShapeType = shapeType.Value;
                shape.Index = index++;
                // shape.VertAlign = PowerPointHelper.GetVerticalAlign(element, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                XmlNode avLstNode = doc.SelectSingleNode("//p:spPr/a:prstGeom/a:avLst", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                shape.ShapeGuides = GenShapeGuide(avLstNode);
                return shape;
            }
            else
            {
                shapeType = doc.SelectSingleNode("//p:spPr/a:custGeom", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                if (shapeType != null)
                {
                    //自定义图形 画线 轨迹

                    //常规图形
                    HiTeachCC.Model.PowerPoint.Position shapePosition = PowerPointHelper.GetPosition(element.OuterXml, slideLayoutSpNode, slideMasterSpNode);
                    Border border = PowerPointHelper.GetBorder(element.OuterXml, false, colors);
                    HiTeachCC.Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(element.OuterXml, colors);
                    var headEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:headEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    var tailEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:tailEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    PowerPointHelper.GenPPTXShape(shapeType);
                    shape.Position = shapePosition;
                    shape.Paragraph = GenTextBody(element.OuterXml, slideLayoutSpNode, slideMasterSpNode, typeNode,
                        slideLayoutTables, slideMasterTables, slideMasterTextStyles, theme, idPartPairs, colors, slidePart);
                    shape.Fill = fill;
                    shape.Border = border;
                    shape.Type = "Sp";
                    shape.ShapeType = "custom";
                    shape.Index = index++;
                    //shape.VertAlign = PowerPointHelper.GetVerticalAlign(element, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                    var pathNode = doc.SelectSingleNode("//p:spPr/a:custGeom/a:pathLst/a:path", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                    shape.Paths = GenPath(pathNode.OuterXml);
                    return shape;
                }
                else
                {
                    // string align = PowerPointHelper.GetVerticalAlign(element, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                    HiTeachCC.Model.PowerPoint.Position shapePosition = PowerPointHelper.GetPosition(element.OuterXml, slideLayoutSpNode, slideMasterSpNode);
                    Border border = PowerPointHelper.GetBorder(element.OuterXml, false, colors);
                    HiTeachCC.Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(element.OuterXml, colors);
                    shape.Position = shapePosition;
                    shape.Paragraph = GenTextBody(element.OuterXml, slideLayoutSpNode, slideMasterSpNode, typeNode,
                        slideLayoutTables, slideMasterTables, slideMasterTextStyles, theme, idPartPairs, colors, slidePart);
                    shape.Fill = fill;
                    shape.Border = border;
                    shape.Type = "Sp";
                    shape.ShapeType = "rect";
                    shape.Index = index++;
                    // shape.VertAlign = PowerPointHelper.GetVerticalAlign(element, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                    return shape;

                }
            }
            //return null;
        }
        public List<HiTeachCC.Model.PowerPoint.ShapeGuide> GenShapeGuide(XmlNode avLstNode)
        {
            if (avLstNode != null)
            {
                AdjustValueList adjustValueList = new AdjustValueList(avLstNode.OuterXml);
                List<HiTeachCC.Model.PowerPoint.ShapeGuide> ShapeGuides = new List<Model.PowerPoint.ShapeGuide>();
                var elements = adjustValueList.ChildElements;
                foreach (var xmlElement in elements)
                {
                    if (xmlElement is DocumentFormat.OpenXml.Drawing.ShapeGuide shapeGuide)
                    {
                        HiTeachCC.Model.PowerPoint.ShapeGuide ShapeGuide = new HiTeachCC.Model.PowerPoint.ShapeGuide { Name = shapeGuide.Name, Fmla = shapeGuide.Formula };
                        ShapeGuides.Add(ShapeGuide);
                    }
                }
                return ShapeGuides;
            }
            return null;

        }

        public List<HiTeachCC.Model.PowerPoint.Path> GenPath(string nodeXml)
        {
            DocumentFormat.OpenXml.Drawing.Path path = new DocumentFormat.OpenXml.Drawing.Path(nodeXml);
            OpenXmlElementList elements = path.ChildElements;
            List<HiTeachCC.Model.PowerPoint.Path> Paths = new List<Model.PowerPoint.Path>();
            foreach (OpenXmlElement xmlElement in elements)
            {
                //起点
                if (xmlElement is DocumentFormat.OpenXml.Drawing.MoveTo moveTo)
                {
                    DocumentFormat.OpenXml.Drawing.Point point = moveTo.Point;
                    MoveToPath moveToPath = new MoveToPath { Type = "MoveTo" };
                    moveToPath.Pts.Add(new Point { X = double.Parse(point.X) * inchpixel / pxBase, Y = double.Parse(point.Y) * inchpixel / pxBase });
                    Paths.Add(moveToPath);
                }
                //连线
                if (xmlElement is DocumentFormat.OpenXml.Drawing.LineTo linTo)
                {
                    DocumentFormat.OpenXml.Drawing.Point point = linTo.Point;
                    LineToPath lineToPath = new LineToPath { Type = "LineTo" };
                    lineToPath.Pts.Add(new Point { X = double.Parse(point.X) * inchpixel / pxBase, Y = double.Parse(point.Y) * inchpixel / pxBase });
                    Paths.Add(lineToPath);
                }
                //三次贝塞尔曲线
                if (xmlElement is DocumentFormat.OpenXml.Drawing.CubicBezierCurveTo cubicBezierCurveTo)
                {
                    OpenXmlElementList list = cubicBezierCurveTo.ChildElements;
                    CubicBezPath cubicBezPath = new CubicBezPath { Type = "CubicBez" };
                    foreach (var ls in list)
                    {
                        if (ls is DocumentFormat.OpenXml.Drawing.Point point)
                        {
                            cubicBezPath.Pts.Add(new Point { X = double.Parse(point.X) * inchpixel / pxBase, Y = double.Parse(point.Y) * inchpixel / pxBase });
                        }
                    }
                    Paths.Add(cubicBezPath);
                }
                //二次贝塞尔曲线
                if (xmlElement is DocumentFormat.OpenXml.Drawing.QuadraticBezierCurveTo quadraticBezierCurveTo)
                {
                    OpenXmlElementList list = quadraticBezierCurveTo.ChildElements;
                    QuadBezPath quadBezPath = new QuadBezPath { Type = "QuadBez" };
                    foreach (var ls in list)
                    {
                        if (ls is DocumentFormat.OpenXml.Drawing.Point point)
                        {
                            quadBezPath.Pts.Add(new Point { X = double.Parse(point.X) * inchpixel / pxBase, Y = double.Parse(point.Y) * inchpixel / pxBase });

                        }
                    }
                    Paths.Add(quadBezPath);
                }
                //处理曲线
                if (xmlElement is DocumentFormat.OpenXml.Drawing.ArcTo arcTO)
                {
                    ArcToPath arcToPath = new ArcToPath() { WidthRadius = arcTO.WidthRadius, HeightRadius = arcTO.HeightRadius, StartAngle = arcTO.StartAngle, SwingAngle = arcTO.SwingAngle };
                    Paths.Add(arcToPath);
                }
                ///判断路径是否闭合
                if (xmlElement is DocumentFormat.OpenXml.Drawing.CloseShapePath close)
                {
                    if (close != null)
                    {
                        ClosePath closePath = new ClosePath { Type = "Close" };
                        closePath.Close = true;
                        Paths.Add(closePath);
                    }
                }
            }
            return Paths;
        }


        public List<Paragraph> GenTextBody(string nodeXml, XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode,
            XmlNode typeNode, Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme, IEnumerable<IdPartPair> idPartPairs, Dictionary<string, string> colors, SlidePart slidePart)
        {
            List<Paragraph> paragraphs = new List<Paragraph>();
            XmlDocument doc = new XmlDocument();
            doc.LoadXml(nodeXml);
            XmlNodeList pNodes = doc.SelectNodes("//p:txBody/child::* ", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            XmlNodeList plvlNodes = doc.SelectNodes("//p:txBody/a:p/a:pPr/@lvl", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            bool hasBuChar = false;
            if (plvlNodes != null && plvlNodes.Count > 0)
            {
                hasBuChar = true;
            }
            if (pNodes != null)
            {
                int size = pNodes.Count;
                for (int i = 0; i < size; i++)
                {
                    XmlNode pNode = pNodes.Item(i);
                    if (!pNode.Name.Equals("a:p"))
                    {
                        continue;
                    }
                    XmlDocument pXmlNode = new XmlDocument();
                    pXmlNode.LoadXml(pNode.OuterXml);
                    //XmlDocument docNode = new XmlDocument();
                    //docNode.LoadXml(pNode.OuterXml);
                    string HorizontalAlign = PowerPointHelper.GetHorizontalAlign(pXmlNode, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                    string VerticalAlign = PowerPointHelper.GetVerticalAlign(nodeXml, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
                    Paragraph paragraph = new Paragraph();
                    ParagraphStyle paragraphStyle = new ParagraphStyle { HoriAlign = HorizontalAlign, VertAlign = VerticalAlign };
                    XmlNodeList pPrNodes = pXmlNode.SelectNodes("//a:pPr", PowerPointHelper.GetXmlnsManager(pXmlNode.NameTable));
                    BuChar buChar = PowerPointHelper.GenBuChar(pXmlNode, slideLayoutTables, slideMasterTables, slideMasterTextStyles, typeNode, hasBuChar);
                    paragraph.BuChar = buChar;
                    paragraph.ParagraphStyle = paragraphStyle;
                    XmlNodeList rNodes = pXmlNode.SelectNodes("//a:r", PowerPointHelper.GetXmlnsManager(pXmlNode.NameTable));
                    if (null == rNodes)
                    {
                        XmlDocument rNode = new XmlDocument();
                        rNode.LoadXml(pNode.OuterXml);
                        paragraph.Texts.Add(GenSpanElement(rNode, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles, theme, idPartPairs, colors, buChar, slidePart));
                    }
                    else
                    {
                        int rsize = rNodes.Count;
                        for (int ri = 0; ri < rsize; ri++)
                        {
                            XmlDocument rNode = new XmlDocument();
                            rNode.LoadXml(rNodes.Item(ri).OuterXml);
                            paragraph.Texts.Add(GenSpanElement(rNode, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles, theme, idPartPairs, colors, buChar, slidePart));
                        }
                    }
                    paragraphs.Add(paragraph);
                }
            }
            return paragraphs;
        }


        public Text GenSpanElement(XmlDocument nodeXml, XmlDocument slideLayoutSpNode, XmlDocument slideMasterSpNode, XmlNode typeNode,
            XmlDocument slideMasterTextStyles, Theme theme, IEnumerable<IdPartPair> idPartPairs, Dictionary<string, string> colors, BuChar buChar, SlidePart slidePart)
        {
            XmlNode tNode = nodeXml.SelectSingleNode("//a:t", PowerPointHelper.GetXmlnsManager(nodeXml.NameTable));
            /*
            var text = node["a:t"];
            if (typeof text !== 'string') {
                text = getTextByPathList(node, ["a:fld", "a:t"]);
                if (typeof text !== 'string') {
                    text = "&nbsp;";
                    //debug("XXX: " + JSON.stringify(node));
                }
            }
             */
            string color = PowerPointHelper.GetFontColor(nodeXml, typeNode, slideMasterTextStyles, colors);
            int font_size = PowerPointHelper.GetFontSize(nodeXml, slideLayoutSpNode, slideMasterSpNode, typeNode, slideMasterTextStyles);
            if (font_size == 0 && buChar != null)
            {
                font_size = buChar.FontSize;
            }
            string font_family = PowerPointHelper.GetFontType(nodeXml, typeNode, slideMasterTextStyles, theme);
            string font_weight = PowerPointHelper.GetFontBold(nodeXml, typeNode, slideMasterTextStyles);
            string font_style = PowerPointHelper.GetFontItalic(nodeXml, typeNode, slideMasterTextStyles);
            string text_decoration = PowerPointHelper.GetFontDecoration(nodeXml, typeNode, slideMasterTextStyles);
            string vertical_align = PowerPointHelper.GetTextVerticalAlign(nodeXml, typeNode, slideMasterTextStyles);
            FontStyle fontStyle = new FontStyle
            {
                Color = color,
                Size = font_size,
                Type = font_family,
                Bold = font_weight,
                Italic = font_style,
                Decoration = text_decoration,
                VertAlign = vertical_align
            };
            string styleText = "color:" + color + ";font-size:" + font_size +
                ";font-family:" + font_family + ";font-weight:" + font_weight +
                ";font-style:" + font_style + ";text-decoration:" + text_decoration +
                ";vertical-align:" + vertical_align;
            string cssName = "";
            if (styleTable.TryGetValue(styleText, out Dictionary<string, string> css))
            {
                cssName = css["name"];
            }
            else
            {
                cssName = "_css_" + (styleTable.Keys.Count + 1);
                styleTable.TryAdd(styleText, new Dictionary<string, string> { { "name", cssName }, { "text", styleText } });
            }

            Text text = new Text { Content = tNode.InnerText, FontStyle = fontStyle };
            XmlNode linkID = nodeXml.SelectSingleNode("//a:rPr/a:hlinkClick/@r:id", PowerPointHelper.GetXmlnsManager(nodeXml.NameTable));
            if (linkID != null)
            {
                List<DocumentFormat.OpenXml.Packaging.HyperlinkRelationship> hyperlinkRelationships = slidePart.HyperlinkRelationships.ToList();
                bool flag = true;
                foreach (var HyperlinkRelationship in hyperlinkRelationships)
                {
                    if (HyperlinkRelationship.Id.Equals(linkID.Value))
                    {
                        text.Href = HyperlinkRelationship.Uri.ToString();
                        flag = false;
                        break;
                    }
                }
                if (flag)
                {
                    text.Href = "#";
                }
            }
            else
            {
                text.Href = null;
            }
            return text;
        }
        /// <summary>
        /// 处理图片
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public Model.PowerPoint.Picture ProcessPicNode(DocumentFormat.OpenXml.Presentation.Picture element,
            IEnumerable<IdPartPair> idPartPairs, SlideMaster slideMaster, Dictionary<string, string> colors, int index,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme)
        {

            HiTeachCC.Model.PowerPoint.Position picPosition = PowerPointHelper.GetPosition(element.OuterXml, null, null);
            //picPosition.Index = index;
            BlipFill blipFill = element.BlipFill;
            var imageRid = blipFill.Blip.Embed.Value;
            IdPartPair idParie = idPartPairs.Where(x => x.RelationshipId == imageRid).FirstOrDefault();
            ImagePart imagePart = (ImagePart)idParie.OpenXmlPart;
            var contentType = imagePart.ContentType;
            string base64 = "";
            using (var stream = imagePart.GetStream())
            {
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                stream.Close();
                base64 = System.Convert.ToBase64String(buffer);
                base64 = "data:" + contentType + ";base64," + base64;
            }

            Border border = PowerPointHelper.GetBorder(element.OuterXml, false, colors);
            Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(element.OuterXml, colors);
            Model.PowerPoint.Picture picture = new Model.PowerPoint.Picture
            {
                Type = "Pic",
                Position = picPosition,
                Base64 = base64,
                Fill = fill,
                Border = border
            };
            picture.Index = index++;
            return picture;
        }

        /// <summary>
        /// 处理包含公式等的信息
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public Model.PowerPoint.Picture ProcessMcNode(DocumentFormat.OpenXml.AlternateContent element, IEnumerable<IdPartPair> slidePart,
            SlideMaster slideMaster, Dictionary<string, string> colors,
            int index,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme)
        {
            var choices = from contentChoice in element.Descendants<AlternateContentChoice>() select contentChoice;
            if (choices.Count() > 0)
            {
                OpenXmlElement celement = choices.First().ChildElements.First();
                if (celement != null)
                {
                    if (celement is DocumentFormat.OpenXml.Presentation.Shape shape)
                    {
                        var textMaths = from shap in shape.Descendants<TextMath>() select shap;
                        if (textMaths.Count() > 0)
                        {
                            //  return MathConvertMathML(shape, theme, colorMap, index);
                            return MathConvertImage(element, theme, colors, slidePart, index);
                        }
                    }
                }
            }
            return null;
        }


        public Model.PowerPoint.Picture MathConvertImage(AlternateContent content, Theme theme, Dictionary<string, string> colors, IEnumerable<IdPartPair> slidePart, int index)
        {
            var fallbacks = from contentChoice in content.Descendants<AlternateContentFallback>() select contentChoice;
            if (fallbacks.Count() > 0)
            {
                OpenXmlElement xmlElement = fallbacks.First().ChildElements.First();
                if (xmlElement != null)
                {
                    if (xmlElement is DocumentFormat.OpenXml.Presentation.Shape shape)
                    {
                        var blipFills = from pic in shape.Descendants<DocumentFormat.OpenXml.Drawing.BlipFill>() select pic;
                        if (blipFills.Count() > 0)
                        {
                            var imageRid = blipFills.First().Blip.Embed.Value;
                            IdPartPair idParie = slidePart.Where(x => x.RelationshipId == imageRid).FirstOrDefault();
                            ImagePart imagePart = (ImagePart)idParie.OpenXmlPart;
                            var contentType = imagePart.ContentType;
                            string base64 = "";
                            using (var stream = imagePart.GetStream())
                            {
                                byte[] buffer = new byte[stream.Length];
                                stream.Read(buffer, 0, buffer.Length);
                                stream.Close();
                                base64 = System.Convert.ToBase64String(buffer);
                                base64 = "data:" + contentType + ";base64," + base64;
                            }

                            Model.PowerPoint.Position picPosition = PowerPointHelper.GetPosition(shape.OuterXml, null, null);
                            Border border = PowerPointHelper.GetBorder(shape.OuterXml, false, colors);
                            Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(shape.OuterXml, colors);
                            //  picPosition.Index = index;
                            Model.PowerPoint.Picture picture = new Model.PowerPoint.Picture
                            {
                                Type = "Math",
                                Position = picPosition,
                                Base64 = base64,
                                Fill = fill,
                                Border = border
                            };
                            picture.Index = index++;
                            return picture;
                        }
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 处理复杂图形的
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public Item ProcessGraphicFrameNode(DocumentFormat.OpenXml.Presentation.GraphicFrame graphicFrame,
            IEnumerable<IdPartPair> slidePart, SlideMaster slideMaster, Dictionary<string, string> colors,
            int index,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme)
        {
            DocumentFormat.OpenXml.Drawing.GraphicData graphicData = graphicFrame.ChildElements.First<DocumentFormat.OpenXml.Drawing.GraphicData>();
            if (graphicData != null)
            {
                OpenXmlElement element = graphicData.ChildElements.First();
                if (element != null)
                {
                    if (element is DocumentFormat.OpenXml.Drawing.Table table)
                    {
                        TableConvert(table, theme, colors);
                    }
                    if (element is DocumentFormat.OpenXml.Drawing.Chart chart)
                    {
                        //return ChartConvert(graphicFrame, theme, colorMap);
                    }
                    if (element is DocumentFormat.OpenXml.Drawing.Diagram diagram)
                    {
                        //return DiagramConvert(graphicFrame, theme, colorMap);
                    }
                }
            }
            return null;
        }
        public void TableConvert(DocumentFormat.OpenXml.Drawing.Table table, Theme theme, Dictionary<string, string> colors)
        {
            int s =
0;
        }
        /// <summary>
        /// 处理组合图形
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public void ProcessGrpSpNode(List<Item> list, DocumentFormat.OpenXml.Presentation.GroupShape element, IEnumerable<IdPartPair> idPartPairs,
            SlideMaster slideMaster, Dictionary<string, string> colors, int index,
            //HiTeachCC.Model.PowerPoint.Position position,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme, SlidePart slidePart)
        {
            var shapes = from shap in element.Descendants<DocumentFormat.OpenXml.Presentation.Shape>() select shap;
            HiTeachCC.Model.PowerPoint.Position position = new HiTeachCC.Model.PowerPoint.Position();
            TransformGroup transformGroup = element.GroupShapeProperties.TransformGroup;
            position.Rot = transformGroup.Rotation == null ? 0 : transformGroup.Rotation.Value;
            position.FlipH = transformGroup.HorizontalFlip == null ? 0 : transformGroup.HorizontalFlip.Value == true ? 1 : 0;
            position.FlipV = transformGroup.VerticalFlip == null ? 0 : transformGroup.VerticalFlip.Value == true ? 1 : 0;
            position.X = transformGroup.Offset.X == null ? 0 : transformGroup.Offset.X.Value;
            position.Y = transformGroup.Offset.Y == null ? 0 : transformGroup.Offset.Y.Value;
            position.Cx = transformGroup.Extents.Cx == null ? 0 : transformGroup.Extents.Cx.Value;
            position.Cy = transformGroup.Extents.Cy == null ? 0 : transformGroup.Extents.Cy.Value;
            long ChX = transformGroup.ChildOffset.X == null ? 0 : transformGroup.ChildOffset.X.Value;
            long ChY = transformGroup.ChildOffset.Y == null ? 0 : transformGroup.ChildOffset.Y.Value;
            long ChCX = transformGroup.ChildExtents.Cx == null ? 0 : transformGroup.ChildExtents.Cx.Value;
            long ChCY = transformGroup.ChildExtents.Cy == null ? 0 : transformGroup.ChildExtents.Cy.Value;
            position.X = position.X - ChX;
            position.Y = position.Y - ChY;
            position.Cx = position.Cx - ChCX;
            position.Cy = position.Cy - ChCY;
            Group group = new Group();
            group.Position = position;
            group.Type = "Group";
            group.Index = index++;
            List<Item> items = new List<Item>();
            foreach (var shape in shapes)
            {
                ProcessNodesInSlide(items, shape, idPartPairs, slideMaster, colors, index, slideLayoutTables, slideMasterTables, slideMasterTextStyles, theme, slidePart, false);
            }
            group.Shapes = items;
            list.Add(group);
            //return list;
        }

        /// <summary>
        /// 处理连接线的信息
        /// </summary>
        /// <param name="element"></param>
        /// <param name="slidePart"></param>
        /// <param name="slideMaster"></param>
        /// <param name="colors"></param>
        /// <param name="index"></param>
        /// <param name="position"></param>
        /// <param name="slideLayoutTables"></param>
        /// <param name="slideMasterTables"></param>
        /// <returns></returns>
        public HiTeachCC.Model.PowerPoint.Connector ProcessCxnSpNode(DocumentFormat.OpenXml.Presentation.ConnectionShape element,
            IEnumerable<IdPartPair> slidePart, SlideMaster slideMaster, Dictionary<string, string> colors,
            int index,
            Style slideLayoutTables,
            Style slideMasterTables, XmlDocument slideMasterTextStyles, Theme theme)
        {
            HiTeachCC.Model.PowerPoint.Connector shape = new HiTeachCC.Model.PowerPoint.Connector();
            HiTeachCC.Model.PowerPoint.Position spPosition = null;
            if (element.ShapeProperties != null)
            {
                Transform2D transform2D = element.ShapeProperties.Transform2D;
                if (transform2D != null)
                {
                    spPosition = PowerPointHelper.GetPositionByTransform2D(transform2D);
                }
            }

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(element.OuterXml);
            XmlNode shapeType = doc.SelectSingleNode("//p:spPr/a:prstGeom/@prst", PowerPointHelper.GetXmlnsManager(doc.NameTable));
            if (shapeType != null)
            {
                //常规图形
                HiTeachCC.Model.PowerPoint.Position shapePosition = PowerPointHelper.GetPosition(element.OuterXml, null, null);
                Border border = PowerPointHelper.GetBorder(element.OuterXml, true, colors);
                HiTeachCC.Model.PowerPoint.Fill fill = PowerPointHelper.GetShapeFill(element.OuterXml, colors);
                var headEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:headEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                var tailEndTypeNode = doc.SelectSingleNode("//p:spPr/a:ln/a:tailEnd/@type", PowerPointHelper.GetXmlnsManager(doc.NameTable));
                PowerPointHelper.GenPPTXShape(shapeType);
                //shapePosition.Index = index;
                shape.Position = shapePosition;
                // shape.Fill = fill;
                shape.Border = border;
                shape.Type = "CxnSp";
                shape.CxnType = shapeType.Value;
                shape.Index = index++;
                if (headEndTypeNode != null)
                {
                    shape.HeadEnd = headEndTypeNode.Value;
                }
                if (tailEndTypeNode != null)
                {
                    shape.TailEnd = tailEndTypeNode.Value;
                }
                return shape;
            }
            return null;
        }
        private async Task ProcessPDF(IFormFile file, Dictionary<string, object> resdict)
        {
            string shaCode = ShaHashHelper.GetSHA1(file.OpenReadStream());
            Dictionary<string, object> dict = new Dictionary<string, object> { { "Sha1Code", shaCode } };
            List<AzureBlobModel> models = await FindListByDict<AzureBlobModel>(dict);
            if (models.IsNotEmpty())
            {
                resdict.Add("pdf", models[0]);
                resdict.Add("type", "pdf");
            }
            else
            {
                AzureBlobModel azureBlobModel = await azureBlobDBRepository.UploadFile(file, "pdffiles", true);
                azureBlobModel.Sha1Code = shaCode;
                await SaveOrUpdate<AzureBlobModel>(azureBlobModel);
                azureBlobModel.Sha1Code = shaCode;
                resdict.Add("pdf", azureBlobModel);
                resdict.Add("type", "pdf");
            }
        }
    }
}