public SearchPageViewModel(IPatientSelectorViewModel patientSelectorViewModel, ISharedStateReadOnly <Patient> selectedPatientVariable, ISharedState <Date> selectedDateVariable, IViewModelCommunication viewModelCommunication, ICommandService commandService, IClientReadModelRepository readModelRepository, IClientMedicalPracticeRepository medicalPracticeRepository, Action <string> errorCallBack) { this.selectedPatientVariable = selectedPatientVariable; this.viewModelCommunication = viewModelCommunication; this.commandService = commandService; this.readModelRepository = readModelRepository; this.medicalPracticeRepository = medicalPracticeRepository; this.errorCallBack = errorCallBack; this.selectedDateVariable = selectedDateVariable; NoAppointmentsAvailable = false; selectedPatientVariable.StateChanged += OnSelectedPatientVariableChanged; PatientSelectorViewModel = patientSelectorViewModel; DeleteAppointment = new ParameterrizedCommand <DisplayAppointmentData>(DoDeleteAppointment); ModifyAppointment = new ParameterrizedCommand <DisplayAppointmentData>(DoModifyAppointment); SelectedPatient = NoPatientSelected; DisplayedAppointments = new ObservableCollection <DisplayAppointmentData>(); }
public MedicalPracticeSelectorViewModel(ISession session, IClientMedicalPracticeRepository medicalPracticeRepository, ILocalSettingsRepository localSettingsRepository, ISharedState <Guid> selectedMedicalPracticeIdVariable, ISharedStateReadOnly <AppointmentModifications> appointmentModificationsVariable, Action <string> errorCallback) { this.localSettingsRepository = localSettingsRepository; this.selectedMedicalPracticeIdVariable = selectedMedicalPracticeIdVariable; this.appointmentModificationsVariable = appointmentModificationsVariable; selectedMedicalPracticeIdVariable.StateChanged += OnSelectedMedicalPracticeIdVariableChanged; appointmentModificationsVariable.StateChanged += OnAppointmentModificationVariableChanged; AvailableMedicalPractices = session.LoggedInUser .ListOfAccessablePractices .Select(practiceId => new MedicalPracticeDisplayData(practiceId, practiceId.ToString())) .ToObservableCollection(); foreach (var medicalPracticeDisplayData in AvailableMedicalPractices) { medicalPracticeRepository.RequestMedicalPractice( practice => { medicalPracticeDisplayData.PracticeName = practice.Name; }, medicalPracticeDisplayData.MedicalPracticeId, errorCallback ); } SelectedMedicalPractice = AvailableMedicalPractices.First(practice => practice.MedicalPracticeId == selectedMedicalPracticeIdVariable.Value); PracticeIsSelectable = true; }
/// <summary> /// Makes sure that the observable is initialized against the shared state and any other objects along the tree. /// </summary> /// <typeparam name="T">The type to return.</typeparam> /// <param name="sharedState">The shared state to attach to.</param> /// <param name="initializerFunction">The initializer function.</param> /// <returns>The observable you wannt.</returns> public static T Observable <T>(this ISharedState sharedState, Func <T> initializerFunction) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (initializerFunction is null) { throw new ArgumentNullException(nameof(initializerFunction)); } try { SharedState.SetAsyncLocalState(sharedState); var result = initializerFunction(); if (((IReactiveObject)result).SharedState != sharedState) { // shared state should have been assigned. throw new ArgumentOutOfRangeException(nameof(initializerFunction)); } return(result); } finally { SharedState.SetAsyncLocalState(null); } }
public PatientSelectorViewModel(IClientPatientRepository patientRepository, ISharedState <Patient> selectedPatientSharedVariable, Action <string> errorCallback) { this.patientRepository = patientRepository; this.selectedPatientSharedVariable = selectedPatientSharedVariable; this.errorCallback = errorCallback; Patients = new CollectionViewSource(); Patients.Filter += Filter; SearchFilter = ""; patientRepository.NewPatientAvailable += PatientRepositoryChanged; patientRepository.UpdatedPatientAvailable += PatientRepositoryChanged; patientRepository.RequestAllPatientList( patientList => { Application.Current.Dispatcher.Invoke(() => { Patients.Source = patientList; UpdateForNewInput(); }); }, errorCallback ); }
/// <summary> /// Executes a function while storing and restoring the computation depth. /// This allows the computed to modify state. /// </summary> /// <typeparam name="T">The result type of the function.</typeparam> /// <param name="sharedState">The shared state to operate on.</param> /// <param name="function">The function to execute.</param> /// <returns>The return value of the function.</returns> public static T AllowStateChangesInsideComputed <T>(this ISharedState sharedState, Func <T> function) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (function is null) { throw new ArgumentNullException(nameof(function)); } var previousComputationDeph = sharedState.ComputationDepth; sharedState.ComputationDepth = 0; try { return(function()); } finally { sharedState.ComputationDepth = previousComputationDeph; } }
/// <summary> /// Initializes a new instance of the <see cref="Reaction"/> class. /// </summary> /// <param name="sharedState">The shared state to use.</param> /// <param name="name">The name to use.</param> /// <param name="onInvalidate">Handler to run when this reaction is invalidated. This handler should call <see cref="Track"/>.</param> /// <param name="errorHandler">The error handler for this reaction.</param> internal Reaction(ISharedState sharedState, string name, Action onInvalidate, Action <Reaction, Exception> errorHandler) { // resolve state state from context if necessary. this.SharedState = Net.SharedState.ResolveState(sharedState); this.onInvalidate = onInvalidate ?? throw new ArgumentNullException(nameof(onInvalidate)); this.errorHandler = errorHandler; this.Name = !string.IsNullOrEmpty(name) ? name : $"{this.SharedState.GetUniqueId()}"; }
/// <summary> /// Traces the tracking derivation on the Shared State. /// </summary> /// <param name="sharedState">The Shared State to trace.</param> /// <param name="traceMode">The trace mode to use.</param> public static void Trace(this ISharedState sharedState, TraceMode traceMode = TraceMode.Log) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } sharedState.TrackingDerivation?.Trace(traceMode); }
/// <summary> /// Gets the reference enhancer from the Shared State. /// </summary> /// <param name="sharedState">The shared state that should provide the reference enhancer.</param> /// <returns>The IEnhancer instance.</returns> public static IEnhancer ReferenceEnhancer(this ISharedState sharedState) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } return(sharedState.Enhancers.Single(x => x is Types.ReferenceEnhancer)); }
public ConfirmChangesMessageHandler(IViewModelCommunication viewModelCommunication, ICommandService commandService, ISharedState <AppointmentModifications> appointmentModificationsVariable, Action <string> errorCallback) { this.viewModelCommunication = viewModelCommunication; this.commandService = commandService; this.appointmentModificationsVariable = appointmentModificationsVariable; this.errorCallback = errorCallback; }
public EditDescriptionWindowBuilder(Appointment appointmentToEdit, IClientLabelRepository labelRepository, ISharedState <AppointmentModifications> modificationsVar, Action <string> errorCallback) { this.modificationsVar = modificationsVar; this.errorCallback = errorCallback; this.appointmentToEdit = appointmentToEdit; this.labelRepository = labelRepository; }
public DateSelectorViewModel(ISharedState <Date> selectedDateVariable) { this.selectedDateVariable = selectedDateVariable; SelectToday = new Command(() => SelectedDate = TimeTools.Today()); selectedDateVariable.StateChanged += OnSelectedDateChanged; SelectedDate = selectedDateVariable.Value; }
public LogoutRequestHandler(Action logoutSuccessfulCallback, ClientUserData user, ISharedState <ConnectionInfo> connectionInfoVariable, Action <string> errorCallback) : base(errorCallback) { this.user = user; this.connectionInfoVariable = connectionInfoVariable; this.logoutSuccessfulCallback = logoutSuccessfulCallback; }
public GetAppointmentsOfADayRequestHandler(Action <IReadOnlyList <AppointmentTransferData>, AggregateIdentifier, uint> dataReceivedCallback, ISharedState <ConnectionInfo> connectionInfoVariable, Date day, Guid medicalPracticeId, Action <string> errorCallback) : base(errorCallback) { this.dataReceivedCallback = dataReceivedCallback; this.connectionInfoVariable = connectionInfoVariable; this.day = day; this.medicalPracticeId = medicalPracticeId; }
/// <summary> /// Initializes a new instance of the <see cref="Atom"/> class. /// </summary> /// <param name="sharedState">The shared state where this atom is created on.</param> /// <param name="name">The name for this Atom.</param> internal Atom(ISharedState sharedState, string name) { // resolve state state from context if necessary. this.SharedState = Net.SharedState.ResolveState(sharedState); if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } this.Name = name; }
public AppointmentModificationsBuilder(IClientMedicalPracticeRepository medicalPracticeRepository, IClientReadModelRepository readModelRepository, IViewModelCommunication viewModelCommunication, ISharedState <Date> selectedDateVariable, ISharedStateReadOnly <Size> gridSizeVariable) { this.medicalPracticeRepository = medicalPracticeRepository; this.readModelRepository = readModelRepository; this.viewModelCommunication = viewModelCommunication; this.selectedDateVariable = selectedDateVariable; this.gridSizeVariable = gridSizeVariable; }
/// <summary> /// Initializes a new instance of the <see cref="ObserverObject"/> class. /// </summary> /// <param name="sharedState">The shared state this observer is connected to.</param> /// <param name="name">The name of the observer.</param> /// <param name="buildRenderTreeAction">The action that should be executed to build the render tree.</param> /// <param name="stateChangedAction">The action that is used to force StateHasChanged for this Component.</param> public ObserverObject(ISharedState sharedState, string name, Action <RenderTreeBuilder> buildRenderTreeAction, Action stateChangedAction) { if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } this.sharedState = sharedState ?? throw new ArgumentNullException(nameof(sharedState)); this.name = name; this.buildRenderTreeAction = buildRenderTreeAction ?? throw new ArgumentNullException(nameof(buildRenderTreeAction)); this.stateChangedAction = stateChangedAction ?? throw new ArgumentNullException(nameof(stateChangedAction)); }
public AppointmentModifications(Appointment originalAppointment, Guid medicalPracticeId, IClientMedicalPracticeRepository medicalPracticeRepository, IClientReadModelRepository readModelRepository, IViewModelCommunication viewModelCommunication, ISharedState <Date> selectedDateVariable, ISharedStateReadOnly <Size> gridSizeVariable, bool isInitialAdjustment, Action <string> errorCallback) { OriginalAppointment = originalAppointment; IsInitialAdjustment = isInitialAdjustment; this.medicalPracticeRepository = medicalPracticeRepository; this.selectedDateVariable = selectedDateVariable; this.gridSizeVariable = gridSizeVariable; this.errorCallback = errorCallback; this.readModelRepository = readModelRepository; this.viewModelCommunication = viewModelCommunication; versions = new VersionManager <ModificationDataSet>(100); versions.CurrentVersionChanged += OnCurrentVersionChanged; versions.PropertyChanged += OnVersionsManagerPropertyChanged; selectedDateVariable.StateChanged += OnSelectedDateVariableChanged; gridSizeVariable.StateChanged += OnGridSizeVariableChanged; OnGridSizeVariableChanged(gridSizeVariable.Value); var aggregateIdentifier = new AggregateIdentifier(originalAppointment.Day, medicalPracticeId); InitialLocation = new TherapyPlaceRowIdentifier(aggregateIdentifier, originalAppointment.TherapyPlace.Id); medicalPracticeRepository.RequestMedicalPractice( practice => { Application.Current.Dispatcher.Invoke(() => currentMedicalPracticeVersion = practice); }, InitialLocation.PlaceAndDate.MedicalPracticeId, InitialLocation.PlaceAndDate.Date, errorCallback ); var initialDataSet = new ModificationDataSet(originalAppointment.StartTime, originalAppointment.EndTime, originalAppointment.Description, originalAppointment.Label, InitialLocation, true); versions.AddnewVersion(initialDataSet); }
/// <summary> /// Creates a computed value. /// </summary> /// <typeparam name="T">The type of the elements.</typeparam> /// <param name="sharedState">The shared state to operate on.</param> /// <param name="getter">The getter function to use.</param> /// <param name="name">The name of the observable collection.</param> /// <returns>The computed value.</returns> public static IComputedValue <T> Computed <T>(this ISharedState sharedState, Func <T> getter, string name = null) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (string.IsNullOrEmpty(name)) { name = $"{nameof(ComputedValue<T>)}@{sharedState.GetUniqueId()}"; } return(new ComputedValue <T>(sharedState, new ComputedValueOptions <T>(getter, name))); }
public async Task Produce(ISharedState state) { await state.Insert(new ActualWork(0)); Console.WriteLine("Produced: 0"); await state.Insert(new ActualWork(1)); Console.WriteLine("Produced: 1"); await state.Insert(new WorkCompleted()); Console.WriteLine("Produced: Completed"); }
/// <summary> /// Converts a <see cref="System.IObservable{T}" /> into an <see cref="IObservableValue{T}"></see> which stores the current value(as `Current`). /// The subscription can be canceled through the `Dispose` method. Takes an initial value as second optional argument. /// </summary> /// <typeparam name="T">The type to observe.</typeparam> /// <param name="sharedState">The shared state to use.</param> /// <param name="observable">The observable to "convert".</param> /// <param name="initialValue">The initial value for the <see cref="IObservableValue{T}" />.</param> /// <param name="exceptionHandler">The exception handler to use.</param> /// <returns>An observable value.</returns> public static RxObserver <T> FromObservable <T>(this ISharedState sharedState, IObservable <T> observable, T initialValue = default, Action <Exception> exceptionHandler = null) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (observable is null) { throw new ArgumentNullException(nameof(observable)); } return(new RxObserver <T>(sharedState, observable, initialValue, exceptionHandler)); }
/// <summary> /// Tries to get a Task scheduler or throws an exception. /// </summary> /// <param name="sharedState">The shared state to use.</param> /// <returns>The task scheduler.</returns> /// <exception cref="InvalidOperationException">When a task scheduler was not specified or could not be inferred from a SynchronizationContext.</exception> internal static TaskScheduler GetTaskScheduler(this ISharedState sharedState) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (sharedState.Configuration.SynchronizationContext != null) { return(sharedState.Configuration.TaskScheduler); } throw new InvalidOperationException(Resources.TaskSchedulerNull); }
/// <summary> /// Initializes a new instance of the <see cref="ObservableCollection{T}"/> class. /// </summary> /// <param name="sharedState">The <see cref="ISharedState"/> instance this observableCollection belongs to.</param> /// <param name="enhancer">The <see cref="IEnhancer"/> implementation to use.</param> /// <param name="name">The name of the ObservableCollection.</param> /// <param name="initialValues">The initial values to use.</param> public ObservableCollection(ISharedState sharedState, IEnhancer enhancer, IEnumerable <T> initialValues, string name = null) { this.SharedState = sharedState ?? throw new ArgumentNullException(nameof(sharedState)); this.enhancer = enhancer ?? throw new ArgumentNullException(nameof(enhancer)); if (string.IsNullOrEmpty(name)) { name = $"{nameof(ObservableCollection<T>)}@{this.SharedState.GetUniqueId()}"; } this.Name = name; this.innerList = initialValues != null ? new List <T>(initialValues) : new List <T>(); this.atom = new Atom(sharedState, name); }
/// <summary> /// Gets the enhancer specified by the type from the Shared State. /// </summary> /// <param name="sharedState">The shared state that should provide the reference enhancer.</param> /// <param name="enhancerType">The type of the enhancer.</param> /// <returns>The IEnhancer instance.</returns> /// <exception cref="ArgumentNullException"> When either of the arguments is null.</exception> /// <exception cref="InvalidOperationException"> When the type was not found in the list of enhancers.</exception> public static IEnhancer GetEnhancer(this ISharedState sharedState, Type enhancerType) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (enhancerType is null) { throw new ArgumentNullException(nameof(enhancerType)); } return(sharedState.Enhancers.Single(x => x.GetType() == enhancerType)); }
/// <summary> /// Initializes a new instance of the <see cref="Atom"/> class. /// </summary> /// <param name="sharedState">The shared state where this atom is created on.</param> /// <param name="name">The name for this Atom.</param> internal Atom(ISharedState sharedState, string name) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (string.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } this.SharedState = sharedState; this.Name = name; }
public PatientSelectorViewModel(IPatientRepository patientRepository, ISharedState <Patient> selectedPatientSharedVariable) { this.patientRepository = patientRepository; this.selectedPatientSharedVariable = selectedPatientSharedVariable; patientRepository.PatientAdded += PatientRepositoryUpdated; patientRepository.PatientModified += PatientRepositoryUpdated; Patients = new CollectionViewSource(); Patients.Filter += Filter; Patients.Source = patientRepository.GetAllPatients(); SearchFilter = ""; }
/// <summary> /// Initializes a new instance of the <see cref="ObservableDictionary{TKey, TValue}"/> class. /// </summary> /// <param name="sharedState">The <see cref="ISharedState"/> instance this observableDictionary belongs to.</param> /// <param name="enhancer">The <see cref="IEnhancer"/> implementation to use.</param> /// <param name="initialValues">The initial values.</param> /// <param name="name">The name of the ObservableDictionary.</param> public ObservableDictionary(ISharedState sharedState, IEnhancer enhancer, IDictionary <TKey, TValue> initialValues, string name = null) { this.SharedState = sharedState ?? throw new ArgumentNullException(nameof(sharedState)); this.enhancer = enhancer ?? throw new ArgumentNullException(nameof(enhancer)); if (string.IsNullOrEmpty(name)) { name = $"{nameof(ObservableDictionary<TKey, TValue>)}@{this.SharedState.GetUniqueId()}"; } this.Name = name; this.innerDictionary = initialValues != null ? new Dictionary <TKey, TValue>(initialValues) : new Dictionary <TKey, TValue>(); this.hasDictionary = new Dictionary <TKey, ObservableValue <bool> >(); this.atom = new Atom(sharedState, name); }
public AppointmentViewModelBuilder(IViewModelCommunication viewModelCommunication, IClientLabelRepository labelRepository, ICommandService commandService, ISharedState <ViewModels.AppointmentView.Helper.AppointmentModifications> appointmentModificationsVariable, ISharedState <Date> selectedDateVariable, AdornerControl adornerControl, IAppointmentModificationsBuilder appointmentModificationsBuilder) { this.viewModelCommunication = viewModelCommunication; this.labelRepository = labelRepository; this.commandService = commandService; this.appointmentModificationsVariable = appointmentModificationsVariable; this.selectedDateVariable = selectedDateVariable; this.adornerControl = adornerControl; this.appointmentModificationsBuilder = appointmentModificationsBuilder; }
/// <summary> /// Initializes a new instance of the <see cref="RxObserver{T}"/> class. /// </summary> /// <param name="sharedState">The shared state.</param> /// <param name="observable">The observable.</param> /// <param name="exceptionHandler">The exception handler.</param> /// <param name="initialValue">The initial value.</param> internal RxObserver(ISharedState sharedState, IObservable <T> observable, T initialValue, Action <Exception> exceptionHandler) { if (observable is null) { throw new ArgumentNullException(nameof(observable)); } this.sharedState = sharedState ?? throw new ArgumentNullException(nameof(sharedState)); this.exceptionHandler = exceptionHandler ?? throw new ArgumentNullException(nameof(exceptionHandler)); this.sharedState.RunInAction(() => { this.observableValue = new ObservableValue <T>(this.sharedState, $"RxObserver<{typeof(T)}>", this.sharedState.ReferenceEnhancer()); this.observableValue.Value = initialValue; observable.Subscribe(this); }); }
/// <summary> /// Starts an action that changes state and recomputes the state tree. /// </summary> /// <param name="sharedState">The shared state instance to use.</param> /// <param name="actionName">The name of the action.</param> /// <param name="scope">The scope of the action.</param> /// <param name="arguments">The arguments to the action.</param> /// <returns>An <see cref="ActionRunInfo"/> instance containing the information on the currently running action.</returns> public static ActionRunInfo StartAction(ISharedState sharedState, string actionName, object scope, object[] arguments) { if (sharedState is null) { throw new ArgumentNullException(nameof(sharedState)); } if (arguments is null) { arguments = Array.Empty <object>(); } var notifySpy = !string.IsNullOrEmpty(actionName); var previousDerivation = sharedState.StartUntracked(); sharedState.StartBatch(); var previousAllowStateChanges = sharedState.StartAllowStateChanges(true); var previousAllowStateReads = sharedState.StartAllowStateReads(true); var actionRunInfo = new ActionRunInfo() { SharedState = sharedState, Name = string.IsNullOrEmpty(actionName) ? $"Action@{sharedState.NextActionId}" : actionName, PreviousDerivation = previousDerivation, PreviousAllowStateChanges = previousAllowStateChanges, PreviousAllowStateReads = previousAllowStateReads, NotifySpy = notifySpy, StartDateTime = DateTime.UtcNow, ActionId = sharedState.NextActionId++, ParentActionId = sharedState.CurrentActionId, }; if (notifySpy) { sharedState.OnSpy(actionRunInfo, new ActionStartSpyEventArgs() { Name = actionRunInfo.Name, ActionId = actionRunInfo.ActionId, Context = scope, Arguments = arguments, StartTime = actionRunInfo.StartDateTime, }); } sharedState.CurrentActionId = actionRunInfo.ActionId; return(actionRunInfo); }
public AppointmentGridViewModel(AggregateIdentifier identifier, ClientMedicalPracticeData medicalPractice, IViewModelCommunication viewModelCommunication, ISharedStateReadOnly <Size> gridSizeVariable, ISharedStateReadOnly <Guid?> roomFilterVariable, ISharedStateReadOnly <Guid> displayedMedicalPracticeVariable, ISharedState <AppointmentModifications> appointmentModificationsVariable, IAppointmentViewModelBuilder appointmentViewModelBuilder, AppointmentsOfADayReadModel readModel, IEnumerable <ITherapyPlaceRowViewModel> therapyPlaceRowViewModels, Action <string> errorCallback) { this.medicalPractice = medicalPractice; this.viewModelCommunication = viewModelCommunication; this.gridSizeVariable = gridSizeVariable; this.roomFilterVariable = roomFilterVariable; this.displayedMedicalPracticeVariable = displayedMedicalPracticeVariable; this.appointmentModificationsVariable = appointmentModificationsVariable; this.appointmentViewModelBuilder = appointmentViewModelBuilder; this.readModel = readModel; this.errorCallback = errorCallback; // Initial appointment-Creation is done at the AppointmentGridBuilder IsActive = false; PracticeIsClosedAtThisDay = false; gridSizeVariable.StateChanged += OnGridSizeChanged; roomFilterVariable.StateChanged += OnGlobalRoomFilterVariableChanged; viewModelCommunication.RegisterViewModelAtCollection <IAppointmentGridViewModel, AggregateIdentifier>( Constants.ViewModelCollections.AppointmentGridViewModelCollection, this ); Identifier = identifier; readModel.AppointmentChanged += OnReadModelAppointmentChanged; TimeGridViewModel = new TimeGridViewModel(Identifier, viewModelCommunication, medicalPractice, gridSizeVariable.Value); TherapyPlaceRowViewModels = new ObservableCollection <ITherapyPlaceRowViewModel>(therapyPlaceRowViewModels); OnGlobalRoomFilterVariableChanged(roomFilterVariable.Value); }