private static void ImportWorker_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker worker = (BackgroundWorker)sender;
// Save import profile
if (ImportProfile.SaveImportProfile && !ImportProfile.UsesConsole)
{
SaveFile(SaveImportProfile);
}
// Decide whether to import
if (!ImportProfile.ImportNow && !ImportProfile.UsesConsole)
{
return;
}
using (new CMSActionContext()
{
LogEvents = false, ContinuousIntegrationAllowObjectSerialization = false
})
{
#region "Initialization"
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
DateTime start = DateTime.Now;
// Initialize CMS context
CMSInit();
if (ImportProfile.UsesConsole)
{
// Ensure object in case they are not present in import profile
EnsureObjects();
}
if (ImportProfile.ImportUsersOnlyFromSelectedRoles)
{
// Narrow down imported users according to imported roles
ImportProfile.Users.Clear();
}
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
// Initialize cumulative changed users and roles storages
var rolesChanged = new CumulatedChanges(WellKnownEventLogEventsEnum.RolesCreated, WellKnownEventLogEventsEnum.RolesUpdated, WellKnownEventLogEventsEnum.RolesDeleted);
var usersChanged = new CumulatedChanges(WellKnownEventLogEventsEnum.UsersCreated, WellKnownEventLogEventsEnum.UsersUpdated, WellKnownEventLogEventsEnum.UsersDeleted);
#endregion
// Delete non-existing objects (this also prevents conflicting code names)
if (ImportProfile.DeleteNotExistingObjects)
{
DeleteNonExistingObjects(usersChanged, rolesChanged);
}
#region "Role import"
foreach (var siteInfo in ImportProfile
.Sites
.Select(site => SiteInfo.Provider.Get(site.Key))
.Where(info => info != null))
{
foreach (Guid groupGuid in ImportProfile.Groups)
{
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
// Try to get group
IPrincipalObject group = PrincipalProvider.GetPrincipalObject(groupGuid);
// If group is still null
if (group == null)
{
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingNonExistingObject"));
warnings++;
// If deleting of not existing objects is enabled
if (ImportProfile.DeleteNotExistingObjects)
{
DeleteRole(siteInfo, groupGuid);
}
}
else
{
// Get role description
string roleDescription = String.Empty;
if (ImportProfile.ImportRoleDescription && (group.Description != null))
{
roleDescription = group.Description;
}
// Get correct role name format
string roleCodeName = group.GetCMSCodeName(true);
// Get role display name
string roleDisplayName = group.GetCMSDisplayName();
// Get safe role name
roleCodeName = ValidationHelper.GetSafeRoleName(roleCodeName, siteInfo.SiteName);
if (!String.IsNullOrEmpty(roleCodeName))
{
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_ImportingRole", roleDisplayName, CMS.Helpers.ResHelper.LocalizeString(siteInfo.DisplayName)));
// Import role
ImportRole(roleCodeName, roleDisplayName, siteInfo.SiteID, roleDescription, groupGuid, ImportProfile.UpdateObjectData, rolesChanged);
if (ImportProfile.ImportUsersOnlyFromSelectedRoles)
{
ImportProfile.Users.AddRange(PrincipalProvider.GetUsersOf(group).Select(u => u.Identifier));
}
}
else
{
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingEmptyRolename", group.Identifier));
warnings++;
}
}
}
}
// Log created and updated and removed roles to EventLog
rolesChanged.WriteEventsToEventLog();
#endregion
#region "User import"
foreach (var user in ImportProfile
.Users
.Distinct()
.Select(userGuid => PrincipalProvider.GetPrincipalObject(userGuid)))
{
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
if (user == null)
{
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingNonExistingObject"));
continue;
}
string domainName = user.GetCMSCodeName(true);
if (!String.IsNullOrEmpty(domainName))
{
// Get user info object
UserInfo userInfo = (UserInfo.Provider.Get((Guid)user.Identifier) ?? UserInfo.Provider.Get(domainName));
bool newUser = (userInfo == null);
// When is desired to import new users only from selected roles
if (newUser && ImportProfile.ImportNewUsersOnlyFromSelectedRoles)
{
// Skip users that does not belong to one of selected role
bool skip = ImportProfile.Groups.Cast <Guid>().All(groupGuid => !user.IsPrincipalInGroup(groupGuid));
if (skip)
{
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingDoesNotBelongToSelectedRole", domainName));
continue;
}
}
if (ImportProfile.UpdateObjectData || newUser)
{
if (userInfo == null)
{
userInfo = new UserInfo();
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_ImportingUser", domainName));
}
else
{
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_UpdatingUser", domainName));
}
using (var transaction = new CMSTransactionScope())
{
if (newUser)
{
userInfo.UserIsDomain = true;
userInfo.UserGUID = (Guid)user.Identifier;
// Set privilege level
UserPrivilegeLevelEnum privilegeLevel = ImportProfile.ConfigureAsCMSEditor ? UserPrivilegeLevelEnum.Editor : UserPrivilegeLevelEnum.None;
userInfo.SiteIndependentPrivilegeLevel = privilegeLevel;
}
if (userInfo.UserIsDomain)
{
// Set user's properties
userInfo.UserIsExternal = true;
userInfo.UserName = domainName;
userInfo.Enabled = ValidationHelper.GetBoolean(user.Enabled, true);
// Bind properties
foreach (KeyValuePair <string, string> property in ImportProfile.UserProperties)
{
// Get attribute
object attribute = user.GetProperty(property.Value);
if (attribute != null)
{
try
{
string attrValue;
// Get string representation of the attribute
if (attribute is float || attribute is double || attribute is decimal)
{
attrValue = String.Format(CultureInfo.InvariantCulture, "{0}", attribute);
}
else if (attribute.GetType() == typeof(byte[]))
{
attrValue = PrincipalProvider.GetSID(attribute);
}
else if (attribute.GetType().BaseType == typeof(MarshalByRefObject))
{
attrValue = PrincipalProvider.GetTimeFromInterval(attribute);
}
else
{
attrValue = attribute.ToString();
}
// Set property
userInfo.SetValue(property.Key, LimitLengthForField(attrValue, property.Key));
}
catch
{
MessageLog.LogEvent(ResHelper.GetString("Log_ErrorParsingAttr", property.Value));
warnings++;
}
}
else
{
FormFieldInfo field = UserFormInfo.GetFormField(property.Key);
userInfo.SetValue(property.Key, field.GetPropertyValue(FormFieldPropertyEnum.DefaultValue));
}
}
// Create full name if empty
if (String.IsNullOrEmpty(userInfo.FullName))
{
userInfo.FullName = user.GetCMSDisplayName();
}
// Store user info object and its user-settings
if (userInfo.ChangedColumns().Any())
{
// Store created/updated user for EventLog
// User name is used, because AD accounts does not have to have first and/or given name specified (e.g. Guest, …)
usersChanged.Add(userInfo.UserGUID, userInfo.UserName, newUser ? ChangeActionEnum.Created : ChangeActionEnum.Updated);
UserInfo.Provider.Set(userInfo);
}
}
else
{
MessageLog.LogEvent(ResHelper.GetString("Log_UserIsNotDomain", userInfo.UserName));
warnings++;
}
transaction.Commit();
}
}
else
{
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingExistingUser", domainName));
}
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
// Assign user to sites and roles (for domain users only)
if (!userInfo.UserIsDomain)
{
continue;
}
#region "Membership (roles) synchronization"
if (!newUser && !ImportProfile.UpdateMemberships && !ImportProfile.UpdateMemberships)
{
// No membership synchronization will be performed
continue;
}
// Initialize collection to cumulate membership changes
var memberShipChanges = new CumulatedRolesMembership();
// Load all user roles from DB
var userRoles = new HashSet <RoleInfo>(newUser
? Enumerable.Empty <RoleInfo>() // non-existing user cannot be present in a single role (in DB)
: RoleInfo.Provider
.Get()
.WhereIn("RoleID",
UserRoleInfo.Provider
.Get()
.WhereEquals("UserID", userInfo.UserID)
.Column("RoleID"))
.Columns("RoleID", "RoleGUID", "RoleDisplayName", "RoleIsDomain"));
// Store user's roles before membership synchronization
memberShipChanges.SetRolesBefore(userRoles);
foreach (KeyValuePair <string, List <Guid> > site in ImportProfile.Sites)
{
// Get site info object
var siteInfo = SiteInfo.Provider.Get(site.Key);
if (siteInfo != null)
{
try
{
// Add user to this site
UserSiteInfo.Provider.Add(userInfo.UserID, siteInfo.SiteID);
}
catch (Exception ex)
{
MessageLog.LogEvent(ResHelper.GetString("Log_GeneralWarning", ex.Message));
warnings++;
}
// Assign user to roles already existing in CMS
if (newUser || ImportProfile.UpdateMemberships)
{
SetMemberships(user, userInfo, siteInfo, userRoles, site);
}
// Remove user from roles they is member no more
if (!newUser && ImportProfile.UpdateMemberships)
{
RemoveExcessiveMemberships(user, userInfo, userRoles);
}
}
else
{
MessageLog.LogEvent(ResHelper.GetString("Log_SiteNotExist", site.Key));
warnings++;
}
}
// Store user's roles after membership synchronization
memberShipChanges.SetRolesAfter(userRoles);
// Log created and removed memberships to EventLog
memberShipChanges.WriteEventsToEventLog(userInfo.UserName);
#endregion
}
else
{
// Add message to log
MessageLog.LogEvent(ResHelper.GetString("Log_SkippingEmptyUsername", user.Identifier));
warnings++;
}
}
// Log created and updated and deleted users to EventLog
usersChanged.WriteEventsToEventLog();
#endregion
// Import canceled
if (worker.CancellationPending)
{
e.Cancel = true;
return;
}
TimeSpan duration = DateTime.Now - start;
if (!worker.CancellationPending)
{
// Add message to log
MessageLog.LogEvent(warnings == 0
? ResHelper.GetString("Log_ImportComplete", duration.Hours, duration.Minutes, duration.Seconds)
: ResHelper.GetString("Log_ImportCompleteWithWarnings", warnings, duration.Hours, duration.Minutes, duration.Seconds));
}
}
}
catch (Exception ex)
{
MessageLog.LogError(ResHelper.GetString("Error_General"), ex);
}
}
/// <summary>
/// Saves data of edited user from TextBoxes into DB.
/// </summary>
protected void btnOk_Click(object sender, EventArgs e)
{
UserPrivilegeLevelEnum privilegeLevel = (UserPrivilegeLevelEnum)drpPrivilege.Value.ToInteger(0);
// Check "modify" permission
if (!CurrentUser.IsAuthorizedPerResource("CMS.Users", "Modify"))
{
RedirectToAccessDenied("CMS.Users", "Modify");
}
string result = ValidateGlobalAndDeskAdmin(userId);
// Find whether user name is valid
if (result == String.Empty)
{
if (!ucUserName.IsValid())
{
result = ucUserName.ValidationError;
}
}
String userName = ValidationHelper.GetString(ucUserName.Value, String.Empty);
if (result == String.Empty)
{
// Finds whether required fields are not empty
result = new Validator().NotEmpty(txtFullName.Text, GetString("Administration-User_New.RequiresFullName")).Result;
}
// Store the old display name
var oldDisplayName = ui.Generalized.ObjectDisplayName;
if ((result == String.Empty) && (ui != null))
{
// If site prefixed allowed - ad site prefix
if ((SiteID != 0) && UserInfoProvider.UserNameSitePrefixEnabled(SiteContext.CurrentSiteName))
{
if (!UserInfoProvider.IsSitePrefixedUser(userName))
{
userName = UserInfoProvider.EnsureSitePrefixUserName(userName, SiteContext.CurrentSite);
}
}
// Validation for site prefixed users
if (!UserInfoProvider.IsUserNamePrefixUnique(userName, ui.UserID))
{
ShowError(GetString("Administration-User_New.siteprefixeduserexists"));
return;
}
// Ensure same password
password = ui.GetValue("UserPassword").ToString();
// Test for unique username
UserInfo uiTest = UserInfoProvider.GetUserInfo(userName);
if ((uiTest == null) || (uiTest.UserID == userId))
{
if (ui == null)
{
ui = new UserInfo();
}
bool globAdmin = ui.IsGlobalAdministrator;
bool editor = ui.IsEditorInternal;
// Email format validation
string email = txtEmail.Text.Trim();
if ((email != string.Empty) && (!ValidationHelper.IsEmail(email)))
{
ShowError(GetString("Administration-User_New.WrongEmailFormat"));
return;
}
bool oldGlobal = ui.IsGlobalAdministrator;
bool oldEditor = ui.IsEditorInternal;
// Define domain variable
string domains = null;
// Get all user sites
DataTable ds = UserInfoProvider.GetUserSites(userId, null, null, 0, "SiteDomainName");
if (!DataHelper.DataSourceIsEmpty(ds))
{
foreach (DataRow dr in ds.Rows)
{
domains += ValidationHelper.GetString(dr["SiteDomainName"], string.Empty) + ";";
}
// Remove ";" at the end
if (domains != null)
{
domains = domains.Remove(domains.Length - 1);
}
}
else
{
DataSet siteDs = SiteInfoProvider.GetSites().Columns("SiteDomainName");
if (!DataHelper.DataSourceIsEmpty(siteDs))
{
// Create list of available site domains
domains = TextHelper.Join(";", DataHelper.GetStringValues(siteDs.Tables[0], "SiteDomainName"));
}
}
// Check limitations for Global administrator
if (CurrentUser.IsGlobalAdministrator && ((privilegeLevel == UserPrivilegeLevelEnum.GlobalAdmin) || (privilegeLevel == UserPrivilegeLevelEnum.Admin)) && !oldGlobal)
{
if (!UserInfoProvider.LicenseVersionCheck(domains, FeatureEnum.Administrators, ObjectActionEnum.Insert, globAdmin))
{
ShowError(GetString("License.MaxItemsReachedGlobal"));
return;
}
}
// Check limitations for editors
if ((privilegeLevel == UserPrivilegeLevelEnum.Editor) && !oldEditor)
{
if (!UserInfoProvider.LicenseVersionCheck(domains, FeatureEnum.Editors, ObjectActionEnum.Insert, editor))
{
ShowError(GetString("License.MaxItemsReachedEditor"));
return;
}
}
// Check whether email is unique if it is required
if (!UserInfoProvider.IsEmailUnique(email, ui))
{
ShowError(GetString("UserInfo.EmailAlreadyExist"));
return;
}
// Set properties
ui.Email = email;
ui.FirstName = txtFirstName.Text.Trim();
ui.FullName = txtFullName.Text.Trim();
ui.LastName = txtLastName.Text.Trim();
ui.MiddleName = txtMiddleName.Text.Trim();
ui.UserName = userName;
ui.Enabled = CheckBoxEnabled.Checked;
ui.UserIsHidden = chkIsHidden.Checked;
ui.IsExternal = chkIsExternal.Checked;
ui.UserIsDomain = chkIsDomain.Checked;
ui.SetValue("UserPassword", password);
ui.UserID = userId;
ui.UserStartingAliasPath = txtUserStartingPath.Text.Trim();
ui.UserMFRequired = chkIsMFRequired.Checked;
// Global admin can set anything
if (CurrentUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin)
// Other users can set only editor and non privileges
|| ((privilegeLevel != UserPrivilegeLevelEnum.Admin) && (privilegeLevel != UserPrivilegeLevelEnum.GlobalAdmin))
// Admin can manage his own privilege
|| ((privilegeLevel == UserPrivilegeLevelEnum.Admin) && (CurrentUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.Admin) && (CurrentUser.UserID == ui.UserID))))
{
ui.SetPrivilegeLevel(privilegeLevel);
}
LoadUserLogon(ui);
// Set values of cultures.
string culture = ValidationHelper.GetString(cultureSelector.Value, "");
ui.PreferredCultureCode = culture;
if (lstUICulture.SelectedValue == "0")
{
ui.PreferredUICultureCode = "";
}
else
{
// Set preferred UI culture
CultureInfo ci = CultureInfoProvider.GetCultureInfo(ValidationHelper.GetInteger(lstUICulture.SelectedValue, 0));
ui.PreferredUICultureCode = ci.CultureCode;
}
// Refresh page breadcrumbs if display name changed
if (ui.Generalized.ObjectDisplayName != oldDisplayName)
{
ScriptHelper.RefreshTabHeader(Page, ui.FullName);
}
using (CMSActionContext context = new CMSActionContext())
{
// Check whether the username of the currently logged user has been changed
if (CurrentUserChangedUserName())
{
// Ensure that an update search task will be created but NOT executed when updating the user
context.EnableSmartSearchIndexer = false;
}
// Update the user
UserInfoProvider.SetUserInfo(ui);
// Check whether the username of the currently logged user has been changed
if (CurrentUserChangedUserName())
{
// Ensure that current user is not logged out if he changes his user name
if (RequestHelper.IsFormsAuthentication())
{
FormsAuthentication.SetAuthCookie(ui.UserName, false);
// Update current user
MembershipContext.AuthenticatedUser = new CurrentUserInfo(ui, true);
// Reset current user
CurrentUser = null;
}
}
}
ShowChangesSaved();
}
else
{
// If user exists
ShowError(GetString("Administration-User_New.UserExists"));
}
}
else
{
ShowError(result);
}
if ((ui.UserInvalidLogOnAttempts == 0) && (ui.UserAccountLockReason != UserAccountLockCode.FromEnum(UserAccountLockEnum.MaximumInvalidLogonAttemptsReached)))
{
btnResetLogonAttempts.Enabled = false;
}
LoadPasswordExpiration(ui);
}
/// <summary>
/// Saves new user's data into DB.
/// </summary>
/// <returns>Returns ID of created user</returns>
protected int SaveNewUser()
{
UserInfo ui = new UserInfo();
// Load default values
FormHelper.LoadDefaultValues("cms.user", ui);
string emailAddress = txtEmailAddress.Text.Trim();
ui.PreferredCultureCode = "";
ui.Email = emailAddress;
ui.FirstName = "";
ui.FullName = txtFullName.Text;
ui.LastName = "";
ui.MiddleName = "";
ui.UserName = userName;
ui.Enabled = chkEnabled.Checked;
ui.IsExternal = false;
// Set privilege level, global admin may set all levels, rest only editor
UserPrivilegeLevelEnum privilegeLevel = (UserPrivilegeLevelEnum)drpPrivilegeLevel.Value.ToInteger(0);
if (CurrentUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin) ||
(privilegeLevel == UserPrivilegeLevelEnum.None) || (privilegeLevel == UserPrivilegeLevelEnum.Editor))
{
ui.SiteIndependentPrivilegeLevel = privilegeLevel;
}
bool assignUserToSite = chkAssignToSite.Checked && AllowAssignToWebsite;
// Check license limitations
if (SiteID > 0 || assignUserToSite)
{
string errorMessage = String.Empty;
UserInfoProvider.CheckLicenseLimitation(ui, ref errorMessage);
if (!String.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}
// Check whether email is unique if it is required
string siteName = SiteName;
if (assignUserToSite)
{
siteName = SiteContext.CurrentSiteName;
}
if (!UserInfoProvider.IsEmailUnique(emailAddress, siteName, 0))
{
ShowError(GetString("UserInfo.EmailAlreadyExist"));
return(-1);
}
if (!error)
{
// Set password and save object
UserInfoProvider.SetPassword(ui, passStrength.Text);
// Add user to current site
if ((SiteID > 0) || assignUserToSite)
{
UserInfoProvider.AddUserToSite(ui.UserName, siteName);
}
return(ui.UserID);
}
return(-1);
}
/// <summary>
/// Saves new user's data into DB.
/// </summary>
/// <returns>Returns ID of created user</returns>
protected int SaveNewUser()
{
UserInfo ui = new UserInfo();
// Load default values
FormHelper.LoadDefaultValues("cms.user", ui);
ui.PreferredCultureCode = "";
ui.Email = TextBoxEmail.Text;
ui.FirstName = "";
ui.FullName = TextBoxFullName.Text;
ui.LastName = "";
ui.MiddleName = "";
ui.UserName = userName;
ui.Enabled = CheckBoxEnabled.Checked;
ui.IsExternal = false;
// Set privilege level, global admin may set all levels, rest only editor.
UserPrivilegeLevelEnum privilegeLevel = (UserPrivilegeLevelEnum)drpPrivilegeLevel.Value.ToInteger(0);
if (CurrentUser.CheckPrivilegeLevel(UserPrivilegeLevelEnum.GlobalAdmin) ||
(privilegeLevel == UserPrivilegeLevelEnum.None) || (privilegeLevel == UserPrivilegeLevelEnum.Editor))
{
ui.SetPrivilegeLevel(privilegeLevel);
}
// Check license limitations only in cmsdesk
if (SiteID > 0)
{
string errorMessage = String.Empty;
UserInfoProvider.CheckLicenseLimitation(ui, ref errorMessage);
if (!String.IsNullOrEmpty(errorMessage))
{
ShowError(errorMessage);
}
}
// Check whether email is unique if it is required
if (!UserInfoProvider.IsEmailUnique(TextBoxEmail.Text.Trim(), SiteName, 0))
{
ShowError(GetString("UserInfo.EmailAlreadyExist"));
return(-1);
}
if (!error)
{
// Set password and save object
UserInfoProvider.SetPassword(ui, passStrength.Text);
// Add user to current site
if (SiteID > 0)
{
UserInfoProvider.AddUserToSite(ui.UserName, SiteName);
}
return(ui.UserID);
}
return(-1);
}
