public virtual void Rename(long id)
{
target(UpdateName, id);
SiteRole role = roleService.GetById(id);
set("r.Name", role.Name);
}
public async Task <IList <ISiteRole> > GetRolesBySite(
int siteId,
string searchInput,
int pageNumber,
int pageSize,
CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
IList <ISiteRole> roles = new List <ISiteRole>();
using (DbDataReader reader = await dbRoles.GetPage(
siteId,
searchInput,
pageNumber,
pageSize,
cancellationToken))
{
while (reader.Read())
{
SiteRole role = new SiteRole();
role.LoadFromReader(reader);
role.MemberCount = Convert.ToInt32(reader["MemberCount"]);
roles.Add(role);
}
}
return(roles);
}
/// <summary>
/// Update existing Role
/// </summary>
/// <param name="role"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <IdentityResult> UpdateAsync(SiteRole role, CancellationToken cancellationToken)
{
try
{
using (var conn = new SqlConnection(_config.GetConnectionString("DefaultConnection")))
{
await conn.OpenAsync(cancellationToken);
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = conn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "identity_UpdateRole";
cmd.Parameters.AddWithValue("@Id", role.Id);
cmd.Parameters.AddWithValue("@Name", role.Name);
cmd.Parameters.AddWithValue("@NormalizedName", role.NormalizedName);
cmd.Parameters.AddWithValue("@Description", role.Description ?? "");
await cmd.ExecuteNonQueryAsync(cancellationToken);
return(IdentityResult.Success);
}
}
}
catch (Exception ex)
{
return(IdentityResult.Failed(new IdentityError {
Code = ex.HResult.ToString(), Description = ex.Message
}));
}
}
public void Create(SiteRole role)
{
role.Id = role.Name.Replace(" ", "");
role.NormalizedName = role.Name.ToUpper();
_dbContext.SiteRoles.Add(role);
_dbContext.SaveChanges();
}
public async Task UpdateRole(
ISiteRole role,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (role == null)
{
throw new ArgumentException("role cannot be null");
}
if (role.SiteId == Guid.Empty)
{
throw new ArgumentException("SiteId must be provided");
}
if (role.Id == Guid.Empty)
{
throw new ArgumentException("Id must be provided");
}
//await EnsureProjectId().ConfigureAwait(false);
var projectId = role.SiteId.ToString();
var siteRole = SiteRole.FromISiteRole(role);
await roleCommands.UpdateAsync(
projectId,
siteRole.Id.ToString(),
siteRole,
cancellationToken).ConfigureAwait(false);
}
public async Task <IList <ISiteRole> > GetRolesBySite(
int siteId,
string searchInput,
int pageNumber,
int pageSize)
{
if (multiTenantOptions.UseRelatedSitesMode)
{
siteId = multiTenantOptions.RelatedSiteId;
}
IList <ISiteRole> roles = new List <ISiteRole>();
using (DbDataReader reader = dbRoles.GetPage(siteId, searchInput, pageNumber, pageSize))
{
while (reader.Read())
{
SiteRole role = new SiteRole();
role.LoadFromReader(reader);
role.MemberCount = Convert.ToInt32(reader["MemberCount"]);
roles.Add(role);
}
}
return(roles);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,SiteRoleName")] SiteRole siteRole)
{
if (id != siteRole.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(siteRole);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SiteRoleExists(siteRole.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(siteRole));
}
/// <summary>
/// Persists a new instance of Role. Returns true on success.
/// when a role is created displayname corresponds to rolename
/// but rolename can never change since it is used in a cookies and coded
/// into security checks in some cases
/// so subsequent changes to rolename really only effect displayname
/// ie for localization or customization
/// to really change a rolename you can delete the role and create a new one with the desired name
/// some specific required system roles (Admin, Content Administrators)
/// are also not allowed to be deleted
/// </summary>
/// <returns></returns>
public async Task CreateRole(
ISiteRole role,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (role == null)
{
throw new ArgumentException("role cannot be null");
}
if (role.SiteId == Guid.Empty)
{
throw new ArgumentException("SiteId must be provided");
}
if (role.Id == Guid.Empty)
{
throw new ArgumentException("Id must be provided");
}
var siteRole = SiteRole.FromISiteRole(role);
if (siteRole.NormalizedRoleName.Length == 0)
{
siteRole.NormalizedRoleName = siteRole.RoleName;
}
dbContext.Roles.Add(siteRole);
int rowsAffected = await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
}
public async Task UpdateRole(
ISiteRole role,
CancellationToken cancellationToken = default(CancellationToken))
{
ThrowIfDisposed();
cancellationToken.ThrowIfCancellationRequested();
if (role == null)
{
throw new ArgumentException("role cannot be null");
}
if (role.SiteId == Guid.Empty)
{
throw new ArgumentException("SiteId must be provided");
}
if (role.Id == Guid.Empty)
{
throw new ArgumentException("Id must be provided");
}
var siteRole = SiteRole.FromISiteRole(role);
bool tracking = dbContext.ChangeTracker.Entries <SiteRole>().Any(x => x.Entity.Id == siteRole.Id);
if (!tracking)
{
dbContext.Roles.Update(siteRole);
}
int rowsAffected = await dbContext.SaveChangesAsync(cancellationToken)
.ConfigureAwait(false);
}
public async Task <bool> EnsureRequiredRoles(ISiteSettings site)
{
bool result = true;
bool exists = await userRepo.RoleExists(site.SiteId, "Admins", CancellationToken);
if (!exists)
{
SiteRole adminRole = new SiteRole();
adminRole.DisplayName = "Admins";
//adminRole.DisplayName = "Administrators";
adminRole.SiteId = site.SiteId;
adminRole.SiteGuid = site.SiteGuid;
result = await userRepo.SaveRole(adminRole, CancellationToken.None);
adminRole.DisplayName = "Administrators";
result = await userRepo.SaveRole(adminRole, CancellationToken.None);
}
exists = await userRepo.RoleExists(site.SiteId, "Role Admins", CancellationToken);
if (!exists)
{
SiteRole roleAdminRole = new SiteRole();
roleAdminRole.DisplayName = "Role Admins";
roleAdminRole.SiteId = site.SiteId;
roleAdminRole.SiteGuid = site.SiteGuid;
result = await userRepo.SaveRole(roleAdminRole, CancellationToken.None);
roleAdminRole.DisplayName = "Role Administrators";
result = await userRepo.SaveRole(roleAdminRole, CancellationToken.None);
}
exists = await userRepo.RoleExists(site.SiteId, "Content Administrators", CancellationToken);
if (!exists)
{
SiteRole contentAdminRole = new SiteRole();
contentAdminRole.DisplayName = "Content Administrators";
contentAdminRole.SiteId = site.SiteId;
contentAdminRole.SiteGuid = site.SiteGuid;
result = await userRepo.SaveRole(contentAdminRole, CancellationToken.None);
}
exists = await userRepo.RoleExists(site.SiteId, "Authenticated Users", CancellationToken);
if (!exists)
{
SiteRole authenticatedUserRole = new SiteRole();
authenticatedUserRole.DisplayName = "Authenticated Users";
authenticatedUserRole.SiteId = site.SiteId;
authenticatedUserRole.SiteGuid = site.SiteGuid;
result = await userRepo.SaveRole(authenticatedUserRole, CancellationToken.None);
}
return(result);
}
public ActionResult DeleteConfirmed(int id)
{
SiteRole siteRole = db.SiteRoles.Find(id);
db.SiteRoles.Remove(siteRole);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public IList GetRoles()
{
if (_rolesAll != null)
{
return(_rolesAll);
}
IList roles = new SiteRole().findAll();
return(roles);
}
public ActionResult Edit([Bind(Include = "SiteRoleId,SiteRoleName")] SiteRole siteRole)
{
if (ModelState.IsValid)
{
db.Entry(siteRole).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(siteRole));
}
public async Task <IActionResult> Create([Bind("Id,SiteRoleName")] SiteRole siteRole)
{
if (ModelState.IsValid)
{
_context.Add(siteRole);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(siteRole));
}
public ActionResult Create([Bind(Include = "SiteRoleId,SiteRoleName")] SiteRole siteRole)
{
if (ModelState.IsValid)
{
db.SiteRoles.Add(siteRole);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(siteRole));
}
public async Task <ISiteRole> FetchRole(
Guid roleId,
CancellationToken cancellationToken = default(CancellationToken))
{
SiteRole item
= await dbContext.Roles.SingleOrDefaultAsync(
x => x.Id == roleId
, cancellationToken)
.ConfigureAwait(false);
return(item);
}
public async Task <ISiteRole> FetchRole(
Guid siteId,
string roleName,
CancellationToken cancellationToken = default(CancellationToken))
{
SiteRole item
= await dbContext.Roles.SingleOrDefaultAsync(
x => x.SiteId == siteId && (x.RoleName == roleName || x.NormalizedRoleName == roleName)
, cancellationToken)
.ConfigureAwait(false);
return(item);
}
private Boolean shouldApprove(IUser objUser)
{
User user = (User)objUser;
if (SiteRole.IsInAdminGroup(user.RoleId))
{
return(false);
}
ContentSubmitter s = ContentSubmitter.find("User.Id=" + user.Id + " and AppId=" + ctx.app.Id).first();
return(s == null);
}
public async Task <ISiteRole> FetchRole(int roleId)
{
using (DbDataReader reader = dbRoles.GetById(roleId))
{
if (reader.Read())
{
SiteRole role = new SiteRole();
role.LoadFromReader(reader);
return(role);
}
}
return(null);
}
// GET: SiteRoles/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
SiteRole siteRole = db.SiteRoles.Find(id);
if (siteRole == null)
{
return(HttpNotFound());
}
return(View(siteRole));
}
public async Task <IActionResult> RoleEdit(RoleViewModel model, int returnPageNumber = 1)
{
ISiteContext selectedSite;
// only server admin site can edit other sites settings
if ((model.SiteId != Guid.Empty) && (model.SiteId != siteManager.CurrentSite.Id) && (siteManager.CurrentSite.IsServerAdminSite))
{
selectedSite = await siteManager.Fetch(model.SiteId) as ISiteContext;
ViewData["Title"] = string.Format(CultureInfo.CurrentUICulture, sr["{0} - Edit Role"], selectedSite.SiteName);
}
else
{
selectedSite = siteManager.CurrentSite;
ViewData["Title"] = sr["Edit Role"];
}
if (!ModelState.IsValid)
{
return(View(model));
}
string successFormat;
var role = SiteRole.FromISiteRole(model);
if (model.Id == Guid.Empty)
{
var exists = await RoleManager.RoleExistsAsync(model.RoleName);
if (exists)
{
ModelState.AddModelError("roleerror", sr["The role name is already in use."]);
return(View(model));
}
role.SiteId = selectedSite.Id;
successFormat = sr["The role <b>{0}</b> was successfully created."];
await RoleManager.CreateAsync(role);
}
else
{
successFormat = sr["The role <b>{0}</b> was successfully updated."];
await RoleManager.UpdateAsync(role);
}
this.AlertSuccess(string.Format(successFormat, role.RoleName), true);
return(RedirectToAction("Index", new { siteId = selectedSite.Id, pageNumber = returnPageNumber }));
}
//public int GetRoleMemberCount(int roleId)
//{
// // TODO: implement actual select count from db
// // this is works but is not ideal
// int count = 0;
// using (DbDataReader reader = dbRoles.GetRoleMembers(roleId))
// {
// while (reader.Read())
// {
// count += 1;
// }
// }
// return count;
//}
public async Task <ISiteRole> FetchRole(int roleId, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
using (DbDataReader reader = await dbRoles.GetById(roleId))
{
if (reader.Read())
{
SiteRole role = new SiteRole();
role.LoadFromReader(reader);
return(role);
}
}
return(null);
}
private void bindRoleLine(IBlock block, SiteRole role, String lbl)
{
block.Set(lbl + ".Name", role.Name);
block.Set(lbl + ".RenameLink", to(Rename, role.Id));
String deleteLink = "";
if (role.Id != SiteRole.Administrator.Id && role.Id != SiteRole.NormalMember.Id && role.Id != SiteRole.Guest.Id)
{
deleteLink = string.Format(" <span href='{0}' class='deleteCmd'>" + lang("delete") + "</span>", to(Delete, role.Id));
}
block.Set(lbl + ".DeleteLink", deleteLink);
block.Next();
}
public async Task <ISiteRole> FetchRole(int siteId, string roleName)
{
SiteRole role = null;
using (DbDataReader reader = await dbRoles.GetByName(siteId, roleName))
{
while (reader.Read())
{
role = new SiteRole();
role.LoadFromReader(reader);
}
}
return(role);
}
public void CheckLogin()
{
if (SiteRole.IsInAdminGroup(ctx.viewer.obj.RoleId) == false)
{
echoRedirect(lang("exNoPermission"));
return;
}
if (config.Instance.Site.LoginNeedImgValidation)
{
if (Html.Captcha.CheckError(ctx))
{
run(Login);
return;
}
}
String name = ctx.Post("Name");
String pwd = ctx.Post("Password1");
if (ctx.viewer.obj.Name.Equals(name) == false || userService.IsNamePwdCorrect(name, pwd) == null)
{
errors.Add(lang("exUserNamePwdError"));
}
if (ctx.HasErrors)
{
logService.Add((User)ctx.viewer.obj, SiteLogString.LoginError(), ctx.Ip, SiteLogCategory.Login);
run(Login);
return;
}
AdminSecurityUtils.SetSession(ctx);
logService.Add((User)ctx.viewer.obj, SiteLogString.LoginOk(), ctx.Ip, SiteLogCategory.Login);
String returnUrl = ctx.Post("returnUrl");
returnUrl = returnUrl.Replace("&", "&");
if (strUtil.IsNullOrEmpty(returnUrl))
{
//redirectUrl( t2( new DashboardController().Index ) );
redirectUrl(t2(Welcome));
}
else
{
redirectUrl(returnUrl);
}
}
public async Task <ISiteRole> FetchRole(int siteId, string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
SiteRole role = null;
using (DbDataReader reader = await dbRoles.GetByName(siteId, roleName))
{
if (reader.Read())
{
role = new SiteRole();
role.LoadFromReader(reader);
}
}
return(role);
}
public virtual void UpdateName(long id)
{
SiteRole role = roleService.GetById(id);
String target = ctx.Post("Name");
if (strUtil.IsNullOrEmpty(target))
{
errors.Add(lang("exName"));
run(Rename, id);
return;
}
role.Name = target;
roleService.UpdateSiteRole(role);
log(SiteLogString.UpdateSiteRoleName(), role);
echoToParentPart(lang("opok"));
}
private String getLoginJsonString()
{
User user = ctx.viewer.obj as User;
Boolean isViewerOwnerSame = (ctx.owner.Id == ctx.viewer.Id && ctx.owner.obj.GetType() == ctx.viewer.obj.GetType());
Boolean isAlertActivation = config.Instance.Site.EnableEmail && config.Instance.Site.AlertActivation;
Dictionary <String, object> dic = new Dictionary <string, object>();
Dictionary <String, object> viewer = new Dictionary <string, object>();
viewer.Add("Id", user.Id);
viewer.Add("IsLogin", ctx.viewer.IsLogin);
viewer.Add("IsAdministrator", ctx.viewer.IsAdministrator());
viewer.Add("IsInAdminGroup", SiteRole.IsInAdminGroup(ctx.viewer.obj.RoleId));
viewer.Add("HasPic", user.HasUploadPic());
viewer.Add("EmailConfirm", user.IsEmailConfirmed == 1);
viewer.Add("IsAlertActivation", isAlertActivation);
viewer.Add("IsAlertUserPic", config.Instance.Site.AlertUserPic);
Dictionary <String, object> objViewer = new Dictionary <string, object>();
objViewer.Add("Id", user.Id);
objViewer.Add("Name", user.Name);
objViewer.Add("FriendlyUrl", user.Url);
objViewer.Add("Url", Link.ToMember(user));
objViewer.Add("PicMedium", user.PicMedium);
viewer.Add("obj", objViewer);
dic.Add("viewer", viewer);
dic.Add("viewerOwnerSame", isViewerOwnerSame);
Dictionary <String, object> owner = new Dictionary <string, object>();
owner.Add("IsSite", ctx.owner.obj.GetType() == typeof(Site));
owner.Add("Id", ctx.owner.Id);
dic.Add("owner", owner);
dic.Add("navInfo", loginNavInfo());
dic.Add("online", getOnlineDic());
return(JsonString.Convert(dic));
}
public IList <ISiteRole> GetRolesUserIsNotIn(
int siteId,
int userId)
{
if (multiTenantOptions.UseRelatedSitesMode)
{
siteId = multiTenantOptions.RelatedSiteId;
}
IList <ISiteRole> roles = new List <ISiteRole>();
using (DbDataReader reader = dbRoles.GetRolesUserIsNotIn(siteId, userId))
{
SiteRole role = new SiteRole();
role.LoadFromReader(reader);
roles.Add(role);
}
return(roles);
}
public async Task <ISiteRole> FetchRole(int siteId, string roleName)
{
if (multiTenantOptions.UseRelatedSitesMode)
{
siteId = multiTenantOptions.RelatedSiteId;
}
SiteRole role = null;
using (DbDataReader reader = dbRoles.GetByName(siteId, roleName))
{
if (reader.Read())
{
role = new SiteRole();
role.LoadFromReader(reader);
}
}
return(role);
}
/// <summary>
/// Create a new SiteRole object.
/// </summary>
/// <param name="roleID">Initial value of RoleID.</param>
/// <param name="roleName">Initial value of RoleName.</param>
/// <param name="roleRefName">Initial value of RoleRefName.</param>
public static SiteRole CreateSiteRole(int roleID, string roleName, string roleRefName)
{
SiteRole siteRole = new SiteRole();
siteRole.RoleID = roleID;
siteRole.RoleName = roleName;
siteRole.RoleRefName = roleRefName;
return siteRole;
}
/// <summary>
/// There are no comments for SiteRole in the schema.
/// </summary>
public void AddToSiteRole(SiteRole siteRole)
{
base.AddObject("SiteRole", siteRole);
}
