merge

1 files changed, 0 insertions, 324 deletions

diff --git a/Software/Visual_Studio/PPC/Modules/Tango.PPC.Maintenance/ViewModels/MaintenanceViewVM.cs b/Software/Visual_Studio/PPC/Modules/Tango.PPC.Maintenance/ViewModels/MaintenanceViewVM.cs
deleted file mode 100644
index c0dc61150..000000000
--- a/Software/Visual_Studio/PPC/Modules/Tango.PPC.Maintenance/ViewModels/MaintenanceViewVM.cs
+++ /dev/null
@@ -1,324 +0,0 @@
-using Ionic.Zip;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Data.Entity;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using Tango.BL;
-using Tango.Core;
-using Tango.Core.Commands;
-using Tango.Explorer;
-using Tango.Integration.Operation;
-using Tango.Logging;
-using Tango.PMR.Diagnostics;
-using Tango.PMR.IFS;
-using Tango.PMR.MachineStatus;
-using Tango.PPC.Common;
-using Tango.PPC.Maintenance.Commands;
-using Tango.PPC.Maintenance.Dialogs;
-using Tango.PPC.Maintenance.Helpers;
-using Tango.PPC.Maintenance.Models;
-using Tango.PPC.Maintenance.Views;
-using Tango.PPC.Storage;
-
-namespace Tango.PPC.Maintenance.ViewModels
-{
-    public class MaintenanceViewVM : PPCViewModel
-    {
-        public class WasteStateModel : ExtendedObject
-        {
-            private CartridgeState _state;
-            public CartridgeState State
-            {
-                get { return _state; }
-                set { _state = value; RaisePropertyChangedAuto(); }
-            }
-
-            public CartridgeSlot Slot { get; set; }
-        }
-
-        public ObservableCollection<GuideBase> Guides { get; set; }
-
-        public RelayCommand<GuideBase> OpenGuideCommand { get; set; }
-
-        private List<MidTankLevelModel> _midTankLevels;
-        public List<MidTankLevelModel> MidTankLevels
-        {
-            get { return _midTankLevels; }
-            set { _midTankLevels = value; RaisePropertyChangedAuto(); }
-        }
-
-        private OverallTemperatureModel _overallTemperature;
-        public OverallTemperatureModel OverallTemperature
-        {
-            get { return _overallTemperature; }
-            set { _overallTemperature = value; RaisePropertyChangedAuto(); }
-        }
-
-        private String _totalDyeTime;
-        public String TotalDyeTime
-        {
-            get { return _totalDyeTime; }
-            set { _totalDyeTime = value; RaisePropertyChangedAuto(); }
-        }
-
-        private String _totalDyeMeters;
-        public String TotalDyeMeters
-        {
-            get { return _totalDyeMeters; }
-            set { _totalDyeMeters = value; RaisePropertyChangedAuto(); }
-        }
-
-        private SpoolState _spoolState;
-        public SpoolState SpoolState
-        {
-            get { return _spoolState; }
-            set
-            {
-                if (_spoolState != value)
-                {
-                    _spoolState = value;
-                    RaisePropertyChangedAuto();
-                }
-            }
-        }
-
-        private List<WasteStateModel> _wasteStates;
-        public List<WasteStateModel> WasteStates
-        {
-            get { return _wasteStates; }
-            set { _wasteStates = value; RaisePropertyChangedAuto(); }
-        }
-
-        public RelayCommand ExportLogsCommand { get; set; }
-
-        public OpenCloseDyeingHeadCommand OpenCloseDyeingHeadCommand { get; set; }
-
-        public OpenCloseLeftLeadingWheelsCommand OpenCloseLeftLeadingWheelsCommand { get; set; }
-
-        public OpenCloseRightLeadingWheelsCommand OpenCloseRightLeadingWheelsCommand { get; set; }
-
-        public ResetThreadLoadingCommand ResetThreadLoadingCommand { get; set; }
-
-        public RelayCommand HeadCleaningCommand { get; set; }
-
-        public RelayCommand StartThreadLoadingCommand { get; set; }
-
-        public RelayCommand StartThreadBreakCommand { get; set; }
-
-        public RelayCommand DispenseCleanerLiquidCommand { get; set; }
-
-        public MaintenanceViewVM()
-        {
-            Guides = new ObservableCollection<GuideBase>(GuideHelper.CreateAllGuides());
-            OverallTemperature = new OverallTemperatureModel();
-
-            OpenGuideCommand = new RelayCommand<GuideBase>(OpenGuide);
-            ExportLogsCommand = new RelayCommand(ExportLogsToStorage);
-
-            OpenCloseDyeingHeadCommand = new OpenCloseDyeingHeadCommand();
-            OpenCloseLeftLeadingWheelsCommand = new OpenCloseLeftLeadingWheelsCommand();
-            OpenCloseRightLeadingWheelsCommand = new OpenCloseRightLeadingWheelsCommand();
-            ResetThreadLoadingCommand = new ResetThreadLoadingCommand();
-            HeadCleaningCommand = new RelayCommand(PerformHeadCleaning, () => MachineProvider.MachineOperator.CanPrint);
-            StartThreadLoadingCommand = new RelayCommand(StartThreadLoadingWizard, () => MachineProvider.MachineOperator.CanPrint);
-            StartThreadBreakCommand = new RelayCommand(StartThreadBreakWizard, () => MachineProvider.MachineOperator.CanPrint);
-
-            WasteStates = new List<WasteStateModel>()
-            {
-                 new WasteStateModel() { Slot = CartridgeSlot.WasteMiddle, State = CartridgeState.Absent },
-                 new WasteStateModel() { Slot = CartridgeSlot.WasteLower, State = CartridgeState.Absent }
-            };
-        }
-
-        public override void OnApplicationStarted()
-        {
-            MachineProvider.MachineOperator.InkFillingStatusChanged += MachineOperator_InkFillingStatusChanged;
-            MachineProvider.MachineOperator.MachineStatusChanged += MachineOperator_MachineStatusChanged;
-            MachineProvider.MachineOperator.MachineEventsStateProvider.EventsChanged += MachineEventsStateProvider_EventsChanged;
-
-            DispenseCleanerLiquidCommand = new RelayCommand(DispenseCleanerLiquid, () =>
-            {
-                if (MachineProvider.Machine.MachineHeadType == BL.Enumerations.HeadTypes.Arc)
-                {
-                    return MachineProvider.MachineOperator.MachineEventsStateProvider.Events.Any(x => x.Type == BL.Enumerations.EventTypes.DYEING_HEAD_ARC_LID_IS_OPEN);
-                }
-                else
-                {
-                    return MachineProvider.MachineOperator.MachineEventsStateProvider.Events.Any(x => x.Type == BL.Enumerations.EventTypes.DYEING_HEAD_COVER_IS_OPEN);
-                }
-            });
-
-            RaisePropertyChanged(nameof(DispenseCleanerLiquidCommand));
-        }
-
-        public override void OnApplicationReady()
-        {
-            base.OnApplicationReady();
-
-            MidTankLevels = MachineProvider.Machine.Configuration.NoneEmptyIdsPacks.OrderBy(x => x.PackIndex).Select(x => new MidTankLevelModel()
-            {
-                Max = MachineOperator.MAX_MIDTANK_LITERS,
-                IDSPack = x,
-            }).OrderBy(y => y.IDSPack.LiquidType.Code).ToList();
-        }
-
-        private void MachineEventsStateProvider_EventsChanged(object sender, IEnumerable<BL.Entities.MachinesEvent> e)
-        {
-            OpenCloseDyeingHeadCommand.IsEnabled = !e.Any(x => x.Type == BL.Enumerations.EventTypes.DRYER_DOOR_OPEN);
-
-            InvokeUI(() =>
-            {
-                DispenseCleanerLiquidCommand.RaiseCanExecuteChanged();
-            });
-        }
-
-        private void MachineOperator_MachineStatusChanged(object sender, MachineStatus status)
-        {
-            UpdateMidTankLevels(status);
-            OverallTemperature.Temperature = status.OverallTemperature;
-            SpoolState = status.SpoolState;
-            InvalidateRelayCommands();
-        }
-
-        private void MachineOperator_InkFillingStatusChanged(object sender, InkFillingStatusChangedEventArgs e)
-        {
-            foreach (var cartridge in e.Status.CartridgesStatuses.Where(x => x.Cartridge.Slot != CartridgeSlot.Ink))
-            {
-                var wasteState = WasteStates.SingleOrDefault(x => x.Slot == cartridge.Cartridge.Slot);
-
-                if (wasteState != null)
-                {
-                    wasteState.State = cartridge.State;
-                }
-            }
-        }
-
-        public async void OpenGuide(GuideBase guide)
-        {
-            await NavigationManager.NavigateWithObject<MaintenanceModule, GeneralGuideView, GuideBase>(guide);
-        }
-
-        private void UpdateMidTankLevels(MachineStatus status)
-        {
-            if (IsVisible)
-            {
-                foreach (var item in status.IDSPacksLevels)
-                {
-                    var model = MidTankLevels.SingleOrDefault(x => x.IDSPack.PackIndex == item.Index);
-
-                    if (model != null)
-                    {
-                        model.Level = item.MidTankLevel;
-                    }
-                }
-            }
-        }
-
-        private async void ExportLogsToStorage()
-        {
-            var result = await NavigationManager.
-                NavigateForResult<StorageModule,
-                Storage.Views.MainView, ExplorerFileItem,
-                Storage.Models.StorageNavigationRequest>(
-                new Storage.Models.StorageNavigationRequest()
-                {
-                    Intent = Storage.Models.StorageNavigationIntent.SaveFile,
-                    DefaultFileName = $"Tango-Logs-{DateTime.Now.ToFileName()}",
-                    Filter = "do not display anything",
-                    Title = "Export System Logs",
-                });
-
-            if (result != null)
-            {
-                String file = result.Path + ".zip";
-
-                IsFree = false;
-
-                try
-                {
-                    NotificationProvider.SetGlobalBusyMessage("Exporting system logs...");
-
-                    var appFileLogger = LogManager.RegisteredLoggers.FirstOrDefault(x => x is FileLogger) as FileLogger;
-
-                    await Task.Factory.StartNew(() =>
-                    {
-                        using (ZipFile zip = new ZipFile(file))
-                        {
-                            zip.Password = "1Creativity";
-
-                            if (appFileLogger != null)
-                            {
-                                zip.AddDirectory(appFileLogger.Folder);
-                            }
-
-                            zip.ParallelDeflateThreshold = -1;
-                            zip.Save();
-                        }
-                    });
-
-                    NotificationProvider.ReleaseGlobalBusyMessage();
-
-                    await NotificationProvider.ShowSuccess("System logs exported successfully.");
-                }
-                catch (Exception ex)
-                {
-                    NotificationProvider.ReleaseGlobalBusyMessage();
-                    LogManager.Log(ex, "Error exporting system logs.");
-                    await NotificationProvider.ShowError($"An error occurred while trying to export the system logs.\n{ex.FlattenMessage()}");
-                }
-                finally
-                {
-                    NotificationProvider.ReleaseGlobalBusyMessage();
-                    IsFree = true;
-                }
-            }
-        }
-
-        public async override void OnNavigatedTo()
-        {
-            base.OnNavigatedTo();
-
-            try
-            {
-                using (ObservablesContext db = ObservablesContext.CreateDefault())
-                {
-                    var jobRuns = await db.JobRuns.Select(x => new { x.StartDate, x.EndDate, x.EndPosition }).ToListAsync();
-
-                    TotalDyeTime = TimeSpan.FromHours(jobRuns.Select(x => x.EndDate - x.StartDate).Sum(x => x.TotalHours)).ToStringUnlimitedHours();
-
-                    int meters = (int)jobRuns.Select(x => x.EndPosition).Sum();
-                    TotalDyeMeters = $"{meters.ToString("N0")} meters";
-                }
-            }
-            catch (Exception ex)
-            {
-                LogManager.Log(ex, "Error loading machine counters.");
-                TotalDyeTime = "error!";
-                TotalDyeMeters = "error!";
-            }
-        }
-
-        private async void PerformHeadCleaning()
-        {
-            await NotificationProvider.ShowDialog<HeadCleaningViewVM>();
-        }
-
-        private void StartThreadLoadingWizard()
-        {
-            ThreadLoadingService.StartThreadLoadingWizard();
-        }
-
-        private void StartThreadBreakWizard()
-        {
-            ThreadLoadingService.StartThreadBreakWizard();
-        }
-
-        private async void DispenseCleanerLiquid()
-        {
-            await NotificationProvider.ShowDialog<CleanerDispensingViewVM>();
-        }
-    }
-}