init

DataPRO/Modules/Hardware/AddEditHardware/ViewModel/AddEditHardwareViewModel.cs

@@ -0,0 +1,352 @@
+using System.ComponentModel;
+using System.ComponentModel.Composition;
+using System.Threading.Tasks;
+using DTS.Common.Events;
+using DTS.Common.Interface.Hardware.AddEditHardware;
+using DTS.Common.Interface.DataRecorders;
+using DTS.Common.Interface.DASFactory.Diagnostics;
+using System.Collections.Generic;
+using DTS.Common.Events.Hardware.HardwareList;
+using System.Linq;
+using System;
+using DTS.Common.Utilities.Logging;
+using DTS.Common.Interface.DASFactory.Diagnostics.HardwareList;
+using Prism.Events;
+using Prism.Regions;
+using Unity;
+using DTS.Common.Interactivity;
+
+// ReSharper disable CheckNamespace
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable InconsistentNaming
+
+namespace AddEditHardware
+{
+    /// <summary>
+    /// this class handles AddEditHardware functionality
+    /// </summary>
+    [PartCreationPolicy(CreationPolicy.Shared)]
+    public class AddEditHardwareViewModel : IAddEditHardwareViewModel
+    {
+        /// <summary>
+        /// Whether StandIn hardware is allowed or not
+        /// datarecorders tile does not allow standin hardware, TestSetup and Group do
+        /// </summary>
+        public bool AllowStandin { get; set; } = true;
+        /// <summary>
+        /// The AddEditHardware View
+        /// </summary>
+        public IAddEditHardwareView View { get; set; }
+
+        private IEventAggregator _eventAggregator { get; }
+        private IRegionManager _regionManager;
+        private IUnityContainer UnityContainer { get; }
+
+        public InteractionRequest<Notification> NotificationRequest { get; }
+        public InteractionRequest<Confirmation> ConfirmationRequest { get; }
+
+        /// <inheritdoc />
+        /// <summary>
+        /// Occurs when a property value changes.
+        /// </summary>
+        public event PropertyChangedEventHandler PropertyChanged;
+        public void OnPropertyChanged(string propertyName)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        #region constructors and initializers
+        /// <summary>
+        /// Creates a new instance of the HardwareListViewModel
+        /// </summary>
+        /// <param name="view"></param>
+        /// <param name="regionManager">The logical placeholder defined within the application's UI (in the shell or within views) into which views are displayed.</param>
+        /// <param name="eventAggregator">The EventAggregator which allows different components to publish/subscribe to events without being coupled to each other.</param>
+        /// <param name="unityContainer">The unityContainer.</param>
+        public AddEditHardwareViewModel(IAddEditHardwareView view, IRegionManager regionManager,
+            IEventAggregator eventAggregator, IUnityContainer unityContainer)
+        {
+            View = view;
+            View.DataContext = this;
+
+            NotificationRequest = new InteractionRequest<Notification>();
+            ConfirmationRequest = new InteractionRequest<Confirmation>();
+
+            _eventAggregator = eventAggregator;
+            UnityContainer = unityContainer;
+            _regionManager = regionManager;
+            _eventAggregator.GetEvent<RaiseNotification>().Subscribe(OnRaiseNotification);
+            _eventAggregator.GetEvent<BusyIndicatorChangeNotification>()
+                .Subscribe(OnBusyIndicatorNotification, ThreadOption.PublisherThread, true);
+        }
+        //required if you want to use the vm in the view xaml
+        public AddEditHardwareViewModel()
+        {
+        }
+        #endregion
+
+        #region Methods
+        /// <summary>
+        /// used to pass in access to SLICE6TreeView module
+        /// </summary>  
+        public void SetSLICE6TreeView(ISLICE6TreeView treeView, IHardwareListViewModel treeViewModel)
+        {
+            SLICE6TreeView = treeView;
+            SLICE6TreeViewModel = treeViewModel;
+        }
+        public void Unset()
+        {
+        }
+        public void Cleanup()
+        {
+        }
+
+        public Task CleanupAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public void Initialize()
+        {
+        }
+
+        public void Initialize(object parameter)
+        {
+        }
+
+        public void Initialize(object parameter, object model)
+        {
+        }
+
+        public Task InitializeAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task InitializeAsync(object parameter)
+        {
+            return Task.CompletedTask;
+        }
+        /// <summary>
+        /// SLICE6TreeView interface
+        /// can be null [not shown in test setups/groups currently]
+        /// </summary>
+        public ISLICE6TreeView SLICE6TreeView { get; private set; }
+        /// <summary>
+        /// SLICE6TreeViewModule, can be null
+        /// </summary>
+        public IHardwareListViewModel SLICE6TreeViewModel { get; private set; }
+        public void Activated()
+        {
+            View?.Activated();
+            if (null != _hardware && !AllowStandin)
+            {
+                _hardware.StandIn = false;
+            }
+
+        }
+
+        /// <summary>
+        /// Private Event handler for RaiseNotification event.
+        /// </summary>
+        private void OnBusyIndicatorNotification(bool eventArg)
+        {
+            IsBusy = eventArg;
+        }
+
+        /// <summary>
+        /// Private Event handler for RaiseNotification event.
+        /// </summary>
+        private void OnRaiseNotification(NotificationContentEventArgs eventArgsWithTitle)
+        {
+            // The NotificationRequest.Raise triggers the Invoke() method of the PopupWindowAction object to show the NotificationWindow window
+            // Notification object expects a NotificationContentEventArgsWithoutTitle object and a Title string.
+            var eventArgsWithoutTitle = new NotificationContentEventArgs(eventArgsWithTitle.Message, "",
+                eventArgsWithTitle.Image, string.Empty);
+
+            NotificationRequest.Raise(new Notification
+            {
+                Content = eventArgsWithoutTitle,
+                Title = eventArgsWithTitle.Title
+            });
+        }
+
+        public void SetHardware(IDASHardware hw, IISOHardware isoHW)
+        {
+            NotificationsOn = false;
+            if (null == hw)
+            {
+                Hardware = new Model.Hardware();
+            }
+            else
+            {
+                Hardware = new Model.Hardware(hw, isoHW);
+            }
+        }
+
+        public void NotifyModified()
+        {
+            if (!NotificationsOn)
+            {
+                return;
+            }
+
+            _eventAggregator.GetEvent<PageModifiedEvent>()
+                .Publish(new PageModifiedArg(PageModifiedArg.Status.Modified, null));
+        }
+        public IISOHardware GetISOHardware()
+        {
+            var isoHW = Hardware.ToISOHardware();
+            if ((isoHW != null) && Hardware.StandIn && !Guid.TryParse(Hardware.SerialNumber, out var guid))
+            {
+                guid = Guid.NewGuid();
+                Hardware.SerialNumber = guid.ToString();
+                isoHW.SerialNumber = guid.ToString();
+                isoHW.FirstUseDate = null;
+                isoHW.IsFirstUseValid = true;
+                isoHW.CalDate = DateTime.Today;
+            }
+            return isoHW;
+        }
+        public bool Validate(IISOHardware isoHW, ref List<string> errors, ref List<string> warnings, bool displayWindow,
+            bool IsAdd)
+        {
+            var bValid = true;
+
+            if (!isoHW.ValidateSerialNumber(ref errors))
+            {
+                bValid = false;
+            }
+            //17639 Adding non-Stand-in DAS from Test Setups tab doesn't warn if DAS already exists
+            if (IsAdd)
+            {
+                try
+                {
+                    //17639 Adding non-Stand-in DAS from Test Setups tab doesn't warn if DAS already exists
+                    if (!Model.Hardware.CheckUniqueSN(isoHW.SerialNumber))
+                    {
+                        errors.Add(Resources.StringResources.UniqueSNCheckFail);
+                        bValid = false;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    APILogger.Log(ex);
+                    bValid = true;
+                    errors.Add($"{Resources.StringResources.CheckUniqueSNError}{ex.Message}");
+                }
+            }
+            if (!isoHW.ValidateIPAddress(ref errors))
+            {
+                bValid = false;
+            }
+
+            PublishPageError(displayWindow, errors, warnings);
+            return bValid;
+        }
+        public void PublishPageError(bool displayWindow, List<string> errors, List<string> warnings)
+        {
+            if (displayWindow && (errors.Any() || warnings.Any()))
+            {
+                var newList = errors.ToList();
+                newList.AddRange(warnings.ToArray());
+                _eventAggregator.GetEvent<PageErrorEvent>().Publish(new PageErrorArg(newList.ToArray(), null));
+            }
+        }
+        /// <summary>
+        /// Updates all SLICE6 associations related to a SLICE6DB
+        /// </summary>
+        public void SaveSLICE6Associations()
+        {
+            switch (Hardware.HardwareType)
+            {
+                case DTS.Common.Enums.Hardware.HardwareTypes.SLICE6DB:
+                case DTS.Common.Enums.Hardware.HardwareTypes.SLICE6DB3:
+                case DTS.Common.Enums.Hardware.HardwareTypes.SLICE6DB_InDummy:
+                    SLICE6TreeViewModel?.SaveSLICE6Associations(Hardware.SerialNumber);
+                    break;
+            }
+        }
+
+        public void Save()
+        {
+            if (!(Hardware is Model.Hardware model)) { return; }
+
+            Model.Hardware.Save(model, TestId, model.IsAdd);
+
+            SaveSLICE6Associations();
+            _eventAggregator.GetEvent<HardwareSavedEvent>()
+                .Publish(new Tuple<int, string>(model.ISOHardware.DASId, model.SerialNumber));
+            SLICE6TreeViewModel?.LoadTreeView(model.SerialNumber);
+        }
+
+        #endregion
+
+        #region Properties
+        public int? TestId { get; set; }
+        public bool NotificationsOn { get; set; } = false;
+        private IAddEditHardwareHardware _hardware = new Model.Hardware();
+
+        /// <summary>
+        /// hardware being operated on in viewmodel
+        /// </summary>
+        public IAddEditHardwareHardware Hardware
+        {
+            get => _hardware;
+            set
+            {
+                _hardware = value;
+                OnPropertyChanged("Hardware");
+                OnPropertyChanged("SerialNumber"); //In case modules were added
+                OnPropertyChanged("FirmwareVersion");
+                OnPropertyChanged("IPAddress");
+                SLICE6TreeViewModel?.LoadTreeView(_hardware.SerialNumber);
+            }
+        }
+
+        public bool IsDirty { get; private set; }
+        private bool _isBusy;
+
+        public bool IsBusy
+        {
+            get => _isBusy;
+            set
+            {
+                _isBusy = value;
+                OnPropertyChanged("IsBusy");
+            }
+        }
+
+        private bool _isMenuIncluded;
+
+        public bool IsMenuIncluded
+        {
+            get => _isMenuIncluded;
+            set
+            {
+                _isMenuIncluded = value;
+                OnPropertyChanged("IsMenuIncluded");
+            }
+        }
+
+        private bool _isNavigationIncluded;
+
+        public bool IsNavigationIncluded
+        {
+            get => _isNavigationIncluded;
+            set
+            {
+                _isNavigationIncluded = value;
+                OnPropertyChanged("IsNavigationIncluded");
+            }
+        }
+
+        //public string ListViewId => "HardwareListView";
+
+        #endregion Properties
+
+        #region Commands
+
+        #endregion
+    }
+}