public async Task <string> CreateFile(CumulativeClaimData data)
        {
            string fileName = $"CD_{ DateTime.Now:yyyyMMddHHmmss}";

            try
            {
                _logger.Info($"Writing cumulative data file {fileName}");
                var filePath = $@"{_config.CumulativeDataFilePath}\{fileName}";
                using (StreamWriter sw = File.AppendText(filePath))
                {
                    await sw.WriteLineAsync(data.EarliestOriginalYear.Value + "," + data.DevelopmentYears);

                    foreach (var cumulativeDataRow in data.Rows)
                    {
                        await sw.WriteLineAsync(cumulativeDataRow.ToString());
                    }
                }

                return(fileName);
            }
            catch (Exception e)
            {
                _logger.Error($"Could not create cumulative data file {fileName}");
                throw;
            }
        }
Пример #2
0
        static async Task Main(string[] args)
        {
            log4net.Config.XmlConfigurator.Configure();
            var container = new UnityContainer();

            try
            {
                container.RegisterType <ILog>(new InjectionFactory(factory => LogManager.GetLogger("Cumulative Data")));
                container.RegisterInstance <IConfig>(new Config
                {
                    CumulativeDataFilePath  = ConfigurationManager.AppSettings["CumulativeDataFilePath"],
                    IncrementalDataFilePath = ConfigurationManager.AppSettings["IncrementalDataFilePath"]
                });
                container.RegisterType <ICsvMapping <IncrementalClaimData>, CsvIncrementalClaimDataMapping>();
                container.RegisterType <IIncrementalDataFileParser, IncrementalDataFileParser>();
                container.RegisterType <ICumulativeClaim, CumulativeClaim>();
                container.RegisterType <ICumulativeDataFileProducer, CumulativeDataFileProducer>();


                var incrementalDataFileParser  = container.Resolve <IncrementalDataFileParser>();
                var cumulativeClaim            = container.Resolve <CumulativeClaim>();
                var cumulativeDataFileProducer = container.Resolve <CumulativeDataFileProducer>();

                List <IncrementalClaimData> incrementalData = await incrementalDataFileParser.Parse();

                CumulativeClaimData cumulativeClaimData = await cumulativeClaim.Process(incrementalData);

                await cumulativeDataFileProducer.CreateFile(cumulativeClaimData);

                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
            catch (Exception e)
            {
                var logger = container.Resolve <ILog>();
                logger.Error(e);
                Console.WriteLine(e);
                Console.WriteLine("Press any key to exit...");
                Console.ReadKey();
            }
        }
        private string serialization(CumulativeClaimData record)
        {
            var data = record.Data.OrderBy(p => p.OriginalYear).ThenBy(p => p.DevelopmentYearNumber).Select(p => p.Amount);

            return(string.Format("{0}, {1}", record.Product, string.Join(", ", data)));
        }