aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/FSE/Tango.FSE.Common/Connection/FSEMachineEventsStateProvider.cs
blob: f4192afeda3bb0d6e45abe993b53d0990a7e6947 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
<
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.Core;
using Tango.Core.DI;
using Tango.FSE.BL;
using Tango.FSE.Common.FSEApplication;
using Tango.FSE.Common.Notifications;
using Tango.Integration.Operation;
using Tango.PMR.Diagnostics;

namespace Tango.FSE.Common.Connection
{
    /// <summary>
    /// Represents the default machine events state provider.
    /// </summary>
    /// <seealso cref="Tango.Integration.Operation.IMachineEventsStateProvider" />
    public class FSEMachineEventsStateProvider : ExtendedObject, IMachineEventsStateProvider
    {
        private static Dictionary<EventTypes, Tango.BL.Entities.EventType> _eventTypesGuids;
        private bool _initialized;

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private FSEServicesContainer Services { get; set; }

        [TangoInject(TangoInjectMode.WhenAvailable)]
        private INotificationProvider NotificationProvider { get; set; }

        private ReadOnlyObservableCollection<MachinesEvent> _events;
        /// <summary>
        /// Gets the current machine events.
        /// </summary>
        public ReadOnlyObservableCollection<MachinesEvent> Events
        {
            get
            {
                return _events;
            }
            private set
            {
                _events = value;
                RaisePropertyChangedAuto();
                RaisePropertyChanged(nameof(HasEvents));
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether this instance has events.
        /// </summary>
        public bool HasEvents
        {
            get
            {
                return Events.Count > 0;
            }
        }

        /// <summary>
        /// Occurs when new events are available.
        /// </summary>
        public event EventHandler<IEnumerable<MachinesEvent>> NewEvents;

        /// <summary>
lass="k">event EventHandler<IEnumerable<MachinesEvent>> EventsReceived; /// <summary> /// Occurs when old events has been resolved. /// </summary> public event EventHandler<IEnumerable<MachinesEvent>> EventsResolved; /// <summary> /// Occurs when the collection of current events has changed. /// </summary> public event EventHandler<IEnumerable<MachinesEvent>> EventsChanged; /// <summary> /// Initializes a new instance of the <see cref="DefaultMachineEventsStateProvider"/> class. /// </summary> public FSEMachineEventsStateProvider() { TangoIOC.Default.Inject(this); Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(new Collection<MachinesEvent>())); } /// <summary> /// Initializes this events state provider only if it was not initialized yet. /// Will retrieve all event types and perform caching and mapping between PMR and DB. /// </summary> public async void Init() { if (_initialized) return; _eventTypesGuids = new Dictionary<EventTypes, Tango.BL.Entities.EventType>(); try { var eventTypes = await Services.MachineEventsService.GetAllEventTypes(); foreach (var type in eventTypes) { try { _eventTypesGuids.Add((EventTypes)type.Code, type); } catch (Exception ex) { LogManager.Log(ex, $"Error initializing event type '{type.Name}'."); } } _initialized = true; } catch (Exception ex) { LogManager.Log(ex, "Error initializing FSE machine events state provider."); NotificationProvider.PushErrorReportingSnackbar(ex, "Events Initialization", "Error initializing machine events definitions."); } } /// <summary> /// Applies the collection of events received from the machine operator. /// </summary> /// <param name="events">The events.</param> public void ApplyEvents(IEnumerable<Event> events) { List<MachinesEvent> receivedEvents = new List<MachinesEvent>(); foreach (var ev in events) { MachinesEvent machineEvent = new MachinesEvent(); machineEvent.DateTime = DateTime.UtcNow; machineEvent.Description = ev.Message; if (_eventTypesGuids.ContainsKey((EventTypes)ev.Type)) { machineEvent.EventType = _eventTypesGuids[(EventTypes)ev.Type]; } else { machineEvent.EventType = _eventTypesGuids[EventTypes.APPLICATION_INFORMATION]; } receivedEvents.Add(machineEvent); } List<MachinesEvent> newEvents = receivedEvents.Where(x => !Events.ToList().Exists(y => y.Type == x.Type)).ToList(); List<MachinesEvent> oldEvents = Events.Where(x => !receivedEvents.Exists(y => y.Type == x.Type)).ToList(); List<MachinesEvent> activeEvents = Events.ToList(); foreach (var oldEvent in oldEvents) { activeEvents.Remove(oldEvent); } foreach (var newEvent in newEvents) { activeEvents.Add(newEvent); } Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(activeEvents)); if (newEvents.Count > 0) { OnNewEvents(newEvents); } if (oldEvents.Count > 0) { OnEventsResolved(oldEvents); } if (newEvents.Count > 0 || oldEvents.Count > 0) { OnEventsChanged(newEvents.Concat(oldEvents)); } OnEventsReceived(Events); RaisePropertyChanged(nameof(HasEvents)); } /// <summary> /// Called when the new has been events /// </summary> /// <param name="events">The events.</param> protected virtual void OnNewEvents(IEnumerable<MachinesEvent> events) { NewEvents?.Invoke(this, events); } /// <summary> /// Called when the events has been received /// </summary> /// <param name="events">The events.</param> protected virtual void OnEventsReceived(IEnumerable<MachinesEvent> events) { EventsReceived?.Invoke(this, events); } /// <summary> /// Called when the events has been resolved /// </summary> /// <param name="events">The events.</param> protected virtual void OnEventsResolved(IEnumerable<MachinesEvent> events) { EventsResolved?.Invoke(this, events); } /// <summary> /// Called when the events has been changed /// </summary> /// <param name="events">The events.</param> protected virtual void OnEventsChanged(IEnumerable<MachinesEvent> events) { EventsChanged?.Invoke(this, events); } /// <summary> /// Resets the current events tracking. /// </summary> public void Reset() { Events = new ReadOnlyObservableCollection<MachinesEvent>(new ObservableCollection<MachinesEvent>(new List<MachinesEvent>())); RaisePropertyChanged(nameof(Events)); OnEventsChanged(new List<MachinesEvent>()); } } }