public PivotDataBusiness()
 {
     if (_pivotDataProvider == null)
     {
         _pivotDataProvider = new PivotDataProvider();
     }
 }
 public PivotDataBusiness(ProviderType providerType)
 {
     if (_pivotDataProvider == null)
     {
         _pivotDataProvider = new PivotDataProvider(providerType);
     }
 }
        /// <summary>
        /// Экспорт в Microsoft Excel.
        /// </summary>
        /// <param name="provider">Provider.</param>
        /// <returns>Возращает строку с xml в формате "Spreadsheet".</returns>
        static public string ExportToExcel(PivotDataProvider provider)
        {
            pivotDataProvider = provider;
            document          = new XmlDocument();

            WriteHeaders();

            //<DocumentProperties>
            WriteDocumentProperties();

            //<Styles>
            WriteDefaultStyles();

            string cubeName = provider.Provider.CellSet_Description.CubeName;

            //<Worksheet>
            worksheet = document.CreateElement("s", "Worksheet", spreadsheetNamespace);
            worksheet.SetAttribute("Protected", spreadsheetNamespace, true.GetHashCode().ToString());
            worksheet.SetAttribute("Name", spreadsheetNamespace, cubeName);
            workbook.AppendChild(worksheet);

            //<Table>
            table = document.CreateElement("s", "Table", spreadsheetNamespace);
            table.SetAttribute("StyleID", spreadsheetNamespace, tableStyle);
            worksheet.AppendChild(table);

            //Количество строк в области колонок:
            int colRowsCount = 0;

            if (pivotDataProvider.Provider.CellSet_Description.Axes.Count > 0 &&
                pivotDataProvider.Provider.CellSet_Description.Axes[0].Positions.Count > 0)
            {
                colRowsCount = pivotDataProvider.Provider.CellSet_Description.Axes[0].Positions[0].Members.Count;
            }
            //количество колонок в области строк:
            int rowColumnsCount = 0;

            if (pivotDataProvider.Provider.CellSet_Description.Axes.Count > 1 &&
                pivotDataProvider.Provider.CellSet_Description.Axes[1].Positions.Count > 0)
            {
                rowColumnsCount = pivotDataProvider.Provider.CellSet_Description.Axes[1].Positions[0].Members.Count;
            }

            //количество колонок в области колонок:
            int colColumnsCount = pivotDataProvider.ColumnsArea.ColumnsCount;

            //Задать ширину колонок:
            SetColumnsWidth(rowColumnsCount, colColumnsCount);

            WriteFilters();
            WriteColumns(rowColumnsCount + 1);
            WriteRows(colColumnsCount);

            //<WorksheetOptions>
            SetWorksheetOptions();

            return(document.OuterXml.Replace("amp;#", "#"));
        }
        public PivotLayoutProvider(PivotDataProvider provider)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }

            m_Provider = provider;
        }
Пример #5
0
        public override String ExportToExcel()
        {
            String result = String.Empty;

            try
            {
                CellSetData       res           = RefreshQuery();
                PivotDataProvider pivotProvider = new PivotDataProvider(new CellSetDataProvider(res));
                result = ExportHelper.ExportToExcel(pivotProvider);
            }
            catch
            {
                result = string.Empty;
            }
            return(result);
        }
Пример #6
0
        private String ExportToExcel(String schema)
        {
            InvokeResultDescriptor result = new InvokeResultDescriptor();
            String res = String.Empty;

            try
            {
                String sessionId  = String.Empty;
                String connection = String.Empty;
                try
                {
                    MdxQueryArgs args = XmlSerializationUtility.XmlStr2Obj <MdxQueryArgs>(schema);
                    if (args != null)
                    {
                        sessionId  = args.SessionId;
                        connection = args.Connection;
                        DefaultQueryExecuter queryExecuter = new DefaultQueryExecuter(GetConnection(args.Connection));
                        if (args.Queries.Count > 0)
                        {
                            res = queryExecuter.GetCellSetDescription(args.Queries[0], ref sessionId);
                        }
                    }
                }
                catch (AdomdConnectionException connection_ex)
                {
                    result.Content     = connection_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (AdomdErrorResponseException response_ex)
                {
                    result.Content     = response_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (AdomdUnknownResponseException unknown_ex)
                {
                    result.Content     = unknown_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }
                catch (InvalidOperationException invalid_ex)
                {
                    result.Content     = invalid_ex.Message;
                    result.ContentType = InvokeContentType.Error;
                }

                if (!String.IsNullOrEmpty(res))
                {
                    CellSetData       cs            = CellSetData.Deserialize(res);
                    PivotDataProvider pivotProvider = new PivotDataProvider(new CellSetDataProvider(cs));
                    res = ExportHelper.ExportToExcel(pivotProvider);
                }

                result.Content = res;
                if (UseCompress)
                {
                    // Архивация строки
                    String compesed = ZipCompressor.CompressAndConvertToBase64String(res);
                    result.Content   = compesed;
                    result.IsArchive = true;
                }
                result.ContentType = InvokeContentType.MultidimData;
                result.Headers.Add(new Header(InvokeResultDescriptor.SESSION_ID, sessionId));
                result.Headers.Add(new Header(InvokeResultDescriptor.CONNECTION_ID, connection));
            }
            catch (Exception)
            {
                throw;
            }
            return(InvokeResultDescriptor.Serialize(result));
        }