public RegionSelectorService(
ISharedContext sharedContext,
IFactory <RegionSelectorWindow> regionSelectorWindowFactory)
{
this.sharedContext = sharedContext;
this.regionSelectorWindowFactory = regionSelectorWindowFactory;
}
public DomesticPaymentConsentContext DomesticPaymentConsent(string openBankingClientProfileId)
{
openBankingClientProfileId.ArgNotNull(nameof(openBankingClientProfileId));
ISharedContext context = CreateContext();
return(new DomesticPaymentConsentContext(context)
.ApiProfileId(openBankingClientProfileId));
}
public AuraIsActiveTriggerEditor(ISharedContext sharedContext)
{
activeSourceAnchors.AddTo(Anchors);
AuraList = new ReadOnlyObservableCollection <IEyeAuraViewModel>(sharedContext.AuraList);
this.WhenAnyValue(x => x.Source)
.Subscribe(HandleSourceChange)
.AddTo(Anchors);
}
public AuraIsActiveTrigger([NotNull] ISharedContext sharedContext)
{
Observable.Merge(
this.WhenAnyValue(x => x.AuraId).ToUnit(),
sharedContext.AuraList.ToObservableChangeSet().SkipInitial().ToUnit(),
sharedContext.AuraList.ToObservableChangeSet().SkipInitial().WhenPropertyChanged(x => x.Id).ToUnit())
.StartWithDefault()
.Select(x => sharedContext.AuraList.FirstOrDefault(y => y.Id == AuraId))
.Subscribe(x => Aura = x)
.AddTo(Anchors);
this.WhenAnyValue(x => x.Aura)
.Select(x => x == null
? Observable.Return(false)
: x.WhenAnyValue(y => y.IsActive).Do(y => Log.Debug($"Child Aura {x.TabName}({x.Id}) IsActive changed to {x.IsActive}")))
.Switch()
.Subscribe(isActive => IsActive = isActive, Log.HandleUiException)
.AddTo(Anchors);
}
internal PaymentInitiationApiProfileContext(ISharedContext context)
{
Context = context;
}
internal BankClientProfileContext(ISharedContext context)
{
Context = context.ArgNotNull(nameof(context));
}
public MainWindowViewModel(
[NotNull] IFactory <IOverlayAuraViewModel, OverlayAuraProperties> auraViewModelFactory,
[NotNull] IApplicationUpdaterViewModel appUpdater,
[NotNull] IClipboardManager clipboardManager,
[NotNull] IConfigSerializer configSerializer,
[NotNull] IGenericSettingsViewModel settingsViewModel,
[NotNull] IMessageBoxViewModel messageBox,
[NotNull] IHotkeyConverter hotkeyConverter,
[NotNull] IFactory <HotkeyIsActiveTrigger> hotkeyTriggerFactory,
[NotNull] IConfigProvider <EyeAurasConfig> configProvider,
[NotNull] IConfigProvider rootConfigProvider,
[NotNull] IPrismModuleStatusViewModel moduleStatus,
[NotNull] IMainWindowBlocksProvider mainWindowBlocksProvider,
[NotNull] IFactory <IRegionSelectorService> regionSelectorServiceFactory,
[NotNull] ISharedContext sharedContext,
[NotNull] IComparisonService comparisonService,
[NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler)
{
using var unused = new OperationTimer(elapsed => Log.Debug($"{nameof(MainWindowViewModel)} initialization took {elapsed.TotalMilliseconds:F0}ms"));
TabsList = new ReadOnlyObservableCollection <IEyeAuraViewModel>(sharedContext.AuraList);
ModuleStatus = moduleStatus.AddTo(Anchors);
var executingAssemblyName = Assembly.GetExecutingAssembly().GetName();
Title = $"{(AppArguments.Instance.IsDebugMode ? "[D]" : "")} {executingAssemblyName.Name} v{executingAssemblyName.Version}";
Disposable.Create(() => Log.Info("Disposing Main view model")).AddTo(Anchors);
ApplicationUpdater = appUpdater.AddTo(Anchors);
MessageBox = messageBox.AddTo(Anchors);
Settings = settingsViewModel.AddTo(Anchors);
StatusBarItems = mainWindowBlocksProvider.StatusBarItems;
this.auraViewModelFactory = auraViewModelFactory;
this.configProvider = configProvider;
this.sharedContext = sharedContext;
this.regionSelectorService = regionSelectorServiceFactory.Create();
this.clipboardManager = clipboardManager;
this.configSerializer = configSerializer;
this.hotkeyConverter = hotkeyConverter;
this.hotkeyTriggerFactory = hotkeyTriggerFactory;
CreateNewTabCommand = CommandWrapper.Create(() => AddNewCommandExecuted(OverlayAuraProperties.Default));
CloseTabCommand = CommandWrapper
.Create <IOverlayAuraViewModel>(CloseTabCommandExecuted, CloseTabCommandCanExecute)
.RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab));
DuplicateTabCommand = CommandWrapper
.Create(DuplicateTabCommandExecuted, DuplicateTabCommandCanExecute)
.RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab));
CopyTabToClipboardCommand = CommandWrapper
.Create(CopyTabToClipboardExecuted, CopyTabToClipboardCommandCanExecute)
.RaiseCanExecuteChangedWhen(this.WhenAnyProperty(x => x.SelectedTab).Select(x => x));
PasteTabCommand = CommandWrapper.Create(PasteTabCommandExecuted);
UndoCloseTabCommand = CommandWrapper.Create(UndoCloseTabCommandExecuted, UndoCloseTabCommandCanExecute);
OpenAppDataDirectoryCommand = CommandWrapper.Create(OpenAppDataDirectory);
SelectRegionCommand = CommandWrapper.Create(SelectRegionCommandExecuted);
Observable
.FromEventPattern <OrderChangedEventArgs>(h => positionMonitor.OrderChanged += h, h => positionMonitor.OrderChanged -= h)
.Select(x => x.EventArgs)
.Subscribe(OnTabOrderChanged, Log.HandleUiException)
.AddTo(Anchors);
sharedContext
.AuraList
.ToObservableChangeSet()
.ObserveOn(uiScheduler)
.OnItemAdded(x => SelectedTab = x)
.Subscribe()
.AddTo(Anchors);
this.WhenAnyValue(x => x.SelectedTab)
.Subscribe(x => Log.Debug($"Selected tab: {x}"))
.AddTo(Anchors);
LoadConfig();
rootConfigProvider.Save();
if (sharedContext.AuraList.Count == 0)
{
CreateNewTabCommand.Execute(null);
}
configUpdateSubject
.Sample(ConfigSaveSamplingTimeout)
.Subscribe(SaveConfig, Log.HandleException)
.AddTo(Anchors);
Observable.Merge(
this.WhenAnyProperty(x => x.Left, x => x.Top, x => x.Width, x => x.Height)
.Sample(ConfigSaveSamplingTimeout)
.Select(x => $"[{x.Sender}] Main window property change: {x.EventArgs.PropertyName}"),
sharedContext.AuraList.ToObservableChangeSet()
.Sample(ConfigSaveSamplingTimeout)
.Select(x => "Tabs list change"),
sharedContext.AuraList.ToObservableChangeSet()
.WhenPropertyChanged(x => x.Properties)
.Sample(ConfigSaveSamplingTimeout)
.WithPrevious((prev, curr) => new { prev, curr })
.Select(x => new { x.curr.Sender, ComparisonResult = comparisonService.Compare(x.prev?.Value, x.curr.Value) })
.Where(x => !x.ComparisonResult.AreEqual)
.Select(x => $"[{x.Sender.TabName}] Tab properties change: {x.ComparisonResult.DifferencesString}"))
.Buffer(ConfigSaveSamplingTimeout)
.Where(x => x.Count > 0)
.Subscribe(
reasons =>
{
const int maxReasonsToOutput = 50;
Log.Debug(
$"Config Save reasons{(reasons.Count <= maxReasonsToOutput ? string.Empty : $"first {maxReasonsToOutput} of {reasons.Count} items")}:\r\n\t{reasons.Take(maxReasonsToOutput).DumpToTable()}");
configUpdateSubject.OnNext(Unit.Default);
},
public FragmentAViewModel(ISharedContext sharedContext)
{
SharedContext = sharedContext;
}
public SoftwareStatementProfileContext(ISharedContext context)
{
Context = context.ArgNotNull(nameof(context));
Data = new SoftwareStatementProfile();
}
public PaymentInitiationApiProfileContext PaymentInitiationApiProfile()
{
ISharedContext context = CreateContext();
return(new PaymentInitiationApiProfileContext(context));
}
public AuthorisationCallbackDataContext AuthorisationCallbackData()
{
ISharedContext context = CreateContext();
return(new AuthorisationCallbackDataContext(context));
}
public DomesticPaymentContext DomesticPayment()
{
ISharedContext context = CreateContext();
return(new DomesticPaymentContext(context));
}
public BankClientProfileContext BankClientProfile()
{
ISharedContext context = CreateContext();
return(new BankClientProfileContext(context));
}
public SoftwareStatementProfileContext SoftwareStatementProfile()
{
ISharedContext context = CreateContext();
return(new SoftwareStatementProfileContext(context));
}
internal DomesticPaymentContext(ISharedContext context)
{
Context = context.ArgNotNull(nameof(context));
}
internal AuthorisationCallbackDataContext(ISharedContext context)
{
Context = context;
}
public OverlayAuraModelBase(
[NotNull] ISharedContext sharedContext,
[NotNull] IAuraRepository repository,
[NotNull] IConfigSerializer configSerializer,
[NotNull] IUniqueIdGenerator idGenerator,
[NotNull] IFactory <IEyeOverlayViewModel, IOverlayWindowController, IAuraModelController> overlayViewModelFactory,
[NotNull] IFactory <IOverlayWindowController, IWindowTracker> overlayWindowControllerFactory,
[NotNull] IFactory <WindowTracker, IStringMatcher> windowTrackerFactory,
[NotNull][Dependency(WellKnownSchedulers.UI)] IScheduler uiScheduler,
[NotNull][Dependency(WellKnownSchedulers.Background)] IScheduler bgScheduler)
{
defaultAuraName = $"Aura #{Interlocked.Increment(ref GlobalAuraIdx)}";
Name = defaultAuraName;
Id = idGenerator.Next();
using var sw = new BenchmarkTimer($"[{Name}({Id})] OverlayAuraModel initialization", Log, nameof(OverlayAuraModelBase));
var auraTriggers = new ComplexAuraTrigger();
Triggers = auraTriggers.Triggers;
var auraActions = new ComplexAuraAction();
OnEnterActions = auraActions.Actions;
this.repository = repository;
this.configSerializer = configSerializer;
var matcher = new RegexStringMatcher().AddToWhitelist(".*");
var windowTracker = windowTrackerFactory
.Create(matcher)
.AddTo(Anchors);
var overlayController = overlayWindowControllerFactory
.Create(windowTracker)
.AddTo(Anchors);
sw.Step($"Overlay controller created: {overlayController}");
var overlayViewModel = overlayViewModelFactory
.Create(overlayController, this)
.AddTo(Anchors);
sw.Step($"Overlay view model created: {overlayViewModel}");
Overlay = overlayViewModel;
Observable.Merge(
overlayViewModel.WhenValueChanged(x => x.AttachedWindow, false).ToUnit(),
overlayViewModel.WhenValueChanged(x => x.IsLocked, false).ToUnit(),
this.WhenValueChanged(x => x.IsActive, false).ToUnit())
.StartWithDefault()
.Select(
() => new
{
OverlayShouldBeShown = IsActive || !overlayViewModel.IsLocked,
WindowIsAttached = overlayViewModel.AttachedWindow != null
})
.Subscribe(x => overlayController.IsEnabled = x.OverlayShouldBeShown && x.WindowIsAttached)
.AddTo(Anchors);
sw.Step($"Overlay view model initialized: {overlayViewModel}");
Observable.CombineLatest(
auraTriggers.WhenAnyValue(x => x.IsActive),
sharedContext.SystemTrigger.WhenValueChanged(x => x.IsActive))
.DistinctUntilChanged()
.Subscribe(x => IsActive = x.All(isActive => isActive), Log.HandleException)
.AddTo(Anchors);
auraTriggers.WhenAnyValue(x => x.IsActive)
.WithPrevious((prev, curr) => new { prev, curr })
.Where(x => x.prev == false && x.curr)
.Subscribe(ExecuteOnEnterActions, Log.HandleException)
.AddTo(Anchors);
this.repository.KnownEntities
.ToObservableChangeSet()
.SkipInitial()
.Throttle(ModelsReloadTimeout, bgScheduler)
.ObserveOn(uiScheduler)
.Subscribe(
() =>
{
var properties = Properties;
ReloadCollections(properties);
})
.AddTo(Anchors);
var modelPropertiesToIgnore = new[]
{
nameof(IAuraTrigger.IsActive),
nameof(IAuraTrigger.TriggerDescription),
nameof(IAuraTrigger.TriggerName),
}.ToImmutableHashSet();
//FIXME Properties mechanism should have inverted logic - only important parameters must matter
Observable.Merge(
this.WhenAnyProperty(x => x.Name, x => x.TargetWindow, x => x.IsEnabled).Select(x => $"[{Name}].{x.EventArgs.PropertyName} property changed"),
Overlay.WhenAnyProperty().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{nameof(Overlay)}.{x.EventArgs.PropertyName} property changed"),
Triggers.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Trigger list changed, item count: {Triggers.Count}"),
Triggers.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Trigger property changed"),
OnEnterActions.ToObservableChangeSet().Select(x => $"[{Name}({Id})] Action list changed, item count: {OnEnterActions.Count}"),
OnEnterActions.ToObservableChangeSet().WhenPropertyChanged().Where(x => !modelPropertiesToIgnore.Contains(x.EventArgs.PropertyName)).Select(x => $"[{Name}].{x.Sender}.{x.EventArgs.PropertyName} Action property changed"))
.Subscribe(reason => RaisePropertyChanged(nameof(Properties)))
.AddTo(Anchors);
Disposable.Create(() =>
{
Log.Debug(
$"Disposed Aura {Name}({Id}) (aka {defaultAuraName}), triggers: {Triggers.Count}, actions: {OnEnterActions.Count}");
OnEnterActions.Clear();
Triggers.Clear();
}).AddTo(Anchors);
sw.Step($"Overlay model properties initialized");
overlayController.RegisterChild(overlayViewModel).AddTo(Anchors);
sw.Step($"Overlay registration completed: {this}");
}
public void RegisterContext(ISharedContext context)
{
_contexts.Add(context);
}
public ActivityViewModel(ISharedContext sharedContext)
{
SharedContext = sharedContext;
}
