source: branches/HeuristicLab.Services.Authentication Prototype/Service/Provider/HeuristicLabRoleProvider.cs @ 3956

using System;
using System.Web.Security;
using System.Linq;
using Persistence;
using System.Text;
using System.Collections.Generic;

namespace Service.Provider {
  class HeuristicLabRoleProvider : RoleProvider {
    protected string applicationName;

    public override void AddUsersToRoles(string[] usernames, string[] roleNames) {
      if (usernames != null && roleNames != null) {
        Persistence.DataClassesDataContext db = DatabaseUtil.createDataClassesDataContext();
        List<HeuristicLabUser> users = db.HeuristicLabUsers.Where(u => usernames.Contains(u.UserName)).ToList<HeuristicLabUser>();
        List<HeuristicLabRole> roles = db.HeuristicLabRole.Where(r => roleNames.Contains(r.RoleName)).ToList<HeuristicLabRole>();
        foreach (HeuristicLabUser user in users) {
          foreach (HeuristicLabRole role in roles) {
            HeuristicLabUserRole userRole = new HeuristicLabUserRole();
            userRole.HeuristicLabRole = role;
            userRole.HeuristicLabUser = user;

            db.HeuristicLabUserRole.InsertOnSubmit(userRole);

          }
        }
        db.SubmitChanges();
      }
    }

    public override string ApplicationName {
      get {
        return this.applicationName;
      }
      set {
        this.applicationName = value;
      }
    }

    public override void CreateRole(string roleName) {
      CreateRole(roleName, false);

    }

    public virtual void CreateRole(String roleName, bool isPermission) {
      if (roleName != null) {
        Persistence.DataClassesDataContext db = DatabaseUtil.createDataClassesDataContext();
        HeuristicLabRole role = new HeuristicLabRole();
        role.RoleName = roleName;
        role.IsPermission = isPermission;
        db.HeuristicLabRole.InsertOnSubmit(role);
        db.SubmitChanges();
      }
    }

    public override bool DeleteRole(string roleName, bool throwOnPopulatedRole) {
      throw new NotImplementedException();
    }

    public override string[] FindUsersInRole(string roleName, string usernameToMatch) {
      List<string> returnValue = new List<string>();
      Persistence.DataClassesDataContext db = DatabaseUtil.createDataClassesDataContext();
      if (roleName != null && db.HeuristicLabRole.Count(r => r.RoleName == roleName) == 1) {
        HeuristicLabRole role = db.HeuristicLabRole.Single(r => r.RoleName == roleName);
        foreach (HeuristicLabUserRole userRole in role.HeuristicLabUserRole) {
          if (userRole.HeuristicLabUser.UserName.Contains(usernameToMatch)) {
            returnValue.Add(userRole.HeuristicLabUser.UserName);
          }
        }
      }
      db.Dispose();
      return returnValue.ToArray();
    }

    public override string[] GetAllRoles() {
      List<string> roleList = new List<string>();

      List<HeuristicLabRole> roles = new List<HeuristicLabRole>(DatabaseUtil.createDataClassesDataContext().HeuristicLabRole.Select(r => r));
      foreach (HeuristicLabRole r in roles) {
        roleList.Add(r.RoleName);
      }

      return roleList.ToArray();
    }

    public override string[] GetRolesForUser(string username) {
      List<string> roleList = new List<string>();
      DataClassesDataContext context = DatabaseUtil.createDataClassesDataContext();
      if (username != null && context.HeuristicLabUsers.Count(u => u.UserName == username) > 0) {

        Persistence.HeuristicLabUser user = context.HeuristicLabUsers.Single(u => u.UserName == username);
        foreach (Persistence.HeuristicLabUserRole userRole in user.HeuristicLabUserRole) {
          roleList.Add(userRole.HeuristicLabRole.RoleName);
        }
      }
      context.Dispose();
      return roleList.ToArray();
    }

    public override string[] GetUsersInRole(string roleName) {
      throw new NotImplementedException();
    }

    public override bool IsUserInRole(string username, string roleName) {
      throw new NotImplementedException();
    }

    public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames) {
      throw new NotImplementedException();
    }

    public override bool RoleExists(string roleName) {

      Persistence.DataClassesDataContext db = DatabaseUtil.createDataClassesDataContext();
      bool returnValue = (DatabaseUtil.createDataClassesDataContext().HeuristicLabRole.Count(r => r.RoleName == roleName) == 1);
      db.Dispose();
      return returnValue;

    }
  }
}