Csla.Blazor/ViewModel.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="ViewModel.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Base type for creating your own viewmodel</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Csla.Reflection;
using Csla.Rules;
 
namespace Csla.Blazor
{
  public class ViewModel<T>
  {
    private IDataPortal<T> DataPortal { get; set; }
 
    public event Action Saved;
    public event Action<T, T> ModelChanging;
    public event Action ModelChanged;
    public event PropertyChangedEventHandler ModelPropertyChanged;
 
    protected virtual void OnModelChanging(T oldValue, T newValue)
    {
      _info.Clear();
      if (oldValue is INotifyPropertyChanged oldObj)
        oldObj.PropertyChanged -= (s, e) => OnModelPropertyChanged(e.PropertyName);
      if (newValue is INotifyPropertyChanged newObj)
        newObj.PropertyChanged += (s, e) => OnModelPropertyChanged(e.PropertyName);
      ModelChanging?.Invoke(oldValue, newValue);
    }
 
    protected virtual void OnModelChanged()
    {
      ModelChanged?.Invoke();
    }
 
    protected virtual void OnModelPropertyChanged(string propertyName)
    {
      ModelPropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
 
    public ViewModel(IDataPortal<T> dataPortal)
    {
      DataPortal = dataPortal;
    }
 
    public async Task<T> RefreshAsync(Func<Task<T>> factory)
    {
      Exception = null;
      ViewModelErrorText = null;
      try
      {
        Model = await factory();
      }
      catch (DataPortalException ex)
      {
        Model = default;
        Exception = ex;
        ViewModelErrorText = ex.BusinessExceptionMessage;
      }
      catch (Exception ex)
      {
        Model = default;
        Exception = ex;
        ViewModelErrorText = ex.Message;
      }
      return Model;
    }
 
    public async Task SaveAsync()
    {
      Exception = null;
      ViewModelErrorText = null;
      if (Model is Core.ITrackStatus obj && !obj.IsSavable)
      {
        ViewModelErrorText = ModelErrorText;
        return;
      }
      try
      {
        Model = await DoSaveAsync();
        Saved?.Invoke();
      }
      catch (Exception ex)
      {
        Exception = ex;
        ViewModelErrorText = ex.Message;
      }
    }
 
    protected virtual async Task<T> DoSaveAsync()
    {
      if (Model is Core.ISavable savable)
      {
        var result = (T)await savable.SaveAsync();
        if (Model is Core.IEditableBusinessObject editable)
          new Core.GraphMerger().MergeGraph(editable, (Core.IEditableBusinessObject)result);
        else
          Model = result;
      }
      return Model;
    }
 
    private T _model;
    public T Model 
    {
      get => _model;
      set
      {
        if (!ReferenceEquals(_model, value))
        {
          OnModelChanging(_model, value);
          _model = value;
        }
      }
    }
 
    private readonly Dictionary<string, object> _info = new Dictionary<string, object>();
 
    public IPropertyInfo GetPropertyInfo<P>(Expression<Func<P>> property)
    {
      if (property == null)
        throw new ArgumentNullException(nameof(property));
 
      var keyName = property.GetKey();
      var identifier = Microsoft.AspNetCore.Components.Forms.FieldIdentifier.Create(property);
      return GetPropertyInfo(keyName, identifier.Model, identifier.FieldName);
    }
 
    public IPropertyInfo GetPropertyInfo<P>(Expression<Func<P>> property, string id)
    {
      if (property == null)
        throw new ArgumentNullException(nameof(property));
 
      var keyName = property.GetKey() + $"[{id}]";
      var identifier = Microsoft.AspNetCore.Components.Forms.FieldIdentifier.Create(property);
      return GetPropertyInfo(keyName, identifier.Model, identifier.FieldName);
    }
 
    public IPropertyInfo GetPropertyInfo(string propertyName)
    {
      var keyName = Model.GetType().FullName + "." + propertyName;
      return GetPropertyInfo(keyName, Model, propertyName);
    }
 
    public IPropertyInfo GetPropertyInfo(string propertyName, string id)
    {
      var keyName = Model.GetType().FullName + "." + propertyName + $"[{id}]";
      return GetPropertyInfo(keyName, Model, propertyName);
    }
 
    private IPropertyInfo GetPropertyInfo(string keyName, object model, string propertyName)
    {
      PropertyInfo result;
      if (_info.TryGetValue(keyName, out object temp))
      {
        result = (PropertyInfo)temp;
      }
      else
      {
        result = new PropertyInfo(model, propertyName);
        _info.Add(keyName, result);
      }
      return result;
    }
 
    public string ViewModelErrorText { get; protected set; }
 
    protected virtual string ModelErrorText
    {
      get
      {
        if (Model is IDataErrorInfo obj)
        {
          return obj.Error;
        }
        return string.Empty;
      }
    }
 
    public Exception Exception { get; private set; }
 
    public static bool CanCreateObject()
    {
      return BusinessRules.HasPermission(AuthorizationActions.CreateObject, typeof(T));
    }
 
    public static bool CanGetObject()
    {
      return BusinessRules.HasPermission(AuthorizationActions.GetObject, typeof(T));
    }
 
    public static bool CanEditObject()
    {
      return BusinessRules.HasPermission(AuthorizationActions.EditObject, typeof(T));
    }
 
    public static bool CanDeleteObject()
    {
      return BusinessRules.HasPermission(AuthorizationActions.DeleteObject, typeof(T));
    }
  }
}