private void BindRoles()
{
// Create new datatable
DataTable rolesTable = new DataTable();
// Create columns in the datatable
rolesTable.Columns.Add(new DataColumn(COLUMN_SELECTED, typeof(Boolean)));
rolesTable.Columns.Add(new DataColumn(COLUMN_ROLENAME, typeof(String)));
rolesTable.Columns.Add(new DataColumn(COLUMN_ROLEGUID, typeof(Guid)));
if (cmbSites.SelectedValue != null)
{
SiteInfo si = SiteInfo.Provider.Get(cmbSites.SelectedValue.ToString());
if (si != null)
{
DataSet roles = RoleInfoProvider.GetAllRoles(si.SiteID, false);
if (!DataHelper.DataSourceIsEmpty(roles))
{
foreach (DataRow role in roles.Tables[0].Rows)
{
// Determine preselection state
string siteName = si.SiteName.ToLowerCSafe();
Guid roleGuid = ValidationHelper.GetGuid(role["RoleGuid"], Guid.Empty);
bool checkRole = ImportProfile.Sites.ContainsKey(siteName) && ImportProfile.Sites[siteName].Contains(roleGuid);
// Create data for the row
object[] dataRow = { checkRole, role["RoleDisplayName"], roleGuid };
// Create new row with the table schema
DataRow dr = rolesTable.NewRow();
dr.ItemArray = dataRow;
// Add row to table
rolesTable.Rows.Add(dr);
}
}
// Apply sorting
rolesTable.DefaultView.Sort = COLUMN_ROLENAME;
// Bind table as a grid's datasource
grdRoles.DataSource = rolesTable;
if (!DataHelper.DataSourceIsEmpty(grdRoles.DataSource))
{
// Adjust columns
DataGridViewColumn columnSelected = grdRoles.Columns[COLUMN_SELECTED];
if (columnSelected != null)
{
columnSelected.HeaderText = ResHelper.GetString("General_Assign");
columnSelected.AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader;
}
DataGridViewColumn columnRoleName = grdRoles.Columns[COLUMN_ROLENAME];
if (columnRoleName != null)
{
columnRoleName.HeaderText = ResHelper.GetString("General_Role");
columnRoleName.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
columnRoleName.ReadOnly = true;
}
DataGridViewColumn columnRoleGuid = grdRoles.Columns[COLUMN_ROLEGUID];
if (columnRoleGuid != null)
{
columnRoleGuid.Visible = false;
}
}
}
}
}
private void ADWizard_FormClosing(object sender, FormClosingEventArgs e)
{
// Show confirmation when not last step
if ((currentStep != 11) && (currentStep != 1))
{
DialogResult result = MessageBox.Show(ResHelper.GetString("Wizard_ConfirmExit"), ResHelper.GetString("Wizard_ConfirmExitCaption"), MessageBoxButtons.YesNo);
if (result != DialogResult.Yes)
{
// Cancel closing
e.Cancel = true;
return;
}
}
// End all threads before application is closed
if (CurrentStep != null)
{
CurrentStep.EndThreads();
}
}
/// <summary>
/// Performs step change of wizard.
/// </summary>
/// <param name="validate">Indicates whether to perform validation</param>
/// <param name="forward">Whether to move forward or backward</param>
private async void MakeStep(bool forward, bool validate)
{
int newStep = forward ? currentStep + 1 : currentStep - 1;
// Adjust step
switch (newStep)
{
case 8:
if (ImportProfile.Sites.Count == 0)
{
if (forward)
{
// Skip irrelevant steps
newStep = GetStepId <Step10>();
}
}
break;
case 9:
if (ImportProfile.Sites.Count == 0)
{
if (!forward)
{
// Skip irrelevant steps
newStep = GetStepId <Step7>();
}
}
break;
}
AbstractStep fromStep = Steps[currentStep];
AbstractStep toStep = Steps[newStep];
bool valid = (fromStep == null) || !validate || await fromStep.IsValid();
// If current step is valid
if (valid)
{
try
{
currentStep = newStep;
// Delete all controls from wizard
WizardBody.Controls.Clear();
// Step should fill parent panel
toStep.Dock = DockStyle.Fill;
// Add new step
WizardBody.Controls.Add(toStep);
}
catch (Exception ex)
{
// Show message
ShowError(ResHelper.GetString("Error_MovingStep"), ResHelper.GetString("Error_MovingStepCaption"), ex);
}
}
// Set step name and description
headerControl.SetTitle(ResHelper.GetString("StepName_" + currentStep));
headerControl.SetSubtitle(ResHelper.GetString("StepDescription_" + currentStep));
// Ensure waiting state is turned off
if (validate && (currentStep != 11))
{
SetWaitState(false, string.Empty);
}
// Set visibility of next and back buttons
ButtonBack.Visible = ((currentStep != 1) && (currentStep != 11));
ButtonNext.Visible = (currentStep != 11);
// Set caption of next button
ButtonNext.Text = ResHelper.GetString("Wizard_Next");
ButtonNext.Enabled = true;
// Raise step loaded event
if (StepLoadedEvent != null)
{
StepLoadedEvent(this, null);
}
}
private void BindUsers()
{
// Set waiting state
SetWait(true, ResHelper.GetString("Step7_LoadingUsers"));
DataTable usersTable = null;
if (DataHelper.DataSourceIsEmpty(grdUsers.DataSource))
{
// Create new datatable
usersTable = new DataTable();
// Create columns
DataColumn selectedCol = new DataColumn(COLUMN_SELECTED, typeof(Boolean));
DataColumn displayNameCol = new DataColumn(COLUMN_DISPLAYNAME, typeof(String));
DataColumn userNameCol = new DataColumn(COLUMN_USERNAME, typeof(String));
DataColumn userGuidCol = new DataColumn(COLUMN_USERGUID, typeof(Guid));
// Add columns to datatable
usersTable.Columns.Add(selectedCol);
usersTable.Columns.Add(displayNameCol);
usersTable.Columns.Add(userNameCol);
usersTable.Columns.Add(userGuidCol);
// Fill table with data
foreach (IPrincipalObject user in ADProvider.GetAllUsers())
{
// Create new row with the table schema
DataRow dr = usersTable.NewRow();
// Get user's identifier
object userIdentifier = user.Identifier;
// Get the display name of user
string displayName = !string.IsNullOrEmpty(user.DisplayName) ? user.DisplayName : user.Name;
// Add data to row
object[] dataRow = { user.IsSelected, displayName, user.GetCMSCodeName(true), userIdentifier };
dr.ItemArray = dataRow;
// Add row to table
usersTable.Rows.Add(dr);
}
// Apply sorting
usersTable.DefaultView.Sort = COLUMN_DISPLAYNAME;
}
else
{
usersTable = (DataTable)grdUsers.DataSource;
foreach (DataRow dr in usersTable.Rows)
{
string userIdentifier = ValidationHelper.GetString(dr[COLUMN_USERGUID], string.Empty);
// Preselect users
bool selected = ImportProfile.Users.Contains(ADProvider.ConvertToObjectIdentifier(userIdentifier));
dr[COLUMN_SELECTED] = selected;
dr[COLUMN_USERNAME] = ADProvider.GetPrincipalObject(userIdentifier).GetCMSCodeName(true);
}
}
using (InvokeHelper ih = new InvokeHelper(grdUsers))
{
ih.InvokeMethod(() => SetupGrid(usersTable));
}
using (InvokeHelper ih = new InvokeHelper(grdUsers))
{
ih.InvokeMethod(() => grdUsers.Enabled = true);
}
// Turn off wait state
SetWait(false, string.Empty);
}
private void btnCancel_Click(object sender, EventArgs e)
{
if (CurrentStep != null)
{
// End all threads
if (CurrentStep != null)
{
DialogResult result = MessageBox.Show(ResHelper.GetString("Wizard_CancelImportConfirmation"), ResHelper.GetString("Wizard_CancelImportTitle"), MessageBoxButtons.YesNo);
if (result == DialogResult.Yes)
{
SetWaitState(false, null);
CurrentStep.EndThreads();
}
}
}
}
private void BindSites()
{
// Create new datatable
DataTable sitesTable = new DataTable();
// Create columns
DataColumn selectedCol = new DataColumn(COLUMN_SELECTED, typeof(Boolean));
DataColumn siteNameCol = new DataColumn(COLUMN_SITENAME, typeof(String));
DataColumn codeNameCol = new DataColumn(COLUMN_CODENAME, typeof(String));
// Add columns to datatable
sitesTable.Columns.Add(selectedCol);
sitesTable.Columns.Add(siteNameCol);
sitesTable.Columns.Add(codeNameCol);
// Bind DataGridView to CMS sites
DataSet sites = SiteInfoProvider.GetSites()
.OrderBy("SiteDisplayName")
.Columns("SiteDisplayName, SiteName");
bool sitesAvailable = !DataHelper.DataSourceIsEmpty(sites);
pnlImportGroups.Enabled = sitesAvailable;
if (sitesAvailable)
{
// Remove non-existing sites
IEnumerator sitesEnumerator = ImportProfile.Sites.GetEnumerator();
List <string> removeSites = new List <string>();
while (sitesEnumerator.MoveNext())
{
// Get site
if (sitesEnumerator.Current != null)
{
KeyValuePair <string, List <Guid> > importedSite = (KeyValuePair <string, List <Guid> >)sitesEnumerator.Current;
// Clear hash tables
ProviderHelper.ClearHashtables(SiteInfo.OBJECT_TYPE, true);
// Get info object
SiteInfo site = SiteInfoProvider.GetSiteInfo(importedSite.Key);
// If site is not present
if (site == null)
{
// Add to removal list
removeSites.Add(importedSite.Key);
}
}
}
foreach (string siteToRemove in removeSites)
{
ImportProfile.Sites.Remove(siteToRemove.ToLowerCSafe());
}
foreach (DataRow site in sites.Tables[0].Rows)
{
// Create new row with the table schema
DataRow dr = sitesTable.NewRow();
// Preselect sites
bool checkSite = (ImportProfile.Sites.ContainsKey(site["SiteName"].ToString().ToLowerCSafe()));
// Localize display name
string siteDisplayName = CMS.Helpers.ResHelper.LocalizeString(site["SiteDisplayName"].ToString());
// Add data to row
object[] dataRow = { checkSite, siteDisplayName, site["SiteName"] };
dr.ItemArray = dataRow;
// Add row to table
sitesTable.Rows.Add(dr);
}
// Bind table as a grid's datasource
grdSites.DataSource = sitesTable;
// Adjust columns
DataGridViewColumn columnSelected = grdSites.Columns[COLUMN_SELECTED];
if (columnSelected != null)
{
columnSelected.HeaderText = ResHelper.GetString("General_Import");
columnSelected.AutoSizeMode = DataGridViewAutoSizeColumnMode.ColumnHeader;
}
DataGridViewColumn columnSiteName = grdSites.Columns[COLUMN_SITENAME];
if (columnSiteName != null)
{
columnSiteName.HeaderText = ResHelper.GetString("General_Sitename");
columnSiteName.AutoSizeMode = DataGridViewAutoSizeColumnMode.Fill;
columnSiteName.ReadOnly = true;
}
DataGridViewColumn columnCodeName = grdSites.Columns[COLUMN_CODENAME];
if (columnCodeName != null)
{
columnCodeName.Visible = false;
}
}
else
{
// No sites to import
ImportProfile.Sites.Clear();
}
}
private void Step4_Load(object sender, EventArgs e)
{
// Localize step
toolTipOnlySelectedAndNew.SetToolTip(radOnlySelectedAndNewGroups, ResHelper.GetString("Step4_UpdateSelectedImportNew"));
toolTipOnlySelectedAndNew.SetToolTip(radOnlySelectedAndNewUsers, ResHelper.GetString("Step4_UpdateSelectedImportNew"));
toolTipImportOnlyUsersFromSelectedRoles.SetToolTip(chkImportNewUsersOnlyFromSelectedRoles, ResHelper.GetString("Step4_ToolTipImportNewUsersOnlyFromSelectedRoles"));
}
private static void Main(string[] args)
{
string profileName = string.Empty;
// Create new instance of AD provider
ImportProfile.OnDirectoryControllerChanged += () => PrincipalProvider.ClearContext();
// If there are some arguments specified
if (args.Length != 0)
{
// Try to attach console
if (!AttachConsole(-1))
{
// Create new console
AllocConsole();
}
// For each argument
for (int i = 0; i < args.Length; i++)
{
string arg = args[i];
// If argument specifies profile
if ((arg == "/profile") || (arg == "-profile"))
{
// Get profile name
if ((i + 1) < args.Length)
{
if (profileName == string.Empty)
{
profileName = args[i + 1].Trim();
}
}
}
if ((arg == "/h") || (arg == "-h") || (arg == "--help") || (arg == "-?") || (arg == "/?"))
{
// Write help
Console.Write(ResHelper.GetString("Console_Help").Replace("\\n", "\n").Replace("\\r", "\r"));
return;
}
}
// If there was profile specified
if (profileName != string.Empty)
{
// If there is no such file
if (!File.Exists(profileName))
{
Console.WriteLine(ResHelper.GetString("Error_ProfileDoesNotExist", profileName));
}
else
{
// Try to get file info
FileInfo fi = FileInfo.New(profileName);
Console.WriteLine(ResHelper.GetString("Console_SelectedImportProfile", fi.FullName));
// Initialize import profile
string validationError = ImportProfile.InitializeImportProfile(profileName);
if (!String.IsNullOrEmpty(validationError))
{
Console.WriteLine(ResHelper.GetString("Error_ProfileIsNotValid"));
Console.WriteLine(validationError);
}
else
{
// Application is in console mode
ImportProfile.UsesConsole = true;
// Check permissions
string permissionsCheckResult = PrincipalProvider.CheckPermissions();
if (!string.IsNullOrEmpty(permissionsCheckResult))
{
Console.WriteLine(permissionsCheckResult);
}
else
{
// Initialize principal provider
bool providerInitialized = ValidatePrincipalProvider(PrincipalProvider);
bool databaseValid = ValidateDatabase();
if (providerInitialized && databaseValid)
{
// Initialize CMS connection
CMSImport.ConfigureApplicationSettings();
// Perform CMS import
CMSImport.Import(PrincipalProvider, MessageLog);
}
}
}
}
}
else
{
// Write message
Console.WriteLine(ResHelper.GetString("Console_SpecifyProfile"));
}
}
// Launch windows form application
else
{
// Preinitialize CMS context
CMSApplication.PreInit();
// Initialize application
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new ADWizard(PrincipalProvider));
}
}
/// <summary>
/// Sets message.
/// </summary>
/// <param name="label">Label to use</param>
/// <param name="message">Error message</param>
/// <param name="isError">Indicates whether message is error</param>
private void SetMessageInternal(Label label, string message, bool isError)
{
label.Visible = true;
label.Text = ResHelper.GetString(message);
label.ForeColor = isError ? Color.Red : SystemColors.ControlText;
}
private static bool ValidatePrincipalProvider(IPrincipalProvider principalProvider)
{
bool providerInitialized = false;
try
{
principalProvider.InitializeDomainContext();
providerInitialized = true;
}
catch (LocalUserAccountException)
{
Console.WriteLine(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ResHelper.GetString("Error_LocalUserAccountException"));
}
catch (DCConnectionException)
{
Console.WriteLine(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ResHelper.GetString("Error_LocalUserAccountException"));
}
catch (Exception ex)
{
Console.WriteLine(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ex.Message);
}
return(providerInitialized);
}
private static bool ValidateDatabase()
{
bool validationResult = false;
try
{
// Change message
Console.WriteLine(ResHelper.GetString("Step2_CheckingLicense"));
if (!string.IsNullOrEmpty(ImportProfile.SQLServerDatabase))
{
// Try to open connection
SqlConnection sc = new SqlConnection(CMSImport.ConnectionString);
// Find out whether CMS version is correct
SqlCommand getVersion = new SqlCommand("SELECT [KeyValue] FROM [CMS_SettingsKey] WHERE [KeyName] = 'CMSDBVersion'", sc);
DataSet ds = null;
using (SqlDataAdapter dataAdapter = new SqlDataAdapter(getVersion))
{
ds = new DataSet();
dataAdapter.Fill(ds);
}
// Get current project version
string projectVersion = null;
if (!DataHelper.DataSourceIsEmpty(ds))
{
projectVersion = ValidationHelper.GetString(ds.Tables[0].Rows[0]["KeyValue"], string.Empty);
}
if (string.IsNullOrEmpty(projectVersion))
{
Console.WriteLine(ResHelper.GetString("Step2_OtherDB"));
}
else
{
Console.WriteLine(ResHelper.GetString("Step2_CheckingVersion"));
// Version has to correspond with DLL version
if (projectVersion.EqualsCSafe(ADWizard.SupportedVersion))
{
// Set new connection string
ConnectionHelper.ConnectionString = CMSImport.ConnectionString;
// Initialize application to enable usage of providers
CMSImport.CMSInit();
validationResult = true;
Console.WriteLine(ResHelper.GetString("Step2_ConnectionToDBSuccessfull"));
}
else
{
Console.WriteLine(ResHelper.GetString("Step2_WrongVersion", ADWizard.SupportedVersion, projectVersion));
}
}
}
else
{
Console.WriteLine(ResHelper.GetString("Step2_SelectDatabase"));
}
}
catch (SqlException)
{
validationResult = false;
Console.WriteLine(ResHelper.GetString("Step2_OtherDB"));
}
return(validationResult);
}
private void BindGroups()
{
// Set waiting state
SetWait(true, ResHelper.GetString("Step8_LoadingGroups"));
DataTable groupsTable = null;
if (DataHelper.DataSourceIsEmpty(grdGroups.DataSource))
{
// Create new datatable
groupsTable = new DataTable();
// Create columns
DataColumn selectedCol = new DataColumn(COLUMN_SELECTED, typeof(Boolean));
DataColumn groupNameCol = new DataColumn(COLUMN_GROUPNAME, typeof(String));
DataColumn groupCMSNameCol = new DataColumn(COLUMN_CMSGROUPNAME, typeof(String));
DataColumn groupGuidCol = new DataColumn(COLUMN_GROUPGUID, typeof(Guid));
// Add columns to datatable
groupsTable.Columns.Add(selectedCol);
groupsTable.Columns.Add(groupNameCol);
groupsTable.Columns.Add(groupCMSNameCol);
groupsTable.Columns.Add(groupGuidCol);
var possibleConflicts = new HashSet <string>();
bool askForGuid = true;
// Fill table with data
foreach (IPrincipalObject group in ADProvider.GetAllGroups())
{
// Look for possible code name conflicts and ask user if he wants to replace them with GUID
string codeName = group.GetCMSCodeName(true);
if (ImportProfile.RoleCodeNameFormat != CodenameFormat.Guid)
{
if (askForGuid && !possibleConflicts.Add(codeName))
{
if (MessageBox.Show(ResHelper.GetString("Step8_ConflictsText"), ResHelper.GetString("Step8_ConflictsCaption"), MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
{
ImportProfile.RoleCodeNameFormat = CodenameFormat.Guid;
}
// Ask user only once
askForGuid = false;
}
}
// Create new row with the table schema
DataRow dr = groupsTable.NewRow();
// Add data to row
object[] dataRow = { group.IsSelected, group.Name, codeName, group.Identifier };
dr.ItemArray = dataRow;
// Add row to table
groupsTable.Rows.Add(dr);
}
// Apply sorting
groupsTable.DefaultView.Sort = COLUMN_GROUPNAME;
}
else
{
groupsTable = (DataTable)grdGroups.DataSource;
foreach (DataRow dr in groupsTable.Rows)
{
string groupIdentifier = ValidationHelper.GetString(dr[COLUMN_GROUPGUID], string.Empty);
// Preselect users
bool selected = ImportProfile.Groups.Contains(ADProvider.ConvertToObjectIdentifier(groupIdentifier));
dr[COLUMN_SELECTED] = selected;
dr[COLUMN_CMSGROUPNAME] = ADProvider.GetPrincipalObject(groupIdentifier).GetCMSCodeName(true);
}
}
using (InvokeHelper ih = new InvokeHelper(grdGroups))
{
ih.InvokeMethod(() => SetupGrid(groupsTable));
}
using (InvokeHelper ih = new InvokeHelper(grdGroups))
{
ih.InvokeMethod(() => grdGroups.Enabled = true);
}
// Turn off wait state
SetWait(false, string.Empty);
}
/// <summary>
/// Verifies connection credentials and performs proper action.
/// </summary>
private Task <bool> VerifyADConnection()
{
TaskCompletionSource <bool> tcs = new TaskCompletionSource <bool>();
try
{
ADProvider.InitializeDomainContext();
SetMessage("Step3_ConnectionSuccessful");
tcs.SetResult(true);
}
catch (LocalUserAccountException)
{
DisableCurrentUserAccount();
SetError(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ResHelper.GetString("Error_LocalUserAccountException"));
}
catch (DCConnectionException)
{
SetError(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ResHelper.GetString("Error_LocalUserAccountException"));
}
catch (Exception ex)
{
SetError(ResHelper.GetString("Error_ConnectingAD") + AbstractResHelper.LINE_BREAK + ex.Message);
}
finally
{
Wizard.SetWaitState(false, string.Empty);
Wizard.SetControlEnabled(Wizard.ButtonNext, true);
using (InvokeHelper ih = new InvokeHelper(this))
{
ih.InvokeMethod(() => Enabled = true);
}
}
return(tcs.Task);
}
/// <summary>
/// Sets up properties by given XML file.
/// </summary>
/// <param name="fileName">Path to import profile XML</param>
public static string InitializeImportProfile(string fileName)
{
// Reset error
validationError = null;
try
{
// Set profile path
ImportProfileFilename = fileName;
if (File.Exists(ImportProfileFilename))
{
using (var schemaStream = Assembly.GetExecutingAssembly().GetManifestResourceStream(
GetManifestResourceName(typeof(ImportProfile), PROFILE_XSD)))
{
// Set profile path
ImportProfileFilename = fileName;
// Load XML with import profile
XmlDocument profile = new XmlDocument();
// Load XML schema
XmlSchema xmlSchema = XmlSchema.Read(schemaStream, xmlReaderSettings_ValidationEventHandler);
// Initialize reader settings
XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
xmlReaderSettings.ValidationType = ValidationType.Schema;
xmlReaderSettings.ValidationEventHandler += xmlReaderSettings_ValidationEventHandler;
xmlReaderSettings.Schemas.Add(xmlSchema);
// Load and validate profile
using (XmlReader reader = XmlReader.Create(fileName, xmlReaderSettings))
{
profile.Load(reader);
}
if (String.IsNullOrEmpty(validationError))
{
// Get settings node
XmlNodeList settings = profile.GetElementsByTagName("setting");
foreach (XmlNode setting in settings)
{
if (setting.Attributes != null)
{
object value = setting.Attributes["value"].Value;
switch (setting.Attributes["key"].Value)
{
case "SQLServerAddress":
SQLServerAddress = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "SQLServerDatabase":
SQLServerDatabase = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "SQLServerUsername":
SQLServerUsername = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "SQLServerPassword":
string sqlPassword = ValidationHelper.GetString(value.ToString(), string.Empty);
try
{
// Try to decrypt password
SQLServerPassword = DecryptPassword(sqlPassword);
}
catch
{
// Password is probably in plaintext form
SQLServerPassword = sqlPassword;
}
break;
case "SQLUseTrustedConnection":
SQLUseTrustedConnection = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "ADControllerAddress":
ADControllerAddress = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "ADUseCurrentUserAccount":
ADUseCurrentUserAccount = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "ADUsername":
ADUsername = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "ADPassword":
string adPassword = ValidationHelper.GetString(value.ToString(), string.Empty);
try
{
// Try to decrypt password
ADPassword = DecryptPassword(adPassword);
}
catch
{
// Password is probably in plaintext form
ADPassword = adPassword;
}
break;
case "ImportUsersType":
ImportUsersType = (ImportType)Enum.Parse(typeof(ImportType), value.ToString());
break;
case "ImportRolesType":
ImportRolesType = (ImportType)Enum.Parse(typeof(ImportType), value.ToString());
break;
case "UpdateObjectData":
UpdateObjectData = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "ImportOnlyUsersFromSelectedRoles":
ImportNewUsersOnlyFromSelectedRoles = ValidationHelper.GetBoolean(value.ToString(), false);
break;
case "ImportAllUsersFromSelectedRolesAndIgnoreOthers":
ImportUsersOnlyFromSelectedRoles = ValidationHelper.GetBoolean(value.ToString(), false);
break;
case "UpdateMemberships":
UpdateMemberships = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "DeleteNotExistingObjects":
DeleteNotExistingObjects = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "LogImportProcess":
LogImportProcess = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "LogPath":
LogPath = ValidationHelper.GetString(value.ToString(), string.Empty);
break;
case "UsernameFormat":
UsernameFormat = (CodenameFormat)Enum.Parse(typeof(CodenameFormat), value.ToString());
break;
case "ConfigureAsCMSEditor":
ConfigureAsCMSEditor = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "BindingEditorMode":
BindingEditorMode = (BindingEditorMode)Enum.Parse(typeof(BindingEditorMode), value.ToString());
break;
case "RoleDisplayNameFormat":
RoleDisplayNameFormat = (CodenameFormat)Enum.Parse(typeof(CodenameFormat), value.ToString());
break;
case "RoleCodeNameFormat":
RoleCodeNameFormat = (CodenameFormat)Enum.Parse(typeof(CodenameFormat), value.ToString());
break;
case "ImportRoleDescription":
ImportRoleDescription = ValidationHelper.GetBoolean(value.ToString(), true);
break;
case "ImportNow":
ImportNow = ValidationHelper.GetBoolean(value.ToString(), true);
break;
}
}
}
// Get user properties bindings
XmlNodeList properties = profile.GetElementsByTagName("property");
UserProperties.Clear();
foreach (XmlNode property in properties)
{
if ((property.Attributes != null) && ((property.Attributes["cmsname"] != null) && (property.Attributes["adname"] != null)))
{
string cmsPropertyName = property.Attributes["cmsname"].Value;
string adPropertyName = property.Attributes["adname"].Value;
UserProperties.Add(cmsPropertyName, adPropertyName);
}
}
// Get users to import
XmlNodeList users = profile.GetElementsByTagName("user");
Users.Clear();
foreach (XmlNode user in users)
{
if ((user.Attributes) != null && (user.Attributes["guid"] != null))
{
Guid userGuid = ValidationHelper.GetGuid(user.Attributes["guid"].Value, Guid.Empty);
Users.Add(userGuid);
}
}
// Get groups to import
XmlNodeList groups = profile.GetElementsByTagName("group");
Groups.Clear();
foreach (XmlNode group in groups)
{
if ((group.Attributes) != null && (group.Attributes["guid"] != null))
{
Guid groupGuid = ValidationHelper.GetGuid(group.Attributes["guid"].Value, Guid.Empty);
Groups.Add(groupGuid);
}
}
// Get sites & roles
XmlNodeList sites = profile.GetElementsByTagName("site");
Sites.Clear();
foreach (XmlNode site in sites)
{
if ((site.Attributes != null) && (site.Attributes["codename"] != null))
{
string siteCodeName = site.Attributes["codename"].Value;
List <Guid> roles = new List <Guid>();
foreach (XmlNode role in site.ChildNodes)
{
if (role.Attributes != null)
{
if (role.Attributes["guid"] != null)
{
XmlAttribute roleGuidAttr = role.Attributes["guid"];
// Get guid of CMS role
Guid roleGuid = Guid.Empty;
if (roleGuidAttr != null)
{
roleGuid = ValidationHelper.GetGuid(roleGuidAttr.Value, Guid.Empty);
}
roles.Add(roleGuid);
}
}
}
Sites.Add(siteCodeName.ToLowerCSafe(), roles);
}
}
}
}
}
else
{
return(ResHelper.GetString("Error_ProfileDoesNotExist", ImportProfileFilename));
}
}
catch (System.IO.IOException ex)
{
return(ex.Message);
}
catch (UnauthorizedAccessException ex)
{
return(ex.Message);
}
catch (Exception ex)
{
// Log detailed information when unexpected exception occurs
return(LogHelper.GetExceptionLogMessage(ex));
}
return(validationError);
}