public async Task <IActionResult> Edit(int id, [Bind("id,JobRoles")] RolesTable rolesTable)
{
if (id != rolesTable.id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(rolesTable);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RolesTableExists(rolesTable.id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(rolesTable));
}
public override async Task <IdentityResult> DeleteAsync(IdentityRole <TKey> role, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
role.ThrowIfNull(nameof(role));
return(await RolesTable.DeleteAsync(role));
}
public RoleStore(IdentityErrorDescriber describer,
RolesTable <TKey> rolesTable,
RoleClaimsTable <TKey> roleClaimsTable
) : base(describer)
{
RolesTable = rolesTable;
RoleClaimsTable = roleClaimsTable;
}
public UserStore(IUsersContext context)
{
_usersTable = new UsersTable(context);
_usersRolesTable = new UserRolesTable(context);
_rolesTable = new RolesTable(context);
_usersClaimsTable = new UserClaimsTable(context);
_usersLoginsTable = new UserLoginsTable(context);
_userTokensTable = new UserTokensTable(context);
}
public UserStore(IDatabaseConnectionFactory databaseConnectionFactory)
{
_usersTable = new UsersTable(databaseConnectionFactory);
_usersRolesTable = new UserRolesTable(databaseConnectionFactory);
_rolesTable = new RolesTable(databaseConnectionFactory);
_usersClaimsTable = new UserClaimsTable(databaseConnectionFactory);
_usersLoginsTable = new UserLoginsTable(databaseConnectionFactory);
_userTokensTable = new UserTokensTable(databaseConnectionFactory);
}
public UserStore(IDatabaseConnectionService databaseConnection)
{
SqlConnection sqlConnection = databaseConnection.CreateConnection();
_usersTable = new UsersTable(sqlConnection);
_usersRolesTable = new UsersRolesTable(sqlConnection);
_rolesTable = new RolesTable(sqlConnection);
_usersClaimsTable = new UsersClaimsTable(sqlConnection);
_usersLoginsTable = new UsersLoginsTable(sqlConnection);
}
public override async Task <IdentityRole <TKey> > FindByNameAsync(string normalizedName, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
if (string.IsNullOrEmpty(normalizedName))
{
throw new ArgumentException($"Parameter {nameof(normalizedName)} cannot be null or empty.");
}
return(await RolesTable.FindByNameAsync(normalizedName));
}
public async Task <IActionResult> Create([Bind("id,JobRoles")] RolesTable rolesTable)
{
if (ModelState.IsValid)
{
_context.Add(rolesTable);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(rolesTable));
}
public override async Task <IdentityResult> CreateAsync(IdentityRole <TKey> role, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
role.ThrowIfNull(nameof(role));
var created = await RolesTable.CreateAsync(role);
return(created ? IdentityResult.Success : IdentityResult.Failed(new IdentityError {
Description = $"Role '{role.Name}' could not be created."
}));
}
public override async Task <IdentityResult> UpdateAsync(IdentityRole <TKey> role, CancellationToken cancellationToken = default)
{
cancellationToken.ThrowIfCancellationRequested();
ThrowIfDisposed();
role.ThrowIfNull(nameof(role));
role.ConcurrencyStamp = Guid.NewGuid().ToString();
var updated = await RolesTable.UpdateAsync(role, RoleClaims);
return(updated ? IdentityResult.Success : IdentityResult.Failed(
new IdentityError {
Description = $"Role '{role.Name}' could not be updated."
}
));
}
public UserStore(
UsersTable <TKey> usersTable,
UserClaimsTable <TKey> userClaimsTable,
UserRolesTable <TKey> userRolesTable,
UserLoginsTable <TKey> userLoginsTable,
UserTokensTable <TKey> userTokensTable,
RolesTable <TKey> rolesTable,
IdentityErrorDescriber describer
) : base(describer)
{
UsersTable = usersTable ?? throw new ArgumentException(nameof(usersTable));
UserClaimsTable = userClaimsTable ?? throw new ArgumentException(nameof(userClaimsTable));
UserRolesTable = userRolesTable ?? throw new ArgumentException(nameof(userRolesTable));
UserLoginsTable = userLoginsTable ?? throw new ArgumentException(nameof(userLoginsTable));
UserTokensTable = userTokensTable ?? throw new ArgumentException(nameof(userTokensTable));
RolesTable = rolesTable ?? throw new ArgumentException(nameof(rolesTable));
}
private void AddRole(long id, string name, string[] permissions)
{
if (id >= UserDatabase.START_FOR_NEXT_IDS)
{
throw new InvalidOperationException("START_FOR_NEXT_IDS too low!");
}
var now = SystemClock.Instance.UtcNow();
RolesTable.Add(new DbRole {
Id = id,
Rolename = name,
CreatedAt = now
});
foreach (string permission in permissions)
{
PermissionRolesTable.Add(new DbPermissionRole {
RoleId = id,
Permission = permission
});
}
}
public IEnumerable <UserRoleIndexViewModel> GetUserRoleListForIndex(string id)
{
return(from Ur in db.UserRole
join R in db.Roles on Ur.RoleId equals R.Id into RolesTable from RolesTab in RolesTable.DefaultIfEmpty()
where Ur.UserId == id
select new UserRoleIndexViewModel
{
UserRoleId = Ur.UserRoleId,
RoleId = RolesTab.Id,
RoleName = RolesTab.Name,
SiteName = Ur.Site.SiteName,
DivisionName = Ur.Division.DivisionName
});
}
public RoleStore(IDatabaseConnectionService databaseConnection)
{
_rolesTable = new RolesTable(databaseConnection.CreateConnection());
}
public RoleStore(IUsersContext context)
{
_rolesTable = new RolesTable(context);
_roleClaimsTable = new RoleClaimsTable(context);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="databaseConnectionFactory"></param>
public RoleStore(IDatabaseConnectionFactory databaseConnectionFactory)
{
_rolesTable = new RolesTable(databaseConnectionFactory);
_roleClaimsTable = new RoleClaimsTable(databaseConnectionFactory);
}
