Example #1
0
        public static Tuple <List <ResultRow>, List <string> > MapSourceRowsToTargetRows(
            List <string> listVersions,
            Dictionary <string, Dictionary <DateTime, string> > versionMapping,
            List <string> versionColumnsPresent,
            List <SourceRow> sourceRows)
        {
            // Convert source rows to target rows
            Dictionary <uint, List <ResultRow> > resultRowsByCustomerId = new Dictionary <uint, List <ResultRow> >(sourceRows.Count);

            foreach (SourceRow sourceRow in sourceRows)
            {
                List <ResultRow> resultRowsPerCustomer;
                if (!resultRowsByCustomerId.TryGetValue(sourceRow.CustomerNumber, out resultRowsPerCustomer))
                {
                    resultRowsPerCustomer = new List <ResultRow>(1);
                    resultRowsByCustomerId.Add(sourceRow.CustomerNumber, resultRowsPerCustomer);
                }

                ResultRow resultRow = new ResultRow
                {
                    CustomerNumber      = sourceRow.CustomerNumber,
                    PerformanceFullDate = sourceRow.PerformanceDate,
                    PerformanceDate     = sourceRow.PerformanceDate.ToString("MM/dd")
                };

                string version = CsvParsingHelper.DetermineVersion(
                    sourceRow.CustomerNumber,
                    !string.IsNullOrEmpty(sourceRow.List1),
                    !string.IsNullOrEmpty(sourceRow.List2),
                    !string.IsNullOrEmpty(sourceRow.List3),
                    !string.IsNullOrEmpty(sourceRow.List4),
                    !string.IsNullOrEmpty(sourceRow.List5),
                    listVersions);

                resultRow.Version = version;

                if (versionMapping != null &&
                    versionMapping.TryGetValue(version, out Dictionary <DateTime, string> dateMapping) &&
                    dateMapping.TryGetValue(resultRow.PerformanceFullDate, out string mappedValue))
                {
                    resultRow[version] = mappedValue;
                }

                resultRow.YearsSubscribed  = sourceRow.YearsSubscribed;
                resultRow.LetterSalutation = sourceRow.LetterSalutation;
                resultRow.FullName         = CsvParsingHelper.ConstructFullName(sourceRow.FirstName, sourceRow.LastName);
                CsvParsingHelper.DetermineLocation(sourceRow, resultRow);

                resultRowsPerCustomer.Add(resultRow);
            }

            List <ResultRow> resultRows = new List <ResultRow>(resultRowsByCustomerId.Count);

            foreach (List <ResultRow> resultRowsPerCustomer in resultRowsByCustomerId.Values)
            {
                resultRowsPerCustomer.Sort(new ResultRowImportanceComparer());
                resultRows.Add(resultRowsPerCustomer[0]);
            }

            resultRows.Sort(new ResultRowLocationComparer());

            // Output target rows into a new CSV
            List <string> targetRows;

            if (versionColumnsPresent != null)
            {
                targetRows = new List <string>(ResultRow.BaseRows.Count + versionColumnsPresent.Count);
                targetRows.AddRange(ResultRow.BaseRows);
                targetRows.AddRange(versionColumnsPresent);
            }
            else
            {
                targetRows = ResultRow.BaseRows;
            }

            return(new Tuple <List <ResultRow>, List <string> >(resultRows, targetRows));
        }
        public static async Task Main(string[] args)
        {
            if (args == null || args.Length < 1)
            {
                Program.PrintHelp(error: "Missing required arguments");
                return;
            }

            if (args.Length > 4)
            {
                Program.PrintHelp(error: "Too many arguments");
                return;
            }

            string sourceFile          = null;
            string targetFile          = null;
            string listVersionNameFile = null;
            string versionMappingFile  = null;

            for (int i = 0; i < args.Length; i++)
            {
                string arg = args[i];
                if (arg.StartsWith("/?"))
                {
                    Program.PrintHelp();
                    return;
                }

                if (arg.StartsWith("/s:"))
                {
                    sourceFile = arg.Substring(3);
                }
                else if (arg.StartsWith("/t:"))
                {
                    targetFile = arg.Substring(3);
                }
                else if (arg.StartsWith("/v:"))
                {
                    listVersionNameFile = arg.Substring(3);
                }
                else if (arg.StartsWith("/m:"))
                {
                    versionMappingFile = arg.Substring(3);
                }
                else
                {
                    Program.PrintHelp($"Unknown argument {arg}");
                    return;
                }
            }

            if (string.IsNullOrEmpty(sourceFile) ||
                !File.Exists(sourceFile))
            {
                Program.PrintHelp($"Source file {sourceFile} doesn't exist");
                return;
            }

            if (targetFile == null)
            {
                targetFile = Path.Combine(Path.GetDirectoryName(sourceFile), Path.GetFileNameWithoutExtension(sourceFile) + ".sorted.csv");
            }

            if (File.Exists(targetFile))
            {
                Program.PrintHelp($"Target file {targetFile} already exists");
                return;
            }

            if (!string.IsNullOrEmpty(listVersionNameFile) && !File.Exists(listVersionNameFile))
            {
                Program.PrintHelp($"List version name file {listVersionNameFile} doesn't exist");
                return;
            }

            if (string.IsNullOrEmpty(versionMappingFile) || !File.Exists(versionMappingFile))
            {
                Program.PrintHelp($"Version-mapping file {versionMappingFile} doesn't exist");
                return;
            }

            try
            {
                // Parse list version-name file:
                List <string> listVersions = CsvParsingHelper.DefaultListVersions;
                if (!string.IsNullOrEmpty(listVersionNameFile))
                {
                    listVersions = await CsvParsingHelper.GetListVersions(listVersionNameFile);
                }

                // Parse version mapping file:
                Dictionary <string, Dictionary <DateTime, string> > versionMapping = null;
                List <string> versionColumnsPresent = null;
                if (!string.IsNullOrEmpty(versionMappingFile))
                {
                    (versionMapping, versionColumnsPresent) = await CsvParsingHelper.GetVersionMappings(versionMappingFile, listVersions);
                }

                // Parse source rows from the CSV
                List <SourceRow> sourceRows = await CsvParsingHelper.GetSourceRows(sourceFile);

                (List <ResultRow> rows, List <string> headers) = CsvParsingHelper.MapSourceRowsToTargetRows(listVersions, versionMapping, versionColumnsPresent, sourceRows);

                await CsvParsingHelper.WriteResultRows(targetFile, rows, headers);
            }
            catch (SeatcardSorterException ex)
            {
                Program.PrintHelp(ex.ToString());
            }
        }
Example #3
0
        private static void DetermineLocation(SourceRow sourceRow, ResultRow resultRow)
        {
            if (string.IsNullOrEmpty(sourceRow.Section) ||
                string.IsNullOrEmpty(sourceRow.Location))
            {
                resultRow.Level    = CsvParsingHelper.ErrorString;
                resultRow.Location = CsvParsingHelper.ErrorString + sourceRow.Location;
                return;
            }

            Match sectionMatch = CsvParsingHelper.sourceSectionParser.Match(sourceRow.Section);

            if (!sectionMatch.Success)
            {
                throw new SeatcardSorterException($"Couldn't parse section for customer_no {sourceRow.CustomerNumber}");
            }

            MatchCollection locationMatches = CsvParsingHelper.sourceLocationParser.Matches(sourceRow.Location);

            if (locationMatches.Count < 1)
            {
                throw new SeatcardSorterException($"Couldn't parse location for customer_no {sourceRow.CustomerNumber}");
            }

            string sectionLevel = sectionMatch.Groups[1].Value;

            resultRow.Section = sectionMatch.Groups[3].Value;

            if (locationMatches.Count > 2)
            {
                resultRow.Level    = CsvParsingHelper.ErrorString;
                resultRow.Location = CsvParsingHelper.ErrorString + sourceRow.Location;
                return;
            }

            if (locationMatches.Count == 1)
            {
                Match  locationMatch = locationMatches[0];
                string locationLevel = locationMatch.Groups[2].Value;
                string row           = locationMatch.Groups[4].Value;
                string seat          = locationMatch.Groups[5].Value;
                if (!uint.TryParse(seat, out uint seatNumber))
                {
                    throw new SeatcardSorterException($"Couldn't parse location seat number for customer_no {sourceRow.CustomerNumber}");
                }

                if (!CsvParsingHelper.LevelsMatch(locationLevel, sectionLevel))
                {
                    resultRow.Level    = CsvParsingHelper.ErrorString;
                    resultRow.Location = CsvParsingHelper.ErrorString + sourceRow.Location;
                }
                else
                {
                    resultRow.Level      = locationLevel;
                    resultRow.Row        = row;
                    resultRow.SeatNumber = seatNumber;

                    resultRow.Location = CsvParsingHelper.GenerateLocation(resultRow.Level, resultRow.Section, resultRow.Row, resultRow.SeatNumber);
                }
            }
            else // if (locationMatches.Count == 2)
            {
                Match firstLocationMatch  = locationMatches[0];
                Match secondLocationMatch = locationMatches[1];

                string firstLocationLevel  = firstLocationMatch.Groups[2].Value;
                string secondLocationLevel = secondLocationMatch.Groups[2].Value;

                char firstAisle      = firstLocationMatch.Groups[3].Value[0];
                char secondAisle     = secondLocationMatch.Groups[3].Value[0];
                int  aisleDifference = firstAisle - secondAisle;
                if (!string.Equals(firstLocationLevel, secondLocationLevel) ||
                    !CsvParsingHelper.LevelsMatch(firstLocationLevel, sectionLevel) ||
                    aisleDifference < -1 ||
                    aisleDifference > 1)
                {
                    resultRow.Level    = CsvParsingHelper.ErrorString;
                    resultRow.Location = CsvParsingHelper.ErrorString + sourceRow.Location;
                }
                else
                {
                    string row  = firstLocationMatch.Groups[4].Value;
                    string seat = firstLocationMatch.Groups[5].Value;
                    uint   seatNumber;
                    if (!uint.TryParse(seat, out seatNumber))
                    {
                        throw new SeatcardSorterException($"Couldn't parse location seat number for customer_no {sourceRow.CustomerNumber}");
                    }

                    resultRow.Level      = firstLocationLevel;
                    resultRow.Row        = row;
                    resultRow.SeatNumber = seatNumber;
                    resultRow.Location   = CsvParsingHelper.GenerateLocation(resultRow.Level, resultRow.Section, resultRow.Row, resultRow.SeatNumber);
                }
            }
        }