示例#1
0
        public static Task <ExitCode> CreateReport(ExcelReportOptions opts, TextWriter stdErr)
        {
            if (!File.Exists(opts.PathToHealthExportFile))
            {
                return(Task.FromResult(ExitCode.ExportFileNotFound(opts.PathToHealthExportFile)));
            }
            if (File.Exists(opts.OutputFilename))
            {
                return(Task.FromResult(ExitCode.ExportFileExists(opts.OutputFilename)));
            }

            var loader = Usable.Using(new StreamReader(opts.PathToHealthExportFile), reader =>
                                      ZipUtilities.ReadArchive(
                                          reader.BaseStream,
                                          entry => entry.FullName == "apple_health_export/export.xml",
                                          entry => new XmlReaderExportLoader(entry.Open()))
                                      .FirstOrDefault());

            var settings = GetSettings(opts, stdErr);

            var(package, customSheets) = GetCustomSheets(opts, stdErr);

            using (var excelFile = new ExcelPackage())
                using (package)
                {
                    var timeZone = DateTimeZone.ForOffset(Offset.FromHours(-5));
                    ExcelReport.BuildReport(loader.Records, loader.Workouts, excelFile.Workbook, settings, timeZone, customSheets);

                    excelFile.SaveAs(new FileInfo(opts.OutputFilename));
                }

            return(Task.FromResult(ExitCode.Success));
        }
示例#2
0
        public void Stopwatch_WhenMultipleOperations_ThenElapsedIncrements()
        {
            using (var trace = new TraceListenerScope())
            {
                var usable =
                    // Stopwatch usable starts counting the moment somebody calls Use().
                    from stopwatch in Usable.Stopwatch()
                    from outer in Usable.Using(() => new TraceSourceScope("outer"))
                    // Snapshot elapsed to know how long it took to instantiate outer.
                    let elapsedOuter = stopwatch.Elapsed
                                       from inner in new TraceSourceScope("inner")
                                       // Snapshot elapsed to know how long it took to instantiate inner.
                                       let elapsedInner = stopwatch.Elapsed - elapsedOuter
                                       // Snapshot elapsed to know how long it took for the entire operation.
                                                          let elapsedTotal = stopwatch.Elapsed
                                       // Return computed value together with all the timing information.
                                                                             select new
                {
                    Value        = string.Join('/', outer.Operation, inner.Operation, "value").Trace(),
                    ElapsedOuter = elapsedOuter,
                    ElapsedInner = elapsedInner,
                    ElapsedTotal = elapsedTotal,
                };
                var expectedTrace = new string[]
                {
                    "Enter: outer",
                    "    Enter: inner",
                    "        Value: outer/inner/value",
                    "    Leave: inner",
                    "Leave: outer",
                };

                Assert.Equal(new string[0], trace.ToLines());

                var value = usable.Value();
                Assert.Equal("outer/inner/value", value.Value);
                Assert.True(value.ElapsedOuter < value.ElapsedTotal);
                Assert.True(value.ElapsedInner < value.ElapsedTotal);
                Assert.Equal(expectedTrace, trace.ToLines());
            }

            Assert.Equal(0, Trace.IndentLevel);
        }