A Pluggable Architecture for Building Silverlight Applications with MVVM

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.Linq;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using GalaSoft.MvvmLight;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using IssueVision.Data.Web;
using IssueVision.Common;
using MVVMPlugin;

namespace IssueVision.ViewModel
{
    [ExportPlugin(ViewModelTypes.AllIssuesViewModel, PluginType.ViewModel)]
    [PartCreationPolicy(CreationPolicy.NonShared)]
    public class AllIssuesViewModel : ViewModelBase
    {
        #region "Private Data Members"
        private IIssueVisionModel _issueVisionModel;
        #endregion "Private Data Members"

        #region "Constructor"
        public AllIssuesViewModel()
        {
            _issueVisionModel = PluginCatalogService.Container.GetExportedValue<IIssueVisionModel>();

            // Set up event handling
            _issueVisionModel.SaveChangesComplete += new EventHandler<SubmitOperationEventArgs>(_issueVisionModel_SaveChangesComplete);
            _issueVisionModel.GetAllIssuesComplete += new EventHandler<EntityResultsArgs<Issue>>(_issueVisionModel_GetAllIssuesComplete);
            _issueVisionModel.PropertyChanged += new PropertyChangedEventHandler(_issueVisionModel_PropertyChanged);

            // cancel any changes when first enter the screen
            _issueVisionModel.RejectChanges();

            // load all issues
            _issueVisionModel.GetAllIssuesAsync();
        }
        #endregion "Constructor"

        #region "ICleanup interface implementation"
        public override void Cleanup()
        {
            // unregister all events
            _issueVisionModel.SaveChangesComplete -= new EventHandler<SubmitOperationEventArgs>(_issueVisionModel_SaveChangesComplete);
            _issueVisionModel.GetAllIssuesComplete -= new EventHandler<EntityResultsArgs<Issue>>(_issueVisionModel_GetAllIssuesComplete);
            _issueVisionModel.PropertyChanged -= new PropertyChangedEventHandler(_issueVisionModel_PropertyChanged);
            // unregister any messages for this ViewModel
            base.Cleanup();
        }
        #endregion "ICleanup interface implementation"

        #region "Public Properties"

        private IEnumerable<Issue> _allIssues;

        public CollectionViewSource AllIssuesSource { get; private set; }

        private Issue _currentIssue;

        public Issue CurrentIssue
        {
            get { return _currentIssue; }
            private set
            {
                if (value != _currentIssue)
                {
                    _currentIssue = value;
                    this.RaisePropertyChanged("CurrentIssue");
                }
            }
        }

        #endregion "Public Properties"

        #region "Public Commands"

        private RelayCommand<SelectionChangedEventArgs> _selectionChangedCommand = null;

        public RelayCommand<SelectionChangedEventArgs> SelectionChangedCommand
        {
            get
            {
                if (_selectionChangedCommand == null)
                {
                    _selectionChangedCommand = new RelayCommand<SelectionChangedEventArgs>(
                        e => this.OnSelectionChangedCommand(e));
                }
                return _selectionChangedCommand;
            }
        }

        private void OnSelectionChangedCommand(SelectionChangedEventArgs e)
        {
            if (e.AddedItems.Count == 1)
            {
                // cancel any changes before editing another issue
                if (_issueVisionModel.HasChanges)
                {
                    AppMessages.CancelChangesMessage.Send();
                }
                var enumerator = e.AddedItems.GetEnumerator();
                enumerator.MoveNext();
                // edit the new selected issue
                AppMessages.EditIssueMessage.Send((Issue)enumerator.Current);
            }
        }

        private RelayCommand _refreshCommand = null;

        public RelayCommand RefreshCommand
        {
            get
            {
                if (_refreshCommand == null)
                {
                    _refreshCommand = new RelayCommand(
                        () => this.OnRefreshCommand(),
                        () => !this._issueVisionModel.HasChanges);
                }
                return _refreshCommand;
            }
        }

        private void OnRefreshCommand()
        {
            try
            {
                if (!_issueVisionModel.IsBusy)
                {
                    // re-load all issues
                    _issueVisionModel.GetAllIssuesAsync();
                }
            }
            catch (Exception ex)
            {
                // notify user if there is any error
                AppMessages.RaiseErrorMessage.Send(ex);
            }
        }

        private RelayCommand _submitChangeCommand = null;

        public RelayCommand SubmitChangeCommand
        {
            get
            {
                if (_submitChangeCommand == null)
                {
                    _submitChangeCommand = new RelayCommand(
                        () => this.OnSubmitChangeCommand(),
                        () => this._issueVisionModel.HasChanges);
                }
                return _submitChangeCommand;
            }
        }

        private void OnSubmitChangeCommand()
        {
            try
            {
                if (!_issueVisionModel.IsBusy)
                {
                    AppMessages.SubmitChangesMessage.Send();
                }
            }
            catch (Exception ex)
            {
                // notify user if there is any error
                AppMessages.RaiseErrorMessage.Send(ex);
            }
        }

        private RelayCommand _cancelChangeCommand = null;

        public RelayCommand CancelChangeCommand
        {
            get
            {
                if (_cancelChangeCommand == null)
                {
                    _cancelChangeCommand = new RelayCommand(
                        () => this.OnCancelChangeCommand(),
                        () => this._issueVisionModel.HasChanges);
                }
                return _cancelChangeCommand;
            }
        }

        private void OnCancelChangeCommand()
        {
            try
            {
                if (!_issueVisionModel.IsBusy)
                {
                    // ask to confirm canceling the current issue in edit
                    DialogMessage dialogMessage = new DialogMessage(
                        this,
                        CommonResources.CancelCurrentIssueMessageBoxText,
                        s =>
                        {
                            if (s == MessageBoxResult.OK)
                            {
                                // if confirmed, cancel this issue
                                AppMessages.CancelChangesMessage.Send();
                            }
                        })
                    {
                        Button = MessageBoxButton.OKCancel,
                        Caption = CommonResources.ConfirmMessageBoxCaption
                    };

                    AppMessages.PleaseConfirmMessage.Send(dialogMessage);
                }
            }
            catch (Exception ex)
            {
                // notify user if there is any error
                AppMessages.RaiseErrorMessage.Send(ex);
            }
        }

        #endregion "Public Commands"

        #region "Private Methods"

        private void _issueVisionModel_SaveChangesComplete(object sender, SubmitOperationEventArgs e)
        {
            if (e.HasError)
            {
                // notify user if there is any error
                AppMessages.RaiseErrorMessage.Send(e.Error);
            }
        }

        private void _issueVisionModel_GetAllIssuesComplete(object sender, EntityResultsArgs<Issue> e)
        {
            if (!e.HasError)
            {
                // cancel any changes before setting AllIssuesSource
                if (_issueVisionModel.HasChanges)
                {
                    AppMessages.CancelChangesMessage.Send();
                }

                this._allIssues = e.Results.OrderBy(g => g.StatusID).ThenBy(g => g.Priority);

                AllIssuesSource = new CollectionViewSource();
                AllIssuesSource.Source = this._allIssues;
                AllIssuesSource.View.CurrentChanging += new CurrentChangingEventHandler(View_CurrentChanging);
                // notify that AllIssuesSource has changed
                this.RaisePropertyChanged("AllIssuesSource");

                // set the first row as the current issue
                if (e.Results.Count() >= 1)
                {
                    var enumerator = this._allIssues.GetEnumerator();
                    enumerator.MoveNext();
                    this.CurrentIssue = enumerator.Current;

                    AppMessages.EditIssueMessage.Send(this.CurrentIssue);
                }
            }
            else
            {
                // notify user if there is any error
                AppMessages.RaiseErrorMessage.Send(e.Error);
            }
        }

        private void View_CurrentChanging(object sender, CurrentChangingEventArgs e)
        {
            MessageBoxResult theResult = MessageBoxResult.OK;

            if (_issueVisionModel.HasChanges)
            {
                // ask to confirm canceling the current issue in edit
                DialogMessage dialogMessage = new DialogMessage(
                    this,
                    CommonResources.CancelCurrentIssueMessageBoxText,
                    s => theResult = s)
                {
                    Button = MessageBoxButton.OKCancel,
                    Caption = CommonResources.ConfirmMessageBoxCaption
                };

                AppMessages.PleaseConfirmMessage.Send(dialogMessage);

                if (theResult == MessageBoxResult.Cancel)
                {
                    e.Cancel = true;
                }
            }
        }

        private void _issueVisionModel_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName.Equals("HasChanges"))
            {
                RefreshCommand.RaiseCanExecuteChanged();
                SubmitChangeCommand.RaiseCanExecuteChanged();
                CancelChangeCommand.RaiseCanExecuteChanged();
            }
        }

        #endregion "Private Methods"
    }
}