lanyuanxiaoyao/gringotts
1
0
Fork 0
Code Activity

feat(web): 适配flowable

Browse Source
This commit is contained in:
兰缘小妖
2025-01-08 10:41:40 +08:00
parent 0aa9ec738a
commit 509410de9a
16 changed files with 412 additions and 384 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
gringotts-frontend/components/constants.js
View File

@@ -261,13 +261,13 @@ export const permissionStateMapping = [
export const checkTypeMapping = [
mappingItem('确权审查', 'CONFIRMATION', 'bg-blue-500'),
mappingItem('授权审查', 'AUTHENTICATION', 'bg-purple-500'),
mappingItem('上架审查', 'MARKET', 'bg-green-500'),
mappingItem('上架审查', 'WARE', 'bg-green-500'),
]
export const checkOverMapping = [
mappingItem('进行中', 'CHECKING', 'bg-warning'),
mappingItem('已撤销', 'RETRACT', 'bg-primary'),
mappingItem('已办结', 'OVER', 'bg-success'),
mappingItem('进行中', 'RUNNING', 'bg-warning'),
mappingItem('已撤销', 'TERMINAL', 'bg-primary'),
mappingItem('已办结', 'COMPLETED', 'bg-success'),
]
function api(method, url) {

20
gringotts-frontend/pages/index/tab-check.js
View File

@@ -31,7 +31,7 @@ export function tabCheck() {
stringField('modifiedUsername', '最后操作人', 100),
operationField('操作', undefined, [
{
visibleOn: "${type === 'CONFIRMATION' && state === 'CHECKING'}",
visibleOn: "${type === 'CONFIRMATION' && state === 'RUNNING'}",
type: 'action',
label: '处理',
level: 'link',
@@ -43,7 +43,7 @@ export function tabCheck() {
label: '同意',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/APPLY'),
api: apiGet('${base}/check_order/approve/${instanceId}'),
reload: 'check_order_list',
},
{
@@ -51,7 +51,7 @@ export function tabCheck() {
label: '拒绝',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/REJECT'),
api: apiGet('${base}/check_order/reject/${instanceId}'),
reload: 'check_order_list',
},
],
@@ -65,7 +65,7 @@ export function tabCheck() {
...confirmationDetailDialog('parameters.confirmationId'),
},
{
visibleOn: "${type === 'AUTHENTICATION' && state === 'CHECKING'}",
visibleOn: "${type === 'AUTHENTICATION' && state === 'RUNNING'}",
type: 'action',
label: '处理',
level: 'link',
@@ -77,7 +77,7 @@ export function tabCheck() {
label: '同意',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/APPLY'),
api: apiGet('${base}/check_order/approve/${instanceId}'),
reload: 'check_order_list',
},
{
@@ -85,7 +85,7 @@ export function tabCheck() {
label: '拒绝',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/REJECT'),
api: apiGet('${base}/check_order/reject/${instanceId}'),
reload: 'check_order_list',
},
],
@@ -99,7 +99,7 @@ export function tabCheck() {
...authenticationDetailDialog('parameters.authenticationId'),
},
{
visibleOn: "${type === 'MARKET' && state === 'CHECKING'}",
visibleOn: "${type === 'WARE' && state === 'RUNNING'}",
type: 'action',
label: '处理',
level: 'link',
@@ -111,7 +111,7 @@ export function tabCheck() {
label: '同意',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/APPLY'),
api: apiGet('${base}/check_order/approve/${instanceId}'),
reload: 'check_order_list',
},
{
@@ -119,14 +119,14 @@ export function tabCheck() {
label: '拒绝',
actionType: 'ajax',
close: true,
api: apiGet('${base}/check_order/operation/${checkOrderId}/REJECT'),
api: apiGet('${base}/check_order/reject/${instanceId}'),
reload: 'check_order_list',
},
],
),
},
{
visibleOn: "${type === 'MARKET' && state !== NORMAL}",
visibleOn: "${type === 'WARE' && state !== NORMAL}",
type: 'action',
label: '查看',
level: 'link',

4
gringotts-web/pom.xml
View File

@@ -20,6 +20,10 @@
<groupId>com.eshore</groupId>
<artifactId>gringotts-forest</artifactId>
</dependency>
<dependency>
<groupId>com.lanyuanxiaoyao</groupId>
<artifactId>flowable-spring-boot-jpa-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>

10
gringotts-web/src/main/java/com/eshore/gringotts/web/WebApplication.java
View File

@@ -8,6 +8,7 @@ import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
@@ -21,7 +22,14 @@ import org.springframework.scheduling.annotation.EnableAsync;
* @author lanyuanxiaoyao
* @date 2024-11-14
*/
@SpringBootApplication(scanBasePackages = {"com.eshore.gringotts"})
@SpringBootApplication(scanBasePackages = {
"com.eshore.gringotts",
"com.lanyuanxiaoyao.flowable.jpa"
})
@EntityScan({
"com.eshore.gringotts.web.domain.entity",
"com.lanyuanxiaoyao.flowable.jpa.entity"
})
@EnableFenix
@EnableJpaAuditing
@EnableAsync

8
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/entity/CheckingNeededEntity.java
View File

@@ -1,14 +1,10 @@
package com.eshore.gringotts.web.domain.base.entity;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.EntityListeners;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToOne;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@@ -26,9 +22,7 @@ public class CheckingNeededEntity extends LogicDeleteEntity {
@Enumerated(EnumType.STRING)
private State state = State.DRAFT;
@OneToOne(cascade = CascadeType.DETACH, fetch = FetchType.LAZY)
@ToString.Exclude
private CheckOrder order;
private String flowableInstanceId;
public enum State {
/**

6
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/base/service/CheckingService.java
View File

@@ -2,10 +2,8 @@ package com.eshore.gringotts.web.domain.base.service;
import com.eshore.gringotts.web.domain.base.entity.LogicDeleteEntity;
import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.service.UserService;
import javax.persistence.EntityManager;
import org.eclipse.collections.api.map.ImmutableMap;
/**
* 需要审查
@@ -21,8 +19,4 @@ public abstract class CheckingService<ENTITY extends LogicDeleteEntity> extends
abstract public void submit(Long id) throws Exception;
abstract public void retract(Long id) throws Exception;
abstract public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters);
abstract public ImmutableMap<String, Object> archive(ENTITY entity);
}

88
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/controller/CheckOrderController.java
View File

@@ -3,18 +3,19 @@ package com.eshore.gringotts.web.domain.controller;
import com.eshore.gringotts.web.configuration.amis.AmisResponse;
import com.eshore.gringotts.web.domain.base.controller.ListController;
import com.eshore.gringotts.web.domain.base.controller.query.Query;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.service.CheckOrderService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.service.UserService;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import com.lanyuanxiaoyao.flowable.jpa.SpringFlowableManager;
import java.time.LocalDateTime;
import lombok.Data;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.collections.api.factory.Lists;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.map.ImmutableMap;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
@@ -32,55 +33,76 @@ import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("check_order")
public class CheckOrderController implements ListController<CheckOrderController.ListItem> {
private final CheckOrderService checkOrderService;
private final ObjectMapper mapper;
private final UserService userService;
private final SpringFlowableManager flowableManager;
public CheckOrderController(CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
this.checkOrderService = checkOrderService;
this.mapper = builder.build();
public CheckOrderController(UserService userService, SpringFlowableManager flowableManager) {
this.userService = userService;
this.flowableManager = flowableManager;
}
@GetMapping("/list")
@Override
public AmisResponse<ImmutableList<CheckOrderController.ListItem>> list() throws Exception {
return AmisResponse.responseSuccess(checkOrderService.list().collect(this::toListItem));
User user = userService.currentLoginUser();
return AmisResponse.responseSuccess(
Lists.immutable.ofAll(flowableManager.listInstances(
(root, query, builder) -> {
if (User.isAdministrator(user)) {
return null;
}
return builder.or(
builder.like(root.get("extra"), user.getRole().name()),
builder.like(root.get("extra"), user.getId().toString())
);
}
)).collect(this::toListItem)
);
}
@PostMapping("/list")
@Override
public AmisResponse<ImmutableList<ListItem>> list(@RequestBody Query query) throws Exception {
return AmisResponse.responseSuccess(checkOrderService.list().collect(this::toListItem));
throw new UnsupportedOperationException();
}
@GetMapping("/approve/{instanceId}")
public AmisResponse<Object> approve(@PathVariable String instanceId) {
flowableManager.approve(instanceId);
return AmisResponse.responseSuccess();
}
@GetMapping("/reject/{instanceId}")
public AmisResponse<Object> reject(@PathVariable String instanceId) {
flowableManager.reject(instanceId);
return AmisResponse.responseSuccess();
}
@SneakyThrows
private ListItem toListItem(CheckOrder order) {
private ListItem toListItem(FlowableInstance instance) {
FlowableNode node = flowableManager.getNode(instance.getCurrentNodeId());
ListItem item = new ListItem();
item.setCheckOrderId(order.getId());
item.setDescription(order.getDescription());
item.setType(order.getType());
item.setParameters(mapper.readValue(order.getParameters(), new TypeReference<>() {}));
item.setState(order.getState());
item.setCreatedUsername(order.getCreatedUser().getUsername());
item.setCreatedTime(order.getCreatedTime());
item.setModifiedUsername(order.getModifiedUser().getUsername());
item.setModifiedTime(order.getModifiedTime());
item.setInstanceId(instance.getInstanceId());
item.setName(node.getName());
item.setDescription(node.getDescription());
item.setType(instance.getMetadata().getStringOrDefault("type", "unknown"));
item.setParameters(Maps.immutable.ofAll(instance.getMetadata().getMetadata()));
item.setState(instance.getStatus());
item.setCreatedUsername(instance.getMetadata().getStringOrDefault("createdUsername", ""));
item.setCreatedTime(instance.getCreatedTime());
item.setModifiedUsername(instance.getMetadata().getStringOrDefault("modifiedUsername", ""));
item.setModifiedTime(instance.getUpdatedTime());
return item;
}
@GetMapping("/operation/{id}/{operation}")
public AmisResponse<Object> operation(@PathVariable Long id, @PathVariable CheckOrder.Operation operation) throws JsonProcessingException {
log.info("id:{}, operation:{}", id, operation);
checkOrderService.operation(id, operation);
return AmisResponse.responseSuccess();
}
@Data
public static final class ListItem {
private Long checkOrderId;
private String instanceId;
private String name;
private String description;
private CheckOrder.Type type;
private String type;
private ImmutableMap<String, Object> parameters;
private CheckOrder.State state;
private FlowableInstance.Status state;
private LocalDateTime createdTime;
private String createdUsername;
private LocalDateTime modifiedTime;

28
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/flowable/CheckRoleAssessor.java Normal file
View File

@@ -0,0 +1,28 @@
package com.eshore.gringotts.web.domain.flowable;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.service.UserService;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAccessor;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAction;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import org.springframework.stereotype.Service;
/**
* @author lanyuanxiaoyao
* @version 20250106
*/
@Service
public class CheckRoleAssessor implements FlowableAccessor {
private final UserService userService;
public CheckRoleAssessor(UserService userService) {
this.userService = userService;
}
@Override
public boolean access(FlowableInstance flowableInstance, FlowableNode flowableNode, FlowableAction flowableAction) {
User.Role role = userService.currentLoginUser().getRole();
return User.Role.ADMINISTRATOR.equals(role) || User.Role.CHECKER.equals(role);
}
}

31
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/flowable/UserAssessor.java Normal file
View File

@@ -0,0 +1,31 @@
package com.eshore.gringotts.web.domain.flowable;
import cn.hutool.core.util.NumberUtil;
import com.eshore.gringotts.web.domain.service.UserService;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAccessor;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAction;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableMetadata;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import org.springframework.stereotype.Service;
/**
* @author lanyuanxiaoyao
* @version 20250106
*/
@Service
public class UserAssessor implements FlowableAccessor {
public static final String KEY = "user_access_key";
private final UserService userService;
public UserAssessor(UserService userService) {
this.userService = userService;
}
@Override
public boolean access(FlowableInstance flowableInstance, FlowableNode flowableNode, FlowableAction flowableAction) {
FlowableMetadata metadata = flowableInstance.getMetadata();
return NumberUtil.equals(userService.currentLoginUser().getId(), metadata.getLong(KEY));
}
}

13
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/repository/AuthenticationRepository.java
View File

@@ -4,9 +4,12 @@ import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
import com.eshore.gringotts.web.domain.entity.Authentication;
import java.util.List;
import java.util.Optional;
import javax.transaction.Transactional;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
/**
@@ -27,4 +30,14 @@ public interface AuthenticationRepository extends SimpleRepository<Authenticatio
@Override
@EntityGraph(value = "authentication.detail", type = EntityGraph.EntityGraphType.FETCH)
Optional<Authentication> findOne(Specification<Authentication> specification);
@Transactional
@Modifying
@Query("update Authentication confirmation set confirmation.state = ?2 where confirmation.id = ?1 and confirmation.deleted = false")
void updateStateById(Long id, Authentication.State state);
@Transactional
@Modifying
@Query("update Authentication confirmation set confirmation.flowableInstanceId = ?2 where confirmation.id = ?1 and confirmation.deleted = false")
void updateInstanceIdById(Long id, String instanceId);
}

15
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/repository/ConfirmationRepository.java
View File

@@ -4,9 +4,12 @@ import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
import com.eshore.gringotts.web.domain.entity.Confirmation;
import java.util.List;
import java.util.Optional;
import javax.transaction.Transactional;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
/**
@@ -28,5 +31,15 @@ public interface ConfirmationRepository extends SimpleRepository<Confirmation, L
@EntityGraph(value = "confirmation.detail", type = EntityGraph.EntityGraphType.FETCH)
Optional<Confirmation> findOne(Specification<Confirmation> specification);
Boolean existsByTarget_Id(Long id);
@Transactional
@Modifying
@Query("update Confirmation confirmation set confirmation.state = ?2 where confirmation.id = ?1 and confirmation.deleted = false")
void updateStateById(Long id, Confirmation.State state);
@Transactional
@Modifying
@Query("update Confirmation confirmation set confirmation.flowableInstanceId = ?2 where confirmation.id = ?1 and confirmation.deleted = false")
void updateInstanceIdById(Long id, String instanceId);
Boolean existsByTarget_Id(Long targetId);
}

13
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/repository/WareRepository.java
View File

@@ -4,9 +4,12 @@ import com.eshore.gringotts.web.domain.base.repository.SimpleRepository;
import com.eshore.gringotts.web.domain.entity.Ware;
import java.util.List;
import java.util.Optional;
import javax.transaction.Transactional;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.data.jpa.repository.EntityGraph;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.stereotype.Repository;
@SuppressWarnings("NullableProblems")
@@ -23,4 +26,14 @@ public interface WareRepository extends SimpleRepository<Ware, Long> {
@Override
@EntityGraph(value = "ware.detail", type = EntityGraph.EntityGraphType.FETCH)
Optional<Ware> findOne(Specification<Ware> specification);
@Transactional
@Modifying
@Query("update Ware ware set ware.state = ?2 where ware.id = ?1 and ware.deleted = false")
void updateStateById(Long id, Ware.State state);
@Transactional
@Modifying
@Query("update Ware ware set ware.flowableInstanceId = ?2 where ware.id = ?1 and ware.deleted = false")
void updateInstanceIdById(Long id, String instanceId);
}

178
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/AuthenticationService.java
View File

@@ -1,29 +1,32 @@
package com.eshore.gringotts.web.domain.service;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
import com.eshore.gringotts.web.domain.base.service.CheckingService;
import com.eshore.gringotts.web.domain.entity.Authentication;
import com.eshore.gringotts.web.domain.entity.Authentication_;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.entity.CheckOrder_;
import com.eshore.gringotts.web.domain.entity.Confirmation;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.flowable.CheckRoleAssessor;
import com.eshore.gringotts.web.domain.flowable.UserAssessor;
import com.eshore.gringotts.web.domain.repository.AuthenticationRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAction;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableListener;
import com.lanyuanxiaoyao.flowable.core.model.FlowableMetadata;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import com.lanyuanxiaoyao.flowable.jpa.SpringFlowableManager;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.transaction.Transactional;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.collections.api.factory.Lists;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.map.ImmutableMap;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
/**
@@ -31,19 +34,38 @@ import org.springframework.stereotype.Service;
* @date 2024-12-02
*/
@Slf4j
@Service("com.eshore.gringotts.web.domain.service.AuthenticationService")
@Service
public class AuthenticationService extends CheckingService<Authentication> {
private static final String AUTHENTICATION_FLOW_ID = "4ba86acd-1420-450b-98f9-0ed41772fe53";
private final AuthenticationRepository authenticationRepository;
private final UserService userService;
private final CheckOrderService checkOrderService;
private final ObjectMapper mapper;
private final SpringFlowableManager flowableManager;
public AuthenticationService(AuthenticationRepository repository, UserService userService, EntityManager manager, CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
public AuthenticationService(AuthenticationRepository repository, UserService userService, EntityManager manager, SpringFlowableManager flowableManager) {
super(repository, userService, manager);
this.authenticationRepository = repository;
this.userService = userService;
this.checkOrderService = checkOrderService;
this.mapper = builder.build();
this.flowableManager = flowableManager;
FlowableNode userCheckNode = FlowableNode.builder()
.nodeId(AUTHENTICATION_FLOW_ID)
.name("用户审查")
.description("用户审查")
.listeners(Lists.mutable.of(AuthenticationService.AuthenticationFlowUserCheckListener.class.getName()))
.accessor(UserAssessor.class.getName())
.targets(Maps.mutable.of(
FlowableAction.APPROVE, "f087b0e4-0efa-4b26-945f-642436aa4aef"
))
.build();
FlowableNode roleCheckNode = FlowableNode.builder()
.nodeId("f087b0e4-0efa-4b26-945f-642436aa4aef")
.name("授权审查")
.description("授权审查")
.listeners(Lists.mutable.of(AuthenticationService.AuthenticationFlowRoleCheckListener.class.getName()))
.accessor(CheckRoleAssessor.class.getName())
.build();
flowableManager.create(userCheckNode, roleCheckNode);
}
@Override
@@ -53,15 +75,7 @@ public class AuthenticationService extends CheckingService<Authentication> {
return Lists.immutable.empty();
}
return Lists.immutable.of(builder.or(
builder.equal(root.get(Authentication_.createdUser), loginUser),
builder.and(
builder.equal(root.get(Authentication_.order).get(CheckOrder_.target), CheckOrder.Target.ROLE),
builder.equal(root.get(Authentication_.order).get(CheckOrder_.targetRole), loginUser.getRole())
),
builder.and(
builder.equal(root.get(Authentication_.order).get(CheckOrder_.target), CheckOrder.Target.USER),
builder.equal(root.get(Authentication_.order).get(CheckOrder_.targetUser), loginUser)
)
builder.equal(root.get(Authentication_.createdUser), loginUser)
));
}
@@ -82,73 +96,29 @@ public class AuthenticationService extends CheckingService<Authentication> {
return super.save(entity);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void submit(Long id) throws JsonProcessingException {
public void submit(Long id) throws Exception {
User user = userService.currentLoginUser();
Authentication authentication = detailOrThrow(id);
authentication.setState(CheckingNeededEntity.State.OWNER_CHECKING);
Long orderId = checkOrderService.save(new CheckOrder(
"authentication_owner_check",
StrUtil.format("数据资源「{}」的授权申请", authentication.getTarget().getName()),
CheckOrder.Type.AUTHENTICATION,
mapper.writeValueAsString(Maps.immutable.of("authenticationId", authentication.getId())),
"com.eshore.gringotts.web.domain.service.AuthenticationService",
authentication.getCreatedUser()
));
CheckOrder order = checkOrderService.detailOrThrow(orderId);
authentication.setOrder(order);
save(authentication);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void retract(Long id) {
Authentication authentication = detailOrThrow(id);
authentication.setState(Authentication.State.DRAFT);
save(authentication);
CheckOrder order = authentication.getOrder();
order.setState(CheckOrder.State.RETRACT);
checkOrderService.save(order);
String instanceId = flowableManager.start(
AUTHENTICATION_FLOW_ID,
MapUtil.<String, Object>builder()
.put("authenticationId", id)
.put("type", "AUTHENTICATION")
.put("createdUsername", user.getUsername())
.put("modifiedUsername", user.getUsername())
.put(UserAssessor.KEY, authentication.getTarget().getCreatedUser().getId())
.build(),
authentication.getTarget().getCreatedUser().getId().toString()
);
authenticationRepository.updateInstanceIdById(id, instanceId);
authenticationRepository.updateStateById(id, Confirmation.State.CHECKING);
}
@Override
@Transactional(rollbackOn = Throwable.class)
public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
Long id = (Long) parameters.get("authenticationId");
public void retract(Long id) throws Exception {
Authentication authentication = detailOrThrow(id);
if (StrUtil.equals(order.getKeyword(), "authentication_owner_check")) {
switch (operation) {
case APPLY:
authentication.setState(Authentication.State.CHECKING);
order.setKeyword("authentication_checker_check");
order.setTarget(CheckOrder.Target.ROLE);
order.setTargetRole(User.Role.CHECKER);
break;
case REJECT:
authentication.setState(Authentication.State.DRAFT);
order.setState(CheckOrder.State.OVER);
break;
}
} else if (StrUtil.equals(order.getKeyword(), "authentication_checker_check")) {
switch (operation) {
case APPLY:
authentication.setState(Authentication.State.NORMAL);
order.setState(CheckOrder.State.OVER);
break;
case REJECT:
authentication.setState(Authentication.State.DRAFT);
order.setState(CheckOrder.State.OVER);
break;
}
}
save(authentication);
checkOrderService.save(order);
}
@Override
public ImmutableMap<String, Object> archive(Authentication authentication) {
return null;
flowableManager.terminal(authentication.getFlowableInstanceId());
}
public static final class AuthenticationDuplicatedException extends RuntimeException {
@@ -156,4 +126,44 @@ public class AuthenticationService extends CheckingService<Authentication> {
super("数据资源已绑定该账号的授权申请，无法再次申请");
}
}
@Component
public static final class AuthenticationFlowUserCheckListener extends FlowableListener.AbstractFlowableListener {
private final AuthenticationRepository authenticationRepository;
public AuthenticationFlowUserCheckListener(AuthenticationRepository authenticationRepository) {
this.authenticationRepository = authenticationRepository;
}
@Override
public void onActionComplete(FlowableInstance instance, FlowableNode node, FlowableAction action) {
FlowableMetadata metadata = instance.getMetadata();
Long authenticationId = metadata.getLong("authenticationId");
if (FlowableAction.APPROVE.equals(action)) {
instance.setExtra(User.Role.CHECKER.name());
} else {
authenticationRepository.updateStateById(authenticationId, Confirmation.State.DRAFT);
}
}
}
@Component
public static final class AuthenticationFlowRoleCheckListener extends FlowableListener.AbstractFlowableListener {
private final AuthenticationRepository authenticationRepository;
public AuthenticationFlowRoleCheckListener(AuthenticationRepository authenticationRepository) {
this.authenticationRepository = authenticationRepository;
}
@Override
public void onActionComplete(FlowableInstance instance, FlowableNode node, FlowableAction action) {
FlowableMetadata metadata = instance.getMetadata();
Long authenticationId = metadata.getLong("authenticationId");
if (FlowableAction.APPROVE.equals(action)) {
authenticationRepository.updateStateById(authenticationId, CheckingNeededEntity.State.NORMAL);
} else {
authenticationRepository.updateStateById(authenticationId, Confirmation.State.DRAFT);
}
}
}
}

82
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/CheckOrderService.java
View File

@@ -1,82 +0,0 @@
package com.eshore.gringotts.web.domain.service;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.eshore.gringotts.web.domain.base.service.CheckingService;
import com.eshore.gringotts.web.domain.base.service.SimpleServiceSupport;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.entity.CheckOrder_;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.repository.CheckOrderRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.collections.api.factory.Lists;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.map.ImmutableMap;
import org.springframework.context.ApplicationContext;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Service;
/**
* @author lanyuanxiaoyao
* @date 2024-11-29
*/
@Slf4j
@Service
public class CheckOrderService extends SimpleServiceSupport<CheckOrder> {
private final ApplicationContext applicationContext;
private final ObjectMapper mapper;
private final CheckOrderRepository checkOrderRepository;
private final UserService userService;
public CheckOrderService(CheckOrderRepository repository, UserService userService, ApplicationContext applicationContext, Jackson2ObjectMapperBuilder builder) {
super(repository, userService);
this.applicationContext = applicationContext;
this.mapper = builder.build();
this.checkOrderRepository = repository;
this.userService = userService;
}
@Override
protected ImmutableList<Predicate> listPredicate(Root<CheckOrder> root, CriteriaQuery<?> query, CriteriaBuilder builder) {
User user = userService.currentLoginUser();
if (User.isAdministrator(user)) {
return Lists.immutable.empty();
}
return Lists.immutable.of(builder.or(
builder.equal(root.get(CheckOrder_.createdUser), user),
builder.and(
builder.equal(root.get(CheckOrder_.target), CheckOrder.Target.USER),
builder.equal(root.get(CheckOrder_.targetUser), user)
),
builder.and(
builder.equal(root.get(CheckOrder_.target), CheckOrder.Target.ROLE),
builder.equal(root.get(CheckOrder_.targetRole), user.getRole())
)
));
}
public void operation(Long id, CheckOrder.Operation operation) throws JsonProcessingException {
CheckOrder order = detailOrThrow(id);
CheckingService service = applicationContext.getBean(order.getTargetClass(), CheckingService.class);
if (ObjectUtil.isNull(service)) {
throw new RuntimeException(StrUtil.format("名为「{}」的服务未找到", order.getTargetClass()));
}
ImmutableMap<String, Object> parameters = mapper.readValue(order.getParameters(), new TypeReference<>() {});
service.onChecked(order, operation, parameters);
}
public void retract(Long id) {
checkOrderRepository.overById(id, CheckOrder.State.RETRACT, userService.currentLoginUser());
}
public void over(Long id) {
checkOrderRepository.overById(id, CheckOrder.State.OVER, userService.currentLoginUser());
}
}

159
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/ConfirmationService.java
View File

@@ -1,31 +1,28 @@
package com.eshore.gringotts.web.domain.service;
import cn.hutool.core.map.MapUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.eshore.gringotts.web.domain.base.entity.CheckingNeededEntity;
import com.eshore.gringotts.web.domain.base.service.CheckingService;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.entity.CheckOrder_;
import com.eshore.gringotts.web.domain.entity.Confirmation;
import com.eshore.gringotts.web.domain.entity.Confirmation_;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.flowable.CheckRoleAssessor;
import com.eshore.gringotts.web.domain.repository.ConfirmationRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAction;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableListener;
import com.lanyuanxiaoyao.flowable.core.model.FlowableMetadata;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import com.lanyuanxiaoyao.flowable.jpa.SpringFlowableManager;
import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.JoinType;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import javax.transaction.Transactional;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.collections.api.factory.Lists;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.map.ImmutableMap;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
/**
@@ -33,17 +30,26 @@ import org.springframework.stereotype.Service;
* @date 2024-11-26
*/
@Slf4j
@Service("com.eshore.gringotts.web.domain.service.ConfirmationService")
@Service
public class ConfirmationService extends CheckingService<Confirmation> {
private final ConfirmationRepository confirmationRepository;
private final CheckOrderService checkOrderService;
private final ObjectMapper mapper;
private static final String CONFIRMATION_FLOW_ID = "69d8ded5-35fd-4f03-b11a-be0ed91a4b8b";
public ConfirmationService(ConfirmationRepository confirmationRepository, UserService userService, EntityManager entityManager, CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
private final ConfirmationRepository confirmationRepository;
private final SpringFlowableManager flowableManager;
public ConfirmationService(ConfirmationRepository confirmationRepository, UserService userService, EntityManager entityManager, SpringFlowableManager flowableManager) {
super(confirmationRepository, userService, entityManager);
this.confirmationRepository = confirmationRepository;
this.checkOrderService = checkOrderService;
this.mapper = builder.build();
this.flowableManager = flowableManager;
FlowableNode node = FlowableNode.builder()
.nodeId(CONFIRMATION_FLOW_ID)
.name("确权审查")
.description("确权审查")
.listeners(Lists.mutable.of(ConfirmationService.ConfirmationFlowRoleCheckListener.class.getName()))
.accessor(CheckRoleAssessor.class.getName())
.build();
flowableManager.create(node);
}
@Override
@@ -52,25 +58,34 @@ public class ConfirmationService extends CheckingService<Confirmation> {
if (User.isAdministrator(loginUser)) {
return Lists.immutable.empty();
}
Join<Confirmation, CheckOrder> orderJoin = root.join(Confirmation_.order, JoinType.LEFT);
return Lists.immutable.of(builder.or(
builder.equal(root.get(Confirmation_.createdUser), loginUser),
builder.and(
builder.isNotNull(orderJoin),
builder.or(
builder.and(
builder.equal(orderJoin.get(CheckOrder_.target), CheckOrder.Target.ROLE),
builder.equal(orderJoin.get(CheckOrder_.targetRole), loginUser.getRole())
),
builder.and(
builder.equal(orderJoin.get(CheckOrder_.target), CheckOrder.Target.USER),
builder.equal(orderJoin.get(CheckOrder_.targetUser), loginUser)
)
)
)
builder.equal(root.get(Confirmation_.createdUser), loginUser)
));
}
@Override
public void submit(Long id) throws Exception {
User user = userService.currentLoginUser();
String instanceId = flowableManager.start(
CONFIRMATION_FLOW_ID,
MapUtil.<String, Object>builder()
.put("confirmationId", id)
.put("type", "CONFIRMATION")
.put("createdUsername", user.getUsername())
.put("modifiedUsername", user.getUsername())
.build(),
User.Role.CHECKER.name()
);
confirmationRepository.updateInstanceIdById(id, instanceId);
confirmationRepository.updateStateById(id, Confirmation.State.CHECKING);
}
@Override
public void retract(Long id) throws Exception {
Confirmation confirmation = detailOrThrow(id);
flowableManager.terminal(confirmation.getFlowableInstanceId());
}
@Override
public Long save(Confirmation entity) {
if (ObjectUtil.isNull(entity.getId()) && confirmationRepository.existsByTarget_Id(entity.getTarget().getId())) {
@@ -79,65 +94,29 @@ public class ConfirmationService extends CheckingService<Confirmation> {
return super.save(entity);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void submit(Long id) throws JsonProcessingException {
Confirmation confirmation = detailOrThrow(id);
confirmation.setState(Confirmation.State.CHECKING);
Long orderId = checkOrderService.save(new CheckOrder(
"confirmation_check",
StrUtil.format("数据资源「{}」的确权申请", confirmation.getTarget().getName()),
CheckOrder.Type.CONFIRMATION,
mapper.writeValueAsString(Maps.immutable.of("confirmationId", confirmation.getId())),
"com.eshore.gringotts.web.domain.service.ConfirmationService",
User.Role.CHECKER
));
CheckOrder order = checkOrderService.detailOrThrow(orderId);
confirmation.setOrder(order);
save(confirmation);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void retract(Long id) {
Confirmation confirmation = detailOrThrow(id);
confirmation.setState(CheckingNeededEntity.State.DRAFT);
save(confirmation);
CheckOrder order = confirmation.getOrder();
order.setState(CheckOrder.State.RETRACT);
checkOrderService.save(order);
}
@Override
@Transactional(rollbackOn = Throwable.class)
public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
if (StrUtil.equals(order.getKeyword(), "confirmation_check")) {
Long id = (Long) parameters.get("confirmationId");
Confirmation confirmation = detailOrThrow(id);
switch (operation) {
case APPLY:
confirmation.setState(Confirmation.State.NORMAL);
order.setState(CheckOrder.State.OVER);
break;
case REJECT:
confirmation.setState(Confirmation.State.DRAFT);
order.setState(CheckOrder.State.OVER);
break;
}
save(confirmation);
checkOrderService.save(order);
}
}
@Override
public ImmutableMap<String, Object> archive(Confirmation confirmation) {
return null;
}
public static final class ConfirmationDuplicatedException extends RuntimeException {
public ConfirmationDuplicatedException() {
super("数据资源已绑定确权申请，无法再次申请");
}
}
@Component
public static final class ConfirmationFlowRoleCheckListener extends FlowableListener.AbstractFlowableListener {
private final ConfirmationRepository confirmationRepository;
public ConfirmationFlowRoleCheckListener(ConfirmationRepository confirmationRepository) {
this.confirmationRepository = confirmationRepository;
}
@Override
public void onActionComplete(FlowableInstance instance, FlowableNode node, FlowableAction action) {
FlowableMetadata metadata = instance.getMetadata();
Long confirmationId = metadata.getLong("confirmationId");
if (action == FlowableAction.APPROVE) {
confirmationRepository.updateStateById(confirmationId, Confirmation.State.NORMAL);
} else {
confirmationRepository.updateStateById(confirmationId, Confirmation.State.DRAFT);
}
}
}
}

133
gringotts-web/src/main/java/com/eshore/gringotts/web/domain/service/WareService.java
View File

@@ -1,21 +1,22 @@
package com.eshore.gringotts.web.domain.service;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.map.MapUtil;
import com.eshore.gringotts.web.domain.base.service.CheckingService;
import com.eshore.gringotts.web.domain.entity.CheckOrder;
import com.eshore.gringotts.web.domain.entity.User;
import com.eshore.gringotts.web.domain.entity.Ware;
import com.eshore.gringotts.web.domain.flowable.UserAssessor;
import com.eshore.gringotts.web.domain.repository.WareRepository;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.lanyuanxiaoyao.flowable.core.model.FlowableAction;
import com.lanyuanxiaoyao.flowable.core.model.FlowableInstance;
import com.lanyuanxiaoyao.flowable.core.model.FlowableListener;
import com.lanyuanxiaoyao.flowable.core.model.FlowableMetadata;
import com.lanyuanxiaoyao.flowable.core.model.FlowableNode;
import com.lanyuanxiaoyao.flowable.jpa.SpringFlowableManager;
import javax.persistence.EntityManager;
import javax.transaction.Transactional;
import lombok.extern.slf4j.Slf4j;
import org.eclipse.collections.api.factory.Lists;
import org.eclipse.collections.api.factory.Maps;
import org.eclipse.collections.api.list.ImmutableList;
import org.eclipse.collections.api.map.ImmutableMap;
import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
/**
@@ -23,17 +24,28 @@ import org.springframework.stereotype.Service;
* @date 2024-12-13
*/
@Slf4j
@Service("com.eshore.gringotts.web.domain.service.WareService")
@Service
public class WareService extends CheckingService<Ware> {
private final WareRepository wareRepository;
private final CheckOrderService checkOrderService;
private final ObjectMapper mapper;
private static final String WARE_FLOW_ID = "870e7376-1713-48ed-9e60-e602981c6ecc";
public WareService(WareRepository repository, UserService userService, EntityManager entityManager, CheckOrderService checkOrderService, Jackson2ObjectMapperBuilder builder) {
private final WareRepository wareRepository;
private final UserService userService;
private final SpringFlowableManager flowableManager;
public WareService(WareRepository repository, UserService userService, EntityManager entityManager, SpringFlowableManager flowableManager) {
super(repository, userService, entityManager);
this.wareRepository = repository;
this.checkOrderService = checkOrderService;
this.mapper = builder.build();
this.userService = userService;
this.flowableManager = flowableManager;
FlowableNode node = FlowableNode.builder()
.nodeId(WARE_FLOW_ID)
.name("上架审查")
.description("上架审查")
.listeners(Lists.mutable.of(WareService.WareFlowUserCheckListener.class.getName()))
.accessor(UserAssessor.class.getName())
.build();
flowableManager.create(node);
}
public ImmutableList<Ware> listPublic() {
@@ -42,59 +54,48 @@ public class WareService extends CheckingService<Ware> {
);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void onChecked(CheckOrder order, CheckOrder.Operation operation, ImmutableMap<String, Object> parameters) {
if (StrUtil.equals(order.getKeyword(), "ware_check")) {
Long wareId = (Long) parameters.get("wareId");
Ware ware = detailOrThrow(wareId);
switch (operation) {
case APPLY:
ware.setState(Ware.State.NORMAL);
order.setState(CheckOrder.State.OVER);
break;
case REJECT:
ware.setState(Ware.State.DRAFT);
order.setState(CheckOrder.State.OVER);
break;
public void submit(Long id) throws Exception {
User user = userService.currentLoginUser();
Ware ware = detailOrThrow(id);
String instanceId = flowableManager.start(
WARE_FLOW_ID,
MapUtil.<String, Object>builder()
.put("wareId", id)
.put("type", "WARE")
.put("createdUsername", user.getUsername())
.put("modifiedUsername", user.getUsername())
.put(UserAssessor.KEY, ware.getResource().getCreatedUser().getId())
.build(),
ware.getResource().getCreatedUser().getId().toString()
);
wareRepository.updateInstanceIdById(id, instanceId);
wareRepository.updateStateById(id, Ware.State.CHECKING);
}
@Override
public void retract(Long id) throws Exception {
Ware ware = detailOrThrow(id);
flowableManager.terminal(ware.getFlowableInstanceId());
}
@Component
public static final class WareFlowUserCheckListener extends FlowableListener.AbstractFlowableListener {
private final WareRepository wareRepository;
public WareFlowUserCheckListener(WareRepository wareRepository) {
this.wareRepository = wareRepository;
}
@Override
public void onActionComplete(FlowableInstance instance, FlowableNode node, FlowableAction action) {
FlowableMetadata metadata = instance.getMetadata();
Long wareId = metadata.getLong("wareId");
if (FlowableAction.APPROVE.equals(action)) {
wareRepository.updateStateById(wareId, Ware.State.NORMAL);
} else {
wareRepository.updateStateById(wareId, Ware.State.DRAFT);
}
save(ware);
checkOrderService.save(order);
}
}
@Override
public ImmutableMap<String, Object> archive(Ware ware) {
return null;
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void submit(Long id) throws JsonProcessingException {
Ware ware = detailOrThrow(id);
ware.setState(Ware.State.CHECKING);
Long orderId = checkOrderService.save(new CheckOrder(
"ware_check",
StrUtil.format("数据资源「{}」的上架申请", ware.getName()),
CheckOrder.Type.MARKET,
mapper.writeValueAsString(Maps.immutable.of("wareId", ware.getId())),
"com.eshore.gringotts.web.domain.service.WareService",
User.Role.CHECKER
));
CheckOrder order = checkOrderService.detailOrThrow(orderId);
ware.setOrder(order);
save(ware);
}
@Transactional(rollbackOn = Throwable.class)
@Override
public void retract(Long id) {
Ware ware = detailOrThrow(id);
ware.setState(Ware.State.DRAFT);
save(ware);
CheckOrder order = ware.getOrder();
order.setState(CheckOrder.State.RETRACT);
checkOrderService.save(order);
}
}