PageModel.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="CslaPageModel.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Custom PageModel for CSLA .NET</summary>
//-----------------------------------------------------------------------
using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;
using Csla.Rules;
using System.Linq;
using Csla.Core;
using System.Threading.Tasks;
 
namespace Csla.AspNetCore.RazorPages
{
  public class PageModel<T> : PageModel
    where T : ISavable
  {
    private ApplicationContext ApplicationContext { get; set; }
 
    public PageModel(ApplicationContext applicationContext)
    {
      ApplicationContext = applicationContext;
    }
 
    [BindProperty]
    public T Item { get; set; }
 
    public async Task<bool> SaveAsync(bool forceUpdate = false)
    {
      try
      {
        if (Item is BusinessBase bb && !bb.IsValid)
          AddBrokenRuleInfo(Item, null);
        if (ModelState.IsValid)
        {
          Item = (T) await Item.SaveAsync(forceUpdate);
          return true;
        }
      }
      catch (ValidationException ex)
      {
        AddBrokenRuleInfo(Item, ex.Message);
      }
      catch (DataPortalException ex)
      {
        if (ex.BusinessException != null)
          ModelState.AddModelError(string.Empty, ex.BusinessException.Message);
        else
          ModelState.AddModelError(string.Empty, ex.Message);
      }
      catch (Exception ex)
      {
        ModelState.AddModelError(string.Empty, ex.Message);
      }
      return false;
    }
 
    private void AddBrokenRuleInfo(T item, string defaultText)
    {
      if (item is BusinessBase bb)
      {
        var errors = bb.BrokenRulesCollection.
          Where(r => r.Severity == RuleSeverity.Error);
        foreach (var rule in errors)
        {
          if (string.IsNullOrEmpty(rule.Property))
          {
            ModelState.AddModelError(string.Empty, rule.Description);
          }
          else
          {
            var modelItem = ModelState
              .Where(r => r.Key == rule.Property || r.Key.EndsWith($".{rule.Property}")).FirstOrDefault();
            var key = modelItem.Key ?? string.Empty;
            ModelState.AddModelError(key, rule.Description);
          }
        }
      }
      else
      {
        ModelState.AddModelError(string.Empty, defaultText);
      }
    }
 
    private readonly Dictionary<string, PropertyInfo> _info = new Dictionary<string, PropertyInfo>();
 
    public PropertyInfo GetPropertyInfo(string propertyName)
    {
      if (!_info.TryGetValue(propertyName, out PropertyInfo info))
      {
        info = new PropertyInfo(Item, propertyName);
        _info.Add(propertyName, info);
      }
      return info;
    }
 
    public bool CanCreateItem()
    {
      return BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.CreateObject, typeof(T));
    }
 
    public bool CanGetItem()
    {
      return BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.GetObject, typeof(T));
    }
 
    public bool CanEditItem()
    {
      return BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.EditObject, typeof(T));
    }
 
    public bool CanDeleteItem()
    {
      return BusinessRules.HasPermission(ApplicationContext, AuthorizationActions.DeleteObject, typeof(T));
    }
  }
}