A Pluggable Architecture for Building Silverlight Applications with MVVM

using System;
using System.ComponentModel;
using System.ComponentModel.Composition;
using System.Linq;
using System.Security.Principal;
using System.ServiceModel.DomainServices.Client;
using IssueVision.Data.Web;
using IssueVision.Common;

namespace IssueVision.Model
{
    [Export(typeof(IAdminIssueVisionModel))]
    [PartCreationPolicy(CreationPolicy.Shared)]
    public class AdminIssueVisionModel : IAdminIssueVisionModel
    {
        #region "Private Data"
        private IssueVisionContext _ctx;
        #endregion "Private Data"

        #region "Protected Propertes"
        protected IssueVisionContext Context
        {
            get
            {
                if (_ctx == null)
                {
                    _ctx = IssueVisionContext.Instance;
                    _ctx.PropertyChanged += new System.ComponentModel.PropertyChangedEventHandler(_ctx_PropertyChanged);
                }

                return _ctx;
            }
        }
        #endregion "Protected Propertes"

        #region "IAdminIssueVisionModel Interface implementation"

        public void GetUsersAsync()
        {
            PerformQuery<User>(Context.GetUsersQuery(), GetUsersComplete);
        }

        public User AddNewUser()
        {
            User g = new User()
                {
                    PasswordQuestion = "PasswordQuestion",
                    UserType = "U"
                };
            this.Context.Users.Add(g);
            return g;
        }

        public void RemoveUser(User user)
        {
            if (this.Context.Users.Contains(user))
                this.Context.Users.Remove(user);
        }

        public void SaveChangesAsync()
        {
            this.Context.SubmitChanges(s =>
            {
                if (SaveChangesComplete != null)
                {
                    try
                    {
                        Exception ex = null;
                        if (s.HasError)
                        {
                            ex = s.Error;
                            s.MarkErrorAsHandled();
                        }
                        SaveChangesComplete(this, new SubmitOperationEventArgs(s, ex));
                    }
                    catch (Exception ex)
                    {
                        SaveChangesComplete(this, new SubmitOperationEventArgs(ex));
                    }
                }
            }, null);
        }

        /// <summary>
        /// Reject any pending changes
        /// </summary>
        public void RejectChanges()
        {
            this.Context.RejectChanges();
        }

        /// <summary>
        /// True if _ctx.HasChanges is true; otherwise, false
        /// </summary>
        public Boolean HasChanges
        {
            get
            {
                return this._hasChanges;
            }

            private set
            {
                if (this._hasChanges != value)
                {
                    this._hasChanges = value;
                    this.OnPropertyChanged("HasChanges");
                }
            }
        }
        private Boolean _hasChanges = false;

        /// <summary>
        /// True if either "IsLoading" or "IsSubmitting" is
        /// in progress; otherwise, false
        /// </summary>
        public Boolean IsBusy
        {
            get
            {
                return this._isBusy;
            }

            private set
            {
                if (this._isBusy != value)
                {
                    this._isBusy = value;
                    this.OnPropertyChanged("IsBusy");
                }
            }
        }
        private Boolean _isBusy = false;

        public event EventHandler<SubmitOperationEventArgs> SaveChangesComplete;
        public event EventHandler<EntityResultsArgs<User>> GetUsersComplete;

        #endregion "IAdminIssueVisionModel Interface implementation"

        #region "INotifyPropertyChanged Interface implementation"
        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged(string propertyName)
        {
            if (this.PropertyChanged != null)
            {
                this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        #endregion "INotifyPropertyChanged Interface implementation"

        #region "Private Methods"
        private void _ctx_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            switch (e.PropertyName)
            {
                case "HasChanges":
                    this.HasChanges = _ctx.HasChanges;
                    break;
                case "IsLoading":
                    this.IsBusy = _ctx.IsLoading;
                    break;
                case "IsSubmitting":
                    this.IsBusy = _ctx.IsSubmitting;
                    break;
            }
        }

        private void PerformQuery<T>(EntityQuery<T> qry, EventHandler<EntityResultsArgs<T>> evt) where T : Entity
        {
            Context.Load<T>(qry, LoadBehavior.RefreshCurrent, r =>
            {
                if (evt != null)
                {
                    try
                    {
                        if (r.HasError)
                        {
                            evt(this, new EntityResultsArgs<T>(r.Error));
                            r.MarkErrorAsHandled();
                        }
                        else
                        {
                            evt(this, new EntityResultsArgs<T>(r.Entities));
                        }
                    }
                    catch (Exception ex)
                    {
                        evt(this, new EntityResultsArgs<T>(ex));
                    }
                }
            }, null);
        }
        #endregion "Private Methods"                                     
    }
}