Ejemplo n.º 1
0
        public static async Task <Tuple <Dictionary <string, Dictionary <DateTime, string> >, List <string> > > GetVersionMappings(string versionMappingFile, List <string> listVersions)
        {
            List <VersionMappingRow> versionMappingRows;

            try
            {
                CsvReadSchema readSchema = new CsvReadSchema(requiredColumns: VersionMappingRow.RequiredRows, optionalColumns: listVersions);
                using (CsvReader reader = new CsvReader(new StreamReader(File.OpenRead(versionMappingFile)), schema: readSchema))
                {
                    versionMappingRows = await reader.ReadAllRows <VersionMappingRow>();
                }

                List <string> versionColumnsPresent = new List <string>(listVersions.Count);
                foreach (string version in listVersions)
                {
                    if (readSchema.ActualColumns.Contains(version))
                    {
                        versionColumnsPresent.Add(version);
                    }
                }

                Dictionary <string, Dictionary <DateTime, string> > versionMapping = new Dictionary <string, Dictionary <DateTime, string> >(versionColumnsPresent.Count);
                foreach (VersionMappingRow row in versionMappingRows)
                {
                    foreach (string version in versionColumnsPresent)
                    {
                        Dictionary <DateTime, string> dateMapping;
                        if (!versionMapping.TryGetValue(version, out dateMapping))
                        {
                            dateMapping             = new Dictionary <DateTime, string>(versionMappingRows.Count);
                            versionMapping[version] = dateMapping;
                        }

                        string value;
                        if (!row.TryGetValue(version, out value))
                        {
                            value = null;
                        }

                        dateMapping[row.PerformanceDate] = value;
                    }
                }

                return(new Tuple <Dictionary <string, Dictionary <DateTime, string> >, List <string> >(versionMapping, versionColumnsPresent));
            }
            catch (Exception ex) when(ex is CsvParsingException || ex is IOException)
            {
                throw new SeatcardSorterException("Unable to parse version mapping file", ex);
            }
        }
Ejemplo n.º 2
0
        public static async Task <Tuple <List <ResultRow>, List <string> > > GetResultRows(string sourceFile)
        {
            List <ResultRow> resultRows;
            List <string>    headers;

            try
            {
                CsvReadSchema schema = new CsvReadSchema(requiredColumns: ResultRow.BaseRows);
                using (CsvReader reader = new CsvReader(new StreamReader(File.OpenRead(sourceFile)), schema))
                {
                    resultRows = await reader.ReadAllRows <ResultRow>();

                    headers = schema.ActualColumns;
                }
            }
            catch (Exception ex) when(ex is CsvParsingException || ex is IOException)
            {
                throw new SeatcardSorterException("Unable to parse source CSV", ex);
            }

            return(new Tuple <List <ResultRow>, List <string> >(resultRows, headers));
        }