/// -----------------------------------------------------------------------------
/// <summary>
/// cmdAuthorize_Click runs when the Authorize User Button is clicked
/// </summary>
/// <history>
/// [cnurse] 03/01/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private void cmdAuthorize_Click(object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (Request.IsAuthenticated != true)
{
return;
}
//Get the Membership Information from the property editors
User.Membership = (UserMembership)membershipForm.DataSource;
User.Membership.Approved = true;
//Update User
UserController.UpdateUser(PortalId, User);
//Update User Roles if needed
if (!User.IsSuperUser && User.IsInRole("Unverified Users") && PortalSettings.UserRegistration == (int)Common.Globals.PortalRegistrationType.VerifiedRegistration)
{
UserController.ApproveUser(User);
}
OnMembershipAuthorized(EventArgs.Empty);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.cmdUpdate.Click += this.OnUpdateClick;
try
{
this.cancelHyperLink.NavigateUrl = this.ReturnURL;
if (this.Page.IsPostBack == false)
{
this.dgPermissions.TabId = this.PortalSettings.ActiveTab.TabID;
this.dgPermissions.ModuleID = this._moduleId;
if (this.Module != null)
{
this.cmdUpdate.Visible = ModulePermissionController.HasModulePermission(this.Module.ModulePermissions, "EDIT,MANAGE") || TabPermissionController.CanAddContentToPage();
this.permissionsRow.Visible = ModulePermissionController.CanAdminModule(this.Module) || TabPermissionController.CanAddContentToPage();
}
}
}
catch (Exception exc)
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
/// <summary>
/// cmdToggleSuperuser_Click runs when the toggle superuser button is clicked
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void cmdToggleSuperuser_Click(object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (Request.IsAuthenticated != true)
{
return;
}
////ensure only superusers can change user superuser state
if (UserController.Instance.GetCurrentUserInfo().IsSuperUser != true)
{
return;
}
var currentSuperUserState = User.IsSuperUser;
User.IsSuperUser = !currentSuperUserState;
//Update User
UserController.UpdateUser(PortalId, User);
DataCache.ClearCache();
if (currentSuperUserState)
{
OnMembershipDemoteFromSuperuser(EventArgs.Empty);
}
else
{
OnMembershipPromoteToSuperuser(EventArgs.Empty);
}
}
protected string GetModuleInfo(object moduleID)
{
string returnValue = "";
if (moduleID != null)
{
var moduleInfo = ModuleController.Instance.GetModule((int)moduleID, Null.NullInteger, true);
if (moduleInfo != null)
{
if (moduleInfo.IsDeleted)
{
returnValue = LocalizeString("ModuleDeleted.Text");
}
else
{
if (ModulePermissionController.CanAdminModule(moduleInfo))
{
returnValue = string.Format(LocalizeString("ModuleInfo.Text"), moduleInfo.ModuleDefinition.FriendlyName, moduleInfo.ModuleTitle, moduleInfo.PaneName);
}
else
{
returnValue = LocalizeString("ModuleInfoForNonAdmins.Text");
}
}
}
}
return(returnValue);
}
public void cmdDeleteUserRole_click(object sender, ImageClickEventArgs e)
{
if ((!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)) && (PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName) == false))
{
return;
}
try
{
var cmdDeleteUserRole = (ImageButton)sender;
int roleId = Convert.ToInt32(cmdDeleteUserRole.Attributes["roleId"]);
int userId = Convert.ToInt32(cmdDeleteUserRole.Attributes["userId"]);
RoleInfo role = RoleController.Instance.GetRole(PortalId, r => r.RoleID == roleId);
if (!RoleController.DeleteUserRole(UserController.GetUserById(PortalId, userId), role, PortalSettings, chkNotify.Checked))
{
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("RoleRemoveError", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
}
BindGrid();
}
catch (Exception exc)
{
Exceptions.LogException(exc);
UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("RoleRemoveError", LocalResourceFile), ModuleMessage.ModuleMessageType.RedError);
}
}
private bool VerifyUserPermissions()
{
if (AddUser && IsHostMenu && !UserInfo.IsSuperUser)
{
AddModuleMessage("NoUser", ModuleMessage.ModuleMessageType.YellowWarning, true);
DisableForm();
return(false);
}
//Check if User is a member of the Current Portal (or a member of the MasterPortal if PortalGroups enabled)
if (User.PortalID != Null.NullInteger && User.PortalID != PortalId)
{
AddModuleMessage("InvalidUser", ModuleMessage.ModuleMessageType.YellowWarning, true);
DisableForm();
return(false);
}
//Check if User is a SuperUser and that the current User is a SuperUser
if (User.IsSuperUser && !UserInfo.IsSuperUser)
{
AddModuleMessage("NoUser", ModuleMessage.ModuleMessageType.YellowWarning, true);
DisableForm();
return(false);
}
if (IsEdit)
{
//Check if user has admin rights
if ((!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)) && (!IsAdmin || (User.IsInRole(PortalSettings.AdministratorRoleName) && !PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName))))
{
AddModuleMessage("NotAuthorized", ModuleMessage.ModuleMessageType.YellowWarning, true);
DisableForm();
return(false);
}
}
else
{
if (Request.IsAuthenticated)
{
if (!PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName))
{
if (HasManageUsersModulePermission() == false)
{
//Display current user's profile
Response.Redirect(Globals.NavigateURL(PortalSettings.UserTabId, "", "UserID=" + UserInfo.UserID), true);
}
}
}
else
{
if ((User.UserID > Null.NullInteger))
{
AddModuleMessage("NotAuthorized", ModuleMessage.ModuleMessageType.YellowWarning, true);
DisableForm();
return(false);
}
}
}
return(true);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdAdd_Click runs when the Update Button is clicked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 9/10/2004 Updated to reflect design changes for Help, 508 support
/// and localisation
/// </history>
/// -----------------------------------------------------------------------------
private void cmdAdd_Click(Object sender, EventArgs e)
{
if ((!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)) && (PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName) == false))
{
return;
}
try
{
if (Page.IsValid)
{
if ((Role != null) && (User != null))
{
//do not modify the portal Administrator account dates
if (User.UserID == PortalSettings.AdministratorId && Role.RoleID == PortalSettings.AdministratorRoleId)
{
effectiveDatePicker.SelectedDate = null;
expiryDatePicker.SelectedDate = null;
}
DateTime datEffectiveDate;
if (effectiveDatePicker.SelectedDate != null)
{
datEffectiveDate = effectiveDatePicker.SelectedDate.Value;
}
else
{
datEffectiveDate = Null.NullDate;
}
DateTime datExpiryDate;
if (expiryDatePicker.SelectedDate != null)
{
datExpiryDate = expiryDatePicker.SelectedDate.Value;
}
else
{
datExpiryDate = Null.NullDate;
}
//Add User to Role
var isOwner = false;
if (((Role.SecurityMode == SecurityMode.SocialGroup) || (Role.SecurityMode == SecurityMode.Both)))
{
isOwner = chkIsOwner.Checked;
}
RoleController.AddUserRole(User, Role, PortalSettings, RoleStatus.Approved, datEffectiveDate, datExpiryDate, chkNotify.Checked, isOwner);
chkIsOwner.Checked = false; //reset the checkbox
}
}
BindGrid();
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Raises the PasswordQuestionAnswerUpdated Event
/// </summary>
/// <history>
/// [cnurse] 03/09/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
public void OnPasswordQuestionAnswerUpdated(PasswordUpdatedEventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (PasswordQuestionAnswerUpdated != null)
{
PasswordQuestionAnswerUpdated(this, e);
}
}
private IList <ModuleInfo> GetModules(int tabID)
{
var isRemote = TabController.Instance.GetTab(tabID, Null.NullInteger, false).PortalID != PortalSettings.Current.PortalId;
var tabModules = ModuleController.Instance.GetTabModules(tabID);
var pageModules = isRemote
? tabModules.Values.Where(m => ModuleSupportsSharing(m)).ToList()
: tabModules.Values.Where(m => ModulePermissionController.CanAdminModule(m) && m.IsDeleted == false).ToList();
return(pageModules);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Raises the MembershipUnLocked Event
/// </summary>
/// <history>
/// [cnurse] 03/01/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
public void OnMembershipUnLocked(EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (MembershipUnLocked != null)
{
MembershipUnLocked(this, e);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Raises the MembershipPromoteToSuperuser Event
/// </summary>
/// -----------------------------------------------------------------------------
public void OnMembershipDemoteFromSuperuser(EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (MembershipDemoteFromSuperuser != null)
{
MembershipDemoteFromSuperuser(this, e);
Response.Redirect(Globals.NavigateURL(), true);
}
}
private void cmdReset_Click(object sender, EventArgs e)
{
if (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration) && IsUserOrAdmin == false)
{
return;
}
string answer = "";
if (MembershipProviderConfig.RequiresQuestionAndAnswer && !IsAdmin)
{
if (String.IsNullOrEmpty(txtAnswer.Text))
{
OnPasswordUpdated(new PasswordUpdatedEventArgs(PasswordUpdateStatus.InvalidPasswordAnswer));
return;
}
answer = txtAnswer.Text;
}
try
{
//create resettoken
UserController.ResetPasswordToken(User, Entities.Host.Host.AdminMembershipResetLinkValidity);
bool canSend = Mail.SendMail(User, MessageType.PasswordReminder, PortalSettings) == string.Empty;
var message = String.Empty;
var moduleMessageType = ModuleMessage.ModuleMessageType.GreenSuccess;
if (canSend)
{
message = Localization.GetString("PasswordSent", LocalResourceFile);
LogSuccess();
}
else
{
message = Localization.GetString("OptionUnavailable", LocalResourceFile);
moduleMessageType = ModuleMessage.ModuleMessageType.RedError;
LogFailure(message);
}
UI.Skins.Skin.AddModuleMessage(this, message, moduleMessageType);
}
catch (ArgumentException exc)
{
Logger.Error(exc);
OnPasswordUpdated(new PasswordUpdatedEventArgs(PasswordUpdateStatus.InvalidPasswordAnswer));
}
catch (Exception exc)
{
Logger.Error(exc);
OnPasswordUpdated(new PasswordUpdatedEventArgs(PasswordUpdateStatus.PasswordResetFailed));
}
}
private void ShowPanel()
{
if (AddUser)
{
adminTabNav.Visible = false;
if (Request.IsAuthenticated && MembershipProviderConfig.RequiresQuestionAndAnswer)
{
//Admin adding user
dnnManageUsers.Visible = false;
actionsRow.Visible = false;
AddModuleMessage("CannotAddUser", ModuleMessage.ModuleMessageType.YellowWarning, true);
}
else
{
dnnManageUsers.Visible = true;
actionsRow.Visible = true;
}
BindUser();
dnnProfileDetails.Visible = false;
}
else
{
if ((!IsAdmin) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
passwordTab.Visible = false;
}
else
{
ctlPassword.User = User;
ctlPassword.DataBind();
}
if ((!IsEdit || User.IsSuperUser))
{
rolesTab.Visible = false;
}
else
{
ctlRoles.DataBind();
}
BindUser();
ctlProfile.User = User;
ctlProfile.DataBind();
}
dnnRoleDetails.Visible = IsEdit && !User.IsSuperUser && !AddUser;
dnnPasswordDetails.Visible = IsEdit && !AddUser;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// MembershipUnAuthorized runs when the User has been unlocked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 3/01/2006 created
/// </history>
/// -----------------------------------------------------------------------------
private void MembershipUnAuthorized(object sender, EventArgs e)
{
if ((IsAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
try
{
AddModuleMessage("UserUnAuthorized", ModuleMessage.ModuleMessageType.GreenSuccess, true);
BindMembership();
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
private void cmdRemove_Click(Object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
var name = User.Username;
var id = UserId;
if (UserController.RemoveUser(User))
{
OnUserRemoved(new UserRemovedEventArgs(id, name));
}
else
{
OnUserRemoveError(new UserUpdateErrorArgs(id, name, "UserRemoveError"));
}
}
private bool HasManageUsersModulePermission()
{
bool ketqua = false;
if (ModulePermissionController.HasModulePermission(ModuleConfiguration.ModulePermissions, "MANAGEUSER"))
{
ketqua = true;
}
else
{
if (ModulePermissionController.CanAdminModule(this.ModuleConfiguration))
{
ketqua = true;
}
}
return(ketqua);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdDelete_Click runs when the delete Button is clicked
/// </summary>
/// <history>
/// [cnurse] 03/01/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private void cmdDelete_Click(Object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
string name = User.Username;
int id = UserId;
UserInfo user = User;
if (UserController.DeleteUser(ref user, true, false))
{
OnUserDeleted(new UserDeletedEventArgs(id, name));
}
else
{
OnUserDeleteError(new UserUpdateErrorArgs(id, name, "UserDeleteError"));
}
}
private void BindUser()
{
if (AddUser)
{
ctlUser.ShowUpdate = false;
CheckQuota();
}
ctlUser.User = User;
ctlUser.DataBind();
//Bind the Membership
if ((AddUser || (!IsAdmin && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))))
{
membershipRow.Visible = false;
}
else
{
BindMembership();
}
}
private void cboTabs_SelectedIndexChanged(object sender, EventArgs e)
{
var objModules = new ModuleController();
var arrModules = new ArrayList();
ModuleInfo objModule;
Dictionary <int, ModuleInfo> arrPortalModules = objModules.GetTabModules(int.Parse(cboTabs.SelectedItem.Value));
foreach (KeyValuePair <int, ModuleInfo> kvp in arrPortalModules)
{
objModule = kvp.Value;
if (ModulePermissionController.CanAdminModule(objModule) && objModule.IsDeleted == false)
{
arrModules.Add(objModule);
}
}
lblModule.Text = Localization.GetString("Tab", LocalResourceFile);
lblTitle.Text = Localization.GetString("Module", LocalResourceFile);
cboModules.DataSource = arrModules;
cboModules.DataBind();
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdUnAuthorize_Click runs when the UnAuthorize User Button is clicked
/// </summary>
/// <history>
/// [cnurse] 03/01/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private void cmdUnAuthorize_Click(object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (Request.IsAuthenticated != true)
{
return;
}
//Get the Membership Information from the property editors
User.Membership = (UserMembership)membershipForm.DataSource;
User.Membership.Approved = false;
//Update User
UserController.UpdateUser(PortalId, User);
OnMembershipUnAuthorized(EventArgs.Empty);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdUnlock_Click runs when the Unlock Account Button is clicked
/// </summary>
/// <history>
/// [cnurse] 03/01/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private void cmdUnLock_Click(Object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (Request.IsAuthenticated != true)
{
return;
}
//update the user record in the database
bool isUnLocked = UserController.UnLockUser(User);
if (isUnLocked)
{
User.Membership.LockedOut = false;
OnMembershipUnLocked(EventArgs.Empty);
}
}
public void SetModuleInfoHelp()
{
var returnValue = "";
var moduleInfo = ModuleController.Instance.GetModule(this.ModuleId, Null.NullInteger, true);
if (moduleInfo != null)
{
if (moduleInfo.IsDeleted)
{
returnValue = this.LocalizeString("ModuleDeleted.Text");
}
else
{
returnValue = ModulePermissionController.CanAdminModule(moduleInfo)
? string.Format(this.LocalizeString("ModuleInfo.Text"),
moduleInfo.ModuleDefinition.FriendlyName, moduleInfo.ModuleTitle, moduleInfo.PaneName)
: this.LocalizeString("ModuleInfoForNonAdmins.Text");
}
}
this.ModuleInfoHelp = returnValue;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdValidate_Click executes when a user selects the Validate link for a username
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// </history>
/// -----------------------------------------------------------------------------
private void cmdValidate_Click(object sender, EventArgs e)
{
if ((!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)) && (PortalSecurity.IsInRole(PortalSettings.AdministratorRoleName) == false))
{
return;
}
if (!String.IsNullOrEmpty(txtUsers.Text))
{
//validate username
UserInfo objUser = UserController.GetUserByName(PortalId, txtUsers.Text);
if (objUser != null)
{
GetDates(objUser.UserID, RoleId);
SelectedUserID = objUser.UserID;
}
else
{
txtUsers.Text = "";
}
}
BindGrid();
}
private static Dictionary <int, string> GetTabModules(int tabID)
{
var moduleCtrl = new ModuleController();
var pageModules = new List <ModuleInfo>();
var tabModules = moduleCtrl.GetTabModules(tabID);
foreach (ModuleInfo m in tabModules.Values)
{
if (ModulePermissionController.CanAdminModule(m) && m.IsDeleted == false)
{
pageModules.Add(m);
}
}
var modulesList = new Dictionary <int, string>();
foreach (var module in pageModules)
{
modulesList.Add(module.ModuleID, module.ModuleTitle);
}
return(modulesList);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// CreateUser creates a new user in the Database
/// </summary>
/// <history>
/// [cnurse] 05/18/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
public void CreateUser()
{
//Update DisplayName to conform to Format
UpdateDisplayName();
if ((IsRegister) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
User.Membership.Approved = PortalSettings.UserRegistration == (int)Globals.PortalRegistrationType.PublicRegistration;
}
else
{
//Set the Approved status from the value in the Authorized checkbox
User.Membership.Approved = chkAuthorize.Checked;
}
var user = User;
// make sure username is set in UseEmailAsUserName" mode
if (PortalController.GetPortalSettingAsBoolean("Registration_UseEmailAsUserName", PortalId, false))
{
user.Username = User.Email;
User.Username = User.Email;
}
var createStatus = UserController.CreateUser(ref user);
var args = (createStatus == UserCreateStatus.Success)
? new UserCreatedEventArgs(User)
{
Notify = chkNotify.Checked
}
: new UserCreatedEventArgs(null);
args.CreateStatus = createStatus;
OnUserCreated(args);
OnUserCreateCompleted(args);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// This routine creates the Installer
/// </summary>
/// <history>
/// [cnurse] 07/26/2007 Created
/// </history>
/// -----------------------------------------------------------------------------
private void CreateInstaller()
{
CheckSecurity();
_Installer = new Installer(TempInstallFolder, ManifestFile, Request.MapPath("."), false);
//The Installer is created automatically with a SecurityAccessLevel of Host
//Check if the User has lowere Security and update as neccessary
if (!ModuleContext.PortalSettings.UserInfo.IsSuperUser)
{
if (ModuleContext.PortalSettings.UserInfo.IsInRole(ModuleContext.PortalSettings.AdministratorRoleName))
{
//Admin User
Installer.InstallerInfo.SecurityAccessLevel = SecurityAccessLevel.Admin;
}
else if (ModulePermissionController.CanAdminModule(ModuleContext.Configuration))
{
//Has Edit rights
Installer.InstallerInfo.SecurityAccessLevel = SecurityAccessLevel.Edit;
}
else if (ModulePermissionController.CanViewModule(ModuleContext.Configuration))
{
//Has View rights
Installer.InstallerInfo.SecurityAccessLevel = SecurityAccessLevel.View;
}
else
{
Installer.InstallerInfo.SecurityAccessLevel = SecurityAccessLevel.Anonymous;
}
}
Installer.InstallerInfo.PortalID = InstallPortalId;
//Read the manifest
if (Installer.InstallerInfo.ManifestFile != null)
{
Installer.ReadManifest(true);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// PasswordUpdated runs when the Password has been updated or reset
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 3/08/2006 created
/// </history>
/// -----------------------------------------------------------------------------
private void PasswordUpdated(object sender, Password.PasswordUpdatedEventArgs e)
{
if ((IsAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
PasswordUpdateStatus status = e.UpdateStatus;
if (status == PasswordUpdateStatus.Success)
{
//Send Notification to User
try
{
var accessingUser = (UserInfo)HttpContext.Current.Items["UserInfo"];
if (accessingUser.UserID != User.UserID)
{
//The password was changed by someone else
Mail.SendMail(User, MessageType.PasswordUpdated, PortalSettings);
}
else
{
//The User changed his own password
Mail.SendMail(User, MessageType.UserUpdatedOwnPassword, PortalSettings);
}
AddModuleMessage("PasswordChanged", ModuleMessage.ModuleMessageType.GreenSuccess, true);
}
catch (Exception ex)
{
AddModuleMessage("PasswordMailError", ModuleMessage.ModuleMessageType.YellowWarning, true);
Exceptions.LogException(ex);
}
}
else
{
AddModuleMessage(status.ToString(), ModuleMessage.ModuleMessageType.RedError, true);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// cmdPassword_Click runs when the ChangePassword Button is clicked
/// </summary>
/// <history>
/// [cnurse] 03/15/2006 Created
/// </history>
/// -----------------------------------------------------------------------------
private void cmdPassword_Click(object sender, EventArgs e)
{
if ((IsUserOrAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
if (Request.IsAuthenticated != true)
{
return;
}
if (MembershipProviderConfig.PasswordRetrievalEnabled || MembershipProviderConfig.PasswordResetEnabled)
{
UserController.ResetPasswordToken(User);
}
bool canSend = Mail.SendMail(User, MessageType.PasswordReminder, PortalSettings) == string.Empty;
var message = String.Empty;
if (canSend)
{
//Get the Membership Information from the property editors
User.Membership = (UserMembership)membershipForm.DataSource;
User.Membership.UpdatePassword = true;
//Update User
UserController.UpdateUser(PortalId, User);
OnMembershipPasswordUpdateChanged(EventArgs.Empty);
}
else
{
message = Localization.GetString("OptionUnavailable", LocalResourceFile);
UI.Skins.Skin.AddModuleMessage(this, message, ModuleMessage.ModuleMessageType.YellowWarning);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// MembershipAuthorized runs when the User has been unlocked
/// </summary>
/// <remarks>
/// </remarks>
/// <history>
/// [cnurse] 3/01/2006 created
/// </history>
/// -----------------------------------------------------------------------------
private void MembershipAuthorized(object sender, EventArgs e)
{
if ((IsAdmin == false) && (!ModulePermissionController.CanAdminModule(this.ModuleConfiguration)))
{
return;
}
try
{
AddModuleMessage("UserAuthorized", ModuleMessage.ModuleMessageType.GreenSuccess, true);
//Send Notification to User
if (string.IsNullOrEmpty(User.Membership.Password) && !MembershipProviderConfig.RequiresQuestionAndAnswer && MembershipProviderConfig.PasswordRetrievalEnabled)
{
UserInfo user = User;
User.Membership.Password = UserController.GetPassword(ref user, "");
}
BindMembership();
}
catch (Exception exc) //Module failed to load
{
Exceptions.ProcessModuleLoadException(this, exc);
}
}
public void BindAll(int tabID)
{
TabID = tabID;
var currentTab = TabController.Instance.GetTab(tabID, PortalSettings.PortalId, false);
//Unique id of default language page
var uniqueId = currentTab.DefaultLanguageGuid != Null.NullGuid ? currentTab.DefaultLanguageGuid : currentTab.UniqueId;
// get all non admin pages and not deleted
var allPages = TabController.Instance.GetTabsByPortal(PortalSettings.PortalId).Values.Where(t => t.TabID != PortalSettings.AdminTabId && (Null.IsNull(t.ParentId) || t.ParentId != PortalSettings.AdminTabId));
allPages = allPages.Where(t => t.IsDeleted == false);
// get all localized pages of current page
var tabInfos = allPages as IList <TabInfo> ?? allPages.ToList();
var localizedPages = tabInfos.Where(t => t.DefaultLanguageGuid == uniqueId || t.UniqueId == uniqueId).OrderBy(t => t.DefaultLanguageGuid).ToList();
Dictionary <string, TabInfo> localizedTabs = null;
// we are going to build up a list of locales
// this is a bit more involved, since we want the default language to be first.
// also, we do not want to add any locales the user has no access to
var locales = new List <string>();
var localeController = new LocaleController();
var localeDict = localeController.GetLocales(PortalSettings.PortalId);
if (localeDict.Count > 0)
{
if (localizedPages.Count() == 1 && localizedPages.First().CultureCode == "")
{
// locale neutral page
locales.Add("");
}
else if (localizedPages.Count() == 1 && localizedPages.First().CultureCode != PortalSettings.DefaultLanguage)
{
locales.Add(localizedPages.First().CultureCode);
localizedTabs = new Dictionary <string, TabInfo>();
localizedTabs.Add(localizedPages.First().CultureCode, localizedPages.First());
}
else
{
//force sort order, so first add default language
locales.Add(PortalSettings.DefaultLanguage);
// build up a list of localized tabs.
// depending on whether or not the selected page is in the default langauge
// we will add the localized tabs from the current page
// or from the defaultlanguage page
if (currentTab.CultureCode == PortalSettings.DefaultLanguage)
{
localizedTabs = currentTab.LocalizedTabs;
}
else
{
// selected page is not in default language
// add localizedtabs from defaultlanguage page
if (currentTab.DefaultLanguageTab != null)
{
localizedTabs = currentTab.DefaultLanguageTab.LocalizedTabs;
}
}
if (localizedTabs != null)
{
// only add locales from tabs the user has at least view permissions to.
// we will handle the edit permissions at a later stage
locales.AddRange(from localizedTab in localizedTabs where TabPermissionController.CanViewPage(localizedTab.Value) select localizedTab.Value.CultureCode);
}
}
}
else
{
locales.Add("");
}
Data = new DnnPages(locales);
// filter the list of localized pages to only those that have a culture we want to see
var viewableLocalizedPages = localizedPages.Where(localizedPage => locales.Find(locale => locale == localizedPage.CultureCode) != null).ToList();
if (viewableLocalizedPages.Count() > 4)
{
mainContainer.Attributes.Add("class", "container RadGrid RadGrid_Default overflow");
}
foreach (var tabInfo in viewableLocalizedPages)
{
var localTabInfo = tabInfo;
var dnnPage = Data.Page(localTabInfo.CultureCode);
if (!TabPermissionController.CanViewPage(tabInfo))
{
Data.RemoveLocale(localTabInfo.CultureCode);
Data.Pages.Remove(dnnPage);
break;
}
dnnPage.TabID = localTabInfo.TabID;
dnnPage.TabName = localTabInfo.TabName;
dnnPage.Title = localTabInfo.Title;
dnnPage.Description = localTabInfo.Description;
dnnPage.Path = localTabInfo.TabPath.Substring(0, localTabInfo.TabPath.LastIndexOf("//", StringComparison.Ordinal)).Replace("//", "");
dnnPage.HasChildren = (TabController.Instance.GetTabsByPortal(PortalSettings.PortalId).WithParentId(tabInfo.TabID).Count != 0);
dnnPage.CanAdminPage = TabPermissionController.CanAdminPage(tabInfo);
dnnPage.CanViewPage = TabPermissionController.CanViewPage(tabInfo);
dnnPage.LocalResourceFile = LocalResourceFile;
// calculate position in the form of 1.3.2...
var SiblingTabs = tabInfos.Where(t => t.ParentId == localTabInfo.ParentId && t.CultureCode == localTabInfo.CultureCode || t.CultureCode == null).OrderBy(t => t.TabOrder).ToList();
dnnPage.Position = (SiblingTabs.IndexOf(localTabInfo) + 1).ToString(CultureInfo.InvariantCulture);
int ParentTabId = localTabInfo.ParentId;
while (ParentTabId > 0)
{
TabInfo ParentTab = tabInfos.Single(t => t.TabID == ParentTabId);
int id = ParentTabId;
SiblingTabs = tabInfos.Where(t => t.ParentId == id && t.CultureCode == localTabInfo.CultureCode || t.CultureCode == null).OrderBy(t => t.TabOrder).ToList();
dnnPage.Position = (SiblingTabs.IndexOf(localTabInfo) + 1).ToString(CultureInfo.InvariantCulture) + "." + dnnPage.Position;
ParentTabId = ParentTab.ParentId;
}
dnnPage.DefaultLanguageGuid = localTabInfo.DefaultLanguageGuid;
dnnPage.IsTranslated = localTabInfo.IsTranslated;
dnnPage.IsPublished = TabController.Instance.IsTabPublished(localTabInfo);
// generate modules information
foreach (var moduleInfo in ModuleController.Instance.GetTabModules(localTabInfo.TabID).Values)
{
var guid = moduleInfo.DefaultLanguageGuid == Null.NullGuid ? moduleInfo.UniqueId : moduleInfo.DefaultLanguageGuid;
var dnnModules = Data.Module(guid); // modules of each language
var dnnModule = dnnModules.Module(localTabInfo.CultureCode);
// detect error : 2 modules with same uniqueId on the same page
dnnModule.LocalResourceFile = LocalResourceFile;
if (dnnModule.TabModuleID > 0)
{
dnnModule.ErrorDuplicateModule = true;
ErrorExists = true;
continue;
}
dnnModule.ModuleTitle = moduleInfo.ModuleTitle;
dnnModule.DefaultLanguageGuid = moduleInfo.DefaultLanguageGuid;
dnnModule.TabId = localTabInfo.TabID;
dnnModule.TabModuleID = moduleInfo.TabModuleID;
dnnModule.ModuleID = moduleInfo.ModuleID;
dnnModule.CanAdminModule = ModulePermissionController.CanAdminModule(moduleInfo);
dnnModule.CanViewModule = ModulePermissionController.CanViewModule(moduleInfo);
dnnModule.IsDeleted = moduleInfo.IsDeleted;
if (moduleInfo.DefaultLanguageGuid != Null.NullGuid)
{
ModuleInfo defaultLanguageModule = ModuleController.Instance.GetModuleByUniqueID(moduleInfo.DefaultLanguageGuid);
if (defaultLanguageModule != null)
{
dnnModule.DefaultModuleID = defaultLanguageModule.ModuleID;
if (defaultLanguageModule.ParentTab.UniqueId != moduleInfo.ParentTab.DefaultLanguageGuid)
{
dnnModule.DefaultTabName = defaultLanguageModule.ParentTab.TabName;
}
}
}
dnnModule.IsTranslated = moduleInfo.IsTranslated;
dnnModule.IsLocalized = moduleInfo.IsLocalized;
dnnModule.IsShared = TabController.Instance.GetTabsByModuleID(moduleInfo.ModuleID).Values.Count(t => t.CultureCode == moduleInfo.CultureCode) > 1;
// detect error : the default language module is on an other page
dnnModule.ErrorDefaultOnOtherTab = moduleInfo.DefaultLanguageGuid != Null.NullGuid && moduleInfo.DefaultLanguageModule == null;
// detect error : different culture on tab and module
dnnModule.ErrorCultureOfModuleNotCultureOfTab = moduleInfo.CultureCode != localTabInfo.CultureCode;
ErrorExists = ErrorExists || dnnModule.ErrorDefaultOnOtherTab || dnnModule.ErrorCultureOfModuleNotCultureOfTab;
}
}
rDnnModules.DataSource = Data.Modules;
rDnnModules.DataBind();
}
