public GetSyntheticCovidCasesQueryHandler(ICsvContext csvContext)
{
_csvContext = csvContext;
}
public static Task WriteRecordsAsync <TRecord, TRecordMap>(this ICsvWriterService csvWriterService, IEnumerable <TRecord> records, string fileName, ICsvContext csvContext = null)
where TRecordMap : ClassMap, new()
{
Argument.IsNotNull(() => csvWriterService);
if (csvContext == null)
{
csvContext = new CsvContext <TRecord, TRecordMap>();
}
return(WriteRecordsAsync(csvWriterService, records, fileName, csvContext));
}
public static CsvWriter CreateWriter(this ICsvWriterService csvWriterService, string fileName, ICsvContext csvContext)
{
Argument.IsNotNull(() => csvWriterService);
var dependencyResolver = csvWriterService.GetDependencyResolver();
var fileService = dependencyResolver.Resolve <IFileService>();
// Note: don't dispose, the writer cannot be used when disposed
var stream = fileService.Open(fileName, FileMode.Create, FileAccess.Write, FileShare.Read);
var streamWriter = new StreamWriter(stream);
return(csvWriterService.CreateWriter(streamWriter, csvContext));
}
protected virtual Configuration EnsureCorrectConfiguration(Configuration configuration, ICsvContext csvContext)
{
configuration = configuration ?? CreateDefaultConfiguration(csvContext);
// Always create a new config object so we can wrap it
var finalConfiguration = new Configuration
{
AllowComments = configuration.AllowComments,
BufferSize = configuration.BufferSize,
BuildRequiredQuoteChars = configuration.BuildRequiredQuoteChars,
Comment = configuration.Comment,
CountBytes = configuration.CountBytes,
CultureInfo = csvContext.Culture ?? configuration.CultureInfo,
Delimiter = configuration.Delimiter,
DetectColumnCountChanges = configuration.DetectColumnCountChanges,
Encoding = configuration.Encoding,
GetConstructor = configuration.GetConstructor,
HasHeaderRecord = configuration.HasHeaderRecord,
HeaderValidated = configuration.HeaderValidated,
IgnoreBlankLines = configuration.IgnoreBlankLines,
IgnoreQuotes = configuration.IgnoreQuotes,
IgnoreReferences = configuration.IgnoreReferences,
IncludePrivateMembers = configuration.IncludePrivateMembers,
InjectionCharacters = configuration.InjectionCharacters,
InjectionEscapeCharacter = configuration.InjectionEscapeCharacter,
MemberTypes = configuration.MemberTypes,
PrepareHeaderForMatch = configuration.PrepareHeaderForMatch,
Quote = configuration.Quote,
QuoteAllFields = configuration.QuoteAllFields,
QuoteNoFields = configuration.QuoteNoFields,
ReferenceHeaderPrefix = configuration.ReferenceHeaderPrefix,
SanitizeForInjection = configuration.SanitizeForInjection,
ShouldSkipRecord = configuration.ShouldSkipRecord,
ShouldUseConstructorParameters = configuration.ShouldUseConstructorParameters,
TrimOptions = configuration.TrimOptions,
TypeConverterCache = configuration.TypeConverterCache,
TypeConverterOptionsCache = configuration.TypeConverterOptionsCache,
UseNewObjectForNullReferenceMembers = configuration.UseNewObjectForNullReferenceMembers
};
// Note: configuration.Maps can be ignored
finalConfiguration.BadDataFound = (context) =>
{
Log.Warning($"Found bad data, row '{context.Row}', char position '{context.CharPosition}', field '{context.Field}'");
var handler = configuration.BadDataFound;
if (handler != null)
{
handler(context);
}
};
finalConfiguration.HeaderValidated = (isValid, headers, index, context) =>
{
if (!isValid)
{
var headerNames = string.Join(", ", headers);
Log.Warning($"Header matching '{headerNames}' names at index '{index}' was not found");
}
var handler = configuration.HeaderValidated;
if (handler != null)
{
handler(isValid, headers, index, context);
}
};
finalConfiguration.MissingFieldFound = (fields, position, context) =>
{
// Don't log when fields are null, special case for which we don't want to pollute the logs
if (fields != null)
{
var ignoreWarning = true;
// This could be a *mapped* field that is not part of the file (thus should not have a header record entry either)
var headerRecord = context.HeaderRecord;
if (headerRecord != null)
{
foreach (var field in fields)
{
if (headerRecord.Contains(field))
{
ignoreWarning = false;
}
else if (context.Row <= 2)
{
var classMap = csvContext.ClassMap?.GetType()?.Name ?? "no-class-map";
Log.Debug("Found field '{0}' defined in class map '{1}', but it's not defined in the actual file", field, classMap);
}
}
}
if (!ignoreWarning)
{
Log.Warning("Found '{0}' missing fields at row '{1}', char position '{1}': '{2}'", fields.Length, context.Row, position, string.Join(",", fields));
}
}
var handler = configuration.MissingFieldFound;
if (handler != null)
{
handler(fields, position, context);
}
};
finalConfiguration.ReadingExceptionOccurred = (ex) =>
{
var readingContext = ex.ReadingContext;
// We always read from a csv file so we know we have a file stream
var fileName = string.Empty;
if (ex.ReadingContext.Reader is StreamReader streamReader)
{
if (streamReader.BaseStream is FileStream fileStream)
{
fileName = fileStream.Name;
}
}
var messageBuilder = new StringBuilder();
messageBuilder.Append("An exception occurred during reading");
if (!string.IsNullOrWhiteSpace(fileName))
{
messageBuilder.Append($", file: '{fileName}'");
}
if (readingContext != null)
{
messageBuilder.Append($", row '{readingContext.Row}'");
var columnName = readingContext.Field;
if (ex is TypeConverterException typeConverterException)
{
if (typeConverterException.MemberMapData.IsNameSet)
{
columnName = typeConverterException.MemberMapData.Names.FirstOrDefault();
}
else
{
columnName = $"idx: {typeConverterException.MemberMapData.Index}";
}
messageBuilder.Append($", content '{typeConverterException.Text}'");
var propertyName = typeConverterException.MemberMapData.Member.Name;
messageBuilder.Append($", property '{propertyName}'");
}
//if (ex is BadDataException badDataException)
//{
//}
//if (ex is ParserException parserException)
//{
//}
//if (ex is ReaderException readerException)
//{
//}
messageBuilder.Append($", column '{columnName}'");
}
var writingContext = ex.WritingContext;
if (writingContext != null)
{
messageBuilder.Append($", row '{writingContext.Row}'");
}
messageBuilder.Append($", message: '{ex.Message}'");
var message = messageBuilder.ToString();
Log.Error(message);
var handler = configuration.ReadingExceptionOccurred;
if (handler != null)
{
handler(ex);
}
};
if (csvContext.ClassMap != null)
{
finalConfiguration.RegisterClassMap(csvContext.ClassMap);
}
return(finalConfiguration);
}
public static async Task WriteRecordsAsync(this ICsvWriterService csvWriterService, IEnumerable records, string fileName, ICsvContext csvContext)
{
Argument.IsNotNull(() => csvWriterService);
var dependencyResolver = csvWriterService.GetDependencyResolver();
var fileService = dependencyResolver.Resolve <IFileService>();
using (var stream = fileService.Open(fileName, FileMode.Create, FileAccess.Write, FileShare.Read))
{
using (var streamWriter = new StreamWriter(stream))
{
await csvWriterService.WriteRecordsAsync(records, streamWriter, csvContext);
}
}
}
protected virtual void WriteRecords(IEnumerable records, CsvWriter csvWriter, ICsvContext csvContext)
{
try
{
// Note: no need to write the header, the WriteRecords method will take care of that.
//var configuration = csvWriter.Configuration;
//if (configuration.HasHeaderRecord)
//{
// Log.Debug($"Writing header record");
// csvWriter.WriteHeader(csvContext.RecordType);
// csvWriter.NextRecord();
// csvWriter.Flush();
//}
Log.Debug($"Writing records");
csvWriter.WriteRecords(records);
}
catch (Exception)
{
if (csvContext.ThrowOnError)
{
throw;
}
}
}
public virtual async Task WriteRecordsAsync(IEnumerable records, StreamWriter streamWriter, ICsvContext csvContext)
{
using (var csvWriter = CreateWriter(streamWriter, csvContext))
{
WriteRecords(records, csvWriter, csvContext);
await csvWriter.FlushAsync();
}
}
public virtual void WriteRecords(IEnumerable records, StreamWriter streamWriter, ICsvContext csvContext)
{
using (var csvWriter = CreateWriter(streamWriter, csvContext))
{
WriteRecords(records, csvWriter, csvContext);
csvWriter.Flush();
}
}
public HomeController(ICsvContext csvContext)
{
this._csvContext = csvContext;
regionCrud = new RegionCRUD(_csvContext);
}
public static void WriteRecords <TRecord, TRecordMap>(this ICsvWriterService csvWriterService, IEnumerable <TRecord> records, StreamWriter streamWriter, ICsvContext csvContext = null)
where TRecordMap : ClassMap, new()
{
Argument.IsNotNull(() => csvWriterService);
if (csvContext == null)
{
csvContext = new CsvContext <TRecord, TRecordMap>();
}
csvWriterService.WriteRecords(records, streamWriter, csvContext);
}
