예제 #1
0
        private List <WidgetViewModel> CreateWidgetViewModels()
        {
            var widgetViewModels = new List <WidgetViewModel>();
            var widgets          = _objectRepository.Set <WidgetModel>().OrderBy(v => v.Order).ToList();

            foreach (var w in widgets)
            {
                try
                {
                    switch (w)
                    {
                    case var wi when w.Properties.Count(s => !string.IsNullOrWhiteSpace(s.Value)) == 0:
                        widgetViewModels.Add(new UnconfiguredWidgetViewModel(wi));

                        break;

                    case var wi when w.Kind == WidgetKind.LastValue:
                        widgetViewModels.Add(new LastValueWidgetViewModel(wi, _vm, Period));
                        break;

                    case var wi when w.Kind == WidgetKind.Expenses:
                        widgetViewModels.Add(new ExpensesWidgetViewModel(wi, _objectRepository, Period));
                        break;

                    case var wi when w.Kind == WidgetKind.Donut:
                        widgetViewModels.Add(new DonutWidgetViewModel(wi, Period, _vm.GetVM()));
                        break;

                    case var wi when w.Kind == WidgetKind.LinearChart:
                        widgetViewModels.Add(new LinearChartWidgetViewModel(wi, Period, _vm.GetVM()));
                        break;

                    case var wi when w.Kind == WidgetKind.Delta:
                        widgetViewModels.Add(new DeltaWidgetViewModel(wi, _vm.GetVM()));
                        break;

                    default:
                        widgetViewModels.Add(new UnknownWidgetViewModel(w));
                        break;
                    }
                }
                catch (Exception ex)
                {
                    widgetViewModels.Add(new ExceptionWidgetViewModel(w, ex));
                }
            }

            return(widgetViewModels);
        }
        public LastValueWidgetViewModel(WidgetModel model, TableViewModelFactory vmf,
                                        int?period) : base(model, new LastValueWidgetSettings(model.Properties.ToDictionary(v => v.Key, v => v.Value)))
        {
            _settings = (LastValueWidgetSettings)Settings;
            var vm = vmf.GetVM();

            var column = vm.Headers.First(v =>
                                          v.Provider == _settings.ProviderName &&
                                          (v.AccountName == _settings.AccountName || v.UserFriendlyName == _settings.AccountName));


            var tableRowViewModel = vm.Values.OrderByDescending(v => v.When).FirstOrDefault(v => v.CalculatedCells.GetValueOrDefault(column)?.IsOk == true);

            var matchedCell = tableRowViewModel?.CalculatedCells.GetValueOrDefault(column);

            CurrentValue = matchedCell?.Value;
            CurrentDate  = matchedCell?.Money?.When ?? tableRowViewModel?.When.Date ?? DateTime.MinValue;

            var p = new PercentageCalculator();

            Values = new Dictionary <DateTime, double?>();
            bool first = true;

            foreach (var row in vm.Values.OrderByDescending(v => v.When).Where(v => IsApplicable(v.When, period)))
            {
                var cell = row.CalculatedCells.GetValueOrDefault(column);

                var value = _settings.ExemptTransfers ? cell?.AdjustedValue : cell?.Value;

                if (value == null || double.IsNaN(value.Value))
                {
                    continue;
                }

                p.PushValue(row.When, cell.Value.Value, cell.Adjustment);

                Values[cell.Money?.When ?? row.When.Date] = value;
                IncompleteData |= cell.FailedToResolve.Any();

                if (first)
                {
                    first = false;

                    (Color, Delta) = SetDiffPercenage(cell.DiffPercentage);
                }
            }

            p.Finalize(this);

            IncompleteData |= _settings.NotifyStaleData && (!Values.Any() || Values.Select(v => v.Key).Max() < DateTime.Now.AddHours(-36));

            if (IsCompact)
            {
                Values = null;
            }
        }