Esempio n. 1
0
        private void ExtractCsv(DataTable table)
        {
            var patterns = new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase)
            {
                { SheetNamePattern, table.TableName },
                { ExcelPathPattern, Path.ChangeExtension(Context.ExcelPath, null) }
            };

            var outputPath = string.IsNullOrWhiteSpace(Context.OutputPath)
                ? Path.ChangeExtension(Context.ExcelPath, $".{table.TableName}.csv")
                : PatternRegex.Replace(Context.OutputPath, match =>
            {
                var patternName = match.Groups["pattern"].Value;

                if (patterns.TryGetValue(patternName, out var replacement))
                {
                    return(replacement);
                }

                throw new ExpectedException($"'{patternName}' is not a known pattern. Must be one of {string.Join(", ", patterns.Keys.Select(p => $"{{{p}}}"))}");
            });

            if (!Context.Overwrite && File.Exists(outputPath))
            {
                Log.Warn($"Skipping existing file '{outputPath}' ...");
                return;
            }

            Log.Info($"Saving '{outputPath}' ...");

            using (var writer = File.CreateText(outputPath))
            {
                foreach (var row in table.Rows.Cast <DataRow>())
                {
                    var columns = row
                                  .ItemArray
                                  .Select((c, i) => row.IsNull(i) ? string.Empty : CsvEscapedColumn(FormatCell(c)))
                                  .ToList();

                    if (Context.TrimEmptyColumns)
                    {
                        for (var i = columns.Count - 1; i > 0; --i)
                        {
                            if (!string.IsNullOrWhiteSpace(columns[i]))
                            {
                                break;
                            }

                            columns.RemoveAt(i);
                        }
                    }

                    writer.WriteLine(string.Join(", ", columns));
                }
            }
        }
Esempio n. 2
0
        public static string GenerateAttachmentFilename(string attachmentFilename, string exportTemplateName, string locationIdentifier, DateTimeOffset exportTime)
        {
            var patterns = new Dictionary <string, Func <string, string> >(StringComparer.InvariantCultureIgnoreCase)
            {
                { TemplatePattern, _ => exportTemplateName },
                { LocationPattern, _ => locationIdentifier },
                { TimePattern, format => exportTime.ToString(string.IsNullOrWhiteSpace(format) ? "yyyy-MM-dd" : format) }
            };

            return(PatternRegex.Replace(attachmentFilename, match =>
            {
                var pattern = match.Groups["pattern"].Value.Trim();
                var format = match.Groups["format"].Value.Trim();

                if (!patterns.TryGetValue(pattern, out var replacement))
                {
                    throw new ExpectedException($"'{pattern}' is not a known attachment filename substitution pattern. Try one of {{{string.Join("}, {", patterns.Keys)}}}.");
                }

                return replacement(format);
            }));
        }