Csla.Xaml.Shared/ViewModelBase.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="ViewModelBase.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Base class used to create ViewModel objects that</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Specialized;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Threading.Tasks;
using System.Windows;
using Csla.Core;
using Csla.Rules;
#if WINDOWS_UWP
using Windows.UI.Xaml;
#endif
 
#if ANDROID
namespace Csla.Axml
#elif IOS
namespace Csla.Iosui
#else
namespace Csla.Xaml
#endif
{
#if ANDROID || IOS || XAMARIN
  public abstract class ViewModelBase<T> : INotifyPropertyChanged, IViewModel
#else
  public abstract class ViewModelBase<T> : DependencyObject,
    INotifyPropertyChanged, IViewModel
#endif
  {
    private ApplicationContext ApplicationContext { get => Csla.Xaml.ApplicationContextManager.GetApplicationContext(); }
 
#if ANDROID || IOS || XAMARIN || WINDOWS_UWP
    private T _model;
    public T Model
    {
      get { return _model; }
      set
      {
        if (!ReferenceEquals(value, _model))
        {
          var oldValue = _model;
          _model = value;
          this.OnModelChanged((T)oldValue, _model);
          OnPropertyChanged(nameof(Model));
        }
      }
    }
#else
    public static readonly DependencyProperty ModelProperty =
        DependencyProperty.Register("Model", typeof(T), typeof(ViewModelBase<T>),
        new PropertyMetadata((o, e) =>
        {
          var viewmodel = (ViewModelBase<T>)o;
          viewmodel.OnModelChanged((T)e.OldValue, (T)e.NewValue);
        }));
 
    public T Model
    {
      get { return (T)GetValue(ModelProperty); }
      set { SetValue(ModelProperty, value); }
    }
#endif
 
#if ANDROID || IOS || XAMARIN
    public bool ManageObjectLifetimeProperty;
#else
    public static readonly DependencyProperty ManageObjectLifetimeProperty =
        DependencyProperty.Register("ManageObjectLifetime", typeof(bool),
        typeof(ViewModelBase<T>), new PropertyMetadata(true));
#endif
    [Browsable(false)]
    [Display(AutoGenerateField = false)]
    [ScaffoldColumn(false)]
    public bool ManageObjectLifetime
    {
#if ANDROID || IOS || XAMARIN
      get { return (bool)ManageObjectLifetimeProperty; }
      set { ManageObjectLifetimeProperty = value; }
#else
      get { return (bool)GetValue(ManageObjectLifetimeProperty); }
      set { SetValue(ManageObjectLifetimeProperty, value); }
#endif
    }
 
    private bool _isBusy;
 
    public bool IsBusy
    {
      get { return _isBusy; }
      protected set
      {
        if (value != _isBusy)
        {
          _isBusy = value;
          OnPropertyChanged(nameof(IsBusy));
          OnSetProperties();
        }
      }
    }
 
    private bool _isDirty;
 
    public virtual bool IsDirty
    {
      get
      {
        return _isDirty;
      }
      protected set
      {
        if (_isDirty != value)
        {
          _isDirty = value;
          OnPropertyChanged(nameof(IsDirty));
        }
      }
    }
 
    private bool _isValid;
 
    public virtual bool IsValid
    {
      get
      {
        return _isValid;
      }
      protected set
      {
        if (_isValid != value)
        {
          _isValid = value;
          OnPropertyChanged(nameof(IsValid));
        }
      }
    }
 
    private bool _canSave = false;
 
    public virtual bool CanSave
    {
      get
      {
        return _canSave;
      }
      protected set
      {
        if (_canSave != value)
        {
          _canSave = value;
          OnPropertyChanged(nameof(CanSave));
        }
      }
    }
 
    private bool _canCancel = false;
 
    public virtual bool CanCancel
    {
      get
      {
        return _canCancel;
      }
      protected set
      {
        if (_canCancel != value)
        {
          _canCancel = value;
          OnPropertyChanged(nameof(CanCancel));
        }
      }
    }
 
    private bool _canCreate = false;
 
    public virtual bool CanCreate
    {
      get
      {
        return _canCreate;
      }
      protected set
      {
        if (_canCreate != value)
        {
          _canCreate = value;
          OnPropertyChanged(nameof(CanCreate));
        }
      }
    }
 
    private bool _canDelete = false;
 
    public virtual bool CanDelete
    {
      get
      {
        return _canDelete;
      }
      protected set
      {
        if (_canDelete != value)
        {
          _canDelete = value;
          OnPropertyChanged(nameof(CanDelete));
        }
      }
    }
 
    private bool _canFetch = false;
 
    public virtual bool CanFetch
    {
      get
      {
        return _canFetch;
      }
      protected set
      {
        if (_canFetch != value)
        {
          _canFetch = value;
          OnPropertyChanged(nameof(CanFetch));
        }
      }
    }
 
    private bool _canRemove = false;
 
    public virtual bool CanRemove
    {
      get
      {
        return _canRemove;
      }
      protected set
      {
        if (_canRemove != value)
        {
          _canRemove = value;
          OnPropertyChanged(nameof(CanRemove));
        }
      }
    }
 
    private bool _canAddNew = false;
 
    public virtual bool CanAddNew
    {
      get
      {
        return _canAddNew;
      }
      protected set
      {
        if (_canAddNew != value)
        {
          _canAddNew = value;
          OnPropertyChanged(nameof(CanAddNew));
        }
      }
    }
 
    private void SetProperties()
    {
      bool isObjectBusy = false;
      if (Model is INotifyBusy busyObject && busyObject.IsBusy)
        isObjectBusy = true;
 
      // Does Model instance implement ITrackStatus 
      if (Model is ITrackStatus targetObject)
      {
        var canDeleteInstance = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.DeleteObject, targetObject);
 
        IsDirty = targetObject.IsDirty;
        IsValid = targetObject.IsValid;
        CanSave = CanEditObject && targetObject.IsSavable && !isObjectBusy;
        CanCancel = CanEditObject && targetObject.IsDirty && !isObjectBusy;
        CanCreate = CanCreateObject && !targetObject.IsDirty && !isObjectBusy;
        CanDelete = CanDeleteObject && !isObjectBusy && canDeleteInstance;
        CanFetch = CanGetObject && !targetObject.IsDirty && !isObjectBusy;
 
        // Set properties for List 
        if (Model is ICollection list)
        {
          Type itemType = Utilities.GetChildItemType(Model.GetType());
          if (itemType == null)
          {
            CanAddNew = false;
            CanRemove = false;
          }
          else
          {
            CanRemove = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.DeleteObject, itemType) &&
                        list.Count > 0 && !isObjectBusy;
            CanAddNew = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.CreateObject, itemType) &&
                        !isObjectBusy;
          }
        }
        else
        {
          CanRemove = false;
          CanAddNew = false;
        }
      }
 
      // Else if Model instance implement ICollection
      else if (Model is ICollection list)
      {
        Type itemType = Utilities.GetChildItemType(Model.GetType());
        if (itemType == null)
        {
          CanAddNew = false;
          CanRemove = false;
        }
        else
        {
          CanRemove = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.DeleteObject, itemType) &&
                      list.Count > 0 && !isObjectBusy;
          CanAddNew = BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.CreateObject, itemType) &&
                      !isObjectBusy;
        }
      }
      else
      {
        IsDirty = false;
        IsValid = false;
        CanCancel = false;
        CanCreate = CanCreateObject;
        CanDelete = false;
        CanFetch = CanGetObject && !IsBusy;
        CanSave = false;
        CanRemove = false;
        CanAddNew = false;
      }
    }
 
    private bool _canCreateObject;
 
    public virtual bool CanCreateObject
    {
      get
      {
        SetPropertiesAtObjectLevel(); 
        return _canCreateObject;
      }
      protected set
      {
        if (_canCreateObject != value)
        {
          _canCreateObject = value;
          OnPropertyChanged(nameof(CanCreateObject));
        }
      }
    }
 
    private bool _canGetObject;
 
    public virtual bool CanGetObject
    {
      get 
      { 
        SetPropertiesAtObjectLevel(); 
        return _canGetObject; 
      }
      protected set
      {
        if (_canGetObject != value)
        {
          _canGetObject = value;
          OnPropertyChanged(nameof(CanGetObject));
        }
      }
    }
 
    private bool _canEditObject;
 
    public virtual bool CanEditObject
    {
      get 
      { 
        SetPropertiesAtObjectLevel(); 
        return _canEditObject; 
      }
      protected set
      {
        if (_canEditObject != value)
        {
          _canEditObject = value;
          OnPropertyChanged(nameof(CanEditObject));
        }
      }
    }
 
    private bool _canDeleteObject;
 
    public virtual bool CanDeleteObject
    {
      get 
      { 
        SetPropertiesAtObjectLevel(); 
        return _canDeleteObject; 
      }
      protected set
      {
        if (_canDeleteObject != value)
        {
          _canDeleteObject = value;
          OnPropertyChanged(nameof(CanDeleteObject));
        }
      }
    }
 
    private bool ObjectPropertiesSet;
 
    private void SetPropertiesAtObjectLevel()
    {
      if (ObjectPropertiesSet)
        return;
      ObjectPropertiesSet = true;
 
      Type sourceType = typeof(T);
 
      CanCreateObject = BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.CreateObject, sourceType);
      CanGetObject = BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.GetObject, sourceType);
      CanEditObject = BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.EditObject, sourceType);
      CanDeleteObject = BusinessRules.HasPermission(ApplicationContext, Rules.AuthorizationActions.DeleteObject, sourceType);
 
      // call SetProperties to set "instance" values 
      OnSetProperties();
    }
 
    public virtual async Task<T> RefreshAsync<F>(Func<Task<T>> factory)
    {
      T result = default;
      try
      {
        IsBusy = true;
        result = await factory.Invoke();
        Model = result;
      }
      finally
      {
        IsBusy = false;
      }
      return result;
    }
 
    public virtual async Task<T> SaveAsync()
    {
      try
      {
        UnhookChangedEvents(Model);
        var savable = Model as ISavable;
        if (ManageObjectLifetime)
        {
          // clone the object if possible
          if (Model is ICloneable clonable)
            savable = (ISavable)clonable.Clone();
 
          //apply changes
          if (savable is ISupportUndo undoable)
            undoable.ApplyEdit();
        }
 
        IsBusy = true;
        Model = (T)await savable.SaveAsync();
      }
      finally
      {
        HookChangedEvents(Model);
        IsBusy = false;
      }
      return Model;
    }
 
    protected virtual void DoCancel()
    {
      if (ManageObjectLifetime)
      {
        if (Model is ISupportUndo undo)
        {
          UnhookChangedEvents(Model);
          try
          {
            undo.CancelEdit();
            undo.BeginEdit();
          }
          finally
          {
            HookChangedEvents(Model);
            OnSetProperties();
          }
        }
      }
    }
 
#if (ANDROID || IOS) || XAMARIN
    protected virtual void BeginAddNew()
    {
#if ANDROID || IOS
      var ibl = (Model as System.ComponentModel.IBindingList);
#else
      var ibl = (Model as IBindingList);
#endif
      if (ibl != null)
      {
        ibl.AddNew();
      }
      else
      {
        // else try to use as IObservableBindingList
        var iobl = ((IObservableBindingList)Model);
        iobl.AddNew();
      }
      OnSetProperties();
    }
#else
    protected virtual object DoAddNew()
    {
      object result;
      // typically use ObserableCollection 
      if (Model is IObservableBindingList iobl)
      {
        result = iobl.AddNew();
      }
      else
      {
        // else try to use as BindingList
        var ibl = ((IBindingList)Model);
        result = ibl.AddNew();
      }
      OnSetProperties();
      return result;
    }
#endif
 
    protected virtual void DoRemove(object item)
    {
      ((IList)Model).Remove(item);
      OnSetProperties();
    }
 
    protected virtual void DoDelete()
    {
      ((IEditableBusinessObject)Model).Delete();
    }
 
    protected virtual void OnModelChanged(T oldValue, T newValue)
    {
      if (ReferenceEquals(oldValue, newValue)) return;
 
      if (ManageObjectLifetime && newValue is ISupportUndo undo)
        undo.BeginEdit();
 
      // unhook events from old value
      if (oldValue != null)
      {
        UnhookChangedEvents(oldValue);
 
        if (oldValue is INotifyBusy nb)
          nb.BusyChanged -= Model_BusyChanged;
      }
 
      // hook events on new value
      if (newValue != null)
      {
        HookChangedEvents(newValue);
 
        if (newValue is INotifyBusy nb)
          nb.BusyChanged += Model_BusyChanged;
      }
 
      OnSetProperties();
    }
 
    protected void UnhookChangedEvents(T model)
    {
      if (model is INotifyPropertyChanged npc)
        npc.PropertyChanged -= Model_PropertyChanged;
 
      if (model is INotifyChildChanged ncc)
        ncc.ChildChanged -= Model_ChildChanged;
 
      if (model is INotifyCollectionChanged cc)
        cc.CollectionChanged -= Model_CollectionChanged;
    }
 
    private void HookChangedEvents(T model)
    {
      if (model is INotifyPropertyChanged npc)
        npc.PropertyChanged += Model_PropertyChanged;
 
      if (model is INotifyChildChanged ncc)
        ncc.ChildChanged += Model_ChildChanged;
 
      if (model is INotifyCollectionChanged cc)
        cc.CollectionChanged += Model_CollectionChanged;
    }
 
    protected virtual void OnSetProperties()
    {
      SetProperties();
    }
 
    private void Model_BusyChanged(object sender, BusyChangedEventArgs e)
    {
      // only set busy state for entire object.  Ignore busy state based
      // on asynch rules being active
      if (string.IsNullOrEmpty(e.PropertyName))
        IsBusy = e.Busy;
      else
        OnSetProperties();
    }
 
    private void Model_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
      OnSetProperties();
    }
 
    private void Model_ChildChanged(object sender, ChildChangedEventArgs e)
    {
      OnSetProperties();
    }
 
    private void Model_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
      OnSetProperties();
    }
 
    object IViewModel.Model
    {
      get { return Model; }
      set { Model = (T)value; }
    }
 
    public event PropertyChangedEventHandler PropertyChanged;
 
    protected virtual void OnPropertyChanged(string propertyName)
    {
      PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
  }
}