private static void FixedWidthSortMurgePurge <T>(string dbConnPath, string line,
MasterDelimitedFileSource <T> master,
FixedWidthFileSource <T> detail,
MergePurgeParam mgPurgeParam,
Action <MergePurgeParam> processData,
MergePurgeResults mgPurgeResults,
DataMode processMode,
StreamWriter[] actionWriters)
{
SortKey <T> srtKey = null;
using (SqliteRepository <T> sqlRepo = new SqliteRepository <T>(dbConnPath))
{
srtKey = sqlRepo.KeyInDb(detail.GetKey(line));
}
mgPurgeParam.KeyFound = srtKey.Found;
string masterData = !srtKey.Found ? string.Empty : srtKey.Data;
if (mgPurgeParam.KeyFound)
{
mgPurgeParam.MasterFields = GetMasterFields <T>(master, masterData);
}
if (processData != null)
{
processData(mgPurgeParam);
mgPurgeResults.IncrementAction(mpAction: mgPurgeParam.DataAction);
string detailLine = GetDetailLine <T>(detail, mgPurgeParam);
string newMasterData = GetNewMasterDelimitedData <T>(master, GetMasterLine <T>(master, mgPurgeParam));
PerformDataActionForPassiveModeWriter(mgPurgeParam.DataAction, mgPurgeParam.KeyFound, processMode, detailLine, actionWriters);
PerformDataAction(mgPurgeParam, dbConnPath, processMode, newMasterData, srtKey);
}
}
private static string[] GetMasterFields <T>(MasterDelimitedFileSource <T> master, string data)
{
string outLine = SortFileHelpers.UnEscapeByDelimiter(data, master.Delimiter);
string[] results = null;
FileParser.ParseDelimitedString(new StringReader(outLine), (fields, lNum) =>
{
results = fields;
}, master.Delimiter);
return(results);
}
internal static SortResults SortDelimited <T>(MasterDelimitedFileSource <T> master, string destinationFolder)
{
return(SortFile.SortDelimitedByKeyCore <T>(sourcefilePath: master.SourceFilePath,
getKey: master.GetKey,
destinationFolder: destinationFolder,
delimiter: master.Delimiter,
hasHeader: master.HasHeader,
isUniqueKey: false,
sortDir: master.SortDirection,
deleteDbConnPath: false,
writeOutSortFile: false));
}
public static MergePurgeResults MergePurge <T>(MasterDelimitedFileSource <T> master,
FixedWidthFileSource <T> detail,
Action <MergePurgeParam> processData,
string destinationFolder = null,
DataMode processMode = DataMode.Passive)
{
ArgumentValidation <T>(master, detail, processData, destinationFolder);
MergePurgeResults mgPurgeResults = new MergePurgeResults();
SortVars mstSortVars = new SortVars(master.SourceFilePath, destinationFolder);
SortResults srtResults = SortDelimited <T>(master, mstSortVars.DestFolder);
mgPurgeResults.InitFilePaths(master.SourceFilePath, detail.SourceFilePath, mstSortVars.DestFolder);
try
{
string hdr = string.Empty;
using (StreamReader reader = new StreamReader(detail.SourceFilePath))
using (StreamWriter addSw = new StreamWriter(mgPurgeResults.AddsFilePath))
using (StreamWriter delSw = new StreamWriter(mgPurgeResults.DeletesFilePath))
using (StreamWriter updSw = new StreamWriter(mgPurgeResults.UpdatesFilePath))
using (StreamWriter ignSw = new StreamWriter(mgPurgeResults.IgnoredFilePath))
{
StreamWriter[] actionWriters = { addSw, delSw, updSw, ignSw };
string line;
hdr = GetHeader(detail.HasHeader, reader);
WriteHeaderToActionWriters(processMode, detail.HasHeader, hdr, actionWriters);
while ((line = reader.ReadLine()) != null)
{
MergePurgeParam mgPurgeParam = new MergePurgeParam();
FileParser.ParseFixedWidthString(new StringReader(line), (fields, lNum) =>
{
mgPurgeParam.DetailFields = fields;
mgPurgeParam.DataAction = MergePurgeAction.Ignore;
}, detail.FixedWidths);
FixedWidthSortMurgePurge <T>(srtResults.DbConnPath, line, master, detail, mgPurgeParam, processData, mgPurgeResults, processMode, actionWriters);
}
}
mgPurgeResults.ClearSubFilesIfNoCount();
if (processMode == DataMode.Active)
{
mgPurgeResults.RemoveSubFilesAndFilePaths();
}
srtResults.SortedFilePath = mgPurgeResults.NewMasterFilePath;
srtResults.WriteOutSorted(dbConnPath: srtResults.DbConnPath, header: srtResults.Header, sortDir: master.SortDirection, delimiter: master.Delimiter, deleteDb: true);
}
catch (Exception)
{
ExceptionCleanUp(srtResults.DbConnPath, mgPurgeResults);
throw;
}
return(mgPurgeResults);
}
private static void ArgumentValidation <T>(MasterDelimitedFileSource <T> master, FixedWidthFileSource <T> detail, Action <MergePurgeParam> processData, string destinationFolder = null)
{
if ((master.GetKey != null && detail.GetKey == null) || (master.GetKey == null && detail.GetKey != null))
{
throw new ArgumentException("Master and Detail must have the same GetKey function type defined.");
}
if (master.GetKey == null)
{
throw new ArgumentException("The Master File Source must have a GetKey function defined.");
}
if (detail.GetKey == null)
{
throw new ArgumentException("The Detail File Source must have a GetKey function defined.");
}
ArgumentValidation <T>(master);
ArgumentValidation <T>(detail);
ArgumentValidation(processData);
ArgumentValidation(destinationFolder);
ArgumentValidation((IFileSource)master);
ArgumentValidation((IFileSource)detail);
}
private static string GetNewMasterDelimitedData <T>(MasterDelimitedFileSource <T> master, string masterLine)
{
return(masterLine + SortFileHelpers.EscapeByDelimiter(master.Delimiter));
}
private static string GetMasterLine <T>(MasterDelimitedFileSource <T> master, MergePurgeParam mgPurgeParam)
{
return(mgPurgeParam.MasterFields != null?mgPurgeParam.MasterFields.SerializeToDelimited(master.Delimiter) : string.Empty);
}