aboutsummaryrefslogtreecommitdiffstats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.MachineDesigner/ViewModels/TupViewVM.cs
blob: 5d1703dc373b71580cf2a2e57dbb12673a71bb0e (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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.Common.Tup;
using Tango.SharedUI;

namespace Tango.MachineStudio.MachineDesigner.ViewModels
{
    public class TupViewVM : ViewModel
    {
        private INotificationProvider _notification;

        private String _latestVersion;
        public String LatestVersion
        {
            get { return _latestVersion; }
            set { _latestVersion = value; RaisePropertyChangedAuto(); }
        }

        private Machine _machine;
        public Machine Machine
        {
            get { return _machine; }
            set { _machine = value; RaisePropertyChangedAuto(); }
        }

        private String _filePath;
        public String FilePath
        {
            get { return _filePath; }
            set { _filePath = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
        }

        private TupFileBuilderProgressEventArgs _progress;
        public TupFileBuilderProgressEventArgs Progress
        {
            get { return _progress; }
            set { _progress = value; RaisePropertyChangedAuto(); }
        }

        public RelayCommand CreateTupFileCommand { get; set; }

        public RelayCommand SelectFileCommand { get; set; }

        public TupViewVM()
        {

        }

        public TupViewVM(INotificationProvider notification) : this()
        {
            _notification = notification;
            CreateTupFileCommand = new RelayCommand(CreateTupFile, () => FilePath != null && IsFree);
            SelectFileCommand = new RelayCommand(SelectFile);
        }

        public void Init(Machine machine)
        {
            Machine = machine;
            DisplayLatestPPCVersion();
        }

        private async void DisplayLatestPPCVersion()
        {
            TupFileBuilder builder = new TupFileBuilder();

            try
            {
                LatestVersion = await builder.GetLatestPPCVersion(Machine.SerialNumber);
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error retrieving latest PPC version.");
                await Task.Delay(5000);
                DisplayLatestPPCVersion();
            }
        }

        private void SelectFile()
        {
            SaveFileDialog dlg = new SaveFileDialog();
            dlg.Title = "Select package location";
            dlg.Filter = "Tango Update Package Files|*.tup";
            dlg.DefaultExt = ".tup";
            dlg.FileName = LatestVersion == null ? $"{Machine.SerialNumber}_Update_{DateTime.Now.Date.ToFileName()}.tup" : $"{Machine.SerialNumber}_Update_{DateTime.Now.Date.ToFileName()}_v{LatestVersion}.tup";

            if (dlg.ShowDialog().Value)
            {
                FilePath = dlg.FileName;
            }
        }

        private async void CreateTupFile()
        {
            try
            {
                LogManager.Log($"Generating TUP file to '{FilePath}'...");

                IsFree = false;
                TupFileBuilder builder = new TupFileBuilder();
                builder.Progress += Builder_Progress;
                await builder.Build(Machine.SerialNumber, FilePath);

                LogManager.Log("TUP file generated successfully.");
                _notification.ShowInfo("Tango update package created successfuly.");
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error generating tup file.");
                _notification.ShowError($"An error occurred while generating the .tup file.\n{ex.FlattenMessage()}");
            }
            finally
            {
                IsFree = true;
            }
        }

        private void Builder_Progress(object sender, TupFileBuilderProgressEventArgs e)
        {
            Progress = e;
        }
    }
}
ommand NavigateToHomeCommand { get; set; } public EventsViewVM(INotificationProvider notification, IEventLogger eventLogger, IStudioApplicationManager application, LoggingNavigationManager navigation) { TimelineViewVM = new TimelineViewVM(notification); _navigation = navigation; _application = application; _notification = notification; _eventLogger = eventLogger; _realTimeEvents = new ObservableCollection<MachinesEvent>(); _eventLogger.NewLog += _eventLogger_NewLog; DisplayTimelineCommand = new RelayCommand<MachinesEvent>(DisplayTimeline); NavigateToEventsCommand = new RelayCommand(() => _navigation.NavigateTo(LoggingNavigationView.EventsView)); NavigateToHomeCommand = new RelayCommand(() => _navigation.NavigateTo(LoggingNavigationView.HomeView)); } private void _eventLogger_NewLog(object sender, MachinesEvent machineEvent) { InvokeUI(() => { _realTimeEvents.Insert(0, machineEvent); }); } private async void OnSelectedMachineChanged() { if (SelectedMachine != null) { using (_notification.PushTaskItem("Loading machine events...")) { try { await Task.Factory.StartNew(() => { _db = ObservablesContext.CreateDefault(); _db.EventTypes.Load(); DateTime now = DateTime.UtcNow.AddMonths(-1); _history_events = _db.MachinesEvents.Where(x => x.MachineGuid == SelectedMachine.Guid && x.DateTime > now).Include(x => x.User).Include(x => x.User.Contact).Include(x => x.Machine).ToList(); Dates = new ObservableCollection<DateTime>(); foreach (var day in _history_events.GroupBy(x => x.DateTime.DayOfYear).Select(x => x.First().DateTime).OrderByDescending(x => x)) { Dates.Add(day); } if (Dates.Count > 0) { MinDate = Dates.Min(); MaxDate = Dates.Max(); } SelectedDate = Dates.FirstOrDefault(); }); } catch (Exception ex) { LogManager.Log(ex, "Error loading machine events."); _notification.ShowError($"An error occurred while trying to load the selected machine events.\n{ex.FlattenMessage()}"); } } } } private void OnSelectedDateChanged() { if (SelectedDate != null && SelectedMachine != null) { if (IsRealTime) { Events = _realTimeEvents; } else if (_history_events != null) { Events = _history_events.Where(x => x.DateTime.DayOfYear == SelectedDate.Date.DayOfYear).OrderByDescending(x => x.DateTime).ToObservableCollection(); } } } private void OnSelectedEventChanged() { if (SelectedEvent != null && SelectedEvent.Type != BL.Enumerations.EventTypes.APPLICATION_STARTED && !_dialog_shown) { _dialog_shown = true; _notification.ShowModalDialog<EventDetailsViewVM, EventDetailsView>(new EventDetailsViewVM(SelectedEvent), (x) => { }, () => { _dialog_shown = false; }); } } private void DisplayTimeline(MachinesEvent ev) { var events = Events.OrderBy(x => x.DateTime).SkipWhile(x => x != ev).Skip(1).TakeWhile(x => x.DateTime > ev.DateTime && x.Type != BL.Enumerations.EventTypes.APPLICATION_STARTED).ToObservableCollection(); events.Insert(0, ev); TimelineViewVM.Initialize(events.ToList()); _navigation.NavigateTo(LoggingNavigationView.TimelineWrapperView); } } }