11535780700

Committed 26 Oct 2024 11:34PM UTC coverage: 78.054% (-0.7%) from 78.772%

Build # 11535780700

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #81 from JaCraig/add-sub-processors

feat: Add sub-processors for file types

Run Details

2395 of 3316 branches covered (72.23%)

Branch coverage included in aggregate %.

37 of 59 new or added lines in 14 files covered. (62.71%)

29 existing lines in 10 files now uncovered.

3139 of 3774 relevant lines covered (83.17%)

11929.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.87

/Archivist/Formats/Excel/ExcelReader.cs

﻿using Archivist.BaseClasses;
using Archivist.Converters;
using Archivist.Interfaces;
using Archivist.Options;
using DocumentFormat.OpenXml.CustomProperties;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Spreadsheet;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Archivist.Formats.Excel
{
    /// <summary>
    /// Represents a reader for Excel files.
    /// </summary>
    /// <seealso cref="ReaderBaseClass"/>
    public class ExcelReader : ReaderBaseClass
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ExcelReader"/> class.
        /// </summary>
        /// <param name="options">The Excel options.</param>
        /// <param name="converter">The converter.</param>
        public ExcelReader(ExcelOptions options, Convertinator? converter)
        {
            Options = options;
            _Converter = converter;
        }

        /// <summary>
        /// Gets the header information for Excel files.
        /// </summary>
        public override byte[] HeaderInfo { get; } = new byte[] { 0x50, 0x4B, 0x03, 0x04 };

        /// <summary>
        /// Gets the Excel options.
        /// </summary>
        public ExcelOptions Options { get; }

        /// <summary>
        /// Gets the regular expression pattern for matching alphabetic strings.
        /// </summary>
        private static Regex AlphaRegex { get; } = new Regex("^[A-Z]+$", RegexOptions.Compiled);

        /// <summary>
        /// Gets the regular expression pattern for matching column names.
        /// </summary>
        private static Regex ColumnNameRegex { get; } = new Regex("[A-Za-z]+", RegexOptions.Compiled);

        /// <summary>
        /// Gets an empty cell.
        /// </summary>
        private static Cell EmptyCell { get; } = new Cell
        {
            DataType = null,
            CellValue = new CellValue("")
        };

        /// <summary>
        /// The converter.
        /// </summary>
        private readonly Convertinator? _Converter;

        /// <summary>
        /// Determines if the reader can read the given stream as an Excel file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>True if the reader can read the file, false otherwise.</returns>
        public override bool InternalCanRead(Stream? stream)
        {
            if (stream is null || !IsValidStream(stream))
                return false;
            try
            {
                var Document = SpreadsheetDocument.Open(stream, false);
                if (Document.RootPart?.ContentType != "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml")
                    return false;
            }
            catch
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// Reads the Excel file asynchronously and returns the data as a generic file.
        /// </summary>
        /// <param name="stream">The stream to read.</param>
        /// <returns>
        /// A task representing the asynchronous operation. The task result is the generic file data.
        /// </returns>
        public override Task<IGenericFile?> ReadAsync(Stream? stream)
        {
            var ReturnValue = new DataTypes.Tables(_Converter);
            if (stream is null || !IsValidStream(stream))
                return Task.FromResult<IGenericFile?>(ReturnValue);

            // Open the excel document
            WorkbookPart? WorkbookPart;
            try
            {
                var Document = SpreadsheetDocument.Open(stream, false);
                ReadMetadata(ReturnValue, Document);

                WorkbookPart = Document.WorkbookPart;
                if (WorkbookPart is null)
                    return Task.FromResult<IGenericFile?>(ReturnValue);

                foreach (Sheet Sheet in WorkbookPart.Workbook.Descendants<Sheet>())
                {
                    DataTypes.Table CurrentTable = ReturnValue.AddTable();
                    CurrentTable.Title = Sheet.Name?.ToString() ?? "";

                    var SheetId = Sheet.Id?.Value ?? "";

                    if (string.IsNullOrEmpty(SheetId))
                        continue;

                    var WorkSheetPart = (WorksheetPart?)WorkbookPart.GetPartById(SheetId);

                    Worksheet? WorkSheet = WorkSheetPart?.Worksheet;
                    if (WorkSheet is null)
                        continue;

                    Columns? Columns = WorkSheet.Descendants<Columns>().FirstOrDefault();

                    SheetData? SheetData = WorkSheet.Elements<SheetData>().FirstOrDefault();
                    if (SheetData is null)
                        continue;
                    var Rows = SheetData.Elements<Row>().ToList();

                    // Read the header
                    if (Rows.Count == 0)
                        continue;

                    var CurrentRow = 0;

                    Row Row = Rows[0];
                    IEnumerator<Cell>? CellEnumerator = null;
                    if (Options.FirstRowIsColumnHeaders)
                    {
                        CellEnumerator = GetExcelCellEnumerator(Row);
                        while (CellEnumerator.MoveNext())
                        {
                            Cell Cell = CellEnumerator.Current;
                            var Text = ReadExcelCell(Cell, WorkbookPart).Trim();
                            CurrentTable.Columns.Add(Text);
                        }
                        CurrentRow = 1;
                    }

                    // Read the sheet data
                    for (var I = CurrentRow; I < Rows.Count; I++)
                    {
                        DataTypes.TableRow DataRow = CurrentTable.AddRow();
                        Row = Rows[I];
                        CellEnumerator = GetExcelCellEnumerator(Row);
                        while (CellEnumerator.MoveNext())
                        {
                            Cell Cell = CellEnumerator.Current;
                            var Text = ReadExcelCell(Cell, WorkbookPart).Trim();
                            DataRow.Add(Text);
                        }
                    }
                }
            }
            catch (Exception)
            {
                return Task.FromResult<IGenericFile?>(ReturnValue);
            }

            return Task.FromResult<IGenericFile?>(ReturnValue);
        }

        /// <summary>
        /// Converts the column name to a number.
        /// </summary>
        /// <param name="columnName">The name of the column.</param>
        /// <returns>The column number.</returns>
        private static int ConvertColumnNameToNumber(string columnName)
        {
            if (!AlphaRegex.IsMatch(columnName))
                return -1;

            var ColLetters = columnName.ToCharArray();
            Array.Reverse(ColLetters);

            var ConvertedValue = 0;
            for (var I = 0; I < ColLetters.Length; I++)
            {
                var Letter = ColLetters[I];
                // ASCII 'A' = 65
                var Current = I == 0 ? Letter - 65 : Letter - 64;
                ConvertedValue += Current * (int)Math.Pow(26, I);
            }

            return ConvertedValue;
        }

        /// <summary>
        /// Gets the column name from the cell reference.
        /// </summary>
        /// <param name="cellReference">The cell reference.</param>
        /// <returns>The column name.</returns>
        private static string GetColumnName(string? cellReference) => string.IsNullOrEmpty(cellReference) ? "" : ColumnNameRegex.Match(cellReference).Value;

        /// <summary>
        /// Gets the enumerator for iterating over the cells in a row.
        /// </summary>
        /// <param name="row">The row.</param>
        /// <returns>The cell enumerator.</returns>
        private static IEnumerator<Cell> GetExcelCellEnumerator(Row row)
        {
            var CurrentCount = 0;
            foreach (Cell CurrentCell in row.Descendants<Cell>())
            {
                var ColumnName = GetColumnName(CurrentCell.CellReference);
                if (string.IsNullOrEmpty(ColumnName))
                    continue;

                var CurrentColumnIndex = ConvertColumnNameToNumber(ColumnName);

                if (CurrentColumnIndex < 0)
                    continue;

                for (; CurrentCount < CurrentColumnIndex; ++CurrentCount)
                {
                    yield return EmptyCell;
                }
                yield return CurrentCell;
                ++CurrentCount;
            }
        }

        /// <summary>
        /// Reads the custom properties from the Excel document.
        /// </summary>
        /// <param name="returnValue">The return value</param>
        /// <param name="document">The Excel document.</param>
        private static void ReadCustomProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
        {
            CustomFilePropertiesPart? CustomPropertiesPart = document.CustomFilePropertiesPart;
            if (CustomPropertiesPart?.Properties is null)
                return;

            foreach (CustomDocumentProperty CustomProperty in CustomPropertiesPart.Properties.Cast<CustomDocumentProperty>())
            {
                DocumentFormat.OpenXml.StringValue? PropName = CustomProperty.Name;
                if (string.IsNullOrEmpty(PropName))
                    continue;

                string? PropValue;
                if (CustomProperty.VTLPWSTR != null)
                    PropValue = CustomProperty.VTLPWSTR.Text;
                else if (CustomProperty.VTFileTime != null)
                    PropValue = CustomProperty.VTFileTime.Text;
                else if (CustomProperty.VTDouble != null)
                    PropValue = CustomProperty.VTDouble.Text;
                else if (CustomProperty.VTBool != null)
                    PropValue = CustomProperty.VTBool.Text;
                else if (CustomProperty.VTInt32 != null)
                    PropValue = CustomProperty.VTInt32.Text;
                else if (CustomProperty.VTInt64 != null)
                    PropValue = CustomProperty.VTInt64.Text;
                else if (CustomProperty.VTBString != null)
                    PropValue = CustomProperty.VTBString.Text;
                else
                    PropValue = CustomProperty.InnerText;

                returnValue.Metadata[PropName!] = PropValue;
            }
        }

        /// <summary>
        /// Reads the value of an Excel cell.
        /// </summary>
        /// <param name="cell">The cell.</param>
        /// <param name="workbookPart">The workbook part.</param>
        /// <returns>The cell value.</returns>
        private static string ReadExcelCell(Cell cell, WorkbookPart workbookPart)
        {
            if (cell is null)
                return "";

            CellValue? CellValue = cell.CellValue;
            var Text = CellValue?.Text ?? cell.InnerText ?? "";

            if (cell.DataType == null || cell.DataType != CellValues.SharedString || string.IsNullOrEmpty(cell.CellValue?.Text))
                return Text.Trim();

            Text = workbookPart.SharedStringTablePart
                               ?.SharedStringTable
                               .Elements<SharedStringItem>()
                               .ElementAt(Convert.ToInt32(cell.CellValue.Text))
                               .InnerText;

            return (Text ?? "").Trim();
        }

        /// <summary>
        /// Reads the extended file properties.
        /// </summary>
        /// <param name="returnValue">Return value</param>
        /// <param name="document">The Excel document.</param>
        private static void ReadExtendedFileProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
        {
            if (document.ExtendedFilePropertiesPart?.Properties is null)
                return;
            returnValue.Metadata["Application"] = document.ExtendedFilePropertiesPart.Properties.Application?.Text ?? "";
            returnValue.Metadata["ApplicationVersion"] = document.ExtendedFilePropertiesPart.Properties.ApplicationVersion?.Text ?? "";
            returnValue.Metadata["Company"] = document.ExtendedFilePropertiesPart.Properties.Company?.Text ?? "";
            returnValue.Metadata["Manager"] = document.ExtendedFilePropertiesPart.Properties.Manager?.Text ?? "";
            returnValue.Metadata["HyperlinkBase"] = document.ExtendedFilePropertiesPart.Properties.HyperlinkBase?.Text ?? "";
            returnValue.Metadata["Template"] = document.ExtendedFilePropertiesPart.Properties.Template?.Text ?? "";
            returnValue.Metadata["TotalTime"] = document.ExtendedFilePropertiesPart.Properties.TotalTime?.Text ?? "";
            returnValue.Metadata["Pages"] = document.ExtendedFilePropertiesPart.Properties.Pages?.Text ?? "";
            returnValue.Metadata["Words"] = document.ExtendedFilePropertiesPart.Properties.Words?.Text ?? "";
            returnValue.Metadata["Characters"] = document.ExtendedFilePropertiesPart.Properties.Characters?.Text ?? "";
            returnValue.Metadata["CharactersWithSpaces"] = document.ExtendedFilePropertiesPart.Properties.CharactersWithSpaces?.Text ?? "";
            returnValue.Metadata["Lines"] = document.ExtendedFilePropertiesPart.Properties.Lines?.Text ?? "";
            returnValue.Metadata["Paragraphs"] = document.ExtendedFilePropertiesPart.Properties.Paragraphs?.Text ?? "";
            returnValue.Metadata["PresentationFormat"] = document.ExtendedFilePropertiesPart.Properties.PresentationFormat?.Text ?? "";
            returnValue.Metadata["LinksUpToDate"] = document.ExtendedFilePropertiesPart.Properties.LinksUpToDate?.Text ?? "";
            returnValue.Metadata["HyperlinksChanged"] = document.ExtendedFilePropertiesPart.Properties.HyperlinksChanged?.Text ?? "";
        }

        /// <summary>
        /// Reads the metadata from the Excel document.
        /// </summary>
        /// <param name="returnValue">The return value.</param>
        /// <param name="document">The Excel document.</param>
        private static void ReadMetadata(DataTypes.Tables returnValue, SpreadsheetDocument document)
        {
            if (document is null || returnValue is null)
                return;

            ReadPackageProperties(returnValue, document);
            ReadExtendedFileProperties(returnValue, document);
            ReadCustomProperties(returnValue, document);
        }

        /// <summary>
        /// Reads the package properties.
        /// </summary>
        /// <param name="returnValue">The return value.</param>
        /// <param name="document">The document.</param>
        private static void ReadPackageProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
        {
            if (document.PackageProperties is null)
                return;
            returnValue.Metadata["Title"] = document.PackageProperties.Title ?? "";
            returnValue.Metadata["Author"] = document.PackageProperties.Creator ?? "";
            returnValue.Metadata["Created"] = document.PackageProperties.Created?.ToString() ?? "";
            returnValue.Metadata["Modified"] = document.PackageProperties.Modified?.ToString() ?? "";
            returnValue.Metadata["LastModifiedBy"] = document.PackageProperties.LastModifiedBy ?? "";
            returnValue.Metadata["Revision"] = document.PackageProperties.Revision ?? "";
            returnValue.Metadata["Version"] = document.PackageProperties.Version ?? "";
            returnValue.Metadata["Category"] = document.PackageProperties.Category ?? "";
            returnValue.Metadata["ContentStatus"] = document.PackageProperties.ContentStatus ?? "";
            returnValue.Metadata["Description"] = document.PackageProperties.Description ?? "";
            returnValue.Metadata["Identifier"] = document.PackageProperties.Identifier ?? "";
            returnValue.Metadata["Keywords"] = document.PackageProperties.Keywords ?? "";
            returnValue.Metadata["Language"] = document.PackageProperties.Language ?? "";
            returnValue.Metadata["Subject"] = document.PackageProperties.Subject ?? "";
            returnValue.Metadata["ContentType"] = document.PackageProperties.ContentType ?? "";
            returnValue.Metadata["LastPrinted"] = document.PackageProperties.LastPrinted?.ToString() ?? "";
        }
    }
}

1	using Archivist.BaseClasses;
2	using Archivist.Converters;
3	using Archivist.Interfaces;
4	using Archivist.Options;
5	using DocumentFormat.OpenXml.CustomProperties;
6	using DocumentFormat.OpenXml.Packaging;
7	using DocumentFormat.OpenXml.Spreadsheet;
8	using System;
9	using System.Collections.Generic;
10	using System.IO;
11	using System.Linq;
12	using System.Text.RegularExpressions;
13	using System.Threading.Tasks;
14
15	namespace Archivist.Formats.Excel
16	{
17	/// <summary>
18	/// Represents a reader for Excel files.
19	/// </summary>
20	/// <seealso cref="ReaderBaseClass"/>
21	public class ExcelReader : ReaderBaseClass
22	{
23	/// <summary>
24	/// Initializes a new instance of the <see cref="ExcelReader"/> class.
25	/// </summary>
26	/// <param name="options">The Excel options.</param>
27	/// <param name="converter">The converter.</param>
28	public ExcelReader(ExcelOptions options, Convertinator? converter)	27✔
29	{
30	Options = options;	27✔
31	_Converter = converter;	27✔
32	}	27✔
33
34	/// <summary>
35	/// Gets the header information for Excel files.
36	/// </summary>
37	public override byte[] HeaderInfo { get; } = new byte[] { 0x50, 0x4B, 0x03, 0x04 };	30✔
38
39	/// <summary>
40	/// Gets the Excel options.
41	/// </summary>
42	public ExcelOptions Options { get; }	3✔
43
44	/// <summary>
45	/// Gets the regular expression pattern for matching alphabetic strings.
46	/// </summary>
47	private static Regex AlphaRegex { get; } = new Regex("^[A-Z]+$", RegexOptions.Compiled);	15✔
48
49	/// <summary>
50	/// Gets the regular expression pattern for matching column names.
51	/// </summary>
52	private static Regex ColumnNameRegex { get; } = new Regex("[A-Za-z]+", RegexOptions.Compiled);	15✔
53
54	/// <summary>
55	/// Gets an empty cell.
56	/// </summary>
57	private static Cell EmptyCell { get; } = new Cell	2✔
58	{	1✔
59	DataType = null,	1✔
60	CellValue = new CellValue("")	1✔
61	};	1✔
62
63	/// <summary>
64	/// The converter.
65	/// </summary>
66	private readonly Convertinator? _Converter;
67
68	/// <summary>
69	/// Determines if the reader can read the given stream as an Excel file.
70	/// </summary>
71	/// <param name="stream">The stream to read.</param>
72	/// <returns>True if the reader can read the file, false otherwise.</returns>
73	public override bool InternalCanRead(Stream? stream)
74	{
75	if (stream is null \|\| !IsValidStream(stream))	3!
76	return false;	3✔
77	try
78	{
UNCOV 79	var Document = SpreadsheetDocument.Open(stream, false);	×
80	if (Document.RootPart?.ContentType != "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml")	×
81	return false;	×
82	}	×
UNCOV 83	catch	×
84	{
UNCOV 85	return false;	×
86	}
87	return true;	×
UNCOV 88	}	×
89
90	/// <summary>
91	/// Reads the Excel file asynchronously and returns the data as a generic file.
92	/// </summary>
93	/// <param name="stream">The stream to read.</param>
94	/// <returns>
95	/// A task representing the asynchronous operation. The task result is the generic file data.
96	/// </returns>
97	public override Task<IGenericFile?> ReadAsync(Stream? stream)
98	{
99	var ReturnValue = new DataTypes.Tables(_Converter);	5✔
100	if (stream is null \|\| !IsValidStream(stream))	5✔
101	return Task.FromResult<IGenericFile?>(ReturnValue);	3✔
102
103	// Open the excel document
104	WorkbookPart? WorkbookPart;
105	try
106	{
107	var Document = SpreadsheetDocument.Open(stream, false);	2✔
108	ReadMetadata(ReturnValue, Document);	2✔
109
110	WorkbookPart = Document.WorkbookPart;	2✔
111	if (WorkbookPart is null)	2!
112	return Task.FromResult<IGenericFile?>(ReturnValue);	×
113
114	foreach (Sheet Sheet in WorkbookPart.Workbook.Descendants<Sheet>())	8✔
115	{
116	DataTypes.Table CurrentTable = ReturnValue.AddTable();	2✔
117	CurrentTable.Title = Sheet.Name?.ToString() ?? "";	2!
118
119	var SheetId = Sheet.Id?.Value ?? "";	2!
120
121	if (string.IsNullOrEmpty(SheetId))	2✔
122	continue;
123
124	var WorkSheetPart = (WorksheetPart?)WorkbookPart.GetPartById(SheetId);	2✔
125
126	Worksheet? WorkSheet = WorkSheetPart?.Worksheet;	2!
127	if (WorkSheet is null)	2✔
128	continue;
129
130	Columns? Columns = WorkSheet.Descendants<Columns>().FirstOrDefault();	2✔
131
132	SheetData? SheetData = WorkSheet.Elements<SheetData>().FirstOrDefault();	2✔
133	if (SheetData is null)	2✔
134	continue;
135	var Rows = SheetData.Elements<Row>().ToList();	2✔
136
137	// Read the header
138	if (Rows.Count == 0)	2✔
139	continue;
140
141	var CurrentRow = 0;	2✔
142
143	Row Row = Rows[0];	2✔
144	IEnumerator<Cell>? CellEnumerator = null;	2✔
145	if (Options.FirstRowIsColumnHeaders)	2✔
146	{
147	CellEnumerator = GetExcelCellEnumerator(Row);	2✔
148	while (CellEnumerator.MoveNext())	7✔
149	{
150	Cell Cell = CellEnumerator.Current;	5✔
151	var Text = ReadExcelCell(Cell, WorkbookPart).Trim();	5✔
152	CurrentTable.Columns.Add(Text);	5✔
153	}
154	CurrentRow = 1;	2✔
155	}
156
157	// Read the sheet data
158	for (var I = CurrentRow; I < Rows.Count; I++)	12✔
159	{
160	DataTypes.TableRow DataRow = CurrentTable.AddRow();	4✔
161	Row = Rows[I];	4✔
162	CellEnumerator = GetExcelCellEnumerator(Row);	4✔
163	while (CellEnumerator.MoveNext())	14✔
164	{
165	Cell Cell = CellEnumerator.Current;	10✔
166	var Text = ReadExcelCell(Cell, WorkbookPart).Trim();	10✔
167	DataRow.Add(Text);	10✔
168	}
169	}
170	}
171	}	2✔
UNCOV 172	catch (Exception)	×
173	{
UNCOV 174	return Task.FromResult<IGenericFile?>(ReturnValue);	×
175	}
176
177	return Task.FromResult<IGenericFile?>(ReturnValue);	2✔
UNCOV 178	}	×
179
180	/// <summary>
181	/// Converts the column name to a number.
182	/// </summary>
183	/// <param name="columnName">The name of the column.</param>
184	/// <returns>The column number.</returns>
185	private static int ConvertColumnNameToNumber(string columnName)
186	{
187	if (!AlphaRegex.IsMatch(columnName))	14!
188	return -1;	×
189
190	var ColLetters = columnName.ToCharArray();	14✔
191	Array.Reverse(ColLetters);	14✔
192
193	var ConvertedValue = 0;	14✔
194	for (var I = 0; I < ColLetters.Length; I++)	56✔
195	{
196	var Letter = ColLetters[I];	14✔
197	// ASCII 'A' = 65
198	var Current = I == 0 ? Letter - 65 : Letter - 64;	14!
199	ConvertedValue += Current * (int)Math.Pow(26, I);	14✔
200	}
201
202	return ConvertedValue;	14✔
203	}
204
205	/// <summary>
206	/// Gets the column name from the cell reference.
207	/// </summary>
208	/// <param name="cellReference">The cell reference.</param>
209	/// <returns>The column name.</returns>
210	private static string GetColumnName(string? cellReference) => string.IsNullOrEmpty(cellReference) ? "" : ColumnNameRegex.Match(cellReference).Value;	14!
211
212	/// <summary>
213	/// Gets the enumerator for iterating over the cells in a row.
214	/// </summary>
215	/// <param name="row">The row.</param>
216	/// <returns>The cell enumerator.</returns>
217	private static IEnumerator<Cell> GetExcelCellEnumerator(Row row)
218	{
219	var CurrentCount = 0;	6✔
220	foreach (Cell CurrentCell in row.Descendants<Cell>())	40✔
221	{
222	var ColumnName = GetColumnName(CurrentCell.CellReference);	14✔
223	if (string.IsNullOrEmpty(ColumnName))	14✔
224	continue;
225
226	var CurrentColumnIndex = ConvertColumnNameToNumber(ColumnName);	14✔
227
228	if (CurrentColumnIndex < 0)	14✔
229	continue;	×
230
231	for (; CurrentCount < CurrentColumnIndex; ++CurrentCount)	16✔
232	{
233	yield return EmptyCell;	1✔
234	}
235	yield return CurrentCell;	14✔
236	++CurrentCount;	14✔
237	}	14✔
238	}	6✔
239
240	/// <summary>
241	/// Reads the custom properties from the Excel document.
242	/// </summary>
243	/// <param name="returnValue">The return value</param>
244	/// <param name="document">The Excel document.</param>
245	private static void ReadCustomProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
246	{
247	CustomFilePropertiesPart? CustomPropertiesPart = document.CustomFilePropertiesPart;	2✔
248	if (CustomPropertiesPart?.Properties is null)	2!
249	return;	2✔
250
251	foreach (CustomDocumentProperty CustomProperty in CustomPropertiesPart.Properties.Cast<CustomDocumentProperty>())	×
252	{
253	DocumentFormat.OpenXml.StringValue? PropName = CustomProperty.Name;	×
254	if (string.IsNullOrEmpty(PropName))	×
255	continue;
256
257	string? PropValue;
258	if (CustomProperty.VTLPWSTR != null)	×
259	PropValue = CustomProperty.VTLPWSTR.Text;	×
260	else if (CustomProperty.VTFileTime != null)	×
261	PropValue = CustomProperty.VTFileTime.Text;	×
262	else if (CustomProperty.VTDouble != null)	×
263	PropValue = CustomProperty.VTDouble.Text;	×
264	else if (CustomProperty.VTBool != null)	×
265	PropValue = CustomProperty.VTBool.Text;	×
266	else if (CustomProperty.VTInt32 != null)	×
267	PropValue = CustomProperty.VTInt32.Text;	×
268	else if (CustomProperty.VTInt64 != null)	×
269	PropValue = CustomProperty.VTInt64.Text;	×
270	else if (CustomProperty.VTBString != null)	×
271	PropValue = CustomProperty.VTBString.Text;	×
272	else
273	PropValue = CustomProperty.InnerText;	×
274
275	returnValue.Metadata[PropName!] = PropValue;	×
276	}
277	}	×
278
279	/// <summary>
280	/// Reads the value of an Excel cell.
281	/// </summary>
282	/// <param name="cell">The cell.</param>
283	/// <param name="workbookPart">The workbook part.</param>
284	/// <returns>The cell value.</returns>
285	private static string ReadExcelCell(Cell cell, WorkbookPart workbookPart)
286	{
287	if (cell is null)	15!
288	return "";	×
289
290	CellValue? CellValue = cell.CellValue;	15✔
291	var Text = CellValue?.Text ?? cell.InnerText ?? "";	15!
292
293	if (cell.DataType == null \|\| cell.DataType != CellValues.SharedString \|\| string.IsNullOrEmpty(cell.CellValue?.Text))	15!
294	return Text.Trim();	11✔
295
296	Text = workbookPart.SharedStringTablePart	4!
297	?.SharedStringTable	4✔
298	.Elements<SharedStringItem>()	4✔
299	.ElementAt(Convert.ToInt32(cell.CellValue.Text))	4✔
300	.InnerText;	4✔
301
302	return (Text ?? "").Trim();	4!
303	}
304
305	/// <summary>
306	/// Reads the extended file properties.
307	/// </summary>
308	/// <param name="returnValue">Return value</param>
309	/// <param name="document">The Excel document.</param>
310	private static void ReadExtendedFileProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
311	{
312	if (document.ExtendedFilePropertiesPart?.Properties is null)	2!
313	return;	×
314	returnValue.Metadata["Application"] = document.ExtendedFilePropertiesPart.Properties.Application?.Text ?? "";	2!
315	returnValue.Metadata["ApplicationVersion"] = document.ExtendedFilePropertiesPart.Properties.ApplicationVersion?.Text ?? "";	2!
316	returnValue.Metadata["Company"] = document.ExtendedFilePropertiesPart.Properties.Company?.Text ?? "";	2!
317	returnValue.Metadata["Manager"] = document.ExtendedFilePropertiesPart.Properties.Manager?.Text ?? "";	2✔
318	returnValue.Metadata["HyperlinkBase"] = document.ExtendedFilePropertiesPart.Properties.HyperlinkBase?.Text ?? "";	2✔
319	returnValue.Metadata["Template"] = document.ExtendedFilePropertiesPart.Properties.Template?.Text ?? "";	2✔
320	returnValue.Metadata["TotalTime"] = document.ExtendedFilePropertiesPart.Properties.TotalTime?.Text ?? "";	2✔
321	returnValue.Metadata["Pages"] = document.ExtendedFilePropertiesPart.Properties.Pages?.Text ?? "";	2✔
322	returnValue.Metadata["Words"] = document.ExtendedFilePropertiesPart.Properties.Words?.Text ?? "";	2✔
323	returnValue.Metadata["Characters"] = document.ExtendedFilePropertiesPart.Properties.Characters?.Text ?? "";	2✔
324	returnValue.Metadata["CharactersWithSpaces"] = document.ExtendedFilePropertiesPart.Properties.CharactersWithSpaces?.Text ?? "";	2✔
325	returnValue.Metadata["Lines"] = document.ExtendedFilePropertiesPart.Properties.Lines?.Text ?? "";	2✔
326	returnValue.Metadata["Paragraphs"] = document.ExtendedFilePropertiesPart.Properties.Paragraphs?.Text ?? "";	2✔
327	returnValue.Metadata["PresentationFormat"] = document.ExtendedFilePropertiesPart.Properties.PresentationFormat?.Text ?? "";	2✔
328	returnValue.Metadata["LinksUpToDate"] = document.ExtendedFilePropertiesPart.Properties.LinksUpToDate?.Text ?? "";	2!
329	returnValue.Metadata["HyperlinksChanged"] = document.ExtendedFilePropertiesPart.Properties.HyperlinksChanged?.Text ?? "";	2!
330	}	2✔
331
332	/// <summary>
333	/// Reads the metadata from the Excel document.
334	/// </summary>
335	/// <param name="returnValue">The return value.</param>
336	/// <param name="document">The Excel document.</param>
337	private static void ReadMetadata(DataTypes.Tables returnValue, SpreadsheetDocument document)
338	{
339	if (document is null \|\| returnValue is null)	2!
340	return;	×
341
342	ReadPackageProperties(returnValue, document);	2✔
343	ReadExtendedFileProperties(returnValue, document);	2✔
344	ReadCustomProperties(returnValue, document);	2✔
345	}	2✔
346
347	/// <summary>
348	/// Reads the package properties.
349	/// </summary>
350	/// <param name="returnValue">The return value.</param>
351	/// <param name="document">The document.</param>
352	private static void ReadPackageProperties(DataTypes.Tables returnValue, SpreadsheetDocument document)
353	{
354	if (document.PackageProperties is null)	2!
355	return;	×
356	returnValue.Metadata["Title"] = document.PackageProperties.Title ?? "";	2✔
357	returnValue.Metadata["Author"] = document.PackageProperties.Creator ?? "";	2!
358	returnValue.Metadata["Created"] = document.PackageProperties.Created?.ToString() ?? "";	2✔
359	returnValue.Metadata["Modified"] = document.PackageProperties.Modified?.ToString() ?? "";	2✔
360	returnValue.Metadata["LastModifiedBy"] = document.PackageProperties.LastModifiedBy ?? "";	2!
361	returnValue.Metadata["Revision"] = document.PackageProperties.Revision ?? "";	2✔
362	returnValue.Metadata["Version"] = document.PackageProperties.Version ?? "";	2✔
363	returnValue.Metadata["Category"] = document.PackageProperties.Category ?? "";	2✔
364	returnValue.Metadata["ContentStatus"] = document.PackageProperties.ContentStatus ?? "";	2✔
365	returnValue.Metadata["Description"] = document.PackageProperties.Description ?? "";	2✔
366	returnValue.Metadata["Identifier"] = document.PackageProperties.Identifier ?? "";	2✔
367	returnValue.Metadata["Keywords"] = document.PackageProperties.Keywords ?? "";	2✔
368	returnValue.Metadata["Language"] = document.PackageProperties.Language ?? "";	2✔
369	returnValue.Metadata["Subject"] = document.PackageProperties.Subject ?? "";	2✔
370	returnValue.Metadata["ContentType"] = document.PackageProperties.ContentType ?? "";	2✔
371	returnValue.Metadata["LastPrinted"] = document.PackageProperties.LastPrinted?.ToString() ?? "";	2!
372	}	2✔
373	}
374	}

JaCraig / Archivist / 11535780700

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous