/// <summary> /// This should only run after the Post exists in the data store. /// </summary> /// <returns>The newly created ContentItemID from the data store.</returns> /// <remarks>This is for the first question in the thread. Not for replies or items with ParentID > 0.</remarks> internal ContentItem CreateContentItem(RoleInfo objItem, int tabId) { var typeController = new ContentTypeController(); string contentTypeName = "DNNCorp_SocialGroup"; if (objItem.RoleID > 0) { contentTypeName = "DNNCorp_SocialGroup"; } var colContentTypes = (from t in typeController.GetContentTypes() where t.ContentType == contentTypeName select t); int contentTypeID; if (colContentTypes.Count() > 0) { var contentType = colContentTypes.Single(); contentTypeID = contentType == null ? CreateContentType(contentTypeName) : contentType.ContentTypeId; } else { contentTypeID = CreateContentType(contentTypeName); } var objContent = new ContentItem { Content = objItem.RoleName, ContentTypeId = contentTypeID, Indexed = false, ContentKey = "GroupId=" + objItem.RoleID, ModuleID = -1, TabID = tabId }; objContent.ContentItemId = Util.GetContentController().AddContentItem(objContent); // Add Terms //var cntTerm = new Terms(); //cntTerm.ManageQuestionTerms(objPost, objContent); return objContent; }
internal virtual Notification AddGroupNotification(string notificationTypeName, int tabId, int moduleId, RoleInfo group, UserInfo initiatingUser, IList<RoleInfo> moderators, IList<UserInfo> recipients) { var notificationType = NotificationsController.Instance.GetNotificationType(notificationTypeName); var tokenReplace = new GroupItemTokenReplace(group); var subject = Localization.GetString(notificationTypeName + ".Subject", Constants.SharedResourcesPath); subject = tokenReplace.ReplaceGroupItemTokens(subject); var body = Localization.GetString(notificationTypeName + ".Body", Constants.SharedResourcesPath); body = tokenReplace.ReplaceGroupItemTokens(body); body = body.Replace("Public.Text", Localization.GetString("Public.Text", Constants.SharedResourcesPath)); body = body.Replace("Private.Text", Localization.GetString("Private.Text", Constants.SharedResourcesPath)); bool dismiss = notificationTypeName != Constants.GroupPendingNotification; var notification = new Notification { NotificationTypeID = notificationType.NotificationTypeId, Subject = subject, Body = body, IncludeDismissAction = dismiss, SenderUserID = initiatingUser.UserID, Context = String.Format("{0}:{1}:{2}", tabId, moduleId, group.RoleID) }; NotificationsController.Instance.SendNotification(notification, initiatingUser.PortalID, moderators, recipients); return notification; }
/// ----------------------------------------------------------------------------- /// <summary> /// CreateRole persists a Role to the Data Store /// </summary> /// <remarks> /// </remarks> /// <param name="role">The role to persist to the Data Store.</param> /// <returns>A Boolean indicating success or failure.</returns> /// ----------------------------------------------------------------------------- public override bool CreateRole(RoleInfo role) { try { role.RoleID = Convert.ToInt32(dataProvider.AddRole(role.PortalID, role.RoleGroupID, role.RoleName, role.Description, role.ServiceFee, role.BillingPeriod.ToString(CultureInfo.InvariantCulture), role.BillingFrequency, role.TrialFee, role.TrialPeriod, role.TrialFrequency, role.IsPublic, role.AutoAssignment, role.RSVPCode, role.IconFile, UserController.GetCurrentUserInfo().UserID, (int)role.Status, (int)role.SecurityMode, role.IsSystemRole)); } catch (SqlException e) { throw new ArgumentException(e.ToString()); } return true; }
public static void CreateJournalEntry(RoleInfo roleInfo, UserInfo createdBy) { var journalController = JournalController.Instance; var journalItem = new JournalItem(); string url = ""; if (roleInfo.Settings.ContainsKey("URL")) { url = roleInfo.Settings["URL"]; } journalItem.PortalId = roleInfo.PortalID; journalItem.ProfileId = createdBy.UserID; journalItem.UserId = createdBy.UserID; journalItem.Title = roleInfo.RoleName; journalItem.ItemData = new ItemData {Url = url}; journalItem.SocialGroupId = roleInfo.RoleID; journalItem.Summary = roleInfo.Description; journalItem.Body = null; journalItem.JournalTypeId = journalController.GetJournalType("groupcreate").JournalTypeId; journalItem.ObjectKey = string.Format("groupcreate:{0}:{1}", roleInfo.RoleID.ToString(CultureInfo.InvariantCulture), createdBy.UserID.ToString(CultureInfo.InvariantCulture)); if (journalController.GetJournalItemByKey(roleInfo.PortalID, journalItem.ObjectKey) != null) journalController.DeleteJournalItemByKey(roleInfo.PortalID, journalItem.ObjectKey); journalItem.SecuritySet = string.Empty; if (roleInfo.IsPublic) journalItem.SecuritySet += "E,"; journalController.SaveJournalItem(journalItem, -1); }
protected void ShowSettings() { //get the tracking ID if (ModuleSettings.ContainsKey("GoogleTrackingId")) txtAnalyticsTrackingId.Text = (string)ModuleSettings["GoogleTrackingId"]; if (ModuleSettings.ContainsKey("LocalHostAddress")) { txtLocalHostName.Text = (string)ModuleSettings["LocalHostAddress"]; } //populate the drop down box RoleController rc = new DotNetNuke.Security.Roles.RoleController(); ArrayList roles = rc.GetPortalRoles(this.PortalId); //put in a dummy role to allow no restriction on role RoleInfo dummyRole = new RoleInfo(); dummyRole.RoleID = -1; dummyRole.RoleName = "[Do Not Hide Tracking]"; roles.Insert(0, dummyRole); ddlSecurityGroups.DataSource = roles; ddlSecurityGroups.DataValueField = "RoleID"; ddlSecurityGroups.DataTextField = "RoleName"; ddlSecurityGroups.DataBind(); //get the security group if (ModuleSettings.ContainsKey("HideTrackingFromRole")) { foreach(ListItem item in ddlSecurityGroups.Items) { string value = (string)ModuleSettings["HideTrackingFromRole"]; if (item.Text == value) ddlSecurityGroups.SelectedValue = item.Value; } } }
public GroupViewParser(PortalSettings portalSettings, RoleInfo roleInfo, UserInfo currentUser, string template, int groupViewTabId) { PortalSettings = portalSettings; RoleInfo = roleInfo; CurrentUser = currentUser; Template = template; GroupViewTabId = groupViewTabId; }
public virtual bool CreateRole(RoleInfo role) { #pragma warning disable 612,618 return CreateRole(-1, ref role); #pragma warning restore 612,618 }
public virtual void DeleteRole(RoleInfo role) { #pragma warning disable 612,618 DeleteRole(-1, ref role); #pragma warning restore 612,618 }
public void GivenThereIsAPageCalled(string pageName, Table permissions) { var reset = false; var tabController = new TabController(); var tab = tabController.GetTabByName(pageName, PortalId); if (tab == null) { tab = new TabInfo { TabName = pageName, PortalID = 0 }; tab.TabID = tabController.AddTab(tab); foreach (var row in permissions.Rows) { var roleId = -1; var roleController = new RoleController(); if (row[0] == "All Users") { roleId = -1; } else { var role = roleController.GetRoleByName(PortalId, row[0]); if (role == null) { if (roleController.GetRoleByName(Null.NullInteger, row[0]) == null) { role = new RoleInfo { RoleName = row[0], RoleGroupID = Null.NullInteger }; roleId = roleController.AddRole(role); } } } var permissionController = new PermissionController(); var permission = permissionController.GetPermissionByCodeAndKey("SYSTEM_TAB", row[1]); var tabPermission = new TabPermissionInfo { PermissionID = 3, TabID = tab.TabID, AllowAccess = true, RoleID = roleId }; tab.TabPermissions.Add(tabPermission); } tabController.UpdateTab(tab); reset = true; } Page = tab; if (reset) { Config.Touch(); } }
/// <summary> /// This overload adds a role and optionally adds the info to the AspNet Roles /// </summary> /// <param name="objRoleInfo">The Role to Add</param> /// <returns>The Id of the new role</returns> public int AddRole(RoleInfo objRoleInfo) { int roleId = -1; bool success = provider.CreateRole(objRoleInfo.PortalID, ref objRoleInfo); if (success) { AutoAssignUsers(objRoleInfo); roleId = objRoleInfo.RoleID; } return roleId; }
/// <summary> /// Constructs a PermissionViewModel from a Permission (for role) object. /// </summary> /// <param name="permission">Permiso.</param> /// <param name="rol">Rol con el que se construye el permiso.</param> /// <param name="resourceGroupId">Grupo al que pertenece.</param> public PermissionViewModel(Permission permission, RoleInfo rol, Guid resourceGroupId) { PermissionId = permission?.PermissionId ?? 0; ResourceGroupId = resourceGroupId; RolId = rol.RoleID; RoleName = rol.RoleName; ReadPermission = permission != null && permission.ReadPermission; WritePermission = permission != null && permission.WritePermission; Cd = permission?.Cd ?? DateTime.Now; Cu = permission?.Cu ?? Common.CurrentUser.UserID; Md = permission?.Md ?? DateTime.Now; Mu = permission?.Mu ?? Common.CurrentUser.UserID; }
public ActionResult Index() { var moduleID = int.Parse(PortalController.GetPortalSetting("MyDnnLiveChatModuleID", PortalSettings.PortalId, "-1")); if (moduleID == -1) { moduleID = ActiveModule.ModuleID; PortalController.UpdatePortalSetting(PortalSettings.PortalId, "MyDnnLiveChatModuleID", moduleID.ToString(), true); var role = RoleController.Instance.GetRoleByName(PortalSettings.PortalId, "MyDnnSupportAgent"); if (role == null) { var objRoleInfo = new RoleInfo(); objRoleInfo.PortalID = PortalSettings.PortalId; objRoleInfo.Description = "mydnn live chat agent"; objRoleInfo.RoleName = "MyDnnSupportAgent"; objRoleInfo.IsPublic = false; objRoleInfo.Status = RoleStatus.Approved; objRoleInfo.RoleGroupID = Null.NullInteger; RoleController.Instance.AddRole(objRoleInfo); var listeners = VisitorsOnlineApi.Instance.GetListeners(PortalSettings.PortalId); if (listeners == null || !listeners.Any(l => l.RoleName == "MyDnnSupportAgent" && l.LoginState == VisitorsOnline.Components.Enums.LoginState.LoggedIn)) { VisitorsOnlineApi.Instance.AddListener(new ListenerInfo() { PortalID = PortalSettings.PortalId, RoleName = "MyDnnSupportAgent", LoginState = VisitorsOnline.Components.Enums.LoginState.LoggedIn, InvokeScript = "$('#mydnnLiveChatMinButton').find('[data-livechat-isonline]').hide();$('#mydnnLiveChatMinButton').find('[data-livechat-isonline=\"online\"]').show();", CreatedByModuleName = "MyDnnSupportLiveChat", CreatedOnDate = DateTime.Now }); } if (listeners == null || !listeners.Any(l => l.RoleName == "MyDnnSupportAgent" && l.LoginState == VisitorsOnline.Components.Enums.LoginState.LoggedOff)) { VisitorsOnlineApi.Instance.AddListener(new ListenerInfo() { PortalID = PortalSettings.PortalId, RoleName = "MyDnnSupportAgent", LoginState = VisitorsOnline.Components.Enums.LoginState.LoggedOff, InvokeScript = "$('#mydnnLiveChatMinButton').find('[data-livechat-isonline]').hide();$('#mydnnLiveChatMinButton').find('[data-livechat-isonline=\"offline\"]').show();", CreatedByModuleName = "MyDnnSupportLiveChat", CreatedOnDate = DateTime.Now }); } } } return View(); }
static public AP_StaffBroker_Staff CreateStaffMember(int PortalId, DotNetNuke.Entities.Users.UserInfo User1in, DotNetNuke.Entities.Users.UserInfo User2in, short staffTypeIn) { //Create Married Staff DotNetNuke.Security.Roles.RoleController rc = new DotNetNuke.Security.Roles.RoleController(); if (rc.GetRoleByName(PortalId, "Staff") == null) { DotNetNuke.Security.Roles.RoleInfo insert = new DotNetNuke.Security.Roles.RoleInfo(); insert.Description = "Staff Members"; insert.RoleName = "Staff"; insert.AutoAssignment = false; insert.IsPublic = false; insert.RoleGroupID = -1; insert.PortalID = PortalId; rc.AddRole(insert); } rc.AddUserRole(PortalId, User1in.UserID, rc.GetRoleByName(PortalId, "Staff").RoleID, DateTime.MaxValue); rc.AddUserRole(PortalId, User2in.UserID, rc.GetRoleByName(PortalId, "Staff").RoleID, DateTime.MaxValue); StaffBrokerDataContext d = new StaffBrokerDataContext(); var searchStaff = from c in d.AP_StaffBroker_Staffs where c.Active && (c.UserId1 == User1in.UserID || c.UserId2 == User1in.UserID || c.UserId1 == User2in.UserID || c.UserId2 == User2in.UserID) select c; if (searchStaff.Count() > 0) { return(searchStaff.First()); } AP_StaffBroker_Staff rtn = new AP_StaffBroker_Staff(); rtn.UserId1 = User1in.UserID; rtn.UserId2 = User2in.UserID; rtn.PortalId = PortalId; rtn.Active = true; rtn.DisplayName = User1in.FirstName + " & " + User2in.FirstName + " " + User1in.LastName; rtn.StaffTypeId = staffTypeIn; rtn.CostCenter = ""; d.AP_StaffBroker_Staffs.InsertOnSubmit(rtn); d.SubmitChanges(); return(rtn); }
public GroupInfo(RoleInfo roleInfo) { RoleID = roleInfo.RoleID; RoleName = roleInfo.RoleName; Description = roleInfo.Description; PortalID = roleInfo.PortalID; SecurityMode = roleInfo.SecurityMode; ServiceFee = roleInfo.ServiceFee; RSVPCode = roleInfo.RSVPCode; }
/// <summary> /// This is used to update the content in the ContentItems table. Should be called when a question is updated. /// </summary> internal void UpdateContentItem(RoleInfo objItem, int tabId) { ContentItem objContent = null; //Util.GetContentController().; if (objContent == null) return; objContent.Content = objItem.RoleName; objContent.TabID = tabId; objContent.ContentKey = "GroupId=" + objItem.RoleID; // we reset this just in case the page changed. Util.GetContentController().UpdateContentItem(objContent); // Update Terms //var cntTerm = new Terms(); //cntTerm.ManageQuestionTerms(objPost, objContent); }
/// <summary> /// Gets the Enabled status of the permission /// </summary> /// <param name="objPerm">The permission being loaded</param> /// <param name="role">The role</param> /// <param name="column">The column of the Grid</param> protected override bool GetEnabled( PermissionInfo objPerm, RoleInfo role, int column ) { bool enabled; if( role.RoleID == AdministratorRoleId ) { enabled = false; } else { enabled = true; } return enabled; }
protected void Page_Load(object sender, EventArgs e) { RoleInfo role = TestableRoleController.Instance.GetRole(PortalId, r => r.SecurityMode != SecurityMode.SecurityRole && r.RoleID == GroupId); if (role == null && GroupId > 0) { UI.Skins.Skin.AddModuleMessage(this, Localization.GetString("GroupIdNotFound", Constants.SharedResourcesPath), ModuleMessage.ModuleMessageType.YellowWarning); } if (role == null && (UserInfo.IsInRole(PortalSettings.AdministratorRoleName) || UserInfo.IsSuperUser)) { role = new RoleInfo(); role.RoleID = -1; role.RoleName = Localization.GetString("Sample_RoleName", LocalResourceFile); role.Description = Localization.GetString("Sample_RoleDescription", LocalResourceFile); } if (role == null) litOutput.Text = string.Empty; else { var resxPath = Constants.SharedResourcesPath; var template = GroupViewTemplate; template = template.Replace("{resx:posts}", Localization.GetString("posts", resxPath)); template = template.Replace("{resx:members}", Localization.GetString("members", resxPath)); template = template.Replace("{resx:photos}", Localization.GetString("photos", resxPath)); template = template.Replace("{resx:documents}", Localization.GetString("documents", resxPath)); template = template.Replace("{resx:Join}", Localization.GetString("Join", resxPath)); template = template.Replace("{resx:JoinGroup}", Localization.GetString("JoinGroup", resxPath)); template = template.Replace("{resx:Pending}", Localization.GetString("Pending", resxPath)); template = template.Replace("{resx:LeaveGroup}", Localization.GetString("LeaveGroup", resxPath)); template = template.Replace("{resx:EditGroup}", Localization.GetString("EditGroup", resxPath)); template = template.Replace("[GroupViewTabId]", GroupViewTabId.ToString()); var groupParser = new GroupViewParser(PortalSettings, role, UserInfo, template, TabId); groupParser.GroupEditUrl = GetEditUrl(); litOutput.Text = groupParser.ParseView(); } }
internal virtual Notification AddGroupOwnerNotification(string notificationTypeName, int tabId, int moduleId, RoleInfo group, UserInfo initiatingUser) { var notificationType = NotificationsController.Instance.GetNotificationType(notificationTypeName); var tokenReplace = new GroupItemTokenReplace(group); var subject = Localization.GetString(notificationTypeName + ".Subject", Constants.SharedResourcesPath); var body = Localization.GetString(notificationTypeName + ".Body", Constants.SharedResourcesPath); subject = subject.Replace("[DisplayName]", initiatingUser.DisplayName); subject = subject.Replace("[ProfileUrl]", Globals.UserProfileURL(initiatingUser.UserID)); subject = tokenReplace.ReplaceGroupItemTokens(subject); body = body.Replace("[DisplayName]", initiatingUser.DisplayName); body = body.Replace("[ProfileUrl]", Globals.UserProfileURL(initiatingUser.UserID)); body = tokenReplace.ReplaceGroupItemTokens(body); var roleCreator = UserController.GetUserById(group.PortalID, group.CreatedByUserID); var roleOwners = new List<UserInfo>(); foreach (UserInfo userInfo in RoleController.Instance.GetUsersByRole(group.PortalID, group.RoleName)) { var userRoleInfo = RoleController.Instance.GetUserRole(group.PortalID, userInfo.UserID, group.RoleID); if (userRoleInfo.IsOwner && userRoleInfo.UserID != group.CreatedByUserID) { roleOwners.Add(UserController.GetUserById(group.PortalID, userRoleInfo.UserID)); } } roleOwners.Add(roleCreator); //Need to add from sender details var notification = new Notification { NotificationTypeID = notificationType.NotificationTypeId, Subject = subject, Body = body, IncludeDismissAction = true, SenderUserID = initiatingUser.UserID, Context = String.Format("{0}:{1}:{2}:{3}", tabId, moduleId, group.RoleID, initiatingUser.UserID) }; NotificationsController.Instance.SendNotification(notification, initiatingUser.PortalID, null, roleOwners); return notification; }
public void MustHaveServiceWithFee() { var roleName = "Paid Subscription"; var role = TestableRoleController.Instance.GetRole(0, r => r.RoleName == roleName); if (role == null) { var subscription = new RoleInfo { PortalID = 0, RoleGroupID = Null.NullInteger, RoleName = roleName, Description = "Test Paid Subscription", ServiceFee = 0.01F, BillingPeriod = 1, BillingFrequency = "Y", IsPublic = true, Status = RoleStatus.Approved, SecurityMode= SecurityMode.SecurityRole }; TestableRoleController.Instance.AddRole(subscription); } }
private RoleInfo FillRoleInfo(IDataReader dr, bool CheckForOpenDataReader) { RoleInfo objRoleInfo = null; // read datareader bool canContinue = true; if (CheckForOpenDataReader) { canContinue = false; if (dr.Read()) { canContinue = true; } } if (canContinue) { objRoleInfo = new RoleInfo(); objRoleInfo.RoleID = Convert.ToInt32(Null.SetNull(dr["RoleId"], objRoleInfo.RoleID)); objRoleInfo.PortalID = Convert.ToInt32(Null.SetNull(dr["PortalID"], objRoleInfo.PortalID)); objRoleInfo.RoleGroupID = Convert.ToInt32(Null.SetNull(dr["RoleGroupId"], objRoleInfo.RoleGroupID)); objRoleInfo.RoleName = Convert.ToString(Null.SetNull(dr["RoleName"], objRoleInfo.RoleName)); objRoleInfo.Description = Convert.ToString(Null.SetNull(dr["Description"], objRoleInfo.Description)); objRoleInfo.ServiceFee = Convert.ToSingle(Null.SetNull(dr["ServiceFee"], objRoleInfo.ServiceFee)); objRoleInfo.BillingPeriod = Convert.ToInt32(Null.SetNull(dr["BillingPeriod"], objRoleInfo.BillingPeriod)); objRoleInfo.BillingFrequency = Convert.ToString(Null.SetNull(dr["BillingFrequency"], objRoleInfo.BillingFrequency)); objRoleInfo.TrialFee = Convert.ToSingle(Null.SetNull(dr["TrialFee"], objRoleInfo.TrialFee)); objRoleInfo.TrialPeriod = Convert.ToInt32(Null.SetNull(dr["TrialPeriod"], objRoleInfo.TrialPeriod)); objRoleInfo.TrialFrequency = Convert.ToString(Null.SetNull(dr["TrialFrequency"], objRoleInfo.TrialFrequency)); objRoleInfo.IsPublic = Convert.ToBoolean(Null.SetNull(dr["IsPublic"], objRoleInfo.IsPublic)); objRoleInfo.AutoAssignment = Convert.ToBoolean(Null.SetNull(dr["AutoAssignment"], objRoleInfo.AutoAssignment)); objRoleInfo.RSVPCode = Convert.ToString(Null.SetNull(dr["RSVPCode"], objRoleInfo.RSVPCode)); objRoleInfo.IconFile = Convert.ToString(Null.SetNull(dr["IconFile"], objRoleInfo.IconFile)); } return objRoleInfo; }
public virtual void DeleteRole(int portalId, ref RoleInfo role) { DeleteRole(role); }
/// ----------------------------------------------------------------------------- /// <summary> /// Gets the Value of the permission /// </summary> /// <param name="objPerm">The permission being loaded</param> /// <param name="role">The role</param> /// <param name="column">The column of the Grid</param> /// <param name="defaultState">Default State.</param> /// <returns>A Boolean (True or False)</returns> /// ----------------------------------------------------------------------------- protected override string GetPermission(PermissionInfo objPerm, RoleInfo role, int column, string defaultState) { string permission; if (InheritViewPermissionsFromTab && column == _ViewColumnIndex) { permission = PermissionTypeNull; } else { permission = role.RoleID == AdministratorRoleId ? PermissionTypeGrant : base.GetPermission(objPerm, role, column, defaultState); } return permission; }
/// ----------------------------------------------------------------------------- /// <summary> /// Update a role /// </summary> /// <param name="role">The role to update</param> /// ----------------------------------------------------------------------------- public override void UpdateRole(RoleInfo role) { dataProvider.UpdateRole(role.RoleID, role.RoleGroupID, role.RoleName, role.Description, role.ServiceFee, role.BillingPeriod.ToString(CultureInfo.InvariantCulture), role.BillingFrequency, role.TrialFee, role.TrialPeriod, role.TrialFrequency, role.IsPublic, role.AutoAssignment, role.RSVPCode, role.IconFile, UserController.GetCurrentUserInfo().UserID, (int)role.Status, (int)role.SecurityMode, role.IsSystemRole); }
/// ----------------------------------------------------------------------------- /// <summary> /// Update the role settings for a role /// </summary> /// <param name="role">The role to update</param> /// ----------------------------------------------------------------------------- public override void UpdateRoleSettings(RoleInfo role) { var currentSettings = GetRoleSettings(role.RoleID); foreach (var setting in role.Settings) { if (!currentSettings.ContainsKey(setting.Key) || currentSettings[setting.Key] != setting.Value) { dataProvider.UpdateRoleSetting(role.RoleID, setting.Key, setting.Value, UserController.GetCurrentUserInfo().UserID); } } }
public HttpResponseMessage JoinGroup(RoleDTO postData) { try { if (UserInfo.UserID >= 0 && postData.RoleId > 0) { var roleController = new RoleController(); _roleInfo = roleController.GetRole(postData.RoleId, PortalSettings.PortalId); if (_roleInfo != null) { var requireApproval = false; if(_roleInfo.Settings.ContainsKey("ReviewMembers")) requireApproval = Convert.ToBoolean(_roleInfo.Settings["ReviewMembers"]); if ((_roleInfo.IsPublic || UserInfo.IsInRole(PortalSettings.AdministratorRoleName)) && !requireApproval) { roleController.AddUserRole(PortalSettings.PortalId, UserInfo.UserID, _roleInfo.RoleID, Null.NullDate); roleController.UpdateRole(_roleInfo); var url = Globals.NavigateURL(postData.GroupViewTabId, "", new[] { "groupid=" + _roleInfo.RoleID }); return Request.CreateResponse(HttpStatusCode.OK, new { Result = "success", URL = url }); } if (_roleInfo.IsPublic && requireApproval) { roleController.AddUserRole(PortalSettings.PortalId, UserInfo.UserID, _roleInfo.RoleID, RoleStatus.Pending, false, Null.NullDate, Null.NullDate); var notifications = new Notifications(); notifications.AddGroupOwnerNotification(Constants.MemberPendingNotification, _tabId, _moduleId, _roleInfo, UserInfo); return Request.CreateResponse(HttpStatusCode.OK, new { Result = "success", URL = string.Empty }); } } } } catch (Exception exc) { Logger.Error(exc); return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc); } return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unknown Error"); }
public virtual bool CreateRole(int portalId, ref RoleInfo role) { return(CreateRole(role)); }
void IRoleController.UpdateRole(RoleInfo role) { UpdateRole(role, true); }
/// ----------------------------------------------------------------------------- /// <summary> /// Gets the Enabled status of the permission /// </summary> /// <param name="objPerm">The permission being loaded</param> /// <param name="role">The role</param> /// <param name="column">The column of the Grid</param> /// <history> /// [cnurse] 01/13/2006 Created /// </history> /// ----------------------------------------------------------------------------- protected override bool GetEnabled(PermissionInfo objPerm, RoleInfo role, int column) { bool enabled; if (InheritViewPermissionsFromTab && column == _ViewColumnIndex) { enabled = false; } else { if (role.RoleID == AdministratorRoleId) { enabled = false; } else { enabled = true; } } return enabled; }
private void ParseKey(string key) { _tabId = -1; _moduleId = -1; _roleId = -1; _memberId = -1; _roleInfo = null; if (!String.IsNullOrEmpty(key)) { string[] keys = key.Split(':'); _tabId = Convert.ToInt32(keys[0]); _moduleId = Convert.ToInt32(keys[1]); _roleId = Convert.ToInt32(keys[2]); if (keys.Length > 3) { _memberId = Convert.ToInt32(keys[3]); } } if (_roleId > 0) { var roleController = new RoleController(); _roleInfo = roleController.GetRole(_roleId, PortalSettings.PortalId); } }
public static void AddUserRole(UserInfo user, RoleInfo role, PortalSettings portalSettings, DateTime effectiveDate, DateTime expiryDate, int userId, bool notifyUser) { AddUserRole(user, role, portalSettings, RoleStatus.Approved, effectiveDate, expiryDate, notifyUser, false); }
public virtual void DeleteRole(RoleInfo role) { throw new NotImplementedException(); }
public abstract void UpdateRole(RoleInfo role);
public void UpdateUserRole(int portalId, int userId, int roleId, RoleStatus status, bool isOwner, bool cancel) { UserInfo user = UserController.GetUserById(portalId, userId); UserRoleInfo userRole = GetUserRole(portalId, userId, roleId); if (cancel) { if (userRole != null && userRole.ServiceFee > 0.0 && userRole.IsTrialUsed) { //Expire Role so we retain trial used data userRole.ExpiryDate = DateTime.Now.AddDays(-1); userRole.Status = status; userRole.IsOwner = isOwner; provider.UpdateUserRole(userRole); EventLogController.Instance.AddLog(userRole, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.USER_ROLE_UPDATED); } else { //Delete Role DeleteUserRoleInternal(portalId, userId, roleId); EventLogController.Instance.AddLog("UserId", userId.ToString(CultureInfo.InvariantCulture), PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, EventLogController.EventLogType.USER_ROLE_DELETED); } } else { int UserRoleId = -1; DateTime ExpiryDate = DateTime.Now; DateTime EffectiveDate = Null.NullDate; bool IsTrialUsed = false; int Period = 0; string Frequency = ""; if (userRole != null) { UserRoleId = userRole.UserRoleID; EffectiveDate = userRole.EffectiveDate; ExpiryDate = userRole.ExpiryDate; IsTrialUsed = userRole.IsTrialUsed; } RoleInfo role = Instance.GetRole(portalId, r => r.RoleID == roleId); if (role != null) { if (IsTrialUsed == false && role.TrialFrequency != "N") { Period = role.TrialPeriod; Frequency = role.TrialFrequency; } else { Period = role.BillingPeriod; Frequency = role.BillingFrequency; } } if (EffectiveDate < DateTime.Now) { EffectiveDate = Null.NullDate; } if (ExpiryDate < DateTime.Now) { ExpiryDate = DateTime.Now; } if (Period == Null.NullInteger) { ExpiryDate = Null.NullDate; } else { switch (Frequency) { case "N": ExpiryDate = Null.NullDate; break; case "O": ExpiryDate = new DateTime(9999, 12, 31); break; case "D": ExpiryDate = ExpiryDate.AddDays(Period); break; case "W": ExpiryDate = ExpiryDate.AddDays(Period * 7); break; case "M": ExpiryDate = ExpiryDate.AddMonths(Period); break; case "Y": ExpiryDate = ExpiryDate.AddYears(Period); break; } } if (UserRoleId != -1 && userRole != null) { userRole.ExpiryDate = ExpiryDate; userRole.Status = status; userRole.IsOwner = isOwner; provider.UpdateUserRole(userRole); EventLogController.Instance.AddLog(userRole, PortalController.Instance.GetCurrentPortalSettings(), UserController.Instance.GetCurrentUserInfo().UserID, "", EventLogController.EventLogType.USER_ROLE_UPDATED); } else { AddUserRole(portalId, userId, roleId, status, isOwner, EffectiveDate, ExpiryDate); } } //Remove the UserInfo from the Cache, as it has been modified DataCache.ClearUserCache(portalId, user.Username); Instance.ClearRoleCache(portalId); }
public void UpdateRole(RoleInfo role) { Instance.UpdateRole(role); }
public int AddRole(RoleInfo role) { return(Instance.AddRole(role, true)); }
public static void AddTranslatorRole(int portalID, Locale language) { //Create new Translator Role string roleName = string.Format("Translator ({0})", language.Code); RoleInfo role = RoleController.Instance.GetRole(portalID, r => r.RoleName == roleName); if (role == null) { role = new RoleInfo(); role.RoleGroupID = Null.NullInteger; role.PortalID = portalID; role.RoleName = roleName; role.Description = string.Format("A role for {0} translators", language.EnglishName); role.SecurityMode = SecurityMode.SecurityRole; role.Status = RoleStatus.Approved; RoleController.Instance.AddRole(role); } string roles = string.Format("Administrators;{0}", string.Format("Translator ({0})", language.Code)); PortalController.UpdatePortalSetting(portalID, string.Format("DefaultTranslatorRoles-{0}", language.Code), roles); }
public void MessagingController_CreateMessage_Marks_Message_As_Dispatched_For_Sender_When_Not_Already_A_Recipient() { //Arrange var message = new Message { Subject = "subject", Body = "body" }; var user = new UserInfo { DisplayName = "user1", UserID = Constants.USER_TenId }; var role = new RoleInfo { RoleName = "role1" }; _mockDataService.Setup(md => md.GetMessageRecipientByMessageAndUser(It.IsAny<int>(), Constants.USER_TenId)) .Callback(SetupDataTables) .Returns(_dtMessageRecipients.CreateDataReader()); _mockDataService.Setup(md => md.GetMessageRecipientByMessageAndUser(It.IsAny<int>(), _adminUserInfo.UserID)) .Callback(SetupDataTables) .Returns(_dtMessageRecipients.CreateDataReader()); _mockMessagingController.Setup(mc => mc.IsAdminOrHost(_adminUserInfo)).Returns(true); InternalMessagingController.SetTestableInstance(_mockInternalMessagingController.Object); _mockInternalMessagingController.Setup(ims => ims.GetMessageRecipient(It.IsAny<int>(), It.IsAny<int>())).Returns((MessageRecipient)null); _mockDataService.Setup(ds => ds.SaveMessageRecipient(It.Is<MessageRecipient>(mr => mr.UserID == _adminUserInfo.UserID), It.IsAny<int>())).Returns(Constants.Messaging_RecipientId_1); //Act _mockMessagingController.Object.SendMessage(message, new List<RoleInfo> { role }, new List<UserInfo> { user }, null, _adminUserInfo); //Assert _mockInternalMessagingController.Verify(imc => imc.MarkMessageAsDispatched(It.IsAny<int>(), Constants.Messaging_RecipientId_1)); }
/// ----------------------------------------------------------------------------- /// <summary> /// Gets the Value of the permission /// </summary> /// <param name="objPerm">The permission being loaded</param> /// <param name="role">The role</param> /// <param name="column">The column of the Grid</param> /// <param name="defaultState">Default State.</param> /// <returns>A Boolean (True or False)</returns> /// <history> /// [cnurse] 01/09/2006 Created /// </history> /// ----------------------------------------------------------------------------- protected override string GetPermission(PermissionInfo objPerm, RoleInfo role, int column, string defaultState) { string permission; if (InheritViewPermissionsFromTab && column == _ViewColumnIndex) { permission = PermissionTypeNull; } else { if (role.RoleID == AdministratorRoleId) { permission = PermissionTypeGrant; } else { //Call base class method to handle standard permissions permission = base.GetPermission(objPerm, role, column, defaultState); } } return permission; }
/// ----------------------------------------------------------------------------- /// <summary> /// DeleteRole deletes a Role from the Data Store /// </summary> /// <param name="role">The role to delete from the Data Store.</param> /// ----------------------------------------------------------------------------- public override void DeleteRole(RoleInfo role) { dataProvider.DeleteRole(role.RoleID); }
public HttpResponseMessage LeaveGroup(RoleDTO postData) { var success = false; try { if (UserInfo.UserID >= 0 && postData.RoleId > 0) { var roleController = new RoleController(); _roleInfo = roleController.GetRole(postData.RoleId, PortalSettings.PortalId); if (_roleInfo != null) { if (UserInfo.IsInRole(_roleInfo.RoleName)) { RoleController.DeleteUserRole(UserInfo, _roleInfo, PortalSettings, false); } success = true; } } } catch (Exception exc) { Logger.Error(exc); return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, exc); } if(success) { return Request.CreateResponse(HttpStatusCode.OK, new {Result = "success"}); } return Request.CreateErrorResponse(HttpStatusCode.InternalServerError, "Unknown Error"); }
public virtual void UpdateRoleSettings(RoleInfo role) { }
public virtual bool CreateRole(RoleInfo role) { throw new NotImplementedException(); }