Geschäftsbenutzer erstellen
Im Gegensatz zum authentifizierten Benutzer IdentityUser des Identitätsverwaltungsmoduls (Identity-Modul) ist der Geschäftsbenutzer (BusinessUser) ein Domänenmodell, das sich auf die Definition von „Benutzer“ im Geschäftssystem konzentriert. Beispiel: In einem Krankenhaussystem können Geschäftsbenutzer Ärzte, Krankenschwestern und Patienten sein; in einem OA-System können Geschäftsbenutzer Mitarbeiter, Administratoren, Kunden usw. sein.
Geschäftsbenutzer und Authentifizierungsbenutzer werden durch einen Synchronisierungsmechanismus verknüpft, und Geschäftsbenutzer werden über den Synchronizer verteilter Ereignisse (DistributedEvent) mit Authentifizierungsbenutzern verknüpft und synchronisiert.
Im Geschäftsmodul „Gesundheit“ sind zwei Arten von Geschäftsbenutzern definiert:
Kunde: Kunde;
Mitarbeiter: Mitarbeiter.
Diese Geschäftsbenutzer erben von HealthUser, der Basisklasse der Geschäftsbenutzer, die grundlegende Informationen von Geschäftsbenutzern wie Name, Geschlecht, Geburtsdatum, ID-Nummer usw. enthält. Und die IUpdateUserData-Schnittstelle muss implementiert werden, um die Basisinformationen des Geschäftsbenutzers zu aktualisieren, wenn die Authentifizierungsbenutzerinformationen synchronisiert werden.
„Mitarbeiter“ enthält Informationen wie Mitarbeiternummer, Berufsbezeichnung, Profil usw. Sein Domänenmodell ist wie folgt definiert:
public class Employee : HealthUser<Guid>, IUser, IUpdateUserData
{
[StringLength(12)]
public string EmployeeNumber { get; set; }
[StringLength(64)]
public string EmployeeTitle { get; set; }
public string Introduction { get; set; }
...
}
Der Kunde enthält Kundennummer, Größe, Gewicht, Familienstand und andere Informationen. Sein Domänenmodell ist wie folgt definiert:
public class Client : HealthUser<Guid>, IUser, IUpdateUserData
{
//unique
[StringLength(12)]
public string ClientNumber { get; set; }
public string ClientNumberType { get; set; }
[Range(0.0, 250.0)]
public double? Height { get; set; }
[Range(0.0, 1000.0)]
public double? Weight { get; set; }
public string Marriage { get; set; }
public string Status { get; set; }
}
Erstellen Sie einen Geschäftsbenutzer-Synchronizer
Am Beispiel von Client ist ClientLookupService ein Abfragedienst für Geschäftsbenutzer. Seine Basisklasse UserLookupService definiert eine Abfrageschnittstelle für zugeordnete Benutzer, einschließlich Abfragen nach ID, Abfragen nach Benutzernamen, Abfragen nach Organisationsstruktur, Abfragen nach Haushaltsbeziehungen usw.
Erstellen Sie ClientLookupService. Der Code lautet wie folgt
public class ClientLookupService : UserLookupService<Client, IClientRepository>, IClientLookupService
{
public ClientLookupService(
IClientRepository userRepository,
IUnitOfWorkManager unitOfWorkManager)
: base(
userRepository,
unitOfWorkManager)
{
}
protected override Client CreateUser(IUserData externalUser)
{
return new Client(externalUser);
}
}
Der Synchronizer abonniert das verteilte Ereignis EntityUpdatedEto. Wenn der authentifizierte Benutzer aktualisiert wird, aktualisiert der Synchronizer die Basisinformationen des Geschäftsbenutzers.
Erstellen Sie ClientSynchronizer. Der Code lautet wie folgt
public class ClientSynchronizer :
IDistributedEventHandler<EntityUpdatedEto<UserEto>>,
ITransientDependency
{
protected IClientRepository UserRepository { get; }
protected IClientLookupService UserLookupService { get; }
public ClientSynchronizer(
IClientRepository userRepository,
IClientLookupService userLookupService)
{
UserRepository = userRepository;
UserLookupService = userLookupService;
}
public async Task HandleEventAsync(EntityUpdatedEto<UserEto> eventData)
{
var user = await UserRepository.FindAsync(eventData.Entity.Id);
if (user != null)
{
if (user.Update(eventData.Entity))
{
await UserRepository.UpdateAsync(user);
}
}
}
}
Erstellen Sie Anwendungsdienste für Geschäftsbenutzer
Nehmen Sie den Mitarbeiter als Beispiel
Erstellen Sie EmployeeAppService in der Anwendungsschicht, wo wir Hinzufügungs-, Lösch-, Änderungs- und Abfragevorgänge für Geschäftsbenutzer implementieren.
EmployeeAppService erbt von CrudAppService, der Basisklasse zum Hinzufügen, Löschen, Ändern und Überprüfen, die vom ABP-Framework bereitgestellt wird. Seine Basisklasse definiert die Schnittstelle zum Hinzufügen, Löschen, Ändern und Überprüfen, einschließlich GetAsync, GetListAsync, CreateAsync, UpdateAsync, DeleteAsync, usw.
OrganizationUnit bietet eine Abfragebasis für die Abfrageschnittstelle von Geschäftsbenutzern zur Abfrage nach Organisationsstruktur. OrganizationUnitAppService wird in EmployeeAppService eingefügt.
public class EmployeeAppService : CrudAppService<Employee, EmployeeDto, Guid, GetAllEmployeeInput, CreateEmployeeInput>, IEmployeeAppService
{
private readonly IOrganizationUnitAppService organizationUnitAppService;
}
Zunahme
Erstellen Sie die Methode „CreateWithUserAsync“ zum Erstellen von Geschäftsbenutzern.
public async Task<EmployeeDto> CreateWithUserAsync(CreateEmployeeWithUserInput input)
{
var createdUser = await identityUserAppService.CreateAsync(input);
await CurrentUnitOfWork.SaveChangesAsync();
var currentEmployee = await userLookupService.FindByIdAsync(createdUser.Id);
ObjectMapper.Map(input, currentEmployee);
var updatedEmployee = await Repository.UpdateAsync(currentEmployee);
var result = ObjectMapper.Map<Employee, EmployeeDto>(updatedEmployee);
if (input.OrganizationUnitId.HasValue)
{
await organizationUnitAppService.AddToOrganizationUnitAsync(
new UserToOrganizationUnitInput()
{ UserId = createdUser.Id, OrganizationUnitId = input.OrganizationUnitId.Value });
}
return result;
}
löschen
Die Löschschnittstelle wird standardmäßig von CrudAppService bereitgestellt und muss nicht neu geschrieben werden.
ändern
Erstellen Sie die UpdateWithUserAsync-Methode, um Geschäftsbenutzer zu aktualisieren.
public async Task<EmployeeDto> UpdateWithUserAsync(CreateEmployeeInput input)
{
var currentEmployee = await userLookupService.FindByIdAsync(input.Id);
if (currentEmployee == null)
{
throw new UserFriendlyException("没有找到对应的用户");
}
ObjectMapper.Map(input, currentEmployee);
var updatedEmployee = await Repository.UpdateAsync(currentEmployee);
var result = ObjectMapper.Map<Employee, EmployeeDto>(updatedEmployee);
return result;
}
überprüfen
Die Standardimplementierung zum Abfragen einer einzelnen Entitätsschnittstelle wird von CrudAppService bereitgestellt und muss nicht neu geschrieben werden.
Abfragesammlung:
Am Beispiel von Employee sind die von der Abfrageschnittstelle benötigten Eingabeparameter:
OrganizationUnitId: Benutzer nach Organisationsstruktur abfragen.
IsWithoutOrganization: Benutzer abfragen, die keiner Organisationsstruktur angehören.
EmployeeTitle: Benutzer nach Berufsbezeichnung abfragen
Erstellen Sie GetAllEmployeeInput. Der Code lautet wie folgt
public class GetAllEmployeeInput : PagedAndSortedResultRequestDto
{
public string EmployeeTitle { get; set; }
public Guid? OrganizationUnitId { get; set; }
public bool IsWithoutOrganization { get; set; }
}
Überschreiben Sie CreateFilteredQueryAsync
protected override async Task<IQueryable<Employee>> CreateFilteredQueryAsync(GetAllEmployeeInput input)
{
var query = await ReadOnlyRepository.GetQueryableAsync().ConfigureAwait(continueOnCapturedContext: false);
if (input.OrganizationUnitId.HasValue && !input.IsWithoutOrganization)
{
var organizationUnitUsers = await organizationUnitAppService.GetOrganizationUnitUsersAsync(new GetOrganizationUnitUsersInput()
{
Id = input.OrganizationUnitId.Value
});
if (organizationUnitUsers.Count() > 0)
{
var ids = organizationUnitUsers.Select(c => c.Id);
query = query.Where(t => ids.Contains(t.Id));
}
else
{
query = query.Where(c => false);
}
}
else if (input.IsWithoutOrganization)
{
var organizationUnitUsers = await organizationUnitAppService.GetUsersWithoutOrganizationAsync(new GetUserWithoutOrganizationInput());
if (organizationUnitUsers.Count() > 0)
{
var ids = organizationUnitUsers.Select(c => c.Id);
query = query.Where(t => ids.Contains(t.Id));
}
else
{
query = query.Where(c => false);
}
}
query = query.WhereIf(!string.IsNullOrEmpty(input.EmployeeTitle), c => c.EmployeeTitle == input.EmployeeTitle);
return query;
}
Bisher haben wir die Implementierung der Funktionen zum Hinzufügen, Löschen, Ändern und Abfragen für Geschäftsbenutzer abgeschlossen.
Controller erstellen
Erstellen Sie EmployeeController im HttpApi-Projekt. Der Code lautet wie folgt:
[Area(HealthRemoteServiceConsts.ModuleName)]
[RemoteService(Name = HealthRemoteServiceConsts.RemoteServiceName)]
[Route("api/Health/employee")]
public class EmployeeController : AbpControllerBase, IEmployeeAppService
{
private readonly IEmployeeAppService _employeeAppService;
public EmployeeController(IEmployeeAppService employeeAppService)
{
_employeeAppService = employeeAppService;
}
[HttpPost]
[Route("CreateWithUser")]
public Task<EmployeeDto> CreateWithUserAsync(CreateEmployeeWithUserInput input)
{
return _employeeAppService.CreateWithUserAsync(input);
}
[HttpDelete]
[Route("Delete")]
public Task DeleteAsync(Guid id)
{
return _employeeAppService.DeleteAsync(id);
}
[HttpPut]
[Route("UpdateWithUser")]
public Task<EmployeeDto> UpdateWithUserAsync(CreateEmployeeInput input)
{
return _employeeAppService.UpdateWithUserAsync(input);
}
[HttpGet]
[Route("Get")]
public Task<EmployeeDto> GetAsync(Guid id)
{
return _employeeAppService.GetAsync(id);
}
[HttpGet]
[Route("GetAll")]
public Task<PagedResultDto<EmployeeDto>> GetAllAsync(GetAllEmployeeInput input)
{
return _employeeAppService.GetAllAsync(input);
}
}