public IMarketFileParseResult ParseFile(ImportFileContext context, FileInfo file, IMarketFileParser parser)
{
try
{
using (var stream = file.Open(FileMode.Open, FileAccess.Read, FileShare.None))
{
return(parser.Parse(stream));
}
}
catch (Exception ex)
{
if (ex is IOException)
{
var code = Marshal.GetHRForException(ex) & ((1 << 16) - 1);
if (code == 32 || code == 33)
{
logger.ErrorFormat(ex,
"Unable to access file \"{0}\". Attempt to read file will be made in the next iteration.",
file.FullName);
return(null);
}
}
logger.ErrorFormat(ex, "Unknown error occurred while parsing file \"{0}\".", file);
MarkFileAsErrored(context, file, ex);
MoveFile(file, context.DirectoryInException);
}
return(null);
}
public static IMarketFileParser GetXmlParser(ImportFileContext context, ILogger logger)
{
var fileType = context.FileType;
switch (fileType)
{
case "248":
return(new Import248Xml(logger));
case "650":
return(new Import650Xml(logger));
case "810":
return(new Import810Xml(logger));
case "814":
var marketDataAccess = new MarketDataAccess(context.MarketConnectionString);
return(new Import814Xml(marketDataAccess, logger));
case "820":
return(new Import820Xml(logger));
case "824":
return(new Import824Xml(logger));
case "867":
return(new Import867Xml(logger));
case "997":
return(new Import997Xml(logger));
}
throw new ArgumentOutOfRangeException(fileType);
}
public static IMarketFileParser GetPrismParser(ImportFileContext context, ILogger logger)
{
var clientDataAccess = new ClientDataAccess(context.ClientConnectionString);
var fileType = context.FileType;
switch (fileType)
{
case "650":
return(new Import650Prism(clientDataAccess, logger));
case "810":
return(new Import810Prism(clientDataAccess, logger));
case "814":
return(new Import814Prism(clientDataAccess, logger));
case "820":
return(new Import820Prism(clientDataAccess, logger));
case "824":
return(new Import824Prism(clientDataAccess, logger));
case "867":
return(new Import867Prism(clientDataAccess, logger));
case "CBF":
return(new ImportCustomerInfo(clientDataAccess, logger));
}
throw new ArgumentOutOfRangeException(fileType);
}
public static IImportTransactionHandler GetXmlHandler(ImportFileContext context, ILogger logger)
{
var fileType = context.FileType;
var connectionString = context.MarketConnectionString;
switch (fileType)
{
case "248":
{
var dataAccess = new Import248XmlDataAccess(connectionString);
return(new Import248Handler(dataAccess, logger));
}
case "650":
{
var dataAccess = new Import650XmlDataAccess(connectionString);
return(new Import650Handler(dataAccess, logger));
}
case "810":
{
var dataAccess = new Import810XmlDataAccess(connectionString);
return(new Import810Handler(dataAccess, logger));
}
case "814":
{
var dataAccess = new Import814XmlDataAccess(connectionString);
return(new Import814Handler(dataAccess, logger));
}
case "820":
{
var dataAccess = new Import820XmlDataAccess(connectionString);
return(new Import820Handler(dataAccess, logger));
}
case "824":
{
var dataAccess = new Import824XmlDataAccess(connectionString);
return(new Import824Handler(dataAccess, logger));
}
case "867":
{
var dataAccess = new Import867XmlDataAccess(connectionString);
return(new Import867Handler(dataAccess, logger));
}
case "997":
{
var dataAccess = new Import997XmlDataAccess(connectionString);
return(new Import997Handler(dataAccess, logger));
}
}
throw new ArgumentOutOfRangeException(fileType);
}
public static IImportTransactionHandler GetPrismHandler(ImportFileContext context, ILogger logger)
{
var fileType = context.FileType;
var connectionString = context.MarketConnectionString;
switch (fileType)
{
case "650":
{
var dataAccess = new Import650PrismDataAccess(connectionString);
return(new Import650Handler(dataAccess, logger));
}
case "810":
{
var dataAccess = new Import810PrismDataAccess(connectionString);
return(new Import810Handler(dataAccess, logger));
}
case "814":
{
var dataAccess = new Import814PrismDataAccess(connectionString);
return(new Import814Handler(dataAccess, logger));
}
case "820":
{
var dataAccess = new Import820PrismDataAccess(connectionString);
return(new Import820Handler(dataAccess, logger));
}
case "824":
{
var dataAccess = new Import824PrismDataAccess(connectionString);
return(new Import824Handler(dataAccess, logger));
}
case "867":
{
var dataAccess = new Import867PrismDataAccess(connectionString);
return(new Import867Handler(dataAccess, logger));
}
case "CBF":
{
var dataAccess = new ImportCustomerInfoDataAccess(connectionString);
return(new ImportClientInfoHandler(dataAccess, logger));
}
}
throw new ArgumentOutOfRangeException(fileType);
}
public void MarkFileAsErrored(ImportFileContext context, FileInfo file, Exception ex)
{
marketFileDataAccess.InsertMarketFile(new MarketFileModel
{
CspDunsId = 0,
LdcId = 0,
DirectionFlag = true,
FileName = file.Name,
FileType = context.FileType,
ProcessError = ex.Message,
ProcessStatus = "N",
Status = MarketFileStatusOptions.Error,
});
}
public static ImportFileContext[] CreateXmlContext(ImportConfigurationModel configuration)
{
return(new[]
{
ImportFileContext.CreateXml("810*.xml", "810", configuration),
ImportFileContext.CreateXml("814*.xml", "814", configuration),
ImportFileContext.CreateXml("867*.xml", "867", configuration),
ImportFileContext.CreateXml("LSE*.xml", "867", configuration),
ImportFileContext.CreateXml("650*.xml", "650", configuration),
ImportFileContext.CreateXml("820*.xml", "820", configuration),
ImportFileContext.CreateXml("824*.xml", "824", configuration),
ImportFileContext.CreateXml("997*.xml", "997", configuration),
ImportFileContext.CreateXml("248*.xml", "248", configuration)
});
}
public static ImportFileContext[] CreatePrismContext(ImportConfigurationModel configuration)
{
return(new[]
{
ImportFileContext.CreatePrism("*_810.*", "810", configuration),
ImportFileContext.CreatePrism("*_814.*", "814", configuration),
ImportFileContext.CreatePrism("*_867.*", "867", configuration),
ImportFileContext.CreatePrism("*_LSE.*", "867", configuration),
ImportFileContext.CreatePrism("*_650.*", "650", configuration),
ImportFileContext.CreatePrism("*_820.*", "820", configuration),
ImportFileContext.CreatePrism("*_824.*", "824", configuration),
ImportFileContext.CreatePrism("*_MTCRCustomerInformation.*", "CBF", configuration),
ImportFileContext.CreatePrism("*_MTERCOT2CR.*", "CBF", configuration)
});
}
public static IImportTransactionHandler GetHandler(ImportFileContext context, ILogger logger)
{
return((context.ProviderId == 1)
? GetPrismHandler(context, logger)
: GetXmlHandler(context, logger));
}
public void Execute(ImportFileContext context, CancellationToken token)
{
var directoryInfo = new DirectoryInfo(context.DirectoryIn);
if (!directoryInfo.Exists)
{
throw new DirectoryNotFoundException();
}
var fileList = directoryInfo.GetFiles(context.FilePattern, SearchOption.TopDirectoryOnly);
logger.TraceFormat("Identified {0} file(s) in directory \"{1}\" with search pattern \"{2}\".",
fileList.Length, directoryInfo.FullName, context.FilePattern);
if (fileList.Length == 0)
{
return;
}
var parser = ImportParserFactory.GetParser(context, logger);
var handler = ImportHandlerFactory.GetHandler(context, logger);
logger.DebugFormat("Iterating over {0} \"{1}\" file(s).", fileList.Length, context.FileType);
using (logger.NestLog(context.FileType))
{
foreach (var file in fileList)
{
if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
if (context.ProviderId == 1)
{
var fileExists = marketFileDataAccess.MarketFileExists(file.Name);
if (fileExists)
{
logger.ErrorFormat("{0} Transaction file \"{1}\" already exists.", context.FileType,
file.Name);
logger.DebugFormat("File \"{0}\" moved to Exception folder.", file.Name);
MoveFile(file, context.DirectoryInException);
continue;
}
}
var result = ParseFile(context, file, parser);
if (result == null)
{
logger.ErrorFormat("Unable to parse file \"{0}\".", file.Name);
continue;
}
if (token.IsCancellationRequested)
{
token.ThrowIfCancellationRequested();
}
logger.DebugFormat("Parsed {0} \"{1}\" transaction(s) from file \"{2}\".",
result.Headers.Length, context.FileType, file.Name);
var headers = result.Headers;
if (!headers.Any())
{
var archivePath = Path.Combine(context.DirectoryInArchive, DateTime.Now.ToString("yyyyMM"));
MoveFile(file, archivePath);
continue;
}
ImportResult(context, file, result, handler);
}
}
}
public void ImportResult(ImportFileContext context, FileInfo file, IMarketFileParseResult result, IImportTransactionHandler handler)
{
var imported = false;
var marketFile = new MarketFileModel
{
DirectionFlag = true,
FileName = file.Name,
FileType = context.FileType,
ProcessError = string.Empty,
ProcessStatus = "N",
LdcId = 0,
CspDunsId = 0,
};
try
{
var options = new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
};
using (var scope = new TransactionScope(TransactionScopeOption.Required, options))
{
if (context.ProviderId == 2)
{
marketFile.ProcessStatus = "Y";
marketFile.SenderTranNum = result.InterchangeControlNbr;
marketFile.TransactionCount = result.TransactionAuditCount;
}
marketFile.Status = MarketFileStatusOptions.Imported;
marketFile.ProcessDate = DateTime.Now;
var marketFileId = marketFileDataAccess.InsertMarketFile(marketFile);
foreach (var header in result.Headers)
{
handler.ProcessHeader(header, marketFileId);
}
marketFileDataAccess.InsertAuditRecord(marketFileId,
result.TransactionAuditCount, result.TransactionActualCount);
if (result.TransactionAuditCount != result.TransactionActualCount)
{
logger.ErrorFormat(
"Transaction Count does not match Transaction Audit Count. File Name \"{0}\".", file.Name);
}
logger.InfoFormat("Imported {0} \"{1}\" transaction(s). File Name \"{2}\".",
result.Headers.Length, context.FileType, file.Name);
imported = true;
scope.Complete();
}
var archivePath = Path.Combine(context.DirectoryInArchive, DateTime.Now.ToString("yyyyMM"));
MoveFile(file, archivePath);
}
catch (Exception ex)
{
logger.ErrorFormat(ex, "Unknown error occurred while import file \"{0}\".", file);
if (!imported)
{
MarkFileAsErrored(context, file, ex);
}
MoveFile(file, context.DirectoryInException);
}
}
public static IMarketFileParser GetParser(ImportFileContext context, ILogger logger)
{
return((context.ProviderId == 1)
? GetPrismParser(context, logger)
: GetXmlParser(context, logger));
}
