New thread loading wizard.

1 files changed, 174 insertions, 81 deletions

diff --git a/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/ThreadLoadingViewVM.cs b/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/ThreadLoadingViewVM.cs
index 5c4d003a1..75354caf2 100644
--- a/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/ThreadLoadingViewVM.cs
+++ b/Software/Visual_Studio/PPC/Tango.PPC.UI/Dialogs/ThreadLoadingViewVM.cs
@@ -3,28 +3,41 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Tango.BL;
+using Tango.BL.Builders;
 using Tango.BL.Entities;
 using Tango.Core.Commands;
+using Tango.Core.DI;
 using Tango.Integration.Operation;
 using Tango.PMR.ThreadLoading;
+using Tango.PPC.Common;
 using Tango.PPC.Common.Connection;
+using Tango.PPC.Common.Notifications;
+using Tango.Settings;
 using Tango.SharedUI;
 
 namespace Tango.PPC.UI.Dialogs
 {
     public class ThreadLoadingViewVM : DialogViewVM
     {
-        public class ThreadLoadingResult
+        public enum ThreadLoadingStage
         {
-            public bool IsCompleted { get; set; }
-            public Exception FailedException { get; set; }
+            Welcome,
+            Preparing,
+            ReadyForLoading,
+            Finalizing,
+            Completed,
+            PreparationError,
+            FinalizationError,
         }
 
-        private ThreadLoadingConfirmationRequiredEventArgs _confirmationArgs;
+        [TangoInject]
+        private IMachineProvider MachineProvider { get; set; }
 
-        public ThreadLoadingResult Result { get; set; }
+        [TangoInject]
+        private INotificationProvider NotificationProvider { get; set; }
 
-        public IMachineProvider MachineProvider { get; set; }
+        private PPCSettings _settings;
 
         private StartThreadLoadingResponse _status;
         public StartThreadLoadingResponse Status
@@ -33,22 +46,13 @@ namespace Tango.PPC.UI.Dialogs
             set { _status = value; RaisePropertyChangedAuto(); }
         }
 
-        private bool _isFinalizing;
-        public bool IsFinalizing
+        private List<Rml> _rmls;
+        public List<Rml> Rmls
         {
-            get { return _isFinalizing; }
-            set { _isFinalizing = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+            get { return _rmls; }
+            set { _rmls = value; RaisePropertyChangedAuto(); }
         }
 
-        private bool _isPreparing;
-        public bool IsPreparing
-        {
-            get { return _isPreparing; }
-            set { _isPreparing = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
-        }
-
-        public List<Rml> Rmls { get; set; }
-
         private Rml _selectedRml;
         public Rml SelectedRml
         {
@@ -56,121 +60,210 @@ namespace Tango.PPC.UI.Dialogs
             set { _selectedRml = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
         }
 
+        private ThreadLoadingStage _stage;
+        public ThreadLoadingStage Stage
+        {
+            get { return _stage; }
+            set { _stage = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+        }
+
+        private String _error;
+        public String Error
+        {
+            get { return _error; }
+            set { _error = value; RaisePropertyChangedAuto(); }
+        }
+
+
         public RelayCommand ContinueCommand { get; set; }
+        public RelayCommand AbortCommand { get; set; }
 
-        public ThreadLoadingViewVM(IMachineProvider machineProvider)
+        public ThreadLoadingViewVM(bool userInvoked = false)
         {
-            CanClose = true;
-            IsPreparing = true;
-            ContinueCommand = new RelayCommand(ContinueThreadLoading, () => !IsFinalizing && SelectedRml != null);
-            MachineProvider = machineProvider;
+            CanClose = false;
+
+            TangoIOC.Default.Inject(this);
+            _settings = SettingsManager.Default.GetOrCreate<PPCSettings>();
+
             MachineProvider.MachineOperator.ThreadLoadingStatusChanged += MachineOperator_ThreadLoadingStatusChanged;
-            MachineProvider.MachineOperator.ThreadLoadingCompleted += MachineOperator_ThreadLoadingCompleted;
-            MachineProvider.MachineOperator.ThreadLoadingFailed += MachineOperator_ThreadLoadingFailed;
-            MachineProvider.MachineOperator.ThreadLoadingConfirmationRequired += MachineOperator_ThreadLoadingConfirmationRequired;
+
+            ContinueCommand = new RelayCommand(Continue, CanContinue);
+            AbortCommand = new RelayCommand(Abort);
+
+            AdaptToState(userInvoked);
         }
 
-        public ThreadLoadingViewVM(IMachineProvider machineProvider, ThreadLoadingConfirmationRequiredEventArgs confirmationArgs) : this(machineProvider)
+        private void AdaptToState(bool userInvoked = false)
         {
-            _confirmationArgs = confirmationArgs;
-            IsPreparing = false;
+            var status = MachineProvider.MachineOperator.ThreadLoadingStatus;
+
+            if (status != null)
+            {
+                if (status.State == ThreadLoadingState.Preparing)
+                {
+                    Stage = ThreadLoadingStage.Preparing;
+                }
+                else if (status.State == ThreadLoadingState.ReadyForLoading)
+                {
+                    Stage = ThreadLoadingStage.ReadyForLoading;
+                }
+                else if (status.State == ThreadLoadingState.Finalizing)
+                {
+                    Stage = ThreadLoadingStage.Finalizing;
+                }
+                else if (status.State == ThreadLoadingState.PreparationError)
+                {
+                    OnPreparationError(status.ErrorReason);
+                }
+                else if (status.State == ThreadLoadingState.FinalizationError)
+                {
+                    OnFinalizationError(status.ErrorReason);
+                }
+                else if (status.State == ThreadLoadingState.Completed)
+                {
+                    if (userInvoked)
+                    {
+                        Stage = ThreadLoadingStage.Welcome;
+                    }
+                    else
+                    {
+                        Stage = ThreadLoadingStage.Completed;
+                    }
+                }
+            }
         }
 
-        private void MachineOperator_ThreadLoadingConfirmationRequired(object sender, ThreadLoadingConfirmationRequiredEventArgs e)
+        private void MachineOperator_ThreadLoadingStatusChanged(object sender, StartThreadLoadingResponse e)
         {
-            _confirmationArgs = e;
-            IsPreparing = false;
+            Status = e;
+            AdaptToState();
         }
 
-        private async void ContinueThreadLoading()
+        private void Continue()
         {
-            IsFinalizing = true;
+            if (Stage == ThreadLoadingStage.Welcome)
+            {
+                Stage = ThreadLoadingStage.Preparing;
+                StartPreparing();
+            }
+            else if (Stage == ThreadLoadingStage.ReadyForLoading)
+            {
+                ContinueThreadLoading();
+            }
+            else if (Stage == ThreadLoadingStage.Completed)
+            {
+                Accept();
+            }
+            else if (Stage == ThreadLoadingStage.PreparationError)
+            {
+                Stage = ThreadLoadingStage.Preparing;
+                StartPreparing();
+            }
+            else if (Stage == ThreadLoadingStage.FinalizationError)
+            {
+                ContinueThreadLoading();
+            }
+        }
 
+        private async void StartPreparing()
+        {
             try
             {
-                await Task.Factory.StartNew(() => { _confirmationArgs.Confirm(SelectedRml.GetActiveProcessGroup().ProcessParametersTables.FirstOrDefault()); });
+                await MachineProvider.MachineOperator.StartThreadLoading();
             }
             catch (Exception ex)
             {
-                Result = new ThreadLoadingResult()
-                {
-                    FailedException = ex,
-                };
-
-                IsFinalizing = false;
-
-                if (IsVisible)
-                {
-                    InvokeUI(() =>
-                    {
-                        Accept();
-                    });
-                }
+                OnPreparationError(ex.Message);
             }
         }
 
-        private void MachineOperator_ThreadLoadingCompleted(object sender, StartThreadLoadingResponse e)
+        private async void ContinueThreadLoading()
         {
-            Result = new ThreadLoadingResult()
+            try
             {
-                IsCompleted = true
-            };
-
-            if (IsVisible)
+                Stage = ThreadLoadingStage.Finalizing;
+                await MachineProvider.MachineOperator.ContinueThreadLoading(SelectedRml.GetActiveProcessGroup().ProcessParametersTables.FirstOrDefault());
+            }
+            catch (Exception ex)
             {
-                InvokeUI(() =>
-                {
-                    Accept();
-                });
+                OnFinalizationError(ex.Message);
             }
         }
 
-        private void MachineOperator_ThreadLoadingFailed(object sender, StartThreadLoadingResponse e)
+        private bool CanContinue()
         {
-            Result = new ThreadLoadingResult()
+            bool canContinue = false;
+
+            if (Stage != ThreadLoadingStage.Preparing && Stage != ThreadLoadingStage.Finalizing)
             {
-                FailedException = new Exception(e.ErrorReason),
-            };
+                canContinue = true;
+            }
 
-            if (IsVisible)
+            if (Stage == ThreadLoadingStage.ReadyForLoading && SelectedRml == null)
             {
-                InvokeUI(() =>
-                {
-                    Accept();
-                });
+                canContinue = false;
             }
+
+            return canContinue;
         }
 
-        private void MachineOperator_ThreadLoadingStatusChanged(object sender, StartThreadLoadingResponse e)
+        private void OnPreparationError(String error)
         {
-            Status = e;
+            Error = error;
+            Stage = ThreadLoadingStage.PreparationError;
+        }
+
+        private void OnFinalizationError(String error)
+        {
+            Error = error;
+            Stage = ThreadLoadingStage.FinalizationError;
+        }
+
+        private void Abort()
+        {
+            Cancel();
+        }
+
+        public async override void OnShow()
+        {
+            base.OnShow();
+
+            LogManager.Log("Loading site RMLS...");
+
+            List<Rml> rmls = new List<Rml>();
 
-            if (Status.State == ThreadLoadingState.Finalizing)
+            using (ObservablesContext db = ObservablesContext.CreateDefault())
             {
-                IsFinalizing = true;
+                rmls = await new RmlsCollectionBuilder(db).SetAll().ForHeadType(MachineProvider.Machine.MachineHeadType).ForSite(MachineProvider.Machine.SiteGuid).WithActiveParametersGroup().BuildListAsync();
             }
+
+            var selectedRml = rmls.SingleOrDefault(x => x.Guid == _settings.LoadedRmlGuid);
+
+            Rmls = rmls;
+            SelectedRml = selectedRml != null ? selectedRml : rmls.FirstOrDefault();
         }
 
         protected override void Cancel()
         {
-            IsFinalizing = false;
-            ClearEvents();
+            CleanUp();
             base.Cancel();
         }
 
         protected override void Accept()
         {
-            IsFinalizing = false;
-            ClearEvents();
+            CleanUp();
             base.Accept();
         }
 
-        private void ClearEvents()
+        private void CleanUp()
         {
             MachineProvider.MachineOperator.ThreadLoadingStatusChanged -= MachineOperator_ThreadLoadingStatusChanged;
-            MachineProvider.MachineOperator.ThreadLoadingCompleted -= MachineOperator_ThreadLoadingCompleted;
-            MachineProvider.MachineOperator.ThreadLoadingFailed -= MachineOperator_ThreadLoadingFailed;
-            MachineProvider.MachineOperator.ThreadLoadingConfirmationRequired -= MachineOperator_ThreadLoadingConfirmationRequired;
+
+            if (SelectedRml != null)
+            {
+                _settings.LoadedRmlGuid = SelectedRml.Guid;
+                _settings.Save();
+            }
         }
     }
 }