/// <inheritdoc/>
public void SetLoggingRole(IRole role, string taskGroupName)
{
// Gets a "collection" of task groups (in this case one group whose code name is equal to "Group_Name")
// TODO: get task groups from a task group service as well.
var taskGroups = TaskGroupInfoProvider.GetTaskGroups().WhereEquals("TaskGroupCodeName", taskGroupName);
// Prepares a synchronization action context
// The context ensures that any staging tasks logged by the wrapped code are included in the specified task groups
using (new SynchronizationActionContext()
{
TaskGroups = taskGroups
})
{
// Creates a new role object
RoleInfo newRole = new RoleInfo
{
// Sets the role properties
RoleDisplayName = role.RoleDisplayName,
RoleName = role.RoleName,
SiteID = role.SiteID,
};
// Saves the role to the database
RoleInfoProvider.SetRoleInfo(newRole);
}
}
/// <summary>
/// Gets and bulk updates roles. Called when the "Get and bulk update roles" button is pressed.
/// Expects the CreateRole method to be run first.
/// </summary>
private bool GetAndBulkUpdateRoles()
{
// Prepare the parameters
string where = "RoleName LIKE N'MyNewRole%'";
// Get the data
DataSet roles = RoleInfoProvider.GetRoles(where, null);
if (!DataHelper.DataSourceIsEmpty(roles))
{
// Loop through the individual items
foreach (DataRow roleDr in roles.Tables[0].Rows)
{
// Create object from DataRow
RoleInfo modifyRole = new RoleInfo(roleDr);
// Update the properties
modifyRole.DisplayName = modifyRole.DisplayName.ToUpper();
// Save the changes
RoleInfoProvider.SetRoleInfo(modifyRole);
}
return(true);
}
return(false);
}
public void SetUp()
{
mMembershipFakeFactory.GetIntegrationUsers().ToList().ForEach(x => UserInfoProvider.SetUserInfo(x));
mMembershipFakeFactory.GetIntegrationRoles().ToList().ForEach(x => RoleInfoProvider.SetRoleInfo(x));
mMembershipFakeFactory.GetIntegrationExternalLogins().ToList().ForEach(x => ExternalLoginInfoProvider.SetExternalLoginInfo(x));
SettingsKeyInfoProvider.SetValue("cmssitesharedaccounts", 0, "True");
mUserStore = new UserStore("NonExistingSiteForTestingPurposes");
}
private void SaveRole(RoleInfo ri, string codeName, string displayName)
{
bool newRole = false;
// Get object
if (ri == null)
{
ri = RoleInfoProvider.GetRoleInfo(ItemID);
if (ri == null)
{
ri = new RoleInfo();
// indicate this is new role and should be redirected after safe
newRole = true;
}
}
if (ri.DisplayName != displayName)
{
// Refresh a breadcrumb if used in the tabs layout
ScriptHelper.RefreshTabHeader(Page, string.Empty);
}
// Set the fields
ri.DisplayName = displayName;
ri.RoleName = codeName;
ri.RoleID = ItemID;
ri.Description = txtDescription.Text;
ri.SiteID = mSiteId;
ri.RoleIsDomain = chkIsDomain.Checked;
// If group id is present then it's group role
if (GroupID > 0)
{
ri.RoleGroupID = mGroupId;
ri.RoleIsGroupAdministrator = chkIsAdmin.Checked;
}
RoleInfoProvider.SetRoleInfo(ri);
ItemID = ri.RoleID;
ShowChangesSaved();
// if new group was created redirect to edit page
if (newRole)
{
RoleID = ri.RoleID;
RaiseOnSaved();
}
}
public HttpResponseMessage CreateNewRole([FromBody] JObject postData)
{
// Creates a new role object
RoleInfo newRole = new RoleInfo();
string newRoleName, newDisplayName;
//parsing of the postdata
try
{
newRoleName = postData["roleName"].ToObject <string>();
newDisplayName = postData["roleDisplayName"].ToObject <string>();
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { errorMessage = e.Message }));
}
// Sets the role properties
newRole.RoleName = newRoleName;
newRole.DisplayName = newDisplayName;
newRole.SiteID = SiteContext.CurrentSiteID;
int roleId;
// Verifies that the role is unique for the current site
if (!RoleInfoProvider.RoleExists(newRole.RoleName, SiteContext.CurrentSiteName))
{
try
{
// Saves the role to the database
RoleInfoProvider.SetRoleInfo(newRole);
roleId = RoleInfoProvider.GetRoleInfo(newRole.RoleName, SiteContext.CurrentSiteName).RoleID;
}
catch (CodeNameNotValidException e)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { errorMessage = e.Message }));
}
catch (Exception e)
{
return(Request.CreateResponse(HttpStatusCode.ServiceUnavailable, new { errorMessage = e.Message }));
}
//everything is OK, the ID of the new role are also returned
return(Request.CreateResponse(HttpStatusCode.OK, new { newRoleId = roleId }));
}
else
{
// A role with the same name already exists on the site
return(Request.CreateResponse(HttpStatusCode.BadRequest, new { errorMessage = "A role with the same name already exists on the site" }));
}
}
/// <summary>
/// Creates role. Called when the "Create role" button is pressed.
/// </summary>
private bool CreateRole()
{
// Create new role object
RoleInfo newRole = new RoleInfo();
// Set the properties
newRole.DisplayName = "My new role";
newRole.RoleName = "MyNewRole";
newRole.SiteID = CMSContext.CurrentSiteID;
// Save the role
RoleInfoProvider.SetRoleInfo(newRole);
return(true);
}
/// <summary>
/// Gets and updates role. Called when the "Get and update role" button is pressed.
/// Expects the CreateRole method to be run first.
/// </summary>
private bool GetAndUpdateRole()
{
// Get the role
RoleInfo updateRole = RoleInfoProvider.GetRoleInfo("MyNewRole", CMSContext.CurrentSiteID);
if (updateRole != null)
{
// Update the properties
updateRole.DisplayName = updateRole.DisplayName.ToLowerCSafe();
// Save the changes
RoleInfoProvider.SetRoleInfo(updateRole);
return(true);
}
return(false);
}
/// <inheritdoc/>
public void SetNoLoggingRole(IRole role)
{
// Prepares an action context for running code without logging of staging tasks
using (new CMSActionContext()
{
LogSynchronization = false
})
{
// Creates a new role without logging any staging tasks
RoleInfo newRole = new RoleInfo
{
RoleDisplayName = role.RoleDisplayName,
RoleName = role.RoleName,
SiteID = role.SiteID,
};
RoleInfoProvider.SetRoleInfo(newRole);
}
}
/// <summary>
/// Stores <see cref="Role"/> in the database.
/// </summary>
/// <param name="role">Role.</param>
public Task CreateAsync(Role role)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
var roleInfo = new RoleInfo
{
RoleDisplayName = String.IsNullOrEmpty(role.DisplayName) ? role.Name : role.DisplayName,
RoleName = role.Name,
SiteID = SiteContext.CurrentSiteID,
};
// Insert role and after set ID to role
RoleInfoProvider.SetRoleInfo(roleInfo);
role.Id = roleInfo.RoleID;
return(Task.FromResult(0));
}
public async Task SetUp()
{
mMembershipFakeFactory.GetIntegrationUsers().ToList().ForEach(x => UserInfoProvider.SetUserInfo(x));
mMembershipFakeFactory.GetIntegrationRoles().ToList().ForEach(x => RoleInfoProvider.SetRoleInfo(x));
mMembershipFakeFactory.GetIntegrationExternalLogins().ToList().ForEach(x => ExternalLoginInfoProvider.SetExternalLoginInfo(x));
SettingsKeyInfoProvider.SetValue("cmssitesharedaccounts", 0, "True");
mOwinContext = new OwinContext();
var options = new IdentityFactoryOptions <UserManager>
{
Provider = new TestIdentityFactoryProvider(),
DataProtectionProvider = new DpapiDataProtectionProvider()
};
var middleware = new IdentityFactoryMiddleware <UserManager, IdentityFactoryOptions <UserManager> >(null, options);
await middleware.Invoke(mOwinContext);
var manager = mOwinContext.GetUserManager <UserManager>();
mSignInManager = new SignInManager(mOwinContext.GetUserManager <UserManager>(), mOwinContext.Authentication);
}
/// <summary>
/// Updates <see cref="Role"/> in the database.
/// </summary>
/// <param name="role">Role.</param>
public Task UpdateAsync(Role role)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
var roleToUpdate = RoleInfoProvider.GetRoleInfo(role.Id);
if (roleToUpdate == null)
{
throw new InvalidOperationException(ResHelper.GetString("general.rolenotfound"));
}
roleToUpdate.RoleName = role.Name;
roleToUpdate.RoleDisplayName = role.DisplayName;
RoleInfoProvider.SetRoleInfo(roleToUpdate);
return(Task.FromResult(0));
}
/// <summary>
/// Gets and bulk updates roles. Called when the "Get and bulk update roles" button is pressed.
/// Expects the CreateRole method to be run first.
/// </summary>
private bool GetAndBulkUpdateRoles()
{
// Prepare the parameters
string where = "RoleName LIKE N'MyNewRole%'";
// Get the data from database
var roles = RoleInfoProvider.GetRoles().Where(where);
// Loop through the individual items
foreach (RoleInfo modifyRole in roles)
{
// Update the properties
modifyRole.DisplayName = modifyRole.DisplayName.ToUpper();
// Save the changes
RoleInfoProvider.SetRoleInfo(modifyRole);
}
// Return TRUE if any object was found and updated, FALSE otherwise
return(roles.Count > 0);
}
/// <summary>
/// Helper to Get or create the given Role
/// </summary>
/// <param name="RoleCodeName">Role Code Name</param>
/// <param name="RoleDisplayName">Role Display Name</param>
/// <param name="RoleDescription">Role Description</param>
/// <returns>The RoleInfo</returns>
private RoleInfo GetOrCreateRole(string RoleCodeName, string RoleDisplayName, string RoleDescription, int?SiteID)
{
if (SiteID.HasValue)
{
// Get Site Specific Role
RoleInfo Role = RoleInfoProvider.GetRoleInfo(RoleCodeName, SiteID.Value);
if (Role == null)
{
Role = new RoleInfo()
{
RoleDisplayName = RoleDisplayName,
RoleName = RoleCodeName,
RoleDescription = RoleDescription,
SiteID = SiteID.Value,
RoleIsDomain = false
};
RoleInfoProvider.SetRoleInfo(Role);
}
return(Role);
}
else
{
// Get Global Role
RoleInfo Role = RoleInfoProvider.GetRoles().WhereEquals("RoleName", RoleCodeName).WhereNull("SiteID").FirstOrDefault();
if (Role == null)
{
Role = new RoleInfo()
{
RoleDisplayName = RoleDisplayName,
RoleName = RoleCodeName,
RoleDescription = RoleDescription,
RoleIsDomain = false
};
RoleInfoProvider.SetRoleInfo(Role);
}
return(Role);
}
}
public void CreateUpdateRole(string roleName)
{
try
{
// Create new role object
RoleInfo newRole = new RoleInfo();
RoleInfo role = RoleInfoProvider.GetRoleInfo(roleName, CMS.SiteProvider.SiteContext.CurrentSiteID);
if (role == null)
{
//create role
newRole.DisplayName = roleName.ToString().ToLower();
roleName = roleName.ToString().ToLower();
/*roleName = roleName.Replace("_", "");
* roleName = roleName.Replace(".", "");
* roleName = roleName.Replace(",", "");
* roleName = roleName.Replace(">", "");*/
WriteError(roleName, "Role for User loggedin ");
newRole.RoleName = roleName;
newRole.SiteID = CMS.SiteProvider.SiteContext.CurrentSiteID;
// Save the role
RoleInfoProvider.SetRoleInfo(newRole);
}
else
{
// Set the properties
newRole.DisplayName = roleName.ToString().ToLower();
newRole.SiteID = CMS.SiteProvider.SiteContext.CurrentSiteID;
// Save the role
RoleInfoProvider.SetRoleInfo(newRole);
}
}
catch (Exception ex)
{
EventLogProvider.LogException("Issue while Update/Creating Roles", "Get", ex);
}
}
public void SetUp()
{
mMembershipFakeFactory.GetIntegrationUsers().ToList().ForEach(x => UserInfoProvider.SetUserInfo(x));
mMembershipFakeFactory.GetIntegrationRoles().ToList().ForEach(x => RoleInfoProvider.SetRoleInfo(x));
SettingsKeyInfoProvider.SetValue("cmssitesharedaccounts", 0, "True");
}
/// <summary>
/// Updates the current Group or creates new if no GroupID is present.
/// </summary>
public void SaveData()
{
// Check banned IP
if (!BannedIPInfoProvider.IsAllowed(SiteContext.CurrentSiteName, BanControlEnum.AllNonComplete))
{
ShowError(GetString("General.BannedIP"));
return;
}
// Validate form entries
string errorMessage = ValidateForm();
if (errorMessage == string.Empty)
{
try
{
codeName = GetSafeCodeName();
codeName = GetUniqueCodeName(codeName);
GroupInfo group = new GroupInfo();
group.GroupDisplayName = txtDisplayName.Text;
group.GroupName = codeName;
group.GroupDescription = txtDescription.Text;
group.GroupAccess = GetGroupAccess();
group.GroupSiteID = mSiteId;
group.GroupApproveMembers = GetGroupApproveMembers();
// Set columns GroupCreatedByUserID and GroupApprovedByUserID to current user
var user = MembershipContext.AuthenticatedUser;
if (user != null)
{
group.GroupCreatedByUserID = user.UserID;
if ((!RequireApproval) || (CurrentUserIsAdmin()))
{
group.GroupApprovedByUserID = user.UserID;
group.GroupApproved = true;
}
}
// Save Group in the database
GroupInfoProvider.SetGroupInfo(group);
// Create group admin role
RoleInfo roleInfo = new RoleInfo();
roleInfo.DisplayName = "Group admin";
roleInfo.RoleName = group.GroupName + "_groupadmin";
roleInfo.RoleGroupID = group.GroupID;
roleInfo.RoleIsGroupAdministrator = true;
roleInfo.SiteID = mSiteId;
// Save group admin role
RoleInfoProvider.SetRoleInfo(roleInfo);
if (user != null)
{
// Set user as member of group
GroupMemberInfo gmi = new GroupMemberInfo();
gmi.MemberUserID = user.UserID;
gmi.MemberGroupID = group.GroupID;
gmi.MemberJoined = DateTime.Now;
gmi.MemberStatus = GroupMemberStatus.Approved;
gmi.MemberApprovedWhen = DateTime.Now;
gmi.MemberApprovedByUserID = user.UserID;
// Save user as member of group
GroupMemberInfoProvider.SetGroupMemberInfo(gmi);
// Set user as member of admin group role
UserRoleInfo userRole = new UserRoleInfo();
userRole.UserID = user.UserID;
userRole.RoleID = roleInfo.RoleID;
// Save user as member of admin group role
UserRoleInfoProvider.SetUserRoleInfo(userRole);
}
// Clear user session a request
MembershipContext.AuthenticatedUser.Generalized.Invalidate(false);
MembershipContext.AuthenticatedUser = null;
string culture = CultureHelper.EnglishCulture.ToString();
if (DocumentContext.CurrentDocument != null)
{
culture = DocumentContext.CurrentDocument.DocumentCulture;
}
// Copy document
errorMessage = GroupInfoProvider.CopyGroupDocument(group, GroupTemplateSourceAliasPath, GroupTemplateTargetAliasPath, GroupProfileURLPath, culture, CombineWithDefaultCulture, MembershipContext.AuthenticatedUser, roleInfo);
if (!String.IsNullOrEmpty(errorMessage))
{
// Display error message
ShowError(errorMessage);
return;
}
// Create group forum
if (CreateForum)
{
CreateGroupForum(group);
// Create group forum search index
if (CreateSearchIndexes)
{
CreateGroupForumSearchIndex(group);
}
}
// Create group media library
if (CreateMediaLibrary)
{
CreateGroupMediaLibrary(group);
}
// Create search index for group documents
if (CreateSearchIndexes)
{
CreateGroupContentSearchIndex(group);
}
// Display information on success
ShowConfirmation(GetString("group.group.createdinfo"));
// If URL is set, redirect user to specified page
if (!String.IsNullOrEmpty(RedirectToURL))
{
URLHelper.Redirect(ResolveUrl(DocumentURLProvider.GetUrl(RedirectToURL)));
}
// After registration message
if ((RequireApproval) && (!CurrentUserIsAdmin()))
{
ShowConfirmation(SuccessfullRegistrationWaitingForApprovalText);
// Send approval email to admin
if (!String.IsNullOrEmpty(SendWaitingForApprovalEmailTo))
{
// Create the message
EmailTemplateInfo eti = EmailTemplateProvider.GetEmailTemplate("Groups.WaitingForApproval", SiteContext.CurrentSiteName);
if (eti != null)
{
EmailMessage message = new EmailMessage();
if (String.IsNullOrEmpty(eti.TemplateFrom))
{
message.From = SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSSendEmailNotificationsFrom");
}
else
{
message.From = eti.TemplateFrom;
}
MacroResolver resolver = MacroContext.CurrentResolver;
resolver.SetAnonymousSourceData(group);
resolver.SetNamedSourceData("Group", group);
message.Recipients = SendWaitingForApprovalEmailTo;
message.Subject = resolver.ResolveMacros(eti.TemplateSubject);
message.Body = resolver.ResolveMacros(eti.TemplateText);
resolver.Settings.EncodeResolvedValues = false;
message.PlainTextBody = resolver.ResolveMacros(eti.TemplatePlainText);
// Send the message using email engine
EmailSender.SendEmail(message);
}
}
}
else
{
string groupPath = SettingsKeyInfoProvider.GetStringValue(SiteContext.CurrentSiteName + ".CMSGroupProfilePath");
string url = String.Empty;
if (!String.IsNullOrEmpty(groupPath))
{
url = DocumentURLProvider.GetUrl(groupPath.Replace("{GroupName}", group.GroupName));
}
ShowConfirmation(String.Format(SuccessfullRegistrationText, url));
}
// Hide form
if (HideFormAfterRegistration)
{
plcForm.Visible = false;
}
else
{
ClearForm();
}
}
catch (Exception ex)
{
// Display error message
ShowError(GetString("general.saveerror"), ex.Message, null);
}
}
else
{
// Display error message
ShowError(errorMessage);
}
}
/// <summary>
/// Imports role to CMS.
/// </summary>
/// <param name="roleName">Name of role</param>
/// <param name="displayName">Display name of role</param>
/// <param name="siteId">ID of site</param>
/// <param name="roleDescription">Role description</param>
/// <param name="roleGuid">GUID of role</param>
/// <param name="updateExistingObject">Determines whether update object if already exists</param>
/// <param name="rolesChanged">Records added and updated roles for CMS event log</param>
private static void ImportRole(string roleName, string displayName, int siteId, string roleDescription, Guid roleGuid, bool updateExistingObject, CumulatedChanges rolesChanged)
{
// Try to get role info by GUID, by GUID in code name, by name
var roleInfo = RoleInfoProvider.GetRoleInfoByGUID(roleGuid, siteId)
?? RoleInfoProvider.GetRoleInfoByGUID(ValidationHelper.GetGuid(roleName, Guid.Empty), siteId)
?? RoleInfoProvider.GetRoleInfo(roleName, siteId);
var newRole = roleInfo == null;
if (newRole)
{
// Create new instance of role
roleInfo = new RoleInfo();
// Set new role properties
roleInfo.SiteID = siteId;
// Mark role as domain role
roleInfo.RoleIsDomain = true;
}
else
{
// Don't update object
if (!updateExistingObject)
{
return;
}
}
if (roleInfo.RoleIsDomain)
{
// Set role name
roleInfo.RoleName = roleName;
// Set display name
roleInfo.RoleDisplayName = displayName;
// Set description
roleInfo.RoleDescription = roleDescription;
// Set GUID
roleInfo.RoleGUID = roleGuid;
try
{
if (!roleInfo.ChangedColumns().Any())
{
return;
}
// Store created/updated role ID for EventLog
rolesChanged.Add(roleInfo.RoleGUID, roleInfo.RoleDisplayName, newRole ? ChangeActionEnum.Created : ChangeActionEnum.Updated);
// Store role into database
RoleInfoProvider.SetRoleInfo(roleInfo);
}
catch (CodeNameNotUniqueException)
{
MessageLog.LogEvent(ResHelper.GetString("Log_RoleNameNotUnique", roleName));
warnings++;
}
}
else
{
MessageLog.LogEvent(ResHelper.GetString("Log_RoleIsNotDomain", roleInfo.RoleDisplayName));
warnings++;
}
}
