Exemplo n.º 1
0
 private static void ExceptionCleanUp(string dbConnPath, MergePurgeResults mgPurgeResults)
 {
     SortFileHelpers.DeleteFileIfExists(dbConnPath);
     SortFileHelpers.DeleteFileIfExists(Path.Combine(Path.GetDirectoryName(dbConnPath), SortFileHelpers.GetDbJournalName(dbConnPath)));
     mgPurgeResults.DeleteActionFiles();
     SortFileHelpers.DeleteFileIfExists(mgPurgeResults.NewMasterFilePath);
 }
Exemplo n.º 2
0
        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);
            }
        }
Exemplo n.º 3
0
        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);
        }