ProcessViewModelBase.cs

/* ProcessViewModelBase.cs
 * part of Bovender framework
 * 
 * Copyright 2014-2018 Daniel Kraus
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using Bovender.Mvvm.Messaging;
using System.Threading.Tasks;

namespace Bovender.Mvvm.ViewModels
{
    public abstract class ProcessViewModelBase : ViewModelBase
    {
        #region Properties

        public Bovender.Mvvm.Models.IProcessModel ProcessModel { get; protected set; }

        public bool IsProcessing
        {
            get
            {
                return ProcessMessageContent.Processing;
            }
        }

        public bool IsIndeterminate { get { return ProcessMessageContent.IsIndeterminate; } }

        public bool WasCancelled
        {
            get
            {
                return ProcessMessageContent.WasCancelled;
            }
        }

        public bool WasSuccessful
        {
            get
            {
                return ProcessMessageContent.WasSuccessful;
            }
        }

        public virtual Exception Exception { get; protected set; }

        #endregion

        #region Public methods

        public virtual void StartProcess()
        {
            Logger.Info("StartProcess: Starting process...");
            _progressTimer = new Timer(
                UpdateProgress,
                null,
                Properties.Settings.Default.ShowProgressDelay,
                Properties.Settings.Default.ShowProgressInterval);
            Execute();
        }

        public virtual void CancelProcess()
        {
            ProcessMessageContent.WasCancelled = true;
            ProcessMessageContent.Processing = false;
            Logger.Info("CancelProcess: CancelProcess was called!");
            ProcessModel.Cancel();
        }
        
        #endregion

        #region MVVM messages

        public Message<ProcessMessageContent> ShowProgressMessage
        {
            get
            {
                if (_showProgressMessage == null)
                {
                    _showProgressMessage = new Message<ProcessMessageContent>();
                }
                return _showProgressMessage;
            }
        }

        public Message<ProcessMessageContent> ProcessFinishedMessage
        {
            get
            {
                if (_processFinishedMessage == null)
                {
                    _processFinishedMessage = new Message<ProcessMessageContent>();
                }
                return _processFinishedMessage;
            }
        }

        #endregion

        #region Abstract methods

        protected abstract void UpdateProcessMessageContent(ProcessMessageContent processMessageContent);

        #endregion

        #region Constructor

        protected ProcessViewModelBase(Models.IProcessModel processModel)
            : base()
        {
            ProcessModel = processModel;
        }

        #endregion

        #region Protected methods

        protected virtual bool BeforeStartProcess()
        {
            Logger.Info("BeforeStartProcess");
            return true;
        }

        protected virtual void AfterStartProcess()
        {
            Logger.Info("AfterStartProcess");
            CloseViewCommand.Execute(null);
        }

        protected virtual void SendProcessFinishedMessage()
        {
            Logger.Info("SendProcessFinishedMessage: Sending message");
            ProcessMessageContent.Processing = false;
            ProcessMessageContent.Exception = Exception;
            ProcessMessageContent.WasSuccessful = Exception == null;
            ProcessFinishedMessage.Send(ProcessMessageContent);
            ProcessMessageContent.CompletedMessage.Send(ProcessMessageContent);
        }

        #endregion

        #region Overrides

        public override object RevealModelObject()
        {
            return ProcessModel;
        }

        #endregion

        #region Protected properties

        protected virtual ProcessMessageContent ProcessMessageContent
        {
            get
            {
                if (_processMessageContent == null)
                {
                    Logger.Debug("Creating new ProcessMessageContent instance");
                    _processMessageContent = new ProcessMessageContent(this, CancelProcess);
                }
                return _processMessageContent;
            }
        }

        #endregion

        #region Private methods

        private void Execute()
        {
            if (ProcessMessageContent.Processing)
            {
                Logger.Fatal("Execute: Process is already running!");
                throw new InvalidOperationException("Cannot start the process because it is already running");
            }
            if (!BeforeStartProcess()) return;

            ProcessMessageContent.Processing = true;
            ProcessMessageContent.WasSuccessful = false;
            ProcessMessageContent.WasCancelled = false;
            Logger.Info("Execute: Starting task");
            Task.Factory.StartNew((Action)(() =>
            {
                try
                {
                    ProcessMessageContent.WasSuccessful = ProcessModel.Execute();
                }
                catch (Exception e)
                {
                    Logger.Warn("Execute: Caught an exception!");
                    Logger.Warn(e);
                    Exception = e;
                }
            })).ContinueWith((task) => Dispatch(SendProcessFinishedMessage));
            AfterStartProcess();
        }

        private void UpdateProgress(object state)
        {
            lock (_lockUpdateProgress)
            {
                if (!_showProgressWasSent && ProcessMessageContent.Processing)
                {
                    _showProgressWasSent = true;
                    Dispatch(() =>
                    {
                        if (IsIndeterminate)
                        {
                            Logger.Info("UpdateProgress: The process is indeterminate");
                        }
                        Logger.Info("UpdateProgress: Sending ShowProgressMessage");
                        ShowProgressMessage.Send(ProcessMessageContent);
                        Logger.Debug("UpdateProgress: ... ShowProgressMessage was sent");
                    });
                }
                else
                {
                    if (ProcessMessageContent.Processing)
                    {
                        if (!IsIndeterminate)
                        {
                            UpdateProcessMessageContent(ProcessMessageContent);
                            Logger.Info("UpdateProgress: PercentCompleted: {0}",
                                ProcessMessageContent.PercentCompleted);
                        }
                    }
                    else
                    {
                        Logger.Info("UpdateProgress: No longer processing, disposing update timer");
                        _progressTimer.Dispose();
                    }
                }
            }
        }

        #endregion

        #region Private fields

        private Message<ProcessMessageContent> _showProgressMessage;
        private Message<ProcessMessageContent> _processFinishedMessage;
        private ProcessMessageContent _processMessageContent;
        private Timer _progressTimer;
        private bool _showProgressWasSent;

        #endregion

        #region Private static fields
        
        private static readonly object _lockUpdateProgress = new object();
        
        #endregion

        #region Class logger

        private static NLog.Logger Logger { get { return _logger.Value; } }

        private static readonly Lazy<NLog.Logger> _logger = new Lazy<NLog.Logger>(() => NLog.LogManager.GetCurrentClassLogger());

        #endregion
    }
}