private async Task SaveItemAsync() { Notification result = Notification.Success(); ModelUpdateEvent updateEvent = _isNewModel ? ModelUpdateEvent.Created : ModelUpdateEvent.Updated; result = _validator.ValidateModel(Model); if (result.IsValid()) { var saveResult = await _repository.SaveSampleItemAsync(Model, updateEvent); result.AddRange(saveResult); } if (result.IsValid()) { var eventMessenger = CC.IoC.Resolve <IEventAggregator>(); ModelUpdatedMessageResult <SampleItem> eventResult = new ModelUpdatedMessageResult <SampleItem>() { UpdatedModel = Model, UpdateEvent = updateEvent }; eventMessenger.GetEvent <ModelUpdatedMessageEvent <SampleItem> >().Publish(eventResult); await Close(); } else { await UserNotifier.ShowMessageAsync(result.ToString(), "Save Failed"); } }
private async void SaveItem() { Notification result = Notification.Success(); ModelUpdateEvent updateEvent = _isNewModel ? ModelUpdateEvent.Created : ModelUpdateEvent.Updated; //TODO: model validation var saveResult = await _repository.SaveItemAsync(Model, updateEvent); result.AddRange(saveResult); if (result.IsValid()) { ModelUpdatedMessageResult <TodoItem> eventResult = new ModelUpdatedMessageResult <TodoItem> { UpdatedModel = Model, UpdateEvent = updateEvent }; App.EventManager.GetEvent <ModelUpdatedMessageEvent <TodoItem> >().Publish(eventResult); await Navigation.GoBackAsync(); //NOTE: fails :( will work if INavigationService injected in constructor } else { //TODO: show user failure message //await UserNotifier.ShowMessageAsync(result.ToString(), "Save Failed"); } }
private static void RegisterTransformers(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var powerTransformer in command.PowerTransformers) { equipmentByGid[powerTransformer.GID] = new EquipmentNodeItem(powerTransformer.GetType(), powerTransformer, connectedTo: powerTransformer.TransformerWindings, hidden: true); } foreach (var ratioTapChanger in command.RatioTapChangers) { equipmentByGid[ratioTapChanger.GID] = new EquipmentNodeItem(ratioTapChanger.GetType(), ratioTapChanger, connectedTo: new[] { ratioTapChanger.TransformerWinding }, hidden: true); } foreach (var winding in command.TransformerWindings) { var tapChanger = equipmentByGid[winding.RatioTapChanger].Item as RatioTapChangerDto; var powerTransformer = equipmentByGid[winding.PowerTransformer].Item as PowerTransformerDto; var transformer = new TransformerModel(winding, tapChanger, powerTransformer); equipmentByGid[winding.GID] = new EquipmentNodeItem(transformer.GetType(), transformer, connectedTo: winding.Terminals); } }
private async Task <Notification> SaveItem <T>(T item, ModelUpdateEvent updateEvent) where T : ModelBase { Notification retNotification = Notification.Success(); try { if (updateEvent == ModelUpdateEvent.Created) { if (string.IsNullOrWhiteSpace(item.Id)) { item.Id = Guid.NewGuid().ToString(); } await _database.InsertAsync(item); } else { await _database.UpdateAsync(item); } } catch (SQLiteException) { //LOG: retNotification.Add(new NotificationItem("Save Failed")); } return(retNotification); }
public async Task <Notification> SaveAppointmentAsync(Appointment item, ModelUpdateEvent updateEvent) { if (updateEvent == ModelUpdateEvent.Created) { item.UserId = _currentUserId; } return(await SaveItem(item, updateEvent)); }
public void Bind(string name, ModelUpdateEvent action) { if (!_events.ContainsKey (name)) { _events.Add(name, null); } _events [name] = _events [name] + action; }
private static void RegisterDisconnectors(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var disconnector in command.Disconnectors) { equipmentByGid[disconnector.GID] = new EquipmentNodeItem(disconnector.GetType(), disconnector, connectedTo: disconnector.Terminals); } }
private static void RegisterBreakers(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var breaker in command.Breakers) { equipmentByGid[breaker.GID] = new EquipmentNodeItem(breaker.GetType(), breaker, connectedTo: breaker.Terminals); } }
private static void RegisterAsynchronousMachines(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var item in command.AsynchronousMachines) { equipmentByGid[item.GID] = new EquipmentNodeItem(item.GetType(), item, connectedTo: item.Terminals); } }
private static void RegisterTerminals(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var terminal in command.Terminals) { equipmentByGid[terminal.GID] = new EquipmentNodeItem(terminal.GetType(), terminal, connectedTo: new[] { terminal.ConnectivityNode, terminal.ConductingEquipment }, hidden: true); } }
private static void RegisterConnectivityNodes(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var connectivityNode in command.ConnectivityNodes) { equipmentByGid[connectivityNode.GID] = new EquipmentNodeItem(connectivityNode.GetType(), connectivityNode, connectedTo: connectivityNode.Terminals, hidden: true); } }
public static void Publish(T updatedModel, ModelUpdateEvent updateEvent) { var messenger = App.EventManager; var updateResult = new ModelUpdatedMessageResult <T> { UpdatedModel = updatedModel, UpdateEvent = updateEvent }; messenger.GetEvent <ModelUpdatedMessageEvent <T> >().Publish(updateResult); }
public static void Publish(T updatedModel, ModelUpdateEvent updateEvent) { var updateResult = new ModelUpdatedMessageResult <T> { UpdatedModel = updatedModel, UpdateEvent = updateEvent }; var eventMessenger = DependencyService.Get <IEventAggregator>(DependencyFetchTarget.GlobalInstance); eventMessenger.GetEvent <ModelUpdatedMessageEvent <T> >().Publish(updateResult); }
public void Update(object sender, ModelUpdateEvent e) { EquipmentTreeNode root = EquipmentTreeFactory.CreateFrom(e); var fastNodeLookupByMrid = new FastLookupByMrid(root); App.Current.Dispatcher.Invoke((System.Action) delegate { measurementUpdater = new MeasurementUpdater(fastNodeLookupByMrid); DisplayTree(root); UpdateTransfomerList(root); }); }
public static Dictionary <long, EquipmentNodeItem> Convert(ModelUpdateEvent command) { var equipmentByGid = new Dictionary <long, EquipmentNodeItem>(); RegisterConnectivityNodes(command, equipmentByGid); RegisterTerminals(command, equipmentByGid); RegisterAsynchronousMachines(command, equipmentByGid); RegisterBreakers(command, equipmentByGid); RegisterDisconnectors(command, equipmentByGid); RegisterTransformers(command, equipmentByGid); RegisterMeasurements(command, equipmentByGid); return(equipmentByGid); }
public static EquipmentTreeNode CreateFrom(ModelUpdateEvent command) { Debug.WriteLine("Creating tree from command..."); Dictionary <long, EquipmentNodeItem> equipmentNodeByGid = EquipmentByGidConverter.Convert(command); var nodes = GetTreeNodes(equipmentNodeByGid, command.SourceGid); foreach (var item in nodes) { item.TurnedOn = false; } return(nodes.FirstOrDefault()); }
private static void RegisterMeasurements(ModelUpdateEvent command, Dictionary <long, EquipmentNodeItem> equipmentByGid) { foreach (var analogMeasurement in command.Analogs) { equipmentByGid[analogMeasurement.GID] = new EquipmentNodeItem(analogMeasurement.GetType(), analogMeasurement, connectedTo: new[] { analogMeasurement.Terminals }, hidden: true); } foreach (var discreteMeasurement in command.Discretes) { equipmentByGid[discreteMeasurement.GID] = new EquipmentNodeItem(discreteMeasurement.GetType(), discreteMeasurement, connectedTo: new[] { discreteMeasurement.Terminals }, hidden: true); } }
public async Task <Notification> SaveContactAsync(Contact item, ModelUpdateEvent updateEvent) { Notification retNotification = Notification.Success(); try { if (updateEvent == ModelUpdateEvent.Created) { await _database.InsertAsync(item); } else { await _database.UpdateAsync(item); } } catch (SQLiteException) { //LOG: retNotification.Add(new NotificationItem("Save Failed")); } return(retNotification); }
public static void UpdateCollection <T>(this ObservableCollection <T> collection, T model, ModelUpdateEvent updateEvent) where T : ModelBase { T existing = collection.FirstOrDefault(x => x.Id == model.Id); switch (updateEvent) { case ModelUpdateEvent.Created: case ModelUpdateEvent.Updated: if (existing != null) { collection.Remove(existing); } collection.Add(model); //NOTE: don't worry about inserting record in original position - caller must filter and order break; case ModelUpdateEvent.Deleted: if (existing != null) { collection.Remove(existing); } break; } }
public Task Handle(ModelUpdateEvent message, IMessageHandlerContext context) { modelUpdate.Invoke(this, message); return(Task.CompletedTask); }
public async Task <Notification> SaveProviderAsync(HealthCareProvider item, ModelUpdateEvent updateEvent) { return(await SaveItem(item, updateEvent)); }
internal void ModelUpdate() { ModelUpdateEvent?.Invoke(this, new ModelUpdateEventArgs()); }
public void Unbind(string name, ModelUpdateEvent action) { if (_events.ContainsKey (name)) { _events[name] = _events[name] - action; } }