Tango - Twine softwares

about summary refs log tree commit diff stats
path: root/Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/ViewModels/EmbeddedLogsViewVM.cs
diff options
Diffstat (limited to 'Software/Visual_Studio/MachineStudio/Modules/Tango.MachineStudio.Logging/ViewModels/EmbeddedLogsViewVM.cs')
0 files changed, 0 insertions, 0 deletions
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using Tango.BL;
using Tango.BL.Builders;
using Tango.BL.Entities;
using Tango.Core.Commands;
using Tango.MachineStudio.Common.Notifications;
using Tango.MachineStudio.MachineDesigner.Views;
using Tango.SharedUI;

namespace Tango.MachineStudio.MachineDesigner.ViewModels
{
    public class MachineUpdatesViewVM : ViewModel
    {
        private INotificationProvider _notification;
        private ObservablesContext _context;
        private const int MAX_UPDATE_ITEMS = 200;

        #region Properties

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

        private List<TangoUpdate> _updates;
        public List<TangoUpdate> Updates
        {
            get { return _updates; }
            set { _updates = value; RaisePropertyChangedAuto(); }
        }

        private ICollectionView _updatesView;
        public ICollectionView UpdatesView
        {
            get { return _updatesView; }
            set { _updatesView = value; RaisePropertyChangedAuto(); }
        }


        private TangoUpdate _selectedUpdate;
        public TangoUpdate SelectedUpdate
        {
            get { return _selectedUpdate; }
            set { _selectedUpdate = value; RaisePropertyChangedAuto(); OnSelectedUpdateChanged(); }
        }

        private bool _displayMachineSetups;
        public bool DisplayMachineSetups
        {
            get { return _displayMachineSetups; }
            set { _displayMachineSetups = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        private bool _displayApplicationUpdates;
        public bool DisplayApplicationUpdates
        {
            get { return _displayApplicationUpdates; }
            set { _displayApplicationUpdates = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        private bool _displayDatabaseUpdates;
        public bool DisplayDatabaseUpdates
        {
            get { return _displayDatabaseUpdates; }
            set { _displayDatabaseUpdates = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        private bool _displaySynchronizations;
        public bool DisplaySynchronizations
        {
            get { return _displaySynchronizations; }
            set { _displaySynchronizations = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        private bool _displayOfflineUpdates;
        public bool DisplayOfflineUpdates
        {
            get { return _displayOfflineUpdates; }
            set { _displayOfflineUpdates = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        private bool _displayFirmwareUpgrades;
        public bool DisplayFirmwareUpgrades
        {
            get { return _displayFirmwareUpgrades; }
            set { _displayFirmwareUpgrades = value; RaisePropertyChangedAuto(); OnFilterChanged(); }
        }

        #endregion

        #region Commands

        public RelayCommand RefreshCommand { get; set; }

        #endregion

        #region Constructors

        public MachineUpdatesViewVM()
        {
            DisplayApplicationUpdates = true;
            DisplayMachineSetups = true;
            DisplayDatabaseUpdates = true;
            DisplaySynchronizations = true;
            DisplayOfflineUpdates = true;
            DisplayFirmwareUpgrades = true;

            RefreshCommand = new RelayCommand(Refresh, () => IsFree);
        }

        public MachineUpdatesViewVM(INotificationProvider notificationProvider) : this()
        {
            _notification = notificationProvider;
        }

        #endregion

        #region Public Methods

        public async Task Init(Machine machine, ObservablesContext context)
        {
            try
            {
                _context = context;
                Machine = machine;
                Updates = (await new TangoUpdatesCollectionBuilder(context).Set(x => x.MachineGuid == machine.Guid).Query(x => x.OrderByDescending(y => y.StartDate).Take(MAX_UPDATE_ITEMS)).BuildAsync()).ToList();
                UpdatesView = CollectionViewSource.GetDefaultView(Updates);
                UpdatesView.Filter = UpdatesFilter;
                OnFilterChanged();
            }
            catch (Exception ex)
            {
                LogManager.Log(ex, "Error loading machine updates.");
                _notification.ShowError($"An error occurred while loading the history of machine updates.\n{ex.FlattenMessage()}");
            }
        }

        #endregion

        #region Private Methods

        private async void Refresh()
        {
            IsFree = false;
            using (_notification.PushTaskItem("Refreshing machine updates..."))
            {
                await Init(Machine, _context);
            }
            IsFree = true;
        }

        private void OnFilterChanged()
        {
            if (UpdatesView != null)
            {
                UpdatesView.Refresh();
            }
        }

        private bool UpdatesFilter(object obj)
        {
            TangoUpdate update = obj as TangoUpdate;
            if (update != null)
            {
                if (!DisplayMachineSetups && update.IsSetup) return false;
                if (!DisplayApplicationUpdates && update.IsUpdate) return false;
                if (!DisplayDatabaseUpdates && update.IsDataBase) return false;
                if (!DisplaySynchronizations && update.IsSynchronization) return false;
                if (!DisplayOfflineUpdates && update.IsOfflineUpdate) return false;
                if (!DisplayFirmwareUpgrades && update.IsOfflineFirmwareUpgrade) return false;
                return true;
            }
            else
            {
                return false;
            }
        }

        private void OnSelectedUpdateChanged()
        {
            if (SelectedUpdate != null && SelectedUpdate.ApplicationVersion != "Fake")
            {
                _notification.ShowModalDialog<MachineUpdateDetailsDialogVM, MachineUpdateDetailsDialog>(new MachineUpdateDetailsDialogVM() { Update = SelectedUpdate }, (vm) => { }, () => { });
                SelectedUpdate = new TangoUpdate() {  ApplicationVersion = "Fake"};
            }
        }

        #endregion
    }
}

context:
space:
mode: