mirror of
https://github.com/hanzoai/jube-fork.git
synced 2026-10-30 18:33:33 +00:00
richard-churchman
7e4850a4e7
* Added role‑based data isolation across all entities related to Case Workflows and Visualisation. * Introduced a common UI JavaScript widget for assigning roles to supported entities; updated existing JS components and generic CRUD logic to integrate the new widget. * Added role‑permission tables and corresponding migrations, POCOs, repositories, controllers, DTOs, and validations for all in‑scope entities. * Updated all end‑user queries to include joins through role allocations, enforcing data isolation for both Case Management and Visualisation. * Included role allocations in preservation/backup logic to ensure they can be exported and restored correctly. * Added documentation describing the isolation model and validation behaviour for Case Management and Visualisation. * Renamed various architectural methods where ActiveOnly semantics now also imply role‑allocation filtering. * Improved “no data found” handling on the case page to avoid appearing as though data is still loading. * Updated the case query compilation routine to enforce role‑based isolation. * Forced session cache invalidation via migrations to rebuild SQL with new filtering rules.
229 lines
8.8 KiB
C#
229 lines
8.8 KiB
C#
/* Copyright (C) 2022-present Jube Holdings Limited.
|
|
*
|
|
* This file is part of Jube™ software.
|
|
*
|
|
* Jube™ is free software: you can redistribute it and/or modify it under the terms of the GNU Affero General Public License
|
|
* as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
|
|
* Jube™ is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
|
|
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more details.
|
|
|
|
* You should have received a copy of the GNU Affero General Public License along with Jube™. If not,
|
|
* see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
namespace Jube.Data.Repository
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using AutoMapper;
|
|
using Context;
|
|
using LinqToDB;
|
|
using Poco;
|
|
|
|
public class UserRegistryRepository
|
|
{
|
|
private readonly DbContext dbContext;
|
|
private readonly int? tenantRegistryId;
|
|
private readonly string userName;
|
|
|
|
public UserRegistryRepository(DbContext dbContext, string userName)
|
|
{
|
|
this.dbContext = dbContext;
|
|
this.userName = userName;
|
|
tenantRegistryId = this.dbContext.UserInTenant.Where(w => w.User == this.userName)
|
|
.Select(s => s.TenantRegistryId).FirstOrDefault();
|
|
}
|
|
|
|
public UserRegistryRepository(DbContext dbContext)
|
|
{
|
|
this.dbContext = dbContext;
|
|
}
|
|
|
|
public UserRegistryRepository(DbContext dbContext, RoleRegistry roleRegistry)
|
|
{
|
|
this.dbContext = dbContext;
|
|
tenantRegistryId = roleRegistry.TenantRegistryId;
|
|
}
|
|
|
|
public Task<UserRegistry> GetByNameAsync(string name, CancellationToken token = default)
|
|
{
|
|
return dbContext.UserRegistry
|
|
.FirstOrDefaultAsync(f =>
|
|
f.RoleRegistry.TenantRegistryId == tenantRegistryId
|
|
&& (f.Deleted == 0 || f.Deleted == null)
|
|
&& f.Name.ToLower() == name.ToLower(), token);
|
|
}
|
|
|
|
public async Task<IEnumerable<UserRegistry>> GetAsync(CancellationToken token = default)
|
|
{
|
|
return await dbContext.UserRegistry
|
|
.Where(w => w.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
.ToListAsync(token);
|
|
}
|
|
|
|
public async Task<IEnumerable<UserRegistry>> GetByRoleRegistryIdAsync(int roleRegistryId, CancellationToken token = default)
|
|
{
|
|
return await dbContext.UserRegistry
|
|
.Where(w => (w.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& w.RoleRegistryId == roleRegistryId && (w.Deleted == 0 || w.Deleted == null))
|
|
.ToListAsync(token);
|
|
}
|
|
|
|
public Task<UserRegistry> GetByIdAsync(int id, CancellationToken token = default)
|
|
{
|
|
return dbContext.UserRegistry.FirstOrDefaultAsync(w =>
|
|
(w.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& w.Id == id && (w.Deleted == 0 || w.Deleted == null), token);
|
|
}
|
|
|
|
public Task<UserRegistry> GetByUserNameAsync(string userNameInTenant, CancellationToken token = default)
|
|
{
|
|
return dbContext.UserRegistry.FirstOrDefaultAsync(w =>
|
|
(w.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& w.Name == userNameInTenant && (w.Deleted == 0 || w.Deleted == null), token);
|
|
}
|
|
|
|
public async Task<UserRegistry> InsertAsync(UserRegistry model, CancellationToken token = default)
|
|
{
|
|
if (!tenantRegistryId.HasValue)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
|
|
model.CreatedUser = userName;
|
|
model.Version = 1;
|
|
model.CreatedDate = DateTime.Now;
|
|
model.Guid = model.Guid == Guid.Empty ? Guid.NewGuid() : model.Guid;
|
|
model.Id = await dbContext.InsertWithInt32IdentityAsync(model, token: token);
|
|
|
|
var userInTenant = new UserInTenant
|
|
{
|
|
User = model.Name,
|
|
TenantRegistryId = tenantRegistryId.Value,
|
|
SwitchedUser = userName,
|
|
SwitchedDate = DateTime.Now
|
|
};
|
|
|
|
await dbContext.InsertAsync(userInTenant, token: token);
|
|
|
|
return model;
|
|
}
|
|
|
|
public async Task<UserRegistry> UpdateAsync(UserRegistry model, CancellationToken token = default)
|
|
{
|
|
var existing = dbContext.UserRegistry
|
|
.FirstOrDefault(w => w.Id
|
|
== model.Id
|
|
&& (w.Deleted == 0 || w.Deleted == null));
|
|
|
|
if (existing == null)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
|
|
model.Version = existing.Version + 1;
|
|
model.Guid = existing.Guid;
|
|
model.CreatedUser = userName;
|
|
model.CreatedDate = DateTime.Now;
|
|
|
|
await dbContext.UpdateAsync(model, token: token);
|
|
|
|
var mapper = new Mapper(new MapperConfiguration(cfg => { cfg.CreateMap<UserRegistry, UserRegistryVersion>(); }));
|
|
|
|
var audit = mapper.Map<UserRegistryVersion>(existing);
|
|
audit.UserRegistryId = existing.Id;
|
|
|
|
await dbContext.InsertAsync(audit, token: token);
|
|
|
|
return model;
|
|
}
|
|
|
|
public async Task ResetFailedPasswordCountAsync(int id, CancellationToken token = default)
|
|
{
|
|
var records = await dbContext.UserRegistry
|
|
.Where(d => (d.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& d.Id == id
|
|
&& (d.Deleted == 0 || d.Deleted == null))
|
|
.Set(s => s.FailedPasswordCount, 0)
|
|
.UpdateAsync(token);
|
|
|
|
if (records == 0)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
}
|
|
|
|
public async Task SetPasswordAsync(int id, string password, DateTime expiryDate, CancellationToken token = default)
|
|
{
|
|
var records = await dbContext.UserRegistry
|
|
.Where(d => (d.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& d.Id == id
|
|
&& (d.Deleted == 0 || d.Deleted == null))
|
|
.Set(s => s.Password, password)
|
|
.Set(s => s.PasswordLocked, (byte)0)
|
|
.Set(s => s.FailedPasswordCount, 0)
|
|
.Set(s => s.PasswordExpiryDate, expiryDate)
|
|
.Set(s => s.PasswordCreatedDate, DateTime.Now)
|
|
.UpdateAsync(token);
|
|
|
|
if (records == 0)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
}
|
|
|
|
public async Task SetLockedAsync(int id, CancellationToken token = default)
|
|
{
|
|
var records = await dbContext.UserRegistry
|
|
.Where(d => (d.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& d.Id == id
|
|
&& (d.Deleted == 0 || d.Deleted == null))
|
|
.Set(s => s.PasswordLocked, (byte)1)
|
|
.Set(s => s.PasswordLockedDate, DateTime.Now)
|
|
.UpdateAsync(token);
|
|
|
|
if (records == 0)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
}
|
|
|
|
public Task IncrementFailedPasswordAsync(int id, CancellationToken token = default)
|
|
{
|
|
var existing = dbContext.UserRegistry
|
|
.FirstOrDefault(w => w.Id
|
|
== id
|
|
&& (w.Deleted == 0 || w.Deleted == null));
|
|
|
|
if (existing == null)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
|
|
existing.FailedPasswordCount += 1;
|
|
|
|
return dbContext.UpdateAsync(existing, token: token);
|
|
}
|
|
|
|
public async Task DeleteAsync(int id, CancellationToken token = default)
|
|
{
|
|
var records = await dbContext.UserRegistry
|
|
.Where(d => (d.RoleRegistry.TenantRegistryId == tenantRegistryId || !tenantRegistryId.HasValue)
|
|
&& d.Id == id
|
|
&& (d.Deleted == 0 || d.Deleted == null))
|
|
.Set(s => s.Deleted, Convert.ToByte(1))
|
|
.Set(s => s.DeletedDate, DateTime.Now)
|
|
.Set(s => s.DeletedUser, userName)
|
|
.UpdateAsync(token);
|
|
|
|
if (records == 0)
|
|
{
|
|
throw new KeyNotFoundException();
|
|
}
|
|
}
|
|
}
|
|
}
|