/// <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();
}
/// -----------------------------------------------------------------------------
/// <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);
}
