public void DeleteUserRole(UserInfo user)
{
try
{
// Get role and user objects
// RoleInfo role = RoleInfoProvider.GetRoleInfo(roleName.ToString(), CMS.SiteProvider.SiteContext.CurrentSiteID);
// UserInfo user = UserInfoProvider.GetUserInfo("MyNewUser");
DataTable dt = UserInfoProvider.GetUserRoles(user);
if (dt.Rows.Count > 0 && dt != null)
{
foreach (DataRow dr in dt.Rows)
{
if (dr["RoleName"].ToString().ToLower().Contains("sso_"))
{
UserRoleInfo deleteRole = UserRoleInfoProvider.GetUserRoleInfo(user.UserID, Convert.ToInt32(dr["RoleID"]));
// Delete the user role
UserRoleInfoProvider.DeleteUserRoleInfo(deleteRole);
}
}
}
}
catch (Exception ex)
{
EventLogProvider.LogException("Issue while DeleteUserRole", "Get", ex);
}
}
/// <summary>
/// Returns where condition for specialized role conditions or <c>null</c> in case no roles were selected.
/// </summary>
/// <param name="selector">Condition to use (ANY/ALL)</param>
/// <param name="selectedRoles">Values separated with semicolon</param>
/// <remarks>
/// <c>null</c> is returned in order to allow calling <see cref="WhereConditionBase{TParent}.WhereNot"/> on method's result
/// (empty <see cref="WhereCondition"/> would cause appending "NOT" to SQL query).
/// </remarks>
private WhereCondition GetRolesSelectorCondition(string selector, string selectedRoles)
{
if (String.IsNullOrEmpty(selectedRoles))
{
return(null);
}
string[] roles = selectedRoles.Split(';');
var globalRolesCondition = GetGlobalRolesCondition(roles);
var roleCondition = GetSiteRolesCondition(roles).Or(globalRolesCondition);
var query = UserRoleInfoProvider.GetUserRoles()
.Column("UserID")
.WhereIn("RoleID", RoleInfoProvider.GetRoles()
.Column("RoleID")
.Where(roleCondition))
.Where(new WhereCondition()
.WhereNull("ValidTo")
.Or()
.WhereGreaterThan("ValidTo", DateTime.Now))
.GroupBy("UserID");
if (selector.Equals(UniGrid.ALL, StringComparison.OrdinalIgnoreCase))
{
query.Having(condition => condition.WhereEquals(new CountColumn("RoleID"), roles.Length));
}
var userIdColumn = SessionInsteadOfUser ? "SessionUserID" : "UserID";
return(new WhereCondition().WhereIn(userIdColumn, query));
}
private void MemberNonMemberRoles(string roletype, UserInfo user)
{
RoleInfo role = RoleInfoProvider.GetRoleInfo(roletype, CMS.SiteProvider.SiteContext.CurrentSiteID);
// UserInfo user = UserInfoProvider.GetUserInfo("test");
if ((role != null))
{
// Create new user role object
UserRoleInfo userRole = new UserRoleInfo();
// Set the properties
userRole.UserID = user.UserID;
userRole.RoleID = role.RoleID;
// Save the user role
UserRoleInfoProvider.SetUserRoleInfo(userRole);
CMS.Membership.UserInfoProvider.AddUserToRole(user.UserName, roletype, CMS.SiteProvider.SiteContext.CurrentSiteName);
//return true;
}
else
{
// create role and add user to it
CreateUpdateRole(roletype);
CMS.Membership.UserInfoProvider.AddUserToRole(user.UserName, roletype, CMS.SiteProvider.SiteContext.CurrentSiteName);
}
}
public void RemoveFromRoleAsync_UserIsNotInRole_DoesNotThrow()
{
var user = new User(mMembershipFakeFactory.UserEnabledWithEmail);
CMSAssert.All(
() => Assert.IsNull(UserRoleInfoProvider.GetUserRoleInfo(user.Id, mMembershipFakeFactory.AdminRole.RoleID)),
() => Assert.DoesNotThrow(() => mUserStore.RemoveFromRoleAsync(user, MembershipFakeFactory.ROLE_ADMIN).Wait()));
}
public async Task AddToRoleAsync_UserIsNotInRole_UserRoleInfoCreated()
{
var user = new User(mMembershipFakeFactory.UserEnabledWithEmail);
await mUserStore.AddToRoleAsync(user, MembershipFakeFactory.ROLE_MEMBER);
CMSAssert.All(
() => Assert.AreEqual(1, UserRoleInfoProvider.GetUserRoles().Count),
() => Assert.IsNotNull(UserRoleInfoProvider.GetUserRoleInfo(user.Id, mMembershipFakeFactory.MemberRole.RoleID)));
}
public bool UserInRole(int UserID, string RoleName, string SiteName)
{
var Role = _Helper.GetRole(RoleName, SiteName, new string[] { "RoleID" });
if (Role == null)
{
_eventLogService.LogEvent(EventTypeEnum.Error, "KenticoUserRepository", "NoAdministratorRole", "No Administrator Role found! Please add!");
}
return(UserRoleInfoProvider.IsUserInRole(UserID, Role.RoleID));
}
private string GetRoleUsers()
{
DataSet ds = UserRoleInfoProvider.GetUserRoles("RoleID = " + RoleID, null, 0, "UserID");
if (!DataHelper.DataSourceIsEmpty(ds))
{
return(TextHelper.Join(";", SystemDataHelper.GetStringValues(ds.Tables[0], "UserID")));
}
return(String.Empty);
}
private string GetRoleUsers()
{
var data = UserRoleInfoProvider.GetUserRoles().Where("RoleID = " + RoleID).Columns("UserID");
if (data.Any())
{
return(TextHelper.Join(";", DataHelper.GetStringValues(data.Tables[0], "UserID")));
}
return(String.Empty);
}
public void AddToRoleAsync_UserIsInRole_DoesNotThrow()
{
var user = new User(mMembershipFakeFactory.UserEnabledWithEmail);
var role = mMembershipFakeFactory.AdminRole;
UserRoleInfoProvider.AddUserToRole(mMembershipFakeFactory.UserEnabledWithEmail, role);
CMSAssert.All(
() => Assert.IsNotNull(UserRoleInfoProvider.GetUserRoleInfo(user.Id, role.RoleID)),
() => Assert.DoesNotThrow(() => mUserStore.AddToRoleAsync(user, role.RoleName).Wait()));
}
public void IsInRoleAsync_UserInAllRoles_ExpectedResult()
{
var userInfo = mMembershipFakeFactory.UserEnabledWithEmail;
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.AdminRole);
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.MemberRole);
var user = new User(userInfo);
CMSAssert.All(
async() => Assert.IsTrue(await mUserStore.IsInRoleAsync(user, MembershipFakeFactory.ROLE_ADMIN), "Admin role missing"),
async() => Assert.IsTrue(await mUserStore.IsInRoleAsync(user, MembershipFakeFactory.ROLE_MEMBER), "Member role missing"));
}
/// <summary>
/// Gets roles for current user.
/// </summary>
private void LoadCurrentRoles()
{
if (this.gmi != null)
{
// Get user roles
DataSet ds = UserRoleInfoProvider.GetUserRoles("UserID = " + gmi.MemberUserID + "AND RoleID IN (SELECT RoleID FROM CMS_Role WHERE RoleGroupID = " + gmi.MemberGroupID + ")", null, 0, "RoleID");
if (!DataHelper.DataSourceIsEmpty(ds))
{
currentValues = TextHelper.Join(";", SqlHelperClass.GetStringValues(ds.Tables[0], "RoleID"));
}
currentRolesLoaded = true;
}
}
public void Roles_DisabledUserInAllRoles_AllRoleNames()
{
var userInfo = mMembershipFakeFactory.UserDisabledWithEmail;
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.AdminRole);
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.MemberRole);
var user = new User(userInfo);
CMSAssert.All(
() => Assert.AreEqual(2, user.Roles.Count()),
() => Assert.IsTrue(user.Roles.Contains(MembershipFakeFactory.ROLE_ADMIN), "Admin role missing"),
() => Assert.IsTrue(user.Roles.Contains(MembershipFakeFactory.ROLE_MEMBER), "Member role missing"));
}
/// <summary>
/// Gets roles for current user.
/// </summary>
private void LoadCurrentRoles()
{
if (CurrentMember != null)
{
// Get user roles
var data = UserRoleInfoProvider.GetUserRoles().Where("UserID = " + CurrentMember.MemberUserID + "AND RoleID IN (SELECT RoleID FROM CMS_Role WHERE RoleGroupID = " + CurrentMember.MemberGroupID + ")").Columns("RoleID");
if (data.Any())
{
currentValues = TextHelper.Join(";", DataHelper.GetStringValues(data.Tables[0], "RoleID"));
}
currentRolesLoaded = true;
}
}
public async Task RemoveFromRoleAsync_UserIsInRole_UserRoleInfoDeletedUserAndRoleExists()
{
var role = mMembershipFakeFactory.AdminRole;
var user = new User(mMembershipFakeFactory.UserEnabledWithEmail);
UserRoleInfoProvider.AddUserToRole(mMembershipFakeFactory.UserEnabledWithEmail, mMembershipFakeFactory.AdminRole);
await mUserStore.RemoveFromRoleAsync(user, role.RoleName);
CMSAssert.All(
() => Assert.AreEqual(0, UserRoleInfoProvider.GetUserRoles().Count),
() => Assert.IsNull(UserRoleInfoProvider.GetUserRoleInfo(user.Id, role.RoleID)),
() => Assert.IsNotNull(RoleInfoProvider.GetRoleInfo(role.RoleID)),
() => Assert.IsNotNull(UserInfoProvider.GetUserInfo(user.Id)));
}
public async Task GetRolesAsync_UserInAllRoles_AllRoleNames()
{
var userInfo = mMembershipFakeFactory.UserEnabledWithEmail;
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.AdminRole);
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.MemberRole);
var user = new User(userInfo);
var roles = await mUserStore.GetRolesAsync(user);
CMSAssert.All(
() => Assert.AreEqual(2, roles.Count),
async() => Assert.IsTrue(await mUserStore.IsInRoleAsync(user, MembershipFakeFactory.ROLE_ADMIN), "Admin role missing"),
async() => Assert.IsTrue(await mUserStore.IsInRoleAsync(user, MembershipFakeFactory.ROLE_MEMBER), "Member role missing"));
}
/// <summary>
/// Adds <see cref="User"/> to <see cref="Role"/>.
/// </summary>
/// <param name="user">User entity.</param>
/// <param name="roleName">Role name.</param>
public Task AddToRoleAsync(User user, string roleName)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (String.IsNullOrWhiteSpace(roleName))
{
throw new ArgumentException("Argument cannot be null or empty", nameof(roleName));
}
UserRoleInfoProvider.AddUserToRole(user.Id, GetRoleByRoleName(roleName, SiteID).RoleID);
return(Task.FromResult(0));
}
public async Task PasswordSignInAsync_CorrectCredentials_AdminUser_UserSignedIn(string userName, string password)
{
var user = UserInfoProvider.GetUserInfo(userName);
UserRoleInfoProvider.AddUserToRole(user, mMembershipFakeFactory.AdminRole);
var result = await mSignInManager.PasswordSignInAsync(user.UserName, password, false, false);
var claims = mOwinContext.Authentication.AuthenticationResponseGrant.Identity.Claims;
CMSAssert.All(
() => Assert.AreEqual(SignInStatus.Success, result),
() => Assert.AreEqual(5, claims.Count()),
() => Assert.IsTrue(claims.Any(x => x.Value == user.UserID.ToString()), "ID claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == user.UserName), "Name claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == user.UserSecurityStamp), "Security stamp claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == MembershipFakeFactory.ROLE_ADMIN), "Role claim missing"));
}
public async Task SignOut_CorrectCredentials_AdminUser_UserSignedInAndOut(string userName, string password)
{
var user = UserInfoProvider.GetUserInfo(userName);
UserRoleInfoProvider.AddUserToRole(user, mMembershipFakeFactory.AdminRole);
var signInResult = await mSignInManager.PasswordSignInAsync(user.UserName, password, false, false);
var signedInClaimsCount = mOwinContext.Authentication.AuthenticationResponseGrant.Identity.Claims.Count();
mOwinContext.Authentication.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
CMSAssert.All(
() => Assert.AreEqual(SignInStatus.Success, signInResult),
() => Assert.AreEqual(5, signedInClaimsCount),
() => Assert.IsNull(mOwinContext.Authentication.AuthenticationResponseGrant));
}
public async Task SignInAsync_AdminUser_UserSignedInUnconditionally(string userName, string password)
{
var userInfo = UserInfoProvider.GetUserInfo(userName);
UserRoleInfoProvider.AddUserToRole(userInfo, mMembershipFakeFactory.AdminRole);
var user = new User(userInfo);
await mSignInManager.SignInAsync(user, false, false);
var claims = mOwinContext.Authentication.AuthenticationResponseGrant.Identity.Claims;
CMSAssert.All(
() => Assert.AreEqual(5, claims.Count()),
() => Assert.IsTrue(claims.Any(x => x.Value == user.Id.ToString()), "ID claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == user.UserName), "Name claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == user.SecurityStamp), "Security stamp claim missing"),
() => Assert.IsTrue(claims.Any(x => x.Value == MembershipFakeFactory.ROLE_ADMIN), "Role claim missing"));
}
/// <summary>
/// Deletes user role. Called when the "Delete role" button is pressed.
/// Expects the CreateUserRole method to be run first.
/// </summary>
private bool DeleteUserRole()
{
// Get role and user objects
RoleInfo role = RoleInfoProvider.GetRoleInfo("MyNewRole", CMSContext.CurrentSiteID);
UserInfo user = UserInfoProvider.GetUserInfo("MyNewUser");
if ((role != null) && (user != null))
{
// Get the user role
UserRoleInfo deleteRole = UserRoleInfoProvider.GetUserRoleInfo(user.UserID, role.RoleID);
// Delete the user role
UserRoleInfoProvider.DeleteUserRoleInfo(deleteRole);
return(true);
}
return(false);
}
/// <summary>
/// Saves roles of specified user.
/// </summary>
private void SaveRoles(int userID)
{
// Load user's roles
if (!currentRolesLoaded)
{
LoadCurrentRoles();
}
// Remove old items
string newValues = ValidationHelper.GetString(usRoles.Value, null);
string items = DataHelper.GetNewItemsInList(newValues, currentValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
// Removes relationship between user and role
foreach (string item in newItems)
{
int roleID = ValidationHelper.GetInteger(item, 0);
UserRoleInfoProvider.RemoveUserFromRole(userID, roleID);
}
}
}
// Add new items
items = DataHelper.GetNewItemsInList(currentValues, newValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems != null)
{
// Add relationship between user and role
foreach (string item in newItems)
{
int roleID = ValidationHelper.GetInteger(item, 0);
UserRoleInfoProvider.AddUserToRole(userID, roleID);
}
}
}
}
public void SetUserRole(int UserID, string RoleName, string SiteName, bool RoleToggle)
{
var Role = _Helper.GetRole(RoleName, SiteName, new string[] { "RoleID" });
if (RoleToggle)
{
if (UserRoleInfoProvider.GetUserRoleInfo(UserID, Role.RoleID) == null)
{
UserRoleInfoProvider.AddUserToRole(UserID, Role.RoleID);
}
}
else
{
var ExistingUserRole = UserRoleInfoProvider.GetUserRoleInfo(UserID, Role.RoleID);
if (ExistingUserRole != null)
{
ExistingUserRole.Delete();
}
}
}
/// <summary>
/// deletes all the roles assigned to particular user
/// </summary>
/// <param name="userID"></param>
private void DeleteUserRoles(int userID)
{
try
{
var userRoleData = UserRoleInfoProvider.GetUserRoles()
.WhereEquals("UserID", userID)
.ToList();
if (!DataHelper.DataSourceIsEmpty(userRoleData))
{
userRoleData.ForEach(x =>
{
UserRoleInfoProvider.DeleteUserRoleInfo(x);
});
}
}
catch (Exception ex)
{
EventLogProvider.LogException("UsersList", "DeleteUserRoles", ex);
}
}
/// <summary>
/// Assigns CMS and AD roles to user.
/// </summary>
/// <param name="user">AD user</param>
/// <param name="userInfo">CMS user</param>
/// <param name="userRoles">Collection of <see cref="RoleInfo"/> objects user is in – infos are supposed to contain RoleGUID.</param>
/// <param name="site">CMS roles</param>
/// <param name="siteInfo">Site info object</param>
private static void SetMemberships(IPrincipalObject user, UserInfo userInfo, SiteInfo siteInfo, ICollection <RoleInfo> userRoles, KeyValuePair <string, List <Guid> > site)
{
var roleGuids = Enumerable.Empty <Guid>()
.Union(site.Value) // CMS role GUIDs user should be in
.Union(user.Groups); // AD role GUIDs user should be in (groups in which the user participates in AD and are imported to CMS)
foreach (RoleInfo roleInfo in roleGuids
.Except(userRoles.Select(userRole => userRole.RoleGUID))
.Select(groupId => RoleInfoProvider.GetRoleInfoByGUID(groupId, siteInfo.SiteID))
.Where(roleInfo => (roleInfo != null)))
{
// Add user to the role
UserRoleInfoProvider.AddUserToRole(userInfo, roleInfo);
// Update collection of user roles (to reflect real roles user is in)
userRoles.Add(roleInfo);
MessageLog.LogEvent(ResHelper.GetString("Log_AssigningUserToRole", userInfo.UserName, roleInfo.RoleDisplayName));
}
}
/// <summary>
/// Removes <see cref="User"/> from <see cref="Role"/>.
/// </summary>
/// <param name="user">User entity.</param>
/// <param name="roleName">Role name.</param>
public Task RemoveFromRoleAsync(User user, string roleName)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (String.IsNullOrWhiteSpace(roleName))
{
throw new ArgumentException("Argument cannot be null or empty", nameof(roleName));
}
var userRole = UserRoleInfoProvider.GetUserRoles()
.WhereEquals("UserID", user.Id)
.WhereEquals("RoleID", GetRoleByRoleName(roleName, SiteID).RoleID)
.FirstObject;
UserRoleInfoProvider.DeleteUserRoleInfo(userRole);
return(Task.FromResult(0));
}
/// <summary>
/// Synchronizes memberships of given user.
/// </summary>
/// <param name="user">AD user</param>
/// <param name="userInfo">CMS user</param>
/// <param name="userRoles">Collection of <see cref="RoleInfo"/> objects user is in – infos are supposed to contain RoleGUID and RoleIsDomain.</param>
private static void RemoveExcessiveMemberships(IPrincipalObject user, UserInfo userInfo, ISet <RoleInfo> userRoles)
{
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_UpdatingMemberships", userInfo.UserName));
// Get all user's roles that originate in AD and user is no longer member of
var removedRoles = new List <RoleInfo>();
foreach (var roleInfo in userRoles
.Where(role => role.RoleIsDomain)
.Where(userRole => !user.IsPrincipalInGroup(userRole.RoleGUID)))
{
// Remove user from CMS role
UserRoleInfoProvider.DeleteUserRoleInfo(userInfo, roleInfo);
// Store removed roles
removedRoles.Add(roleInfo);
}
// Update set of user roles (to reflect real roles user is in)
userRoles.ExceptWith(removedRoles);
}
private string GetUniGridWhereCondition()
{
// Global administrators can see all forms.
if (currentUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin))
{
return("FormSiteID = " + SiteContext.CurrentSiteID);
}
var bizFormsAvailableForUser = BizFormInfoProvider.GetBizForms()
.Column("CMS_Form.FormID")
.OnSite(SiteContext.CurrentSiteID)
.Distinct()
.Source(s => s.LeftJoin <BizFormRoleInfo>("FormID", "FormID"))
.Where(new WhereCondition()
.WhereIn("RoleID", UserRoleInfoProvider.GetUserRoles().Column("RoleID").WhereEquals("UserID", currentUser.UserID))
.Or()
.WhereNull("FormAccess")
.Or()
.WhereEquals("FormAccess", (int)FormAccessEnum.AllBizFormUsers));
return(new WhereCondition().WhereIn("CMS_Form.FormID", bizFormsAvailableForUser).ToString(true));
}
/// <summary>
/// Creates user role. Called when the "Create role" button is pressed.
/// </summary>
private bool CreateUserRole()
{
// Get role and user objects
RoleInfo role = RoleInfoProvider.GetRoleInfo("MyNewRole", CMSContext.CurrentSiteID);
UserInfo user = UserInfoProvider.GetUserInfo("MyNewUser");
if ((role != null) && (user != null))
{
// Create new user role object
UserRoleInfo userRole = new UserRoleInfo();
// Set the properties
userRole.UserID = user.UserID;
userRole.RoleID = role.RoleID;
// Save the user role
UserRoleInfoProvider.SetUserRoleInfo(userRole);
return(true);
}
return(false);
}
/// <summary>
/// Page_load event.
/// </summary>
protected void Page_Load(object sender, EventArgs e)
{
// Check permissions and UI elements
var user = MembershipContext.AuthenticatedUser;
if (user != null)
{
if (!user.IsAuthorizedPerUIElement("CMS.Users", "CmsDesk.Roles"))
{
RedirectToUIElementAccessDenied("CMS.Users", "CmsDesk.Roles");
}
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Roles", "Read"))
{
RedirectToAccessDenied("CMS.Roles", "Read");
}
}
ScriptHelper.RegisterJQuery(Page);
// Get user id and site Id from query
mUserId = QueryHelper.GetInteger("userid", 0);
// Show content placeholder where site selector can be shown
CurrentMaster.DisplaySiteSelectorPanel = true;
if ((SiteID > 0) && !MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin))
{
plcSites.Visible = false;
CurrentMaster.DisplaySiteSelectorPanel = false;
}
if (mUserId > 0)
{
// Check that only global administrator can edit global administrator's accounts
mUserInfo = UserInfoProvider.GetUserInfo(mUserId);
CheckUserAvaibleOnSite(mUserInfo);
EditedObject = mUserInfo;
if (!CheckGlobalAdminEdit(mUserInfo))
{
plcTable.Visible = false;
ShowError(GetString("Administration-User_List.ErrorGlobalAdmin"));
return;
}
// Set site selector
siteSelector.DropDownSingleSelect.AutoPostBack = true;
siteSelector.AllowAll = false;
siteSelector.AllowEmpty = false;
// Global roles only for global admin
if (MembershipContext.AuthenticatedUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin))
{
siteSelector.AllowGlobal = true;
}
// Only sites assigned to user
siteSelector.UserId = mUserId;
siteSelector.OnlyRunningSites = false;
siteSelector.UniSelector.OnSelectionChanged += UniSelector_OnSelectionChanged;
if (!RequestHelper.IsPostBack())
{
mSiteId = SiteContext.CurrentSiteID;
// If user is member of current site
if (UserSiteInfoProvider.GetUserSiteInfo(mUserId, mSiteId) != null)
{
// Force uniselector to preselect current site
siteSelector.Value = mSiteId;
}
// Force to load data
siteSelector.Reload(true);
}
// Get truly selected item
mSiteId = ValidationHelper.GetInteger(siteSelector.Value, 0);
}
usRoles.OnSelectionChanged += usRoles_OnSelectionChanged;
string siteIDWhere = (mSiteId <= 0) ? " SiteID IS NULL " : " SiteID =" + mSiteId;
usRoles.WhereCondition = siteIDWhere + " AND RoleGroupID IS NULL";
usRoles.SelectItemPageUrl = "~/CMSModules/Membership/Pages/Users/User_Edit_Add_Item_Dialog.aspx";
usRoles.ListingWhereCondition = siteIDWhere + " AND RoleGroupID IS NULL AND UserID=" + mUserId;
usRoles.ReturnColumnName = "RoleID";
usRoles.DynamicColumnName = false;
usRoles.GridName = "User_Role_List.xml";
usRoles.AdditionalColumns = "ValidTo";
usRoles.OnAdditionalDataBound += usMemberships_OnAdditionalDataBound;
usRoles.DialogWindowHeight = 760;
// Exclude generic roles
string genericWhere = String.Empty;
ArrayList genericRoles = RoleInfoProvider.GetGenericRoles();
if (genericRoles.Count != 0)
{
foreach (string role in genericRoles)
{
genericWhere += "'" + SqlHelper.EscapeQuotes(role) + "',";
}
genericWhere = genericWhere.TrimEnd(',');
usRoles.WhereCondition += " AND ( RoleName NOT IN (" + genericWhere + ") )";
}
// Get the active roles for this site
var roleIds = new IDQuery <RoleInfo>().Where(siteIDWhere).Column("RoleID");
var data = UserRoleInfoProvider.GetUserRoles().WhereEquals("UserID", mUserId).And().WhereIn("RoleID", roleIds).Columns("RoleID").TypedResult;
if (data.Any())
{
mCurrentValues = TextHelper.Join(";", data.Select(i => i.RoleID));
}
// If not postback or site selection changed
if (!RequestHelper.IsPostBack() || (mSiteId != Convert.ToInt32(ViewState["rolesOldSiteId"])))
{
// Set values
usRoles.Value = mCurrentValues;
}
// Store selected site id
ViewState["rolesOldSiteId"] = mSiteId;
string script = "function setNewDateTime(date) {$cmsj('#" + hdnDate.ClientID + "').val(date);}";
ScriptHelper.RegisterClientScriptBlock(Page, typeof(string), "key", ScriptHelper.GetScript(script));
string eventTarget = Request[postEventSourceID];
string eventArgument = Request[postEventArgumentID];
if (eventTarget == ucCalendar.DateTimeTextBox.UniqueID)
{
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Users", "ManageUserRoles"))
{
RedirectToAccessDenied("CMS.Users", "Manage user roles");
}
int id = ValidationHelper.GetInteger(hdnDate.Value, 0);
if (id != 0)
{
DateTime dt = ValidationHelper.GetDateTime(eventArgument, DateTimeHelper.ZERO_TIME);
UserRoleInfo uri = UserRoleInfoProvider.GetUserRoleInfo(mUserId, id);
if (uri != null)
{
uri.ValidTo = dt;
UserRoleInfoProvider.SetUserRoleInfo(uri);
// Invalidate user
UserInfoProvider.InvalidateUser(mUserId);
ShowChangesSaved();
}
}
}
}
/// <summary>
/// Saves data.
/// </summary>
private void SaveData()
{
// Check "modify" permission
if (!MembershipContext.AuthenticatedUser.IsAuthorizedPerResource("CMS.Users", "ManageUserRoles"))
{
RedirectToAccessDenied("CMS.Users", "Manage user roles");
}
bool saved = false;
string result = ValidateGlobalAndDeskAdmin();
if (result != String.Empty)
{
ShowError(result);
return;
}
string selectorValues = ValidationHelper.GetString(usRoles.Value, null);
// Remove old items
string items = DataHelper.GetNewItemsInList(selectorValues, mCurrentValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems.Any())
{
// Remove all old items from site
foreach (string item in newItems)
{
int roleID = ValidationHelper.GetInteger(item, 0);
var uri = UserRoleInfoProvider.GetUserRoleInfo(mUserId, roleID);
UserRoleInfoProvider.DeleteUserRoleInfo(uri);
}
saved = true;
}
}
// Add new items
items = DataHelper.GetNewItemsInList(mCurrentValues, selectorValues);
if (!String.IsNullOrEmpty(items))
{
string[] newItems = items.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
if (newItems.Any())
{
DateTime dt = ValidationHelper.GetDateTime(hdnDate.Value, DateTimeHelper.ZERO_TIME);
// Add all new items to site
foreach (string item in newItems)
{
int roleID = ValidationHelper.GetInteger(item, 0);
UserRoleInfoProvider.AddUserToRole(mUserId, roleID, dt);
}
saved = true;
}
}
if (saved)
{
ShowChangesSaved();
usRoles.Reload(true);
}
}
