package jnpf.limsService.impl;
|
|
import jnpf.limsEntity.LimsRecipientRef;
|
import jnpf.limsEntity.LimsRecipientType;
|
import jnpf.limsService.LimsRecipientResolver;
|
import jnpf.permission.RoleApi;
|
import jnpf.permission.RoleRelationApi;
|
import jnpf.permission.UserApi;
|
import jnpf.permission.UserRelationApi;
|
import jnpf.permission.entity.RoleEntity;
|
import jnpf.permission.entity.RoleRelationEntity;
|
import jnpf.permission.entity.UserEntity;
|
import jnpf.permission.entity.UserRelationEntity;
|
import jnpf.permission.model.rolerelaiton.RoleRelationModel;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.util.StringUtils;
|
|
import java.util.ArrayList;
|
import java.util.Collections;
|
import java.util.LinkedHashSet;
|
import java.util.List;
|
import java.util.Objects;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class LimsRecipientResolverImpl implements LimsRecipientResolver {
|
private final UserApi userApi;
|
private final UserRelationApi userRelationApi;
|
private final RoleApi roleApi;
|
private final RoleRelationApi roleRelationApi;
|
|
@Override
|
public List<String> resolve(String tenantId, List<LimsRecipientRef> refs) {
|
if (refs == null || refs.isEmpty()) {
|
return Collections.emptyList();
|
}
|
Set<String> candidateIds = new LinkedHashSet<>();
|
for (LimsRecipientRef ref : refs) {
|
if (ref == null || ref.getType() == null || !StringUtils.hasText(ref.getValue())) {
|
continue;
|
}
|
if (ref.getType() == LimsRecipientType.USER) {
|
candidateIds.add(ref.getValue());
|
} else if (ref.getType() == LimsRecipientType.POSITION) {
|
addRelationUsers(candidateIds, ref.getValue(), "Position");
|
} else if (ref.getType() == LimsRecipientType.ROLE) {
|
addRoleUsers(candidateIds, ref.getValue());
|
} else if (ref.getType() == LimsRecipientType.ROLE_ENCODE) {
|
List<RoleEntity> roles = roleApi.getListAll();
|
RoleEntity role = (roles == null ? Collections.<RoleEntity>emptyList() : roles).stream()
|
.filter(item -> !StringUtils.hasText(tenantId)
|
|| Objects.equals(tenantId, item.getTenantId()))
|
.filter(item -> ref.getValue().equals(item.getEnCode()))
|
.findFirst().orElse(null);
|
if (role != null) {
|
addRoleUsers(candidateIds, role.getId());
|
}
|
}
|
}
|
if (candidateIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
List<UserEntity> users = userApi.getUserName(new ArrayList<>(candidateIds));
|
if (users == null) {
|
return Collections.emptyList();
|
}
|
return users.stream()
|
.filter(Objects::nonNull)
|
.filter(user -> Integer.valueOf(1).equals(user.getEnabledMark()))
|
.filter(user -> !Integer.valueOf(1).equals(user.getDeleteMark()))
|
.filter(user -> !StringUtils.hasText(tenantId) || Objects.equals(tenantId, user.getTenantId()))
|
.map(UserEntity::getId)
|
.filter(StringUtils::hasText)
|
.distinct()
|
.collect(Collectors.toList());
|
}
|
|
private void addRelationUsers(Set<String> userIds, String objectId, String objectType) {
|
List<UserRelationEntity> relations = userRelationApi.getListByObjectIdAll(Collections.singletonList(objectId));
|
if (relations != null) {
|
relations.stream()
|
.filter(item -> objectType.equalsIgnoreCase(item.getObjectType()))
|
.map(UserRelationEntity::getUserId)
|
.filter(StringUtils::hasText)
|
.forEach(userIds::add);
|
}
|
}
|
|
private void addRoleUsers(Set<String> userIds, String roleId) {
|
RoleRelationModel model = new RoleRelationModel();
|
model.setRoleId(Collections.singletonList(roleId));
|
model.setObjectType("user");
|
List<RoleRelationEntity> relations = roleRelationApi.getListByRoleId(model);
|
if (relations != null) {
|
relations.stream()
|
.filter(item -> "user".equalsIgnoreCase(item.getObjectType()))
|
.map(RoleRelationEntity::getObjectId)
|
.filter(StringUtils::hasText)
|
.forEach(userIds::add);
|
}
|
}
|
}
|
