Authorization Extender

[ProvideProperty("Roles", typeof(Control))]
 [DesignerSerializer(typeof(AuthExtenderCodeDomSerializer), typeof(CodeDomSerializer))]
 public class AuthExtender : System.ComponentModel.Component, IExtenderProvider
 {
  #region IExtenderProvider Members

  public bool CanExtend(object extendee)
  {
   if (extendee is AuthExtender || extendee is Page)
    return false;
   return true;
  }

  #endregion

  internal Hashtable _roles = new Hashtable();
  public string GetRoles(Control c)
  {
   return _roles[c] as string;
  }

  public void SetRoles(Control c, string roles)
  {
   _roles[c] = roles;
   c.PreRender += new EventHandler(Control_OnPreRender);
  }

  private void Control_OnPreRender(object sender, EventArgs e)
  {
   Control c = sender as Control;
   if (c.Visible)
   {
    string[] roles = ((string)_roles[c]).Split(',');
    c.Visible = false;
    foreach (string role in roles)
    {
     if (HttpContext.Current.User.IsInRole(role))
     {
      c.Visible = true;
      break;
     }
    }
   }
  }
 }


 internal class AuthExtenderCodeDomSerializer : CodeDomSerializer
 {
  public override object Deserialize(IDesignerSerializationManager manager, object codeObject)
  {
   // This is how we associate the component with the serializer.
   CodeDomSerializer baseClassSerializer =
    (CodeDomSerializer)manager.GetSerializer(
     typeof(AuthExtender).BaseType, typeof(CodeDomSerializer));

   object root = baseClassSerializer.Deserialize(manager, codeObject);

   if (codeObject is CodeStatementCollection)
   {
    CodeStatementCollection statements = (CodeStatementCollection)codeObject;

    foreach (CodeStatement statement in statements)
    {
     // if the statement is an expression it should be
     // the SetRoles method invoke expression
     if (statement is CodeExpressionStatement)
     {
      base.DeserializeStatement(manager, statement);
     }
    }
   }

   return root;
  }
 
  public override object Serialize(IDesignerSerializationManager manager, object value)
  {
   CodeDomSerializer baseClassSerializer =
    (CodeDomSerializer)manager.GetSerializer(
     typeof(AuthExtender).BaseType, typeof(CodeDomSerializer));
 
   object codeObject = baseClassSerializer.Serialize(manager, value);
   if (codeObject is CodeStatementCollection)
   {
    CodeStatementCollection statements = (CodeStatementCollection)codeObject;
 
    string commentText = "Setup the authorization for the controls on the form.";
    CodeCommentStatement comment = new CodeCommentStatement(commentText);
    statements.Add(comment);

    AuthExtender ext = value as AuthExtender;
    foreach (Control c in ext._roles.Keys)
    {
     string roles = ext._roles[c] as string;
     if (roles != null && roles != "")
     {
      CodeMethodInvokeExpression methodInvoke = new CodeMethodInvokeExpression(
       // targetObject that contains the method to invoke.
       new CodePropertyReferenceExpression(
       new CodeThisReferenceBLOCKED EXPRESSION,
       manager.GetName(ext)
       ),
       // methodName indicates the method to invoke.
       "SetRoles",
       // parameters array contains the parameters for the method.
       new CodeExpression[]
       {
        new CodePropertyReferenceExpression(
         new CodeThisReferenceBLOCKED EXPRESSION,
         c.ID
        ),
        new CodePrimitiveExpression(
         ext._roles[c]
        )
       }
      );
      statements.Add(methodInvoke);
     }
    }
   }
   return codeObject;
  }
 }

No Comments