private static void FixedWidthSortMurgePurge <T>(string dbConnPath, string line,
                                                         MasterFixedWidthFileSource <T> master,
                                                         DelimitedFileSource <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(mgPurgeParam.DetailFields, 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 = GetNewMasterDataFixedWidth(GetMasterLine <T>(master, mgPurgeParam));
                PerformDataActionForPassiveModeWriter(mgPurgeParam.DataAction, mgPurgeParam.KeyFound, processMode, detailLine, actionWriters);
                PerformDataAction(mgPurgeParam, dbConnPath, processMode, newMasterData, srtKey);
            }
        }
        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 PerformDataAction <T>(MergePurgeParam mgPurgeParam,
                                                  string dbConnPath,
                                                  DataMode processMode,
                                                  string newMasterData,
                                                  SortKey <T> sortKey
                                                  )
        {
            using (SqliteRepository <T> sqlRepo = new SqliteRepository <T>(dbConnPath))
            {
                switch (mgPurgeParam.DataAction)
                {
                case MergePurgeAction.Add:
                    if (!mgPurgeParam.KeyFound)
                    {
                        if (processMode == DataMode.Active)
                        {
                            sqlRepo.Add(sortKey.Key, newMasterData);
                        }
                    }
                    break;

                case MergePurgeAction.Delete:
                    if (mgPurgeParam.KeyFound)
                    {
                        if (processMode == DataMode.Active)
                        {
                            sqlRepo.Delete(sortKey.Id);
                        }
                    }
                    break;

                case MergePurgeAction.Update:
                    if (mgPurgeParam.KeyFound)
                    {
                        if (processMode == DataMode.Active)
                        {
                            sqlRepo.Update(sortKey.Id, newMasterData);
                        }
                    }

                    break;

                default:
                    break;
                }
            }
        }
 private static string GetDetailLine <T>(FixedWidthFileSource <T> detail, MergePurgeParam mgPurgeParam)
 {
     return(mgPurgeParam.DetailFields.SerializeToFixedWidth(detail.FixedWidths));
 }
 private static string GetDetailLine <T>(DelimitedFileSource <T> detail, MergePurgeParam mgPurgeParam)
 {
     return(mgPurgeParam.DetailFields.SerializeToDelimited(detail.Delimiter));
 }
 private static string GetMasterLine <T>(MasterDelimitedFileSource <T> master, MergePurgeParam mgPurgeParam)
 {
     return(mgPurgeParam.MasterFields != null?mgPurgeParam.MasterFields.SerializeToDelimited(master.Delimiter) : string.Empty);
 }
 private static string GetMasterLine <T>(MasterFixedWidthFileSource <T> master, MergePurgeParam mgPurgeParam)
 {
     return(mgPurgeParam.MasterFields != null?mgPurgeParam.MasterFields.SerializeToFixedWidth(master.FixedWidths) : string.Empty);
 }