Machine Manager Module !!

1 files changed, 313 insertions, 0 deletions

diff --git a/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.MachineManager/ViewModels/MainViewVM.cs b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.MachineManager/ViewModels/MainViewVM.cs
new file mode 100644
index 000000000..b97f5e1d9
--- /dev/null
+++ b/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.MachineManager/ViewModels/MainViewVM.cs
@@ -0,0 +1,313 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Data.Entity;
+using Tango.BL;
+using Tango.MachineStudio.Common;
+using Tango.MachineStudio.MachineManager.Models;
+using Tango.BL.Entities;
+using Tango.Core.Commands;
+using Tango.MachineStudio.Common.Notifications;
+using Z.EntityFramework.Plus;
+
+namespace Tango.MachineStudio.MachineManager.ViewModels
+{
+    public class MainViewVM : StudioViewModel
+    {
+        private INotificationProvider _notification;
+        private bool _preventChange;
+
+        private List<MachineModel> _machines;
+        public List<MachineModel> Machines
+        {
+            get { return _machines; }
+            set { _machines = value; RaisePropertyChangedAuto(); }
+        }
+
+        private String _filter;
+        public String Filter
+        {
+            get { return _filter; }
+            set
+            {
+                if (_filter != value)
+                {
+                    _filter = value;
+                    OnFilterChanged();
+                }
+            }
+        }
+
+        private List<HardwareVersion> _hardwareVersions;
+        public List<HardwareVersion> HardwareVersions
+        {
+            get { return _hardwareVersions; }
+            set { _hardwareVersions = value; RaisePropertyChangedAuto(); }
+        }
+
+        private HardwareVersion _selectedHardwareVersion;
+        public HardwareVersion SelectedHardwareVersion
+        {
+            get { return _selectedHardwareVersion; }
+            set { _selectedHardwareVersion = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+        }
+
+        private bool? _enableSoftwareUpdate;
+        public bool? EnableSoftwareUpdate
+        {
+            get { return _enableSoftwareUpdate; }
+            set { _enableSoftwareUpdate = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+        }
+
+        private bool? _enableFirmwareUpgrade;
+        public bool? EnableFirmwareUpgrade
+        {
+            get { return _enableFirmwareUpgrade; }
+            set { _enableFirmwareUpgrade = value; RaisePropertyChangedAuto(); InvalidateRelayCommands(); }
+        }
+
+        private bool? _selectAll;
+        public bool? SelectAll
+        {
+            get { return _selectAll; }
+            set { _selectAll = value; RaisePropertyChangedAuto(); OnSelectAllChanged(); InvalidateRelayCommands(); }
+        }
+
+        public RelayCommand ApplyCommand { get; set; }
+
+        public MainViewVM(INotificationProvider notificationProvider)
+        {
+            Machines = new List<MachineModel>();
+            _notification = notificationProvider;
+            ApplyCommand = new RelayCommand(Apply, CanApply);
+        }
+
+        public override void OnApplicationReady()
+        {
+
+        }
+
+        private async void OnFilterChanged()
+        {
+            await LoadMachines();
+        }
+
+        private void OnSelectAllChanged()
+        {
+            if (Machines != null && SelectAll != null)
+            {
+                _preventChange = true;
+                Machines.ForEach(x => x.IsSelected = SelectAll.Value);
+                _preventChange = false;
+            }
+        }
+
+        private async Task LoadMachines()
+        {
+            SelectAll = null;
+
+            foreach (var machine in Machines.ToList())
+            {
+                machine.PropertyChanged -= Machine_PropertyChanged;
+            }
+
+            using (ObservablesContext db = ObservablesContext.CreateDefault())
+            {
+                var sites = await db.Sites.ToListAsync();
+
+                var machines = await db.Machines
+                    .Include(x => x.Organization.Name)
+                    .Include(x => x.Configuration.HardwareVersion.Name)
+                    .Include(x => x.Configuration.HardwareVersion.Version)
+                    .Include(x => x.Configuration.HardwareVersion.Guid)
+                    .Select(x => new
+                    {
+                        x.Guid,
+                        x.SerialNumber,
+                        x.Name,
+                        x.SuspendVersionUpdate,
+                        x.SetupFirmware,
+                        x.SetupFpga,
+                        x.ConfigurationGuid,
+                        HardwareVersionGuid = x.Configuration.HardwareVersion.Guid,
+                        HardwareVersionName = x.Configuration.HardwareVersion.Name,
+                        HardwareVersionVersion = x.Configuration.HardwareVersion.Version,
+                        OrganizationName = x.Organization.Name,
+                        x.SiteGuid
+                    }).ToListAsync();
+
+                var models = new List<MachineModel>();
+
+                foreach (var machine in machines)
+                {
+                    MachineModel model = new MachineModel();
+                    model.Guid = machine.Guid;
+                    model.SerialNumber = machine.SerialNumber;
+                    model.Name = machine.Name;
+                    model.EnableFirmwareUpgrade = machine.SetupFirmware;
+                    model.EnableSoftwareUpdate = !machine.SuspendVersionUpdate;
+                    model.ConfigurationGuid = machine.ConfigurationGuid;
+                    model.HardwareVersionGuid = machine.HardwareVersionGuid;
+                    model.HardwareVersionName = machine.HardwareVersionName;
+                    model.HardwareVersionVersion = machine.HardwareVersionVersion;
+                    model.OrganizationName = machine.OrganizationName;
+                    model.Site = sites.FirstOrDefault(x => x.Guid == machine.SiteGuid)?.Name;
+
+                    models.Add(model);
+                }
+
+                if (Filter.IsNotNullOrEmpty())
+                {
+                    var filter = Filter.ToLower();
+
+                    models = models.Where(x =>
+                    x.SerialNumber.ToLower().StartsWith(filter) ||
+                    x.Name.ToLower().StartsWith(filter) ||
+                    x.OrganizationName.ToLower().StartsWith(filter) ||
+                    x.Site.ToStringOrEmpty().ToLower().StartsWith(filter)
+                    ).ToList();
+                }
+
+                HardwareVersions = (await db.HardwareVersions.ToListAsync()).OrderByDescending(x => x.Version).ToList();
+
+                SelectedHardwareVersion = null;
+                EnableSoftwareUpdate = null;
+                EnableFirmwareUpgrade = null;
+
+                Machines = models;
+
+                foreach (var machine in Machines.ToList())
+                {
+                    machine.PropertyChanged += Machine_PropertyChanged;
+                }
+            }
+        }
+
+        private void Machine_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
+        {
+            if (_preventChange) return;
+
+            if (e.PropertyName == nameof(MachineModel.IsSelected))
+            {
+                if (Machines.TrueForAll(x => x.IsSelected))
+                {
+                    _selectAll = true;
+                }
+                else if (Machines.TrueForAll(x => !x.IsSelected))
+                {
+                    _selectAll = false;
+                }
+                else
+                {
+                    _selectAll = null;
+                }
+
+                RaisePropertyChanged(nameof(SelectAll));
+
+                var selectedMachines = Machines.Where(x => x.IsSelected).ToList();
+
+                if (selectedMachines.Count > 0)
+                {
+                    if (selectedMachines.TrueForAll(x => x.EnableSoftwareUpdate))
+                    {
+                        EnableSoftwareUpdate = true;
+                    }
+                    else if (selectedMachines.TrueForAll(x => !x.EnableSoftwareUpdate))
+                    {
+                        EnableSoftwareUpdate = false;
+                    }
+                    else
+                    {
+                        EnableSoftwareUpdate = null;
+                    }
+
+                    if (selectedMachines.TrueForAll(x => x.EnableFirmwareUpgrade))
+                    {
+                        EnableFirmwareUpgrade = true;
+                    }
+                    else if (selectedMachines.TrueForAll(x => !x.EnableFirmwareUpgrade))
+                    {
+                        EnableFirmwareUpgrade = false;
+                    }
+                    else
+                    {
+                        EnableFirmwareUpgrade = null;
+                    }
+
+                    if (selectedMachines.TrueForAll(x => x.HardwareVersionGuid == selectedMachines.First().HardwareVersionGuid))
+                    {
+                        SelectedHardwareVersion = HardwareVersions.FirstOrDefault(x => x.Guid == selectedMachines.First().HardwareVersionGuid);
+                    }
+                    else
+                    {
+                        SelectedHardwareVersion = null;
+                    }
+                }
+
+                InvalidateRelayCommands();
+            }
+        }
+
+        private bool CanApply()
+        {
+            var selectedMachines = Machines.Where(x => x.IsSelected).ToList();
+
+            if (selectedMachines.Count == 0) return false;
+            if (EnableSoftwareUpdate != null && selectedMachines.Any(x => x.EnableSoftwareUpdate != EnableSoftwareUpdate)) return true;
+            if (EnableFirmwareUpgrade != null && selectedMachines.Any(x => x.EnableFirmwareUpgrade != EnableFirmwareUpgrade)) return true;
+            if (SelectedHardwareVersion != null && selectedMachines.Any(x => x.HardwareVersionGuid != SelectedHardwareVersion.Guid)) return true;
+
+            return false;
+        }
+
+        private async void Apply()
+        {
+            if (Machines == null || Machines.Count(x => x.IsSelected) == 0)
+            {
+                _notification.ShowInfo("No machines selected");
+                return;
+            }
+
+            using (ObservablesContext db = ObservablesContext.CreateDefault())
+            {
+                var machines = Machines.Where(x => x.IsSelected).ToList();
+
+                var guids = machines.Select(x => x.Guid).ToArray();
+
+                if (EnableSoftwareUpdate != null)
+                {
+                    await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
+                    new Machine()
+                    {
+                        SuspendVersionUpdate = !EnableSoftwareUpdate.Value
+                    });
+                }
+
+                if (EnableFirmwareUpgrade != null)
+                {
+                    await db.Machines.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
+                    new Machine()
+                    {
+                        SetupFirmware = EnableFirmwareUpgrade.Value,
+                        SetupFpga = EnableFirmwareUpgrade.Value,
+                    });
+                }
+
+                if (SelectedHardwareVersion != null)
+                {
+                    guids = machines.Select(x => x.ConfigurationGuid).ToArray();
+
+                    await db.Configurations.Where(x => guids.Contains(x.Guid)).UpdateAsync(x =>
+                    new Configuration()
+                    {
+                        HardwareVersionGuid = SelectedHardwareVersion.Guid
+                    });
+                }
+            }
+
+            await LoadMachines();
+        }
+    }
+}