HtmlExtensions.cs

Go to the documentation of this file.

//-----------------------------------------------------------------------
// <copyright file="HtmlExtensions.cs" company="Marimer LLC">
//     Copyright (c) Marimer LLC. All rights reserved.
//     Website: https://cslanet.com
// </copyright>
// <summary>Html extension methods providing support for HTML rendering based on security permissions in an application.</summary>
//-----------------------------------------------------------------------
#if NETSTANDARD2_0 || NET5_0_OR_GREATER || NETCOREAPP3_1
using System;
using System.Linq;
using Microsoft.AspNetCore.Html;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.AspNetCore.Mvc.ViewFeatures;
using Csla.AspNetCore;
 
namespace Csla.Web.Mvc
{
  public static class HtmlExtensions
  {
    public static HtmlString InformationFor<T>(
      this IHtmlHelper<T> htmlHelper,
      System.Linq.Expressions.Expression<Func<T, object>> expression)
    {
      var result = string.Empty;
      var model = htmlHelper.ViewData.Model;
      System.Reflection.PropertyInfo reflectedPropertyInfo = Csla.Reflection.Reflect<T>.GetProperty(expression);
      var propertyName = reflectedPropertyInfo.Name;
      if (model is Csla.Core.BusinessBase bb)
        result = bb.BrokenRulesCollection.ToString(",", Rules.RuleSeverity.Information, propertyName);
      return new HtmlString(result);
    }
 
    public static HtmlString WarningFor<T>(
      this IHtmlHelper<T> htmlHelper,
      System.Linq.Expressions.Expression<Func<T, object>> expression)
    {
      var result = string.Empty;
      var model = htmlHelper.ViewData.Model;
      System.Reflection.PropertyInfo reflectedPropertyInfo = Csla.Reflection.Reflect<T>.GetProperty(expression);
      var propertyName = reflectedPropertyInfo.Name;
      if (model is Csla.Core.BusinessBase bb)
        result = bb.BrokenRulesCollection.ToString(",", Rules.RuleSeverity.Warning, propertyName);
      return new HtmlString(result);
    }
 
    public static HtmlString ErrorFor<T>(
      this IHtmlHelper<T> htmlHelper,
      System.Linq.Expressions.Expression<Func<T, object>> expression)
    {
      var result = string.Empty;
      var model = htmlHelper.ViewData.Model;
      System.Reflection.PropertyInfo reflectedPropertyInfo = Csla.Reflection.Reflect<T>.GetProperty(expression);
      var propertyName = reflectedPropertyInfo.Name;
      if (model is Csla.Core.BusinessBase bb)
        result = bb.BrokenRulesCollection.ToString(",", Rules.RuleSeverity.Error, propertyName);
      return new HtmlString(result);
    }
 
    private static ApplicationContext GetApplication(IHtmlHelper htmlHelper)
    {
      return (ApplicationContext)htmlHelper.ViewContext.HttpContext.Items["Csla.ApplicationContext"];
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    HtmlString granted,
                                    HtmlString denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return granted;
      else
        return denied;
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    HtmlString granted,
                                    string denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return granted;
      else
        return new HtmlString(denied);
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    string granted,
                                    string denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return new HtmlString(granted);
      else
        return new HtmlString(denied);
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    HtmlString granted,
                                    HtmlString denied)
    {
      if (target is not Csla.Security.IAuthorizeReadWrite instance) return denied;
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return granted;
      else
        return denied;
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    HtmlString granted,
                                    string denied)
    {
      if (target is not Csla.Security.IAuthorizeReadWrite instance) return new HtmlString(denied);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return granted;
      else
        return new HtmlString(denied);
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    string granted,
                                    string denied)
    {
      var instance = target as Csla.Security.IAuthorizeReadWrite;
      if (instance == null) return new HtmlString(denied);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return new HtmlString(granted);
      else
        return new HtmlString(denied);
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    Func<IHtmlHelper, HtmlString> grantedAction)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return grantedAction.Invoke(htmlHelper);
      else
        return HtmlString.Empty;
    }
 
    public static HtmlString HasPermission(
                                    this IHtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    Func<IHtmlHelper, HtmlString> grantedAction,
                                    Func<IHtmlHelper, HtmlString> denieddAction)
    {
      if (target is not Csla.Security.IAuthorizeReadWrite instance) return denieddAction.Invoke(htmlHelper);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return grantedAction.Invoke(htmlHelper);
      else
        return denieddAction.Invoke(htmlHelper);
    }
  }
}
#else
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;
 
namespace Csla.Web.Mvc
{
  public static class HtmlExtensions
  {
    private static ApplicationContext GetApplication(HtmlHelper htmlHelper)
    {
      return (ApplicationContext)htmlHelper.ViewContext.HttpContext.Items["Csla.ApplicationContext"];
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    MvcHtmlString granted,
                                    MvcHtmlString denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return granted;
      else
        return denied;
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    MvcHtmlString granted,
                                    string denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return granted;
      else
        return MvcHtmlString.Create(denied);
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    string granted,
                                    string denied)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return MvcHtmlString.Create(granted);
      else
        return MvcHtmlString.Create(denied);
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    MvcHtmlString granted,
                                    MvcHtmlString denied)
    {
      var instance = target as Csla.Security.IAuthorizeReadWrite;
      if (instance == null) return denied;
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return granted;
      else
        return denied;
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    MvcHtmlString granted,
                                    string denied)
    {
      var instance = target as Csla.Security.IAuthorizeReadWrite;
      if (instance == null) return MvcHtmlString.Create(denied);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return granted;
      else
        return MvcHtmlString.Create(denied);
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    string granted,
                                    string denied)
    {
      var instance = target as Csla.Security.IAuthorizeReadWrite;
      if (instance == null) return MvcHtmlString.Create(denied);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return MvcHtmlString.Create(granted);
      else
        return MvcHtmlString.Create(denied);
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    Type objectType,
                                    Func<HtmlHelper, MvcHtmlString> grantedAction)
    {
      var applicationContext = GetApplication(htmlHelper);
      if (Csla.Rules.BusinessRules.HasPermission(applicationContext, action, objectType))
        return grantedAction.Invoke(htmlHelper);
      else
        return MvcHtmlString.Empty;
    }
 
    public static MvcHtmlString HasPermission(
                                    this HtmlHelper htmlHelper,
                                    Csla.Rules.AuthorizationActions action,
                                    object target,
                                    Csla.Core.IMemberInfo member,
                                    Func<HtmlHelper, MvcHtmlString> grantedAction,
                                    Func<HtmlHelper, MvcHtmlString> denieddAction)
    {
      var instance = target as Csla.Security.IAuthorizeReadWrite;
      if (instance == null) return denieddAction.Invoke(htmlHelper);
 
      if ((action == Rules.AuthorizationActions.ReadProperty && instance.CanReadProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.WriteProperty && instance.CanWriteProperty(member.Name)) ||
          (action == Rules.AuthorizationActions.ExecuteMethod && instance.CanExecuteMethod(member.Name)))
        return grantedAction.Invoke(htmlHelper);
      else
        return denieddAction.Invoke(htmlHelper);
    }
  }
}
#endif