proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/view/Page.java
|
Page
|
setTotal
|
class Page {
public static final int PAGE_MAX_DATA = 1000000;
private Integer pageIndex;
private Integer pageSize;
private String sort;
//总页数
private Integer totalPage;
//总条数
private Long total;
@Comment("Map → value 为复杂对象需做特殊处理，如：{region:{id:1,name:'xxxx'}},则需转换成：region_name 前端才可正常渲染")
private Collection<Map<String, Object>> list;
public void setTotal(Long total) {<FILL_FUNCTION_BODY>}
public Page(Integer pageIndex, Integer pageSize) {
this.pageIndex = pageIndex;
this.pageSize = pageSize;
}
public Page() {
}
}
|
this.total = total;
if (total % pageSize == 0) {
totalPage = total.intValue() / pageSize;
} else {
totalPage = total.intValue() / pageSize + 1;
}
| 218
| 61
| 279
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-core/src/main/java/xyz/erupt/core/view/TreeModel.java
|
TreeModel
|
setRoot
|
class TreeModel {
private String id;
private String label;
private String pid;
private Integer level; //树层级
private boolean root;
private Collection<TreeModel> children;
public TreeModel(Object id, Object label, Object pid, Object root) {
this(id, label, pid);
this.setRoot(root);
}
public TreeModel(Object id, Object label, Object pid) {
if (id != null) {
this.id = id.toString();
}
if (label != null) {
this.label = label.toString();
}
if (pid != null) {
this.pid = pid.toString();
}
}
public void setRoot(Object root) {<FILL_FUNCTION_BODY>}
}
|
if (null != root && StringUtils.isNotBlank(root.toString())) {
if (null == pid) {
this.root = false;
} else {
this.root = root.equals(pid);
}
} else {
this.root = null == pid;
}
| 213
| 80
| 293
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/config/HikariCpConfig.java
|
HikariCpConfig
|
toHikariConfig
|
class HikariCpConfig {
private static final long CONNECTION_TIMEOUT = TimeUnit.SECONDS.toMillis(30L);
private static final long VALIDATION_TIMEOUT = TimeUnit.SECONDS.toMillis(5L);
private static final long IDLE_TIMEOUT = TimeUnit.MINUTES.toMillis(10L);
private static final long MAX_LIFETIME = TimeUnit.MINUTES.toMillis(30L);
private static final int DEFAULT_POOL_SIZE = 10;
private String username;
private String password;
private String driverClassName;
private String jdbcUrl;
private String poolName;
private String catalog;
private Long connectionTimeout;
private Long validationTimeout;
private Long idleTimeout;
private Long leakDetectionThreshold;
private Long maxLifetime;
private Integer maxPoolSize;
private Integer minIdle;
private Long initializationFailTimeout;
private String connectionInitSql;
private String connectionTestQuery;
private String dataSourceClassName;
private String dataSourceJndiName;
private String schema;
private String transactionIsolationName;
private Boolean isAutoCommit;
private Boolean isReadOnly;
private Boolean isIsolateInternalQueries;
private Boolean isRegisterMbeans;
private Boolean isAllowPoolSuspension;
private Properties dataSourceProperties;
private Properties healthCheckProperties;
@SneakyThrows
public HikariConfig toHikariConfig() {<FILL_FUNCTION_BODY>}
}
|
HikariCpConfig g = this;
HikariConfig config = new HikariConfig();
String tempSchema = this.schema == null ? g.getSchema() : this.schema;
if (tempSchema != null) {
Field schemaField = HikariConfig.class.getDeclaredField("schema");
schemaField.setAccessible(true);
schemaField.set(config, tempSchema);
}
String tempCatalog = this.catalog == null ? g.getCatalog() : this.catalog;
if (tempCatalog != null) {
config.setCatalog(tempCatalog);
}
Long tempConnectionTimeout = this.connectionTimeout == null ? g.getConnectionTimeout() : this.connectionTimeout;
if (tempConnectionTimeout != null && !tempConnectionTimeout.equals(CONNECTION_TIMEOUT)) {
config.setConnectionTimeout(tempConnectionTimeout);
}
Long tempValidationTimeout = this.validationTimeout == null ? g.getValidationTimeout() : this.validationTimeout;
if (tempValidationTimeout != null && !tempValidationTimeout.equals(VALIDATION_TIMEOUT)) {
config.setValidationTimeout(tempValidationTimeout);
}
Long tempIdleTimeout = this.idleTimeout == null ? g.getIdleTimeout() : this.idleTimeout;
if (tempIdleTimeout != null && !tempIdleTimeout.equals(IDLE_TIMEOUT)) {
config.setIdleTimeout(tempIdleTimeout);
}
Long tempLeakDetectionThreshold = this.leakDetectionThreshold == null ? g.getLeakDetectionThreshold() : this.leakDetectionThreshold;
if (tempLeakDetectionThreshold != null) {
config.setLeakDetectionThreshold(tempLeakDetectionThreshold);
}
Long tempMaxLifetime = this.maxLifetime == null ? g.getMaxLifetime() : this.maxLifetime;
if (tempMaxLifetime != null && !tempMaxLifetime.equals(MAX_LIFETIME)) {
config.setMaxLifetime(tempMaxLifetime);
}
Integer tempMaxPoolSize = this.maxPoolSize == null ? g.getMaxPoolSize() : this.maxPoolSize;
if (tempMaxPoolSize != null && !tempMaxPoolSize.equals(-1)) {
config.setMaximumPoolSize(tempMaxPoolSize);
}
Integer tempMinIdle = this.minIdle == null ? g.getMinIdle() : this.getMinIdle();
if (tempMinIdle != null && !tempMinIdle.equals(-1)) {
config.setMinimumIdle(tempMinIdle);
}
Long tempInitializationFailTimeout = this.initializationFailTimeout == null ? g.getInitializationFailTimeout() : this.initializationFailTimeout;
if (tempInitializationFailTimeout != null && !tempInitializationFailTimeout.equals(1L)) {
config.setInitializationFailTimeout(tempInitializationFailTimeout);
}
String tempConnectionInitSql = this.connectionInitSql == null ? g.getConnectionInitSql() : this.connectionInitSql;
if (tempConnectionInitSql != null) {
config.setConnectionInitSql(tempConnectionInitSql);
}
String tempConnectionTestQuery = this.connectionTestQuery == null ? g.getConnectionTestQuery() : this.connectionTestQuery;
if (tempConnectionTestQuery != null) {
config.setConnectionTestQuery(tempConnectionTestQuery);
}
String tempDataSourceClassName = this.dataSourceClassName == null ? g.getDataSourceClassName() : this.dataSourceClassName;
if (tempDataSourceClassName != null) {
config.setDataSourceClassName(tempDataSourceClassName);
}
String tempDataSourceJndiName = this.dataSourceJndiName == null ? g.getDataSourceJndiName() : this.dataSourceJndiName;
if (tempDataSourceJndiName != null) {
config.setDataSourceJNDI(tempDataSourceJndiName);
}
String tempTransactionIsolationName = this.transactionIsolationName == null ? g.getTransactionIsolationName() : this.transactionIsolationName;
if (tempTransactionIsolationName != null) {
config.setTransactionIsolation(tempTransactionIsolationName);
}
Boolean tempAutoCommit = this.isAutoCommit == null ? g.getIsAutoCommit() : this.isAutoCommit;
if (tempAutoCommit != null && tempAutoCommit.equals(Boolean.FALSE)) {
config.setAutoCommit(false);
}
Boolean tempReadOnly = this.isReadOnly == null ? g.getIsReadOnly() : this.isReadOnly;
if (tempReadOnly != null) {
config.setReadOnly(tempReadOnly);
}
Boolean tempIsolateInternalQueries = this.isIsolateInternalQueries == null ? g.getIsIsolateInternalQueries() : this.isIsolateInternalQueries;
if (tempIsolateInternalQueries != null) {
config.setIsolateInternalQueries(tempIsolateInternalQueries);
}
Boolean tempRegisterMbeans = this.isRegisterMbeans == null ? g.getIsRegisterMbeans() : this.isRegisterMbeans;
if (tempRegisterMbeans != null) {
config.setRegisterMbeans(tempRegisterMbeans);
}
Boolean tempAllowPoolSuspension = this.isAllowPoolSuspension == null ? g.getIsAllowPoolSuspension() : this.isAllowPoolSuspension;
if (tempAllowPoolSuspension != null) {
config.setAllowPoolSuspension(tempAllowPoolSuspension);
}
Properties tempDataSourceProperties = this.dataSourceProperties == null ? g.getDataSourceProperties() : this.dataSourceProperties;
if (tempDataSourceProperties != null) {
config.setDataSourceProperties(tempDataSourceProperties);
}
Properties tempHealthCheckProperties = this.healthCheckProperties == null ? g.getHealthCheckProperties() : this.healthCheckProperties;
if (tempHealthCheckProperties != null) {
config.setHealthCheckProperties(tempHealthCheckProperties);
}
return config;
| 420
| 1,576
| 1,996
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/dao/EruptDao.java
|
EruptDao
|
mergeAndFlush
|
class EruptDao {
@PersistenceContext
private EntityManager entityManager;
@Resource
private EntityManagerService entityManagerService;
@Resource
private JdbcTemplate jdbcTemplate;
@Resource
private NamedParameterJdbcTemplate namedParameterJdbcTemplate;
private static final String SELECT = "select ";
private static final String FROM = " from ";
private static final String NEW_MAP = "new map(";
private static final String AS = " as ";
private static final String EQU = " = ";
private static final String WHERE = " where ";
public <T> T findById(Class<T> clazz, Object id) {
entityManager.clear();
return entityManager.find(clazz, id);
}
//修改
public <T> T merge(T t) {
return entityManager.merge(t);
}
public <T> T mergeAndFlush(T t) {<FILL_FUNCTION_BODY>}
public void flush() {
entityManager.flush();
}
//删除
public void delete(Object obj) {
entityManager.remove(obj);
}
//新增
public void persist(Object obj) {
entityManager.persist(obj);
}
public void persistAndFlush(Object obj) {
this.persist(obj);
this.flush();
}
public EntityManager getEntityManager() {
return entityManager;
}
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public NamedParameterJdbcTemplate getNamedParameterJdbcTemplate() {
return namedParameterJdbcTemplate;
}
public <T> EruptLambdaQuery<T> lambdaQuery(Class<T> eruptClass) {
return new EruptLambdaQuery<>(entityManager, eruptClass);
}
@Comment("根据数据源名称获取 EntityManager 注意：必须手动执行 entityManager.close() 方法")
public EntityManager getEntityManager(String name) {
return entityManagerService.findEntityManager(name);
}
//不存在则新增
public <T> T persistIfNotExist(Class<T> eruptClass, T obj, String field, String val) throws NonUniqueResultException {
T t = (T) queryEntity(eruptClass, field + EQU + " :val", new HashMap<String, Object>(1) {{
this.put("val", val);
}});
if (null == t) {
entityManager.persist(obj);
entityManager.flush();
return obj;
}
return t;
}
//以下方法调用时需考虑sql注入问题，切勿随意传递expr参数值!!!
public List<Map<String, Object>> queryMapList(Class<?> eruptClass, String expr, Map<String, Object> param, String... cols) {
return simpleQuery(eruptClass, true, expr, param, cols).getResultList();
}
public List<Object[]> queryObjectList(Class<?> eruptClass, String expr, Map<String, Object> param, String... cols) {
return simpleQuery(eruptClass, false, expr, param, cols).getResultList();
}
public <T> List<T> queryEntityList(Class<T> eruptClass, String expr, Map<String, Object> param) {
return simpleQuery(eruptClass, false, expr, param).getResultList();
}
public <T> List<T> queryEntityList(Class<T> eruptClass, String expr) {
return this.queryEntityList(eruptClass, expr, null);
}
public <T> List<T> queryEntityList(Class<T> eruptClass) {
return this.queryEntityList(eruptClass, null);
}
public Map<String, Object> queryMap(Class<?> eruptClass, String expr, Map<String, Object> param, String... cols) throws NonUniqueResultException {
try {
return (Map<String, Object>) simpleQuery(eruptClass, true, expr, param, cols).getSingleResult();
} catch (NoResultException e) {
return null;
}
}
public Object[] queryObject(Class<?> eruptClass, String expr, Map<String, Object> param, String... cols) throws NonUniqueResultException {
try {
return (Object[]) simpleQuery(eruptClass, false, expr, param, cols).getSingleResult();
} catch (NoResultException e) {
return null;
}
}
public <T> T queryEntity(Class<T> eruptClass, String expr, Map<String, Object> param) throws NonUniqueResultException {
try {
return (T) simpleQuery(eruptClass, false, expr, param).getSingleResult();
} catch (NoResultException e) {
return null;
}
}
public <T> T queryEntity(Class<T> eruptClass, String expr) {
return this.queryEntity(eruptClass, expr, null);
}
public <T> T queryEntity(Class<T> eruptClass) {
return this.queryEntity(eruptClass, null);
}
private Query simpleQuery(Class<?> eruptClass, boolean isMap, String expr, Map<String, Object> paramMap, String... cols) {
StringBuilder sb = new StringBuilder();
if (cols.length > 0) {
sb.append(SELECT);
if (isMap) {
sb.append(NEW_MAP);
for (int i = 0; i < cols.length; i++) {
sb.append(cols[i]).append(AS).append(cols[i]).append(i == cols.length - 1 ? "" : ",");
}
sb.append(")");
} else {
for (int i = 0; i < cols.length; i++) {
sb.append(cols[i]).append(i == cols.length - 1 ? "" : ",");
}
}
}
expr = StringUtils.isBlank(expr) ? "" : WHERE + expr;
Query query = entityManager.createQuery(sb + FROM + eruptClass.getSimpleName() + expr);
Optional.ofNullable(paramMap).ifPresent(map -> map.forEach(query::setParameter));
return query;
}
}
|
try {
return this.merge(t);
} finally {
this.flush();
}
| 1,667
| 30
| 1,697
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/dao/EruptJpaDao.java
|
EruptJpaDao
|
queryEruptList
|
class EruptJpaDao {
@Resource
private EntityManagerService entityManagerService;
public void addEntity(Class<?> eruptClass, Object entity) {
entityManagerService.entityManagerTran(eruptClass, (em) -> {
em.persist(entity);
em.flush();
});
}
public void editEntity(Class<?> eruptClass, Object entity) {
entityManagerService.entityManagerTran(eruptClass, (em) -> {
em.merge(entity);
em.flush();
});
}
public void removeEntity(Class<?> eruptClass, Object entity) {
entityManagerService.entityManagerTran(eruptClass, (em) -> {
EruptDataSource eruptDataSource = eruptClass.getAnnotation(EruptDataSource.class);
if (null == eruptDataSource) {
em.remove(entity);
} else {
em.remove(em.merge(entity));
}
em.flush();
});
}
public Page queryEruptList(EruptModel eruptModel, Page page, EruptQuery eruptQuery) {<FILL_FUNCTION_BODY>}
}
|
String hql = EruptJpaUtils.generateEruptJpaHql(eruptModel, "new map(" + String.join(",", EruptJpaUtils.getEruptColJpaKeys(eruptModel)) + ")", eruptQuery, false);
String countHql = EruptJpaUtils.generateEruptJpaHql(eruptModel, "count(*)", eruptQuery, true);
return entityManagerService.getEntityManager(eruptModel.getClazz(), entityManager -> {
Query query = entityManager.createQuery(hql);
Query countQuery = entityManager.createQuery(countHql);
Map<String, EruptFieldModel> eruptFieldMap = eruptModel.getEruptFieldMap();
if (null != eruptQuery.getConditions()) {
for (Condition condition : eruptQuery.getConditions()) {
EruptFieldModel eruptFieldModel = eruptFieldMap.get(condition.getKey());
condition.setKey(condition.getKey().replace(EruptConst.DOT, "_"));
switch (condition.getExpression()) {
case EQ:
countQuery.setParameter(condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, condition.getValue()));
query.setParameter(condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, condition.getValue()));
break;
case LIKE:
countQuery.setParameter(condition.getKey(), EruptJpaUtils.PERCENT + condition.getValue() + EruptJpaUtils.PERCENT);
query.setParameter(condition.getKey(), EruptJpaUtils.PERCENT + condition.getValue() + EruptJpaUtils.PERCENT);
break;
case RANGE:
List<?> list = (List<?>) condition.getValue();
countQuery.setParameter(EruptJpaUtils.L_VAL_KEY + condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, list.get(0)));
countQuery.setParameter(EruptJpaUtils.R_VAL_KEY + condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, list.get(1)));
query.setParameter(EruptJpaUtils.L_VAL_KEY + condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, list.get(0)));
query.setParameter(EruptJpaUtils.R_VAL_KEY + condition.getKey(), EruptUtil.convertObjectType(eruptFieldModel, list.get(1)));
break;
case IN:
List<Object> listIn = new ArrayList<>();
for (Object o : (List<?>) condition.getValue()) {
listIn.add(EruptUtil.convertObjectType(eruptFieldModel, o));
}
countQuery.setParameter(condition.getKey(), listIn);
query.setParameter(condition.getKey(), listIn);
break;
}
}
}
page.setTotal((Long) countQuery.getSingleResult());
if (page.getTotal() > 0) {
page.setList(query.setMaxResults(page.getPageSize()).setFirstResult((page.getPageIndex() - 1) * page.getPageSize()).getResultList());
} else {
page.setList(new ArrayList<>(0));
}
return page;
});
| 310
| 832
| 1,142
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/dao/EruptLambdaQuery.java
|
EruptLambdaQuery
|
eq
|
class EruptLambdaQuery<T> {
private final QuerySchema querySchema = new QuerySchema();
private final EntityManager entityManager;
private final Class<T> eruptClass;
public EruptLambdaQuery(EntityManager entityManager, Class<T> eruptClass) {
this.entityManager = entityManager;
this.eruptClass = eruptClass;
}
public <R> EruptLambdaQuery<T> isNull(SFunction<T, R> field) {
querySchema.getWheres().add(LambdaSee.info(field).getField() + " is null");
return this;
}
public <R> EruptLambdaQuery<T> isNotNull(SFunction<T, R> field) {
querySchema.getWheres().add(LambdaSee.info(field).getField() + " is not null");
return this;
}
public <R> EruptLambdaQuery<T> eq(SFunction<T, R> field, Object val) {<FILL_FUNCTION_BODY>}
public <R> EruptLambdaQuery<T> ne(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(LambdaSee.info(field).getField() + " <> :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> gt(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " > :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> lt(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " < :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> ge(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " >= :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> le(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " <= :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> between(SFunction<T, R> field, Object val1, Object val2) {
String l = this.genePlaceholder();
String r = this.genePlaceholder();
querySchema.getWheres().add(LambdaSee.info(field).getField() + " between :" + l + " and " + ":" + r);
querySchema.getParams().put(l, val1);
querySchema.getParams().put(r, val2);
return this;
}
public <R> EruptLambdaQuery<T> in(SFunction<T, R> field, List<Object> val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(LambdaSee.info(field).getField() + " in (:" + placeholder + ")");
querySchema.getParams().put(placeholder, val);
return this;
}
public <R> EruptLambdaQuery<T> in(SFunction<T, R> field, Object... val) {
return this.in(field, Arrays.stream(val).collect(Collectors.toList()));
}
public <R> EruptLambdaQuery<T> like(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " like :" + placeholder);
querySchema.getParams().put(placeholder, "%" + val + "%");
return this;
}
public <R> EruptLambdaQuery<T> likeValue(SFunction<T, R> field, Object val) {
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " like :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
}
//添加条件
public EruptLambdaQuery<T> addCondition(String condition) {
querySchema.getWheres().add(condition);
return this;
}
public EruptLambdaQuery<T> orderBy(SFunction<T, ?> field) {
querySchema.getOrders().add(LambdaSee.info(field).getField() + " asc");
return this;
}
public EruptLambdaQuery<T> orderByDesc(SFunction<T, ?> field) {
querySchema.getOrders().add(LambdaSee.info(field).getField() + " desc");
return this;
}
public EruptLambdaQuery<T> limit(Integer limit) {
querySchema.setLimit(limit);
return this;
}
public EruptLambdaQuery<T> offset(Integer offset) {
querySchema.setOffset(offset);
return this;
}
public T one() {
return (T) this.geneQuery().getSingleResult();
}
public List<T> list() {
return this.geneQuery().getResultList();
}
private Query geneQuery() {
StringBuilder expr = new StringBuilder(SqlLang.FROM + eruptClass.getSimpleName() + SqlLang.AS + eruptClass.getSimpleName());
if (!querySchema.getWheres().isEmpty()) {
expr.append(SqlLang.WHERE).append(String.join(SqlLang.AND, querySchema.getWheres()));
}
if (!querySchema.getOrders().isEmpty()) {
expr.append(SqlLang.ORDER_BY).append(String.join(",", querySchema.getOrders()));
}
Query query = entityManager.createQuery(expr.toString());
querySchema.getParams().forEach(query::setParameter);
Optional.ofNullable(querySchema.getLimit()).ifPresent(query::setMaxResults);
Optional.ofNullable(querySchema.getOffset()).ifPresent(query::setFirstResult);
return query;
}
private String genePlaceholder() {
return RandomStringUtils.randomAlphabetic(4);
}
private String geneField(SFunction<?, ?> field) {
LambdaInfo lambdaInfo = LambdaSee.info(field);
return lambdaInfo.getClazz().getSimpleName() + "." + lambdaInfo.getField();
}
@Getter
@Setter
public static class QuerySchema {
private Map<String, Object> params = new HashMap<>();
private List<String> wheres = new ArrayList<>();
private List<String> orders = new ArrayList<>();
private Integer limit;
private Integer offset;
}
}
|
String placeholder = this.genePlaceholder();
querySchema.getWheres().add(geneField(field) + " = :" + placeholder);
querySchema.getParams().put(placeholder, val);
return this;
| 1,872
| 60
| 1,932
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/service/EntityManagerService.java
|
EntityManagerService
|
getEntityManagerFactory
|
class EntityManagerService implements DisposableBean {
@PersistenceContext
private EntityManager entityManager;
@Resource
private EruptPropForDb eruptPropForDb;
private final Map<String, EntityManagerFactory> entityManagerFactoryMap = new HashMap<>();
private final List<EntityManager> extEntityManagers = new ArrayList<>();
private synchronized EntityManagerFactory getEntityManagerFactory(String dbName) {<FILL_FUNCTION_BODY>}
//注册扩展的EntityManager
public void addExtEntityManager(EntityManager entityManager) {
if (!extEntityManagers.contains(entityManager)) {
extEntityManagers.add(entityManager);
}
}
//移除扩展的EntityManager
public void removeExtEntityManager(EntityManager entityManager) {
extEntityManagers.remove(entityManager);
}
private EntityManager getExtEntityManager(Class<?> eruptClass) {
if (extEntityManagers.isEmpty()) return null;
return extEntityManagers.stream().filter(em -> {
try {
return em.getMetamodel().entity(eruptClass) != null;
} catch (Exception e) {
return false;
}
}).findFirst().orElse(null);
}
public <R> R getEntityManager(Class<?> eruptClass, Function<EntityManager, R> function) {
EntityManager extEntityManager = getExtEntityManager(eruptClass);
if (null != extEntityManager) return function.apply(extEntityManager);
EruptDataSource eruptDataSource = eruptClass.getAnnotation(EruptDataSource.class);
if (null == eruptDataSource) return function.apply(entityManager);
EntityManager em = this.getEntityManagerFactory(eruptDataSource.value()).createEntityManager();
try {
return function.apply(em);
} finally {
if (em.isOpen()) em.close();
}
}
public void entityManagerTran(Class<?> eruptClass, Consumer<EntityManager> consumer) {
EntityManager extEntityManager = getExtEntityManager(eruptClass);
if (null != extEntityManager) {
consumer.accept(extEntityManager);
return;
}
EruptDataSource eruptDataSource = eruptClass.getAnnotation(EruptDataSource.class);
if (null == eruptDataSource) {
consumer.accept(entityManager);
return;
}
EntityManager em = this.getEntityManagerFactory(eruptDataSource.value()).createEntityManager();
try {
em.getTransaction().begin();
consumer.accept(em);
em.getTransaction().commit();
} catch (Exception e) {
em.getTransaction().rollback();
throw e;
} finally {
if (em.isOpen()) em.close();
}
}
@Comment("必须手动执行 close() 方法")
public EntityManager findEntityManager(String name) {
return this.getEntityManagerFactory(name).createEntityManager();
}
@Override
public void destroy() {
for (EntityManagerFactory value : entityManagerFactoryMap.values()) {
value.close();
}
extEntityManagers.clear();
}
}
|
if (entityManagerFactoryMap.containsKey(dbName)) return entityManagerFactoryMap.get(dbName);
for (EruptPropForDb.DB prop : eruptPropForDb.getDbs()) {
if (dbName.equals(prop.getDatasource().getName())) {
Objects.requireNonNull(prop.getDatasource().getName(), "dbs configuration Must specify name → dbs.datasource.name");
Objects.requireNonNull(prop.getScanPackages(), String.format("%s DataSource not found 'scanPackages' configuration",
prop.getDatasource().getName()));
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
{
JpaProperties jpa = prop.getJpa();
HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
vendorAdapter.setGenerateDdl(jpa.isGenerateDdl());
vendorAdapter.setDatabase(jpa.getDatabase());
vendorAdapter.setShowSql(jpa.isShowSql());
vendorAdapter.setDatabasePlatform(jpa.getDatabasePlatform());
factory.setJpaVendorAdapter(vendorAdapter);
Properties properties = new Properties();
properties.putAll(jpa.getProperties());
factory.setJpaProperties(properties);
}
{
HikariConfig hikariConfig = prop.getDatasource().getHikari().toHikariConfig();
Optional.ofNullable(prop.getDatasource().getUrl()).ifPresent(hikariConfig::setJdbcUrl);
Optional.ofNullable(prop.getDatasource().getDriverClassName()).ifPresent(hikariConfig::setDriverClassName);
Optional.ofNullable(prop.getDatasource().getUsername()).ifPresent(hikariConfig::setUsername);
Optional.ofNullable(prop.getDatasource().getPassword()).ifPresent(hikariConfig::setPassword);
Optional.ofNullable(prop.getDatasource().getHikari().getPoolName()).ifPresent(hikariConfig::setPoolName);
factory.setDataSource(new HikariDataSource(hikariConfig));
factory.setPackagesToScan(prop.getScanPackages());
factory.afterPropertiesSet();
}
entityManagerFactoryMap.put(prop.getDatasource().getName(), factory.getObject());
return factory.getObject();
}
}
throw new RuntimeException("Failed to match data source '" + dbName + "'");
| 836
| 615
| 1,451
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/support/CommentIntegrator.java
|
CommentIntegrator
|
fieldComment
|
class CommentIntegrator implements Integrator {
/**
* Perform comment integration.
*
* @param metadata The "compiled" representation of the mapping information
* @param sessionFactory The session factory being created
* @param serviceRegistry The session factory's service registry
*/
@Override
public void integrate(Metadata metadata, SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry) {
this.processComment(metadata);
}
/**
* Not used.
*
* @param sessionFactoryImplementor The session factory being closed.
* @param sessionFactoryServiceRegistry That session factory's service registry
*/
@Override
public void disintegrate(SessionFactoryImplementor sessionFactoryImplementor, SessionFactoryServiceRegistry sessionFactoryServiceRegistry) {
}
/**
* Process comment annotation.
*
* @param metadata process annotation of this {@code Metadata}.
*/
private void processComment(Metadata metadata) {
for (PersistentClass persistentClass : metadata.getEntityBindings()) {
// Process the Comment annotation is applied to Class
Class<?> clazz = persistentClass.getMappedClass();
if (clazz.isAnnotationPresent(Erupt.class)) {
Erupt comment = clazz.getAnnotation(Erupt.class);
persistentClass.getTable().setComment(comment.name());
Optional.ofNullable(persistentClass.getIdentifierProperty()).ifPresent(it -> {
this.fieldComment(persistentClass, it.getName());
});
Iterator<Property> iterator = persistentClass.getPropertyIterator();
while (iterator.hasNext()) {
this.fieldComment(persistentClass, iterator.next().getName());
}
}
}
}
/**
* Process @{code comment} annotation of field.
*
* @param persistentClass Hibernate {@code PersistentClass}
* @param columnName name of field
*/
private void fieldComment(PersistentClass persistentClass, String columnName) {<FILL_FUNCTION_BODY>}
}
|
try {
Field field = ReflectUtil.findClassField(persistentClass.getMappedClass(), columnName);
if (null == field) return;
if (field.isAnnotationPresent(EruptField.class)
&& !field.isAnnotationPresent(OneToOne.class)
&& !field.isAnnotationPresent(OneToMany.class)
&& !field.isAnnotationPresent(ManyToMany.class)
) {
EruptField eruptField = field.getAnnotation(EruptField.class);
String comment = eruptField.edit().title();
if (StringUtils.isBlank(comment) && eruptField.views().length > 0) {
comment = eruptField.views()[0].title();
}
if (StringUtils.isNotBlank(comment)) {
String sqlColumnName = persistentClass.getProperty(columnName).getValue().getColumnIterator().next().getText();
Iterator<Column> columnIterator = persistentClass.getTable().getColumnIterator();
while (columnIterator.hasNext()) {
Column column = columnIterator.next();
if (sqlColumnName.equalsIgnoreCase(column.getName())) {
column.setComment(comment);
break;
}
}
}
}
} catch (SecurityException ignored) {
} catch (Exception e) {
log.warn(e.getMessage());
}
| 517
| 342
| 859
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-data/erupt-jpa/src/main/java/xyz/erupt/jpa/support/JpaSupport.java
|
JpaSupport
|
referencedColumnNameSupport
|
class JpaSupport {
@Resource
private EruptDao eruptDao;
/**
* 对jpa @JoinColumn提供的referencedColumnName配置实现适配
*/
@SneakyThrows
public void referencedColumnNameSupport(Object obj, Field field) {<FILL_FUNCTION_BODY>}
}
|
EruptField eruptField = field.getAnnotation(EruptField.class);
if (null != eruptField) {
JoinColumn joinColumn = field.getAnnotation(JoinColumn.class);
if (null != joinColumn && !"".equals(joinColumn.referencedColumnName())) {
String id;
if (eruptField.edit().type() == EditType.REFERENCE_TREE) {
id = eruptField.edit().referenceTreeType().id();
} else if (eruptField.edit().type() == EditType.REFERENCE_TABLE) {
id = eruptField.edit().referenceTableType().id();
} else {
return;
}
field.setAccessible(true);
Object refObject = field.get(obj);
if (null != refObject) {
Field idField = ReflectUtil.findClassField(refObject.getClass(), id);
idField.setAccessible(true);
EntityManager em = eruptDao.getEntityManager();
EruptDataSource eruptDataSource = refObject.getClass().getAnnotation(EruptDataSource.class);
if (eruptDataSource != null) {
em = eruptDao.getEntityManager(eruptDataSource.value());
}
Object result = em.createQuery("from " + refObject.getClass().getSimpleName() + " I where I.id = :id")
.setParameter("id", idField.get(refObject)).getSingleResult();
em.close();
field.set(obj, result);
}
}
}
| 90
| 400
| 490
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-excel/src/main/java/xyz/erupt/excel/controller/EruptExcelController.java
|
EruptExcelController
|
importExcel
|
class EruptExcelController {
private final EruptProp eruptProp;
private final EruptExcelService dataFileService;
private final EruptModifyController eruptModifyController;
private final EruptService eruptService;
//模板下载
@GetMapping(value = "/template/{erupt}")
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public void getExcelTemplate(@PathVariable("erupt") String eruptName, HttpServletRequest request,
HttpServletResponse response) throws IOException {
if (eruptProp.isCsrfInspect() && SecurityUtil.csrfInspect(request, response)) return;
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
Erupts.powerLegal(eruptModel, PowerObject::isImportable);
try (Workbook wb = dataFileService.createExcelTemplate(eruptModel)) {
wb.write(ExcelUtil.downLoadFile(request, response, eruptModel.getErupt().name() + "_template" + EruptExcelService.XLS_FORMAT));
}
}
//导出
@PostMapping("/export/{erupt}")
@EruptRecordOperate(value = "Export Excel", dynamicConfig = EruptRecordNaming.class)
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
public void exportData(@PathVariable("erupt") String eruptName,
@RequestBody(required = false) List<Condition> conditions,
HttpServletRequest request, HttpServletResponse response) throws IOException {
if (eruptProp.isCsrfInspect() && SecurityUtil.csrfInspect(request, response)) return;
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
Erupts.powerLegal(eruptModel, PowerObject::isExport);
TableQuery tableQuery = new TableQuery();
tableQuery.setPageIndex(1);
tableQuery.setPageSize(Page.PAGE_MAX_DATA);
Optional.ofNullable(conditions).ifPresent(tableQuery::setCondition);
Page page = eruptService.getEruptData(eruptModel, tableQuery, null);
try (Workbook wb = dataFileService.exportExcel(eruptModel, page)) {
DataProxyInvoke.invoke(eruptModel, (dataProxy -> dataProxy.excelExport(wb)));
wb.write(ExcelUtil.downLoadFile(request, response, eruptModel.getErupt().name() + EruptExcelService.XLSX_FORMAT));
}
}
//导入
@PostMapping("/import/{erupt}")
@EruptRecordOperate(value = "Import Excel", dynamicConfig = EruptRecordNaming.class)
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT)
@Transactional(rollbackOn = Exception.class)
public EruptApiModel importExcel(@PathVariable("erupt") String eruptName, @RequestParam("file") MultipartFile file) {<FILL_FUNCTION_BODY>}
}
|
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
Erupts.powerLegal(eruptModel, PowerObject::isImportable, "Not import permission");
if (file.isEmpty() || null == file.getOriginalFilename()) return EruptApiModel.errorApi("上传失败，请选择文件");
List<JsonObject> list;
int i = 1;
try {
i++;
Workbook wb;
if (file.getOriginalFilename().endsWith(EruptExcelService.XLS_FORMAT)) {
wb = new HSSFWorkbook(file.getInputStream());
} else if (file.getOriginalFilename().endsWith(EruptExcelService.XLSX_FORMAT)) {
wb = new XSSFWorkbook(file.getInputStream());
} else {
throw new EruptWebApiRuntimeException("上传文件格式必须为Excel");
}
DataProxyInvoke.invoke(eruptModel, (dataProxy -> dataProxy.excelImport(wb)));
list = dataFileService.excelToEruptObject(eruptModel, wb);
wb.close();
} catch (Exception e) {
throw new EruptWebApiRuntimeException("Excel解析异常，出错行数：" + i + "，原因：" + e.getMessage(), e);
}
try {
eruptModifyController.batchAddEruptData(eruptModel, list);
} catch (Exception e) {
throw new EruptWebApiRuntimeException("数据导入异常，原因：" + e.getMessage());
}
return EruptApiModel.successApi();
| 805
| 417
| 1,222
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-excel/src/main/java/xyz/erupt/excel/util/ExcelUtil.java
|
ExcelUtil
|
downLoadFile
|
class ExcelUtil {
public static CellStyle beautifyExcelStyle(Workbook wb) {
CellStyle style = wb.createCellStyle();
style.setBorderTop(BorderStyle.THIN);
style.setBorderBottom(BorderStyle.THIN);
style.setBorderLeft(BorderStyle.THIN);
style.setBorderRight(BorderStyle.THIN);
style.setTopBorderColor(IndexedColors.GREY_50_PERCENT.index);
style.setBottomBorderColor(IndexedColors.GREY_50_PERCENT.index);
style.setLeftBorderColor(IndexedColors.GREY_50_PERCENT.index);
style.setRightBorderColor(IndexedColors.GREY_50_PERCENT.index);
style.setAlignment(HorizontalAlignment.CENTER);
style.setVerticalAlignment(VerticalAlignment.CENTER);
style.setWrapText(true);
return style;
}
public static OutputStream downLoadFile(HttpServletRequest request, HttpServletResponse response, String fileName) {<FILL_FUNCTION_BODY>}
}
|
try {
String headStr = "attachment; filename=" + java.net.URLEncoder.encode(fileName, StandardCharsets.UTF_8.name());
response.setContentType("application/x-download");
response.setHeader("Content-Disposition", headStr);
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
return response.getOutputStream();
} catch (IOException e) {
log.error("erupt downLoad error", e);
return null;
}
| 295
| 131
| 426
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/EruptFlowAutoConfiguration.java
|
EruptFlowAutoConfiguration
|
initMenus
|
class EruptFlowAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptFlowAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name(FlowConstant.SERVER_NAME).build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
List<MetaMenu> metaMenus = new ArrayList<>();
//目录名和下面的权限名重复，所以加个后缀
metaMenus.add(MetaMenu.createRootMenu(FlowConstant.SERVER_NAME + "_root", "流程服务", "fa fa-send", 80));
// 添加菜单
metaMenus.add(MetaMenu.createSimpleMenu(FlowConstant.SERVER_NAME, "流程服务基础权限", "erupt-flow"
, metaMenus.get(0), 0, MenuTypeEnum.BUTTON.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu("workSpace", "工作区", FlowConstant.SERVER_NAME + "/index.html#/workSpace"
, metaMenus.get(0), 10, MenuTypeEnum.LINK.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu("formsPanel", "后台管理", FlowConstant.SERVER_NAME + "/index.html#/formsPanel"
, metaMenus.get(0), 20, MenuTypeEnum.LINK.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu("OaProcessInstanceHistory", "流程实例", "OaProcessInstanceHistory"
, metaMenus.get(0), 30, MenuTypeEnum.TABLE.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu("OaTaskHistory", "任务", "OaTaskHistory"
, metaMenus.get(0), 40, MenuTypeEnum.TABLE.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu("OaTaskOperation", "操作记录", "OaTaskOperation"
, metaMenus.get(0), 50, MenuTypeEnum.TABLE.getCode()));
return metaMenus;
| 108
| 443
| 551
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/conf/ListenerRegister.java
|
ListenerRegister
|
registerForTask
|
class ListenerRegister implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
if (ListenerRegister.applicationContext == null) {
ListenerRegister.applicationContext = applicationContext;
}
}
/**
* 注册流程实例的监听器
*/
@PostConstruct
public void registerForInstance() {
ProcessInstanceService service = applicationContext.getBean(ProcessInstanceService.class);
Class<ExecutableNodeListener>[] classes = new Class[]{
AfterCreateInstanceListener.class
, AfterFinishInstanceListener.class
, AfterStopInstanceListener.class
};
for (Class<ExecutableNodeListener> c : classes) {
this.addListener(service, c);
}
}
/**
* 注册线程的监听器
*/
@PostConstruct
public void registerForExecution() {
ProcessExecutionService service = applicationContext.getBean(ProcessExecutionService.class);
Class<ExecutableNodeListener>[] classes = new Class[]{
AfterCreateExecutionListener.class
, AfterActiveExecutionListener.class
, AfterDeactiveExecutionListener.class
, AfterFinishExecutionListener.class
, AfterStopExecutionListener.class
};
for (Class<ExecutableNodeListener> c : classes) {
this.addListener(service, c);
}
}
/**
* 注册活动的监听器
*/
@PostConstruct
public void registerForActivity() {
ProcessActivityService service = applicationContext.getBean(ProcessActivityService.class);
Class<ExecutableNodeListener>[] classes = new Class[]{
AfterCreateActivityListener.class
, AfterActiveActivityListener.class
, AfterDeactiveActivityListener.class
, AfterFinishActivityListener.class
, AfterStopActivityListener.class
};
for (Class<ExecutableNodeListener> c : classes) {
this.addListener(service, c);
}
}
/**
* 注册任务的监听器
*/
@PostConstruct
public void registerForTask() {<FILL_FUNCTION_BODY>}
private void addListener(WithListener service, Class<ExecutableNodeListener> c) {
String[] beanNamesForType = applicationContext.getBeanNamesForType(c);
List<ExecutableNodeListener> listeners = new ArrayList<>();
if(beanNamesForType!=null || beanNamesForType.length>0) {
for (String s : beanNamesForType) {
ExecutableNodeListener<OaProcessInstance> bean = applicationContext.getBean(s, c);
listeners.add(bean);
}
}
service.getListenerMap().put(c, listeners);
}
}
|
TaskService service = applicationContext.getBean(TaskService.class);
Class<ExecutableNodeListener>[] classes = new Class[]{
AfterCreateTaskListener.class
, AfterActiveTaskListener.class
, AfterDeactiveTaskListener.class
, AfterFinishTaskListener.class
, AfterStopTaskListener.class
, BeforeAssignTaskListener.class
, AfterAssignTaskListener.class
, AfterCompleteTaskListener.class
, AfterRefuseTaskListener.class
};
for (Class<ExecutableNodeListener> c : classes) {
this.addListener(service, c);
}
| 692
| 153
| 845
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/conf/UserLinkServiceHolderConfiguration.java
|
UserLinkServiceHolderConfiguration
|
userLinkServiceHolder
|
class UserLinkServiceHolderConfiguration {
/**
* 注入所有的 userLinkServices，然后按照优先级选择其中一个
* @param userLinkServices
*/
@Bean
public UserLinkServiceHolder userLinkServiceHolder(UserLinkService... userLinkServices) {<FILL_FUNCTION_BODY>}
}
|
UserLinkServiceHolder holder = new UserLinkServiceHolder();
//获取到优先级大于等于0的实例中，优先级最高的一个
UserLinkService userLinkService = Arrays.stream(userLinkServices)
.filter(e -> e.priority() >= 0)
.sorted()
.findFirst()
.get();
if(userLinkService==null) {
throw new RuntimeException("至少要有一个 " +UserLinkService.class.getName()+" 的实例");
}
holder.setUserLinkService(userLinkService);
return holder;
| 80
| 148
| 228
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/controller/EruptFlowFileController.java
|
EruptFlowFileController
|
deleteFile
|
class EruptFlowFileController {
private final EruptProp eruptProp;
/**
* 上传图片
* @param file
* @return
*/
@SneakyThrows
@PostMapping("/upload")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel upload(@RequestParam("file") MultipartFile file) {
if (file.isEmpty() || StringUtils.isBlank(file.getOriginalFilename())) {
return EruptApiModel.errorApi("上传失败，请选择文件");
}
String path;
if (eruptProp.isKeepUploadFileName()) {
path = File.separator + DateUtil.getFormatDate(new Date(), DateUtil.DATE) + File.separator + file.getOriginalFilename()
.replaceAll("&|#|\\?|\\s", "");
} else {
String[] fileNameSplit = file.getOriginalFilename().split("\\.");
path = File.separator + DateUtil.getFormatDate(new Date(), DateUtil.DATE)
+ File.separator + RandomStringUtils.randomAlphabetic(12) + EruptConst.DOT + fileNameSplit[fileNameSplit.length - 1];
}
//加一个独享空间，方便查找
path = File.separator + FlowConstant.SERVER_NAME + path;
try {
//是否本地存储
boolean localSave = true;
AttachmentProxy attachmentProxy = EruptUtil.findAttachmentProxy();
if (null != attachmentProxy) {
path = attachmentProxy.upLoad(file.getInputStream(), path.replace("\\", "/"));
localSave = attachmentProxy.isLocalSave();
}
if (localSave) {
File dest = new File(eruptProp.getUploadPath() + path);
if (!dest.getParentFile().exists()) {
if (!dest.getParentFile().mkdirs()) {
return EruptApiModel.errorApi("上传失败，文件目录无法创建");
}
}
file.transferTo(dest);
}
return EruptApiModel.successApi(new FileUploadResult(file.getOriginalFilename(), EruptRestPath.ERUPT_ATTACHMENT+path.replace("\\", "/")));
} catch (Exception e) {
return EruptApiModel.errorApi("上传失败，" + e.getMessage());
}
}
@SneakyThrows
@DeleteMapping("/file")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel deleteFile(@RequestParam("path") String path) {<FILL_FUNCTION_BODY>}
}
|
path = eruptProp.getUploadPath() + path.replace(EruptRestPath.ERUPT_ATTACHMENT, "");
File file = new File(path);
if(file.exists()) {
FileUtils.delete(file);
}
return EruptApiModel.successApi();
| 684
| 78
| 762
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/controller/ProcessInstanceController.java
|
ProcessInstanceController
|
getMineAbout
|
class ProcessInstanceController {
@Autowired
private ProcessInstanceService processInstanceService;
@GetMapping("/data/OaProcessInstance/{id}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel getById(@PathVariable("id") Long id) {
OaProcessInstance byId = processInstanceService.getById(id);
return EruptApiModel.successApi(byId);
}
/**
* 查询与我相关的流程
* @return
*/
@GetMapping("/inst/mine/about")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel getMineAbout(String keywords, int pageIndex, int pageSize) {<FILL_FUNCTION_BODY>}
}
|
PageHelper.startPage(pageIndex, pageSize);//分页
List<OaProcessInstanceHistory> datas = processInstanceService.getMineAbout(keywords, pageIndex, pageSize);
return EruptApiPageModel.successApi(datas, pageIndex, pageIndex);
| 213
| 71
| 284
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/controller/TaskController.java
|
TaskController
|
listMyTasks
|
class TaskController {
@Autowired
private TaskService taskService;
/**
* 查询我的任务
* @return
*/
@GetMapping("/task/mine")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel listMyTasks(String keywords, int pageIndex, int pageSize) {<FILL_FUNCTION_BODY>}
/**
* 完成任务
* @return
*/
@PostMapping("/task/complete/{taskId}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel complete(@PathVariable("taskId") Long taskId, @RequestBody JSONObject formContent) {
taskService.complete(taskId, formContent.getString("remarks"), formContent.getJSONObject("data").toJSONString());
return EruptApiModel.successApi();
}
/**
* 拒绝任务
* @return
*/
@PostMapping("/task/refuse/{taskId}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel refuse(@PathVariable("taskId") Long taskId, @RequestBody JSONObject formContent) {
taskService.refuse(taskId, formContent.getString("remarks"), formContent.getJSONObject("data").toJSONString());
return EruptApiModel.successApi();
}
/**
* 查询任务详情
* @return
*/
@GetMapping("/task/detail/{taskId}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel getTaskDetail(@PathVariable("taskId") Long taskId) {
TaskDetailVo taskView = taskService.getTaskDetail(taskId);
return EruptApiModel.successApi(taskView);
}
/**
* 查询任务详情
* @return
*/
@GetMapping("/inst/detail/{instId}")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel getInstDetail(@PathVariable("instId") Long instId) {
TaskDetailVo taskView = taskService.getInstDetail(instId);
return EruptApiModel.successApi(taskView);
}
}
|
PageHelper.startPage(pageIndex, pageSize);//分页
List<OaTask> page = taskService.listMyTasks(keywords);
return EruptApiPageModel.successApi(page, pageIndex, pageSize);
| 598
| 60
| 658
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/builder/TaskBuilder.java
|
TaskBuilder
|
addUser
|
class TaskBuilder {
//会签模式 NEXT顺序会签 AND并行会签 OR或签
private String completeMode;
//任务类型
private String taskType;
//是否激活
private Boolean active;
private int sort = 0;
private OaProcessActivity activity;
//任务分配用户，每个用户创建一个任务
private LinkedHashSet<OrgTreeVo> users = new LinkedHashSet<>();
//任务候选角色，创建一个任务，关联到候选人
private LinkedHashSet<OrgTreeVo> linkRoles = new LinkedHashSet<>();
//任务候选人，创建一个任务，关联到候选人
private LinkedHashSet<OrgTreeVo> linkUsers = new LinkedHashSet<>();
private UserLinkService userLinkService;
public TaskBuilder(OaProcessActivity activity) {
this.activity = activity;
this.userLinkService = EruptSpringUtil.getBean(UserLinkServiceHolder.class);
}
public List<OaTask> build() {
ArrayList<OaTask> tasks = new ArrayList<>();
if(FlowConstant.COMPLETE_MODE_OR.equals(this.completeMode)) {//或签，始终只会产生一个任务
OaTask build = buildPrimeTask();//先把任务生成
tasks.add(build);
if(!CollectionUtils.isEmpty(this.users)) {
if(this.users.size()>1) {//或签情况下，如果分配人大于1，自动转到候选人
this.linkUsers.addAll(this.users);
}else {//否则设置为分配人
build.setAssignee(this.users.iterator().next().getId());
}
}
//候选人也可以继续设置，但是有分配人的情况下会优先分配人处理
ArrayList<OaTaskUserLink> userLinks = new ArrayList<>();
if(!CollectionUtils.isEmpty(this.linkUsers)) {
userLinks.addAll(this.linkUsers.stream().map(u -> {
OaTaskUserLink link = new OaTaskUserLink();
link.setUserLinkType(FlowConstant.USER_LINK_USERS);
link.setLinkId(u.getId());
link.setLinkName(u.getName());
return link;
}).collect(Collectors.toList()));
}
if(!CollectionUtils.isEmpty(this.linkRoles)) {
userLinks.addAll(this.linkRoles.stream().map(u -> {
OaTaskUserLink link = new OaTaskUserLink();
link.setUserLinkType(FlowConstant.USER_LINK_ROLES);
link.setLinkId(u.getId());
link.setLinkName(u.getName());
return link;
}).collect(Collectors.toList()));
}
build.setUserLinks(userLinks);
}else {
/**
* 注意会签是生成多个任务，所以是不支持候选人的（一任务对应多人）
* 会把所有候选人变为分配人，然后为每一个分配人生成任务
*/
if(!CollectionUtils.isEmpty(this.linkUsers)) {
this.users.addAll(this.linkUsers);//候选人直接转为审批人
}
if(!CollectionUtils.isEmpty(this.linkRoles)) {//候选角色则需要查询，然后转为审批人
LinkedHashSet<OrgTreeVo> users =
userLinkService.getUserIdsByRoleIds(this.linkRoles.stream().map(l -> l.getId()).toArray(String[]::new));
this.users.addAll(users);
}
if(!CollectionUtils.isEmpty(this.users)) {
int i = 0;
while (this.users.iterator().hasNext()) {
OaTask oaTask = this.buildPrimeTask();
oaTask.setAssignee(this.users.iterator().next().getId());
if(this.active && i>0) {//当前任务需要激活时，串行只激活第一个，并行激活全部（无需处理）
oaTask.setActive(false);
}
tasks.add(oaTask);
}
}
}
return tasks;
}
/**
* 添加审批人
* @return
*/
public TaskBuilder addUser(OrgTreeVo... vos) {<FILL_FUNCTION_BODY>}
/**
* 添加候选人
* @return
*/
public TaskBuilder addLinkUser(OrgTreeVo... vos) {
for (OrgTreeVo id : vos) {
this.linkUsers.add(id);
}
return this;
}
/**
* 添加候选角色
* @return
*/
public TaskBuilder addLinkRole(OrgTreeVo... vos) {
for (OrgTreeVo id : vos) {
this.linkRoles.add(id);
}
return this;
}
private OaTask buildPrimeTask() {
return OaTask.builder()
.activityId(this.activity.getId())
.activityKey(this.activity.getActivityKey())
.executionId(this.activity.getExecutionId())
.processInstId(this.activity.getProcessInstId())
.processDefId(this.activity.getProcessDefId())
.taskName(this.activity.getActivityName())
.taskDesc(this.activity.getDescription())
.createDate(new Date())
.finished(false)
.completeMode(
this.completeMode.equals(FlowConstant.COMPLETE_MODE_NEXT)
? OaProcessActivity.SERIAL
: OaProcessActivity.PARALLEL
)
.taskType(this.taskType)
.completeSort(sort++)
.active(active)
.build();
}
}
|
for (OrgTreeVo id : vos) {
this.users.add(id);
}
return this;
| 1,501
| 36
| 1,537
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/engine/condition/DateChecker.java
|
DateChecker
|
check
|
class DateChecker implements ConditionChecker {
private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
@Override
public boolean check(OaProcessExecution execution, JSONObject form, OaProcessNodeCondition condition) throws ParseException {<FILL_FUNCTION_BODY>}
}
|
Date formValue = form.getDate(condition.getId());//表单值
String[] value = condition.getValue();//对照值
if(value==null || value.length<=0) {
log.error("条件没有对照值");
return false;
}
if(formValue==null) {//不能报错，因为可能是测试走流程
log.error("分支条件不能为空");
return false;
}
if("=".equals(condition.getCompare())) {
return formValue.compareTo(dateFormat.parse(value[0]))==0;
}else if(">".equals(condition.getCompare())) {
return formValue.compareTo(dateFormat.parse(value[0]))>0;
}else if("<".equals(condition.getCompare())) {
return formValue.compareTo(dateFormat.parse(value[0]))<0;
}else if(">=".equals(condition.getCompare())) {
return formValue.compareTo(dateFormat.parse(value[0]))>=0;
}else if("<=".equals(condition.getCompare())) {
return formValue.compareTo(dateFormat.parse(value[0]))<=0;
}else if("IN".equals(condition.getCompare())) {//等于任意一个
for (String s : value) {
if(formValue.compareTo(dateFormat.parse(s))==0) {
return true;
}
}
return false;
}else {
if(value==null || value.length!=2) {
throw new RuntimeException("必须有2个对照值");
}
if("B".equals(condition.getCompare())) {//x < 值 < x，左右都是开区间
return formValue.compareTo(dateFormat.parse(value[0]))>0 && formValue.compareTo(dateFormat.parse(value[1]))<0;
}else if("'AB'".equals(condition.getCompare())) {//x ≤ 值 < x，左闭右开
return formValue.compareTo(dateFormat.parse(value[0]))>=0 && formValue.compareTo(dateFormat.parse(value[1]))<0;
}else if("'BA'".equals(condition.getCompare())) {//x < 值 ≤ x，左开右闭
return formValue.compareTo(dateFormat.parse(value[0]))>0 && formValue.compareTo(dateFormat.parse(value[1]))<=0;
}else if("'ABA'".equals(condition.getCompare())) {//x ≤ 值 ≤ x，左右都是闭区间
return formValue.compareTo(dateFormat.parse(value[0]))>=0 && formValue.compareTo(dateFormat.parse(value[1]))<=0;
}
}
return false;
| 79
| 707
| 786
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/engine/condition/DeptChecker.java
|
DeptChecker
|
compareForDept
|
class DeptChecker implements ConditionChecker {
@Autowired
private EruptOrgRepository eruptOrgRepository;
@Override
public boolean check(OaProcessExecution execution, JSONObject form, OaProcessNodeCondition condition) {
/** 获取选中的值 */
Set<Long> formValues = new HashSet<>();
JSONArray jsonArray = form.getJSONArray(condition.getId());
if(jsonArray!=null && jsonArray.size()>0) {
for (int i = 0; i < jsonArray.size(); i++) {
formValues.add(jsonArray.getJSONObject(i).getLongValue("id"));
}
}else {
return false;//如果没有选值，则一定不符合要求
}
/** 获取参考值 */
String[] value = condition.getValue();//对照值
if(value==null || value.length<=0) {
log.error("条件没有对照值");
return false;
}
if(formValues==null) {//不能报错，因为可能是测试走流程
log.error("分支条件不能为空");
return false;
}
// 根据不同的比较符进行判断
if("dept".equals(condition.getCompare())) {
return compareForDept(formValues, value);
}
log.error("比较符无法识别"+condition.getCompare());
return false;
}
public boolean compareForDept(Set<Long> formValues, String[] value) {<FILL_FUNCTION_BODY>}
/**
* 判断A部门的所有上级中有没有B部门
* @return
*/
public boolean instanceOfDept(Long deptId, Long parentId) {
EruptOrg dept = eruptOrgRepository.findById(deptId).get();
while((dept = dept.getParentOrg())!=null) {
if(parentId.equals(dept.getId())) {
return true;
}
}
return false;
}
}
|
if(formValues==null || formValues.size()<=0) {
return false;
}
Iterator<Long> iterator = formValues.iterator();
while(iterator.hasNext()) {
Long next = iterator.next();//取出所选用户
boolean found = false;
for (int i = 0; i < value.length; i++) {//循环匹配参考值
//部门id是long型的
if(next.equals(JSON.parseObject(value[i]).getLongValue("id"))) {
found = true;
break;
}else if(instanceOfDept(next, JSON.parseObject(value[i]).getLongValue("id"))) {
found = true;
break;
}
}
if(!found) {//如果没有匹配到，则条件不符合
return false;
}
}
return true;
| 515
| 228
| 743
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/engine/condition/NumberChecker.java
|
NumberChecker
|
check
|
class NumberChecker implements ConditionChecker {
@Override
public boolean check(OaProcessExecution execution, JSONObject form, OaProcessNodeCondition condition) {<FILL_FUNCTION_BODY>}
}
|
Double formValue = form.getDouble(condition.getId());//表单值
String[] value = condition.getValue();//对照值
if(value==null || value.length<=0) {
log.error("条件没有对照值");
return false;
}
if(formValue==null) {//不能报错，因为可能是测试走流程
log.error("分支条件不能为空");
return false;
}
if("=".equals(condition.getCompare())) {
return formValue.compareTo(Double.valueOf(value[0]))==0;
}else if(">".equals(condition.getCompare())) {
return formValue.compareTo(Double.valueOf(value[0]))>0;
}else if("<".equals(condition.getCompare())) {
return formValue.compareTo(Double.valueOf(value[0]))<0;
}else if(">=".equals(condition.getCompare())) {
return formValue.compareTo(Double.valueOf(value[0]))>=0;
}else if("<=".equals(condition.getCompare())) {
return formValue.compareTo(Double.valueOf(value[0]))<=0;
}else if("IN".equals(condition.getCompare())) {//等于任意一个
for (String s : value) {
if(formValue.compareTo(Double.valueOf(s))==0) {
return true;
}
}
return false;
}else {
if(value==null || value.length!=2) {
throw new RuntimeException("必须有2个对照值");
}
if("B".equals(condition.getCompare())) {//x < 值 < x，左右都是开区间
return formValue.compareTo(Double.valueOf(value[0]))>0 && formValue.compareTo(Double.valueOf(value[1]))<0;
}else if("'AB'".equals(condition.getCompare())) {//x ≤ 值 < x，左闭右开
return formValue.compareTo(Double.valueOf(value[0]))>=0 && formValue.compareTo(Double.valueOf(value[1]))<0;
}else if("'BA'".equals(condition.getCompare())) {//x < 值 ≤ x，左开右闭
return formValue.compareTo(Double.valueOf(value[0]))>0 && formValue.compareTo(Double.valueOf(value[1]))<=0;
}else if("'ABA'".equals(condition.getCompare())) {//x ≤ 值 ≤ x，左右都是闭区间
return formValue.compareTo(Double.valueOf(value[0]))>=0 && formValue.compareTo(Double.valueOf(value[1]))<=0;
}
}
return false;
| 53
| 707
| 760
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/engine/condition/StringChecker.java
|
StringChecker
|
check
|
class StringChecker implements ConditionChecker {
@Override
public boolean check(OaProcessExecution execution, JSONObject form, OaProcessNodeCondition condition) {<FILL_FUNCTION_BODY>}
}
|
String formValue = form.getString(condition.getId());//表单值
String[] value = condition.getValue();//对照值
if(value==null || value.length<=0) {
log.error("条件没有对照值");
return false;
}
if(formValue==null) {//不能报错，因为可能是测试走流程
log.error("分支条件不能为空");
return false;
}
if("=".equals(condition.getCompare())) {
return value[0].equals(formValue);
}
return false;
| 53
| 147
| 200
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/engine/condition/UserChecker.java
|
UserChecker
|
compareForUser
|
class UserChecker implements ConditionChecker {
@Autowired
private ProcessInstanceService processInstanceService;
@Autowired
private EruptUserService eruptUserService;
@Autowired
private EruptUserRepository eruptUserRepository;
@Autowired
private DeptChecker deptChecker;
/**
* 所选用户分为2种，发起人，或者人员选择字段
* 比较方式分为三种：人员、部门、角色
* @param form
* @param condition
* @return
*/
@Override
public boolean check(OaProcessExecution execution, JSONObject form, OaProcessNodeCondition condition) {
String fieldId = condition.getId();
Set<String> formValues = new HashSet<>();
//所选人员属于集合之一，选择的每个人都要命中才返回true
if("root".equals(fieldId)) {//取发起人进行对比
if(execution!=null) {//已有实例，则取实例发起人
OaProcessInstance instance = processInstanceService.getById(execution.getProcessInstId());
formValues.add(instance.getCreator());
}else {//否则取当前用户
formValues.add(eruptUserService.getCurrentAccount());
}
}else {
JSONArray jsonArray = form.getJSONArray(condition.getId());
if(jsonArray!=null && jsonArray.size()>0) {
for (int i = 0; i < jsonArray.size(); i++) {
formValues.add(jsonArray.getJSONObject(i).getString("id"));
}
}else {
return false;//如果没有选值，则一定不符合要求
}
}
String[] value = condition.getValue();//对照值
if(value==null || value.length<=0) {
log.error("条件没有对照值");
return false;
}
if(formValues==null) {//不能报错，因为可能是测试走流程
log.error("分支条件不能为空");
return false;
}
// 根据三种不同的比较符进行判断
if("user".equals(condition.getCompare())) {
return compareForUser(formValues, value);
}else if("dept".equals(condition.getCompare())) {
return compareForDept(formValues, value);
}else if("role".equals(condition.getCompare())) {
return compareForRole(formValues, value);
}
log.error("比较符无法识别"+condition.getCompare());
return false;
}
public boolean compareForUser(Set<String> formValues, String[] value) {<FILL_FUNCTION_BODY>}
public boolean compareForDept(Set<String> formValues, String[] value) {
if(formValues==null || formValues.size()<=0) {
return false;
}
List<EruptUser> users = eruptUserRepository.findByAccountIn(formValues);
for (EruptUser user : users) {
if(user.getEruptOrg()==null) {//任意用户没有部门则返回false
return false;
}
Long deptId = user.getEruptOrg().getId();
boolean found = false;
for (int i = 0; i < value.length; i++) {//循环匹配参考值
//部门id是long型的
if(deptId.equals(JSON.parseObject(value[i]).getLongValue("id"))) {
found = true;
break;
}else if(deptChecker.instanceOfDept(deptId, JSON.parseObject(value[i]).getLongValue("id"))) {
found = true;
break;
}
}
if(!found) {//如果没有匹配到，则条件不符合
return false;
}
}
return true;
}
public boolean compareForRole(Set<String> formValues, String[] value) {
if(formValues==null || formValues.size()<=0) {
return false;
}
Iterator<String> iterator = formValues.iterator();
while(iterator.hasNext()) {
String next = iterator.next();//取出所选用户
EruptUser account = eruptUserRepository.findByAccount(next);//查询用户信息
boolean found = false;
for (int i = 0; i < value.length; i++) {//循环匹配参考值
if(account.getRoles()!=null) {
for (EruptRole role : account.getRoles()) {
if(role.getCode().equals(JSON.parseObject(value[i]).getString("id"))) {
found = true;//任意一个角色命中即可
break;
}
}
}
}
if(!found) {//如果没有匹配到，则条件不符合s
return false;
}
}
return true;
}
}
|
if(formValues==null || formValues.size()<=0) {
return false;
}
Iterator<String> iterator = formValues.iterator();
while(iterator.hasNext()) {
String next = iterator.next();//取出所选用户
boolean found = false;
for (int i = 0; i < value.length; i++) {//循环匹配参考值
if(next.equals(JSON.parseObject(value[i]).getString("id"))) {
found = true;
break;
}
}
if(!found) {//如果没有匹配到，则条件不符合
return false;
}
}
return true;
| 1,255
| 177
| 1,432
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/listener/impl/AfterActiveTaskImpl.java
|
AfterActiveTaskImpl
|
execute
|
class AfterActiveTaskImpl implements AfterCreateTaskListener {
@Override
public int sort() {
return 0;
}
@Autowired
private ProcessActivityService processActivityService;
@Autowired
private TaskService taskService;
@Autowired
private UserLinkServiceHolder userLinkService;
@Autowired
private TaskUserLinkService taskUserLinkService;
@Override
public void execute(OaTask task) {<FILL_FUNCTION_BODY>}
}
|
if(!task.getActive()) {
return;
}
//判断任务是否有人可以处理
if(
task.getTaskOwner()==null//没有所属人
&& task.getAssignee()==null//没有分配人
&& taskUserLinkService.countUsersByTaskId(task.getId())<=0//候选人
) {//触发无人审批事件
OaProcessActivity activity = processActivityService.getById(task.getActivityId());
OaProcessNodeProps props = activity.getProcessNode().getProps();
OaProcessNodeNobody nobodyConf = props.getNobody();
if(nobodyConf==null) {//未配置无人审批策略
throw new EruptApiErrorTip("无人处理的审批方式为空");
}
if(FlowConstant.NOBODY_TO_PASS.equals(nobodyConf.getHandler())) {
//直接完成
taskService.complete(task.getId(), null, "无人处理，自动完成", null, null);
}else if(FlowConstant.NOBODY_TO_REFUSE.equals(nobodyConf.getHandler())) {
//直接拒绝
taskService.refuse(task.getId(), "无人处理，自动拒绝", null);
}else if(FlowConstant.NOBODY_TO_ADMIN.equals(nobodyConf.getHandler())) {//分配给超管用户
LinkedHashSet<OrgTreeVo> userIds = userLinkService.getAdminUsers();
if(CollectionUtils.isEmpty(userIds)) {
throw new EruptApiErrorTip("未查询到超管用户");
}
//将任务转办给超管
taskService.assign(task.getId(), userIds, "无人处理，转办给超管用户");
}else if(FlowConstant.NOBODY_TO_USER.equals(nobodyConf.getHandler())) {
//将任务转办给指定用户
Set<OrgTreeVo> users =
nobodyConf.getAssignedUser().stream().map(au -> OrgTreeVo.builder()
.id(au.getId())
.name(au.getName())
.build()
).collect(Collectors.toSet());
taskService.assign(task.getId(), users, "无人处理，转办给指定用户");
}else {
throw new EruptApiErrorTip("请设置无人处理的审批方式");
}
}
| 130
| 604
| 734
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/listener/impl/CompleteActivity.java
|
CompleteActivity
|
execute
|
class CompleteActivity implements AfterCompleteTaskListener {
@Override
public int sort() {
return 0;
}
@Autowired
private TaskService taskService;
@Autowired
private ProcessActivityService processActivityService;
@Override
public void execute(OaTask task) {<FILL_FUNCTION_BODY>}
}
|
//尝试激活下一个任务，如果激活成功则不继续执行
boolean a = taskService.activeTaskByActivityId(task.getActivityId());
if(a) {
return;
}
processActivityService.complete(task.getActivityId());
| 92
| 69
| 161
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/process/listener/impl/NewTaskListener.java
|
NewTaskListener
|
generateTask
|
class NewTaskListener implements AfterCreateActivityListener {
@Override
public int sort() {
return 0;
}
@Autowired
private ProcessInstanceService processInstanceService;
@Autowired
private ProcessExecutionService processExecutionService;
@Autowired
private ProcessActivityService processActivityService;
@Autowired
private ProcessActivityHistoryService processActivityHistoryService;
@Autowired
private TaskService taskService;
@Autowired
private UserLinkServiceHolder userLinkService;
@Autowired
private EruptUserService eruptUserService;
@Override
public void execute(OaProcessActivity activity) {
OaProcessExecution execution = processExecutionService.getById(activity.getExecutionId());
OaProcessNode node = activity.getProcessNode();
//生成任务
this.generateTask(execution, activity, node, node.getProps());
}
private void generateTask(OaProcessExecution execution, OaProcessActivity activity, OaProcessNode node, OaProcessNodeProps props) {<FILL_FUNCTION_BODY>}
/**
* 解析领导审批
* @param execution
* @param node
* @param props
* @param leaderMap
*/
private void forLeaders(
OaProcessExecution execution, OaProcessNode node, OaProcessActivity activity
, OaProcessNodeProps props, LinkedHashMap<Integer, List<OrgTreeVo>> leaderMap) {
//这种情况要删除原本的活动
processActivityService.removeById(activity.getId());
processActivityHistoryService.removeById(activity.getId());
boolean first = true;
for (Integer integer : leaderMap.keySet()) {
List<OrgTreeVo> leaders = leaderMap.get(integer);
OaProcessNodeProps buildProps = new OaProcessNodeProps().builder()
.assignedType(FlowConstant.ASSIGN_TYPE_USER)//分配给用户
.assignedUser(
leaders.stream().map(l -> {
OaProcessNodeAssign assign = new OaProcessNodeAssign();
assign.setId(l.getId());
return assign;
}).collect(Collectors.toList())
)
.mode(props.getMode())//沿用传入的会签模式
.nobody(props.getNobody())
.timeLimit(props.getTimeLimit())
.refuse(props.getRefuse())
.formPerms(props.getFormPerms())
.build();
node.setDesc("第"+integer+"级主管审批");
if(first) {//只有第一个活动激活，生成新活动，注意这个活动不能触发后置监听器，不然胡递归
processActivityService.newActivity(execution, node, OaProcessExecution.STATUS_RUNNING, buildProps, integer);
first = false;
}else {
processActivityService.newActivity(execution, node, OaProcessExecution.STATUS_WAITING, buildProps, integer);
}
}
}
}
|
TaskBuilder builder = new TaskBuilder(activity);
//查询出当前实例
OaProcessInstance inst = processInstanceService.getById(activity.getProcessInstId());
//设置会签模式
builder.setCompleteMode(props.getMode());
builder.setTaskType(node.getType());
builder.setActive(activity.getActive());
//如果是开始节点，直接指定处理人
if(FlowConstant.NODE_TYPE_ROOT_VALUE.equals(activity.getActivityKey())) {
builder.addUser(OrgTreeVo.builder()
.id(inst.getCreator())
.build());
}else {
/**
* 确定用户处理人
*/
switch (props.getAssignedType()) {
case FlowConstant.ASSIGN_TYPE_CC://抄送人和分配人一样的处理方式
case FlowConstant.ASSIGN_TYPE_USER://循环添加分配人
props.getAssignedUser().forEach(au -> builder.addUser(au));
break;
case FlowConstant.ASSIGN_TYPE_ROLE://循环添加候选角色
props.getRole().forEach(a -> builder.addLinkRole(a));
break;
case FlowConstant.ASSIGN_TYPE_SELF_SELECT://发起人自选，暂不支持
throw new RuntimeException("暂不支持发起人自选");
case FlowConstant.ASSIGN_TYPE_SELF:
builder.addUser(
OrgTreeVo.builder()
.id(inst.getCreator())
.name("发起人")
.build());//将发起人作为审批人
break;
case FlowConstant.ASSIGN_TYPE_LEADER_TOP://发起人的所有上级
int endLevel = props.getLeaderTop().getLevel();//最多x级的领导
if("TOP".equals(props.getLeaderTop().getEndCondition())) {
endLevel = -1;//不限制层级
}
//查询主管
LinkedHashMap<Integer, List<OrgTreeVo>> leaderMap =
userLinkService.getLeaderMap(inst.getCreator(), 1, endLevel);
this.forLeaders(execution, node, activity, props, leaderMap);
return;//这种情况不需要继续后续操作
case FlowConstant.ASSIGN_TYPE_LEADER://特定层级主管
//查询主管
LinkedHashMap<Integer, List<OrgTreeVo>> leaderMapNew =
userLinkService.getLeaderMap(inst.getCreator(), props.getLeader().getLevel(), props.getLeader().getLevel());
this.forLeaders(execution, node, activity, props, leaderMapNew);
return;//这种情况不需要继续后续操作
case FlowConstant.ASSIGN_TYPE_FORM_USER:
//从表单中取值
JSONObject formContent = JSON.parseObject(inst.getFormItems());
List<JSONObject> users = formContent.getObject(props.getFormUser(), List.class);
if(CollectionUtils.isEmpty(users)) {
throw new RuntimeException("从表单中获取联系人失败");
}
users.forEach(u -> {
builder.addUser(
OrgTreeVo.builder()
.id(u.getString("id"))
.name(u.getString("name"))
.build()
);//全部都是分配人
});
break;
default:
throw new RuntimeException("请指定审批人");
}
}
List<OaTask> oaTasks = builder.build();
if(CollectionUtils.isEmpty(oaTasks)) {
throw new RuntimeException("为活动"+activity.getActivityName()+"生成任务失败");
}
//保存任务列表
taskService.saveBatchWithUserLink(oaTasks);
| 769
| 957
| 1,726
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/FormGroupServiceImpl.java
|
FormGroupServiceImpl
|
getFormGroupList
|
class FormGroupServiceImpl extends ServiceImpl<OaFormGroupsMapper, OaFormGroups> implements FormGroupService {
@Autowired
private FormsService formsService;
@Override
public List<OaFormGroups> getFormGroups(OaFormGroups formGroupVo) {
List<OaFormGroups> voList = this.getFormGroupList();
//循环添加组内的表单
voList.forEach(vo -> {
//添加组内的流程列表
List<OaForms> oaForms = formsService.listByGroupId(vo.getGroupId(), formGroupVo.getKeywords());
vo.setItems(oaForms);
});
return voList;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void formGroupsSort(List<Long> groups) {
List<OaFormGroups> updateList = new ArrayList<>();
for (int i1 = 0; i1 < groups.size(); i1++) {
updateList.add(
OaFormGroups.builder()
.groupId(groups.get(i1))
.sort(i1)
.build()
);
}
super.updateBatchById(updateList);
return;
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateFormGroupName(Long id, String name) {
super.updateById(OaFormGroups.builder().groupId(id).groupName(name).build());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void createFormGroup(String name) {
super.save(OaFormGroups.builder().sort(1).groupName(name).updated(new Date()).build());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteFormGroup(Long id) {
super.removeById(id);
}
@Override
public List<OaFormGroups> getFormGroupList() {<FILL_FUNCTION_BODY>}
}
|
QueryWrapper<OaFormGroups> query = new QueryWrapper<OaFormGroups>()
.orderByAsc("sort");
List<OaFormGroups> list = super.list(query);
//结尾添加两个固定分组
list.add(OaFormGroups.builder()
.groupId(0L)
.groupName("其他")
.sort(999)
.updated(new Date())
.build());
list.add(OaFormGroups.builder()
.groupId(-1L)
.groupName("已停用")
.sort(9999)
.updated(new Date())
.build());
return list;
| 516
| 172
| 688
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/FormsServiceImpl.java
|
FormsServiceImpl
|
formsSort
|
class FormsServiceImpl extends ServiceImpl<OaFormsMapper, OaForms> implements FormsService {
@Lazy
@Autowired
private ProcessDefinitionService processDefinitionService;
@Override
@Transactional(rollbackFor = Exception.class)
public boolean updateById(OaForms entity) {
entity.setIsStop(entity.getGroupId()==-1);
//需要同时修改对应的流程定义的锁定状态和分组
OaProcessDefinition lastVersionByFromId = processDefinitionService.getLastVersionByFromId(entity.getFormId());
lastVersionByFromId.setIsStop(entity.getIsStop());
lastVersionByFromId.setGroupId(entity.getGroupId());
processDefinitionService.updateById(lastVersionByFromId);
return super.updateById(entity);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void createForm(OaForms form) {
Date now = new Date();
form.setSort(0);
form.setIsStop(false);
form.setCreated(now);
form.setUpdated(now);
super.save(form);//保存表单
processDefinitionService.deploy(form);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateFormDetail(OaForms forms) {
processDefinitionService.deploy(forms);
//不更新的字段设为null
forms.setSort(null);
forms.setIsStop(null);
forms.setUpdated(new Date());
super.updateById(forms);
}
@Override
public List<OaForms> listByGroupId(Long groupId, String keywords) {
QueryWrapper<OaForms> queryWrapper = new QueryWrapper<>(OaForms.builder()
.groupId(groupId)
.build()).orderByAsc("sort");
if(StringUtils.isNotEmpty(keywords)) {
queryWrapper.lambda().like(OaForms::getFormName, keywords);
}
return super.list(queryWrapper);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void formsSort(List<Long> formIds) {<FILL_FUNCTION_BODY>}
@Override
@Transactional(rollbackFor = Exception.class)
public boolean removeById(Serializable id) {
//级联删除流程定义
processDefinitionService.removeByFormId((Long) id);
return super.removeById(id);
}
}
|
List<OaForms> updateList = new ArrayList<>();
for (int i1 = 0; i1 < formIds.size(); i1++) {
updateList.add(
OaForms.builder()
.formId(formIds.get(i1))
.sort(i1)
.build()
);
}
super.updateBatchById(updateList);
| 645
| 100
| 745
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/ProcessActivityHistoryServiceImpl.java
|
ProcessActivityHistoryServiceImpl
|
listFinishedByExecutionId
|
class ProcessActivityHistoryServiceImpl extends ServiceImpl<OaProcessActivityHistoryMapper, OaProcessActivityHistory>
implements ProcessActivityHistoryService, DataProxy<OaProcessActivityHistory> {
@Autowired
private TaskHistoryService taskHistoryService;
@Override
public List<OaProcessActivityHistory> listByProcInstId(Long instId, boolean active) {
LambdaQueryWrapper<OaProcessActivityHistory> queryWrapper = new LambdaQueryWrapper<OaProcessActivityHistory>()
.eq(OaProcessActivityHistory::getProcessInstId, instId)
.eq(OaProcessActivityHistory::getActive, active)
.orderByAsc(OaProcessActivityHistory::getFinishDate);
List<OaProcessActivityHistory> list = super.list(queryWrapper);
//查询任务历史
list.forEach(h -> {
List<OaTaskHistory> taskHistories = taskHistoryService.listByActivityId(h.getId());
h.setTasks(taskHistories);
});
return list;
}
@Override
@Transactional(rollbackFor = Exception.class)
public OaProcessActivityHistory copyAndSave(OaProcessActivity activity) {
OaProcessActivityHistory oaTaskHistory = new OaProcessActivityHistory();
BeanUtils.copyProperties(activity, oaTaskHistory);
super.saveOrUpdate(oaTaskHistory);
return oaTaskHistory;
}
@Override
public List<OaProcessActivityHistory> listFinishedByExecutionId(Long executionId) {<FILL_FUNCTION_BODY>}
}
|
LambdaQueryWrapper<OaProcessActivityHistory> queryWrapper = new LambdaQueryWrapper<OaProcessActivityHistory>()
.eq(OaProcessActivityHistory::getExecutionId, executionId)
.eq(OaProcessActivityHistory::getFinished, true)
.orderByAsc(OaProcessActivityHistory::getFinishDate);
List<OaProcessActivityHistory> list = super.list(queryWrapper);
//查询任务历史
list.forEach(h -> {
List<OaTaskHistory> taskHistories = taskHistoryService.listByActivityId(h.getId());
h.setTasks(taskHistories);
});
return list;
| 395
| 167
| 562
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/ProcessExecutionServiceImpl.java
|
ProcessExecutionServiceImpl
|
newExecution
|
class ProcessExecutionServiceImpl extends ServiceImpl<OaProcessExecutionMapper, OaProcessExecution>
implements ProcessExecutionService {
private Map<Class<ExecutableNodeListener>, List<ExecutableNodeListener>> listenerMap = new HashMap<>();
@Autowired
private ProcessInstanceService processInstanceService;
@Autowired
private ProcessActivityService processActivityService;
@Autowired
private ProcessDefinitionService processDefinitionService;
@Override
@Transactional(rollbackFor = Exception.class)
public OaProcessExecution newExecutionForInstance(OaProcessInstance inst) {
OaProcessDefinition def = processDefinitionService.getById(inst.getProcessDefId());
return this.newExecution(def.getId(), inst.getId(), def.getProcessNode(), null);
}
@Override
@Transactional(rollbackFor = Exception.class)
public OaProcessExecution newExecution(String defId, Long instanceId, OaProcessNode startNode, OaProcessExecution parent) {<FILL_FUNCTION_BODY>}
/**
* 线程前进
* @param executionId
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void step(Long executionId, OaProcessNode currentNode) {
//判断是否满足继续的条件
int count = this.countRunningChildren(executionId);
if(count>0) {
//如果还有运行中的子线程，禁止前进
return;
}
OaProcessExecution execution = this.getById(executionId);
if(!OaProcessExecution.STATUS_RUNNING.equals(execution.getStatus())) {
throw new EruptApiErrorTip("当前线程状态"+execution.getStatus()+"不可完成");
}
//获取下一个节点
OaProcessNode nextNode = null;
if(execution.getProcess()!=null) {
nextNode = currentNode.getChildren();
}
if(nextNode==null || nextNode.getId()==null) {//没有下一步，当前线程结束了
this.finish(execution);//调用结束
}else {//当前线程没结束，生成下一批活动
OaProcessInstance inst = processInstanceService.getById(execution.getProcessInstId());
JSONObject jsonObject = JSON.parseObject(inst.getFormItems());
processActivityService.newActivities(execution, jsonObject, nextNode, OaProcessExecution.STATUS_RUNNING);
}
}
private int countRunningChildren(Long parentId) {
QueryWrapper<OaProcessExecution> queryWrapper = new QueryWrapper<>();
queryWrapper.lambda().eq(OaProcessExecution::getParentId, parentId);
//运行中和等待中的任务都算
queryWrapper.lambda().in(OaProcessExecution::getStatus
, OaProcessExecution.STATUS_RUNNING, OaProcessExecution.STATUS_WAITING);
return this.count(queryWrapper);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void removeByProcessInstId(Long procInstId) {
QueryWrapper<OaProcessExecution> queryWrapper = new QueryWrapper<>();
queryWrapper.lambda().eq(OaProcessExecution::getProcessInstId, procInstId);
this.remove(queryWrapper);
}
//完成一个线程
@Override
@Transactional(rollbackFor = Exception.class)
public void finish(OaProcessExecution execution) {
//线程结束
Date now = new Date();
execution.setProcess("{}");
execution.setStatus(OaProcessExecution.STATUS_ENDED);
execution.setEnded(now);
execution.setUpdated(new Date());
this.updateById(execution);
//触发结束后置监听
this.listenerMap.get(AfterFinishExecutionListener.class).forEach(l -> l.execute(execution));
}
@Override
@Transactional(rollbackFor = Exception.class)
public void freshProcess(Long id, String json) {
OaProcessExecution build = OaProcessExecution.builder()
.process(json)
.updated(new Date())
.build();
build.setId(id);
this.updateById(build);
}
@Override
public void stopByInstId(Long instId, String reason) {
Date now = new Date();
List<OaProcessExecution> executions = this.listByInstId(instId, true);
if(CollectionUtils.isEmpty(executions)) {
return;
}
executions.forEach(e -> {
OaProcessExecution build = OaProcessExecution.builder()
.process("{}")
.status(OaProcessExecution.STATUS_ENDED)
.reason(reason)
.ended(now)
.updated(now)
.id(e.getId())
.build();
this.updateById(build);
});
}
private List<OaProcessExecution> listByInstId(Long instId, boolean active) {
LambdaQueryWrapper<OaProcessExecution> wrapper = new LambdaQueryWrapper<OaProcessExecution>()
.eq(OaProcessExecution::getProcessInstId, instId);
if(active) {
wrapper.in(OaProcessExecution::getStatus, OaProcessExecution.STATUS_RUNNING, OaProcessExecution.STATUS_WAITING);
}else {
wrapper.in(OaProcessExecution::getStatus, OaProcessExecution.STATUS_ENDED);
}
return this.list(wrapper);
}
/**
* 继续线程
* @param executionId
*/
@Override
@Transactional(rollbackFor = Exception.class)
public void active(Long executionId) {
//否则判断是否满足继续的条件
int count = this.countRunningChildren(executionId);
if(count>0) {
//当前线程还有子线程未合并，不能继续
return;
}
//否则激活
OaProcessExecution updateBean = OaProcessExecution.builder()
.status(OaProcessExecution.STATUS_RUNNING)
.build();
updateBean.setId(executionId);
this.updateById(updateBean);
//激活线程下的所有活动和任务
processActivityService.activeByExecutionId(executionId);
}
}
|
//创建线程
OaProcessExecution execution = OaProcessExecution.builder()
.processInstId(instanceId)
.processDefId(defId)
.startNodeId(startNode.getId())
.startNodeName(startNode.getName())
.process(JSON.toJSONString(startNode))
.status(OaProcessExecution.STATUS_RUNNING)//直接就是运行状态
.created(new Date())
.build();
if(parent==null) {
execution.setId(instanceId);//主线程id与流程实例相同
execution.setParentId(null);
}else{
execution.setId(null);
execution.setParentId(parent.getId());
}
super.save(execution);
//创建后置监听
this.listenerMap.get(AfterCreateExecutionListener.class).forEach(l -> l.execute(execution));
return execution;
| 1,591
| 235
| 1,826
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/ProcessInstanceHistoryServiceImpl.java
|
ProcessInstanceHistoryServiceImpl
|
afterFetch
|
class ProcessInstanceHistoryServiceImpl extends ServiceImpl<OaProcessInstanceHistoryMapper, OaProcessInstanceHistory>
implements ProcessInstanceHistoryService, DataProxy<OaProcessInstanceHistory> {
@Autowired
private EruptContextService eruptContextService;
@Override
@Transactional(rollbackFor = Exception.class)
public OaProcessInstanceHistory copyAndSave(OaProcessInstance procInst) {
OaProcessInstanceHistory oaProcessInstanceHistory = new OaProcessInstanceHistory();
BeanUtils.copyProperties(procInst, oaProcessInstanceHistory);//拷贝全部属性
super.saveOrUpdate(oaProcessInstanceHistory);
return oaProcessInstanceHistory;
}
@Override
public void afterFetch(Collection<Map<String, Object>> list) {<FILL_FUNCTION_BODY>}
}
|
String currentToken = eruptContextService.getCurrentToken();
list.forEach(m -> {
//拼接详情链接
m.put("detailLink", FlowConstant.SERVER_NAME+"/index.html#/detail/"+ m.get("id") +"/null/_/view?_token="+currentToken);
});
| 208
| 86
| 294
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/TaskHistoryServiceImpl.java
|
TaskHistoryServiceImpl
|
afterFetch
|
class TaskHistoryServiceImpl extends ServiceImpl<OaTaskHistoryMapper, OaTaskHistory>
implements TaskHistoryService, DataProxy<OaTaskHistory> {
@Autowired
@Lazy
private ProcessDefinitionService processDefinitionService;
@Autowired
private TaskUserLinkService taskUserLinkService;
@Override
public void afterFetch(Collection<Map<String, Object>> list) {<FILL_FUNCTION_BODY>}
@Override
@Transactional(rollbackFor = Exception.class)
public OaTaskHistory copyAndSave(OaTask task) {
OaTaskHistory oaTaskHistory = new OaTaskHistory();
BeanUtils.copyProperties(task, oaTaskHistory);
super.saveOrUpdate(oaTaskHistory);
return oaTaskHistory;
}
@Override
public List<OaTaskHistory> copyAndSave(Collection<OaTask> tasks) {
List<OaTaskHistory> collect = tasks.stream().map(t -> {
OaTaskHistory hist = new OaTaskHistory();
BeanUtils.copyProperties(t, hist);
return hist;
}).collect(Collectors.toList());
collect.forEach(this::saveOrUpdate);
return collect;
}
@Override
public List<OaTaskHistory> listByActivityId(Long activityId) {
return this.list(new LambdaQueryWrapper<OaTaskHistory>()
.eq(OaTaskHistory::getActivityId, activityId)
.orderByAsc(OaTaskHistory::getCompleteSort)
);
}
}
|
Map<String, OaProcessDefinition> definitionMap = new HashMap<>();
for (Map<String, Object> map : list) {
OaProcessDefinition def = definitionMap.get(map.get("processDefId"));
if(def==null) {
def = processDefinitionService.getById((String) map.get("processDefId"));
definitionMap.put((String) map.get("processDefId")
, def==null?new OaProcessDefinition():def);
}
map.put("formName", def.getFormName());//填充流程名
//如果是未完成，且激活的任务，查询一下候选人
if(!(Boolean)map.get("finished") && (Boolean) map.get("active")
&& StringUtils.isBlank((String)map.get("taskOwner"))
&& StringUtils.isBlank((String) map.get("assignee"))
) {
List<OaTaskUserLink> links =
taskUserLinkService.listByTaskId((Long) map.get("id"));
if(!CollectionUtils.isEmpty(links)) {
String str = null;
for (int i = 0; i < links.size(); i++) {
if(links.get(i).getUserLinkType().equals(FlowConstant.USER_LINK_ROLES)) {
str += "[角色]";
}else if(links.get(i).getUserLinkType().equals(FlowConstant.USER_LINK_USERS)){
str = "[用户]";
}else if(links.get(i).getUserLinkType().equals(FlowConstant.USER_LINK_CC)){
str = "[抄送]";
}
if(i>0) {
str += "," + links.get(i).getLinkName();
}else {
str += links.get(i).getLinkName();
}
}
map.put("links", str);
}
}
}
| 404
| 487
| 891
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/TaskOperationServiceImpl.java
|
TaskOperationServiceImpl
|
log
|
class TaskOperationServiceImpl extends ServiceImpl<OaTaskOperationMapper, OaTaskOperation>
implements TaskOperationService, DataProxy<OaTaskOperation> {
@Autowired
private EruptUserService eruptUserService;
@Override
@Transactional(rollbackFor = Exception.class)
public void log(OaTask task, String operation, String remarks) {<FILL_FUNCTION_BODY>}
@Override
@Transactional(rollbackFor = Exception.class)
public void log(OaTask task, String operation, String remarks, String nodeId, String nodeName) {
EruptUser currentEruptUser = eruptUserService.getCurrentEruptUser();
OaTaskOperation build = OaTaskOperation.builder()
.processInstId(task.getProcessInstId())
.processDefId(task.getProcessDefId())
.taskId(task.getId())
.taskName(task.getTaskName())
.operator(currentEruptUser.getAccount())
.operatorName(currentEruptUser.getName())
.operation(operation)
.remarks(remarks)
.operationDate(new Date())
.targetNodeId(nodeId)
.targetNodeName(nodeName)
.build();
this.save(build);
}
@Override
public List<OaTaskOperation> listByOperator(String account) {
return this.list(new LambdaQueryWrapper<OaTaskOperation>()
.eq(OaTaskOperation::getOperator, account)
.orderByDesc(OaTaskOperation::getOperationDate)
);
}
}
|
EruptUser currentEruptUser = eruptUserService.getCurrentEruptUser();
OaTaskOperation build = OaTaskOperation.builder()
.processInstId(task.getProcessInstId())
.processDefId(task.getProcessDefId())
.taskId(task.getId())
.taskName(task.getTaskName())
.operator(currentEruptUser.getAccount())
.operatorName(currentEruptUser.getName())
.operation(operation)
.remarks(remarks)
.operationDate(new Date())
.build();
this.save(build);
| 402
| 151
| 553
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/service/impl/TaskUserLinkServiceImpl.java
|
TaskUserLinkServiceImpl
|
countUsersByTaskId
|
class TaskUserLinkServiceImpl extends ServiceImpl<OaTaskUserLinkMapper, OaTaskUserLink> implements TaskUserLinkService {
@Autowired
private UserLinkServiceHolder userLinkServiceHolder;
@Override
public long countByTaskId(Long taskId) {
return this.count(
new LambdaQueryWrapper<OaTaskUserLink>()
.eq(OaTaskUserLink::getTaskId, taskId)
);
}
@Override
public void removeByTaskId(Long taskId) {
this.remove(
new LambdaQueryWrapper<OaTaskUserLink>()
.eq(OaTaskUserLink::getTaskId, taskId)
);
}
@Override
public List<OaTaskUserLink> listByRoleIds(Collection<String> roleIds) {
if(CollectionUtils.isEmpty(roleIds)) {
return new ArrayList<>(0);
}
return this.list(new LambdaQueryWrapper<OaTaskUserLink>()
.eq(OaTaskUserLink::getUserLinkType, "ROLES")
.in(OaTaskUserLink::getLinkId, roleIds)
);
}
@Override
public List<OaTaskUserLink> listByUserIds(Collection<String> userIds) {
if(CollectionUtils.isEmpty(userIds)) {
return new ArrayList<>(0);
}
return this.list(new LambdaQueryWrapper<OaTaskUserLink>()
.eq(OaTaskUserLink::getUserLinkType, "USERS")
.in(OaTaskUserLink::getLinkId, userIds)
);
}
@Override
public List<OaTaskUserLink> listByTaskId(Long taskId) {
return this.list(
new LambdaQueryWrapper<OaTaskUserLink>()
.eq(OaTaskUserLink::getTaskId, taskId)
);
}
/**
* 统计任务的实际处理人数量
* 即把 角色 转化为人进行统计
* @param taskId
* @return
*/
@Override
public int countUsersByTaskId(Long taskId) {<FILL_FUNCTION_BODY>}
@Override
public boolean saveBatch(Collection<OaTaskUserLink> entityList) {
entityList.forEach(this::save);
return true;
}
}
|
List<OaTaskUserLink> links = this.listByTaskId(taskId);
if(CollectionUtils.isEmpty(links)) {
return 0;
}
//查询用户数
Set<String> userIds = links.stream()
.filter(link -> FlowConstant.USER_LINK_USERS.equals(link.getUserLinkType()))
.map(l -> l.getLinkId())
.collect(Collectors.toSet());
//角色ids
Set<String> roleIds = links.stream()
.filter(link -> FlowConstant.USER_LINK_ROLES.equals(link.getUserLinkType()))
.map(l -> l.getLinkId())
.collect(Collectors.toSet());
//如果有角色，把角色解析为用户数
if(!CollectionUtils.isEmpty(roleIds)) {
Set<OrgTreeVo> users =
userLinkServiceHolder.getUserIdsByRoleIds(roleIds.toArray(new String[roleIds.size()]));
userIds.addAll(users.stream().map(u -> u.getId()).collect(Collectors.toSet()));
}
return userIds.size();
| 606
| 299
| 905
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-flow/src/main/java/xyz/erupt/flow/web/EruptApiPageModel.java
|
EruptApiPageModel
|
successApi
|
class EruptApiPageModel extends EruptApiModel {
public EruptApiPageModel(Status status, String message, Object data, PromptWay promptWay) {
super(status, message, data, promptWay);
}
/**
* 为分页查询返回结果
* 必须是mybatis分页
*
* @param list
* @param <T>
* @return
*/
public static <T> EruptApiModel successApi(List<T> list, int pageNum, int pageSize) {<FILL_FUNCTION_BODY>}
}
|
PageInfo page = new PageInfo(list);//转化为pageInfo
List<Map<String, Object>> mapList = list.stream().map(t -> {
Map<String, Object> map = new HashMap<>();
BeanMap beanMap = BeanMap.create(t);
for (Object object : beanMap.entrySet()) {
if (object instanceof Map.Entry) {
Map.Entry<String, Object> entry = (Map.Entry<String, Object>) object;
String key = entry.getKey();
map.put(key, beanMap.get(key));
}
}
return map;
}).collect(Collectors.toList());
Page p = new Page();
p.setList(mapList);
p.setPageIndex(pageNum);
p.setPageSize(pageSize);
p.setTotal(page.getTotal());
p.setTotalPage(page.getPages());//总页数
return new EruptApiModel(Status.SUCCESS, null, p, PromptWay.MESSAGE);
| 153
| 270
| 423
|
<methods>public void <init>(xyz.erupt.core.view.EruptApiModel.Status, java.lang.String, java.lang.Object, xyz.erupt.core.view.EruptApiModel.PromptWay) ,public void <init>(xyz.erupt.core.view.EruptApiModel.Status, java.lang.String, xyz.erupt.core.view.EruptApiModel.PromptWay) ,public static xyz.erupt.core.view.EruptApiModel errorApi(java.lang.String) ,public static xyz.erupt.core.view.EruptApiModel errorApi(java.lang.Exception) ,public static xyz.erupt.core.view.EruptApiModel errorNoInterceptApi(java.lang.String) ,public static xyz.erupt.core.view.EruptApiModel errorNoInterceptMessage(java.lang.String) ,public static xyz.erupt.core.view.EruptApiModel successApi() ,public static xyz.erupt.core.view.EruptApiModel successApi(java.lang.String, java.lang.Object) ,public static xyz.erupt.core.view.EruptApiModel successApi(java.lang.Object) <variables>private java.lang.Object data,private boolean errorIntercept,private java.lang.String message,private xyz.erupt.core.view.EruptApiModel.PromptWay promptWay,private xyz.erupt.core.view.EruptApiModel.Status status
|
erupts_erupt
|
erupt/erupt-extra/erupt-generator/src/main/java/xyz/erupt/generator/EruptGeneratorAutoConfiguration.java
|
EruptGeneratorAutoConfiguration
|
initMenus
|
class EruptGeneratorAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptGeneratorAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-generator").build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
List<MetaMenu> menus = new ArrayList<>();
menus.add(MetaMenu.createRootMenu("$generator", "代码生成", "fa fa-code", 40));
menus.add(MetaMenu.createEruptClassMenu(GeneratorClass.class, menus.get(0), 0));
return menus;
| 106
| 87
| 193
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-generator/src/main/java/xyz/erupt/generator/model/GeneratorClass.java
|
GeneratorClass
|
bindTplData
|
class GeneratorClass extends MetaModel implements Tpl.TplHandler {
@EruptField(
views = @View(title = "名称"),
edit = @Edit(title = "名称", notNull = true, search = @Search(vague = true))
)
private String name;
@EruptField(
views = @View(title = "实体类名"),
edit = @Edit(title = "实体类名", notNull = true, search = @Search(vague = true))
)
private String className;
@EruptField(
views = @View(title = "表名"),
edit = @Edit(title = "表名", notNull = true, search = @Search(vague = true))
)
private String tableName;
@Column(length = AnnotationConst.REMARK_LENGTH)
@EruptField(
views = @View(title = "简介"),
edit = @Edit(title = "简介", type = EditType.TEXTAREA)
)
private String remark;
// @EruptField(
// views = @View(title = "维护"),
// edit = @Edit(title = "自动维护创建字段与更新字段")
// )
// private Boolean createField;
@OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
@JoinColumn(name = "class_id")
@OrderBy("sort")
@EruptField(
edit = @Edit(title = "字段管理", type = EditType.TAB_TABLE_ADD)
)
private Set<GeneratorField> fields;
@SneakyThrows
@Override
public void bindTplData(Map<String, Object> binding, String[] params) {<FILL_FUNCTION_BODY>}
}
|
TemplateHashModel staticModels = BeansWrapper.getDefaultInstance().getStaticModels();
TemplateHashModel fileStatics = (TemplateHashModel) staticModels.get(GeneratorType.class.getName());
binding.put(GeneratorType.class.getSimpleName(), fileStatics);
| 466
| 68
| 534
|
<methods>public non-sealed void <init>() <variables>private java.lang.String createBy,private java.time.LocalDateTime createTime,private java.lang.String updateBy,private java.time.LocalDateTime updateTime
|
erupts_erupt
|
erupt/erupt-extra/erupt-generator/src/main/java/xyz/erupt/generator/model/GeneratorField.java
|
GeneratorField
|
fetch
|
class GeneratorField extends BaseModel implements DataProxy<GeneratorField>, ChoiceFetchHandler {
@EruptField(
views = @View(title = "字段名"),
edit = @Edit(title = "字段名", notNull = true,
desc = "驼峰命名法，字母以小写开头，其后每个单词首字母大写")
)
private String fieldName;
@EruptField(
views = @View(title = "显示名称"),
edit = @Edit(title = "显示名称", notNull = true)
)
private String showName;
@EruptField(
views = @View(title = "显示顺序", sortable = true),
edit = @Edit(title = "显示顺序", notNull = true)
)
private Integer sort;
@EruptField(
views = @View(title = "编辑类型"),
edit = @Edit(title = "编辑类型",
notNull = true, type = EditType.CHOICE,
choiceType = @ChoiceType(type = ChoiceType.Type.RADIO, fetchHandler = GeneratorField.class))
)
private String type;
@EruptField(
views = @View(title = "关联实体类"),
edit = @Edit(title = "关联实体类", showBy = @ShowBy(dependField = "type",
expr = "value == 'REFERENCE_TREE'||value == 'REFERENCE_TABLE'||value == 'CHECKBOX'||" +
"value == 'TAB_TREE'||value == 'TAB_TABLE_REFER'||value == 'TAB_TABLE_ADD'"))
)
private String linkClass;
@EruptField(
views = @View(title = "查询项"),
edit = @Edit(title = "查询项", notNull = true)
)
private Boolean query = true;
@EruptField(
views = @View(title = "字段排序"),
edit = @Edit(title = "字段排序", notNull = true)
)
private Boolean sortable = false;
@EruptField(
views = @View(title = "是否必填"),
edit = @Edit(title = "是否必填", notNull = true)
)
private Boolean notNull = true;
@EruptField(
views = @View(title = "是否显示"),
edit = @Edit(title = "是否显示", notNull = true)
)
private Boolean isShow = true;
@Override
public List<VLModel> fetch(String[] params) {<FILL_FUNCTION_BODY>}
@SneakyThrows
@Override
public void beforeAdd(GeneratorField generatorField) {
if (null != GeneratorType.class.getDeclaredField(generatorField.getType()).getAnnotation(Ref.class)) {
if (StringUtils.isBlank(generatorField.getLinkClass())) {
throw new EruptWebApiRuntimeException("关联实体类必填！");
}
}
}
@Override
public void beforeUpdate(GeneratorField generatorField) {
this.beforeAdd(generatorField);
}
}
|
List<VLModel> list = new ArrayList<>();
for (GeneratorType value : GeneratorType.values()) {
list.add(new VLModel(value.name(), value.getName()));
}
return list;
| 817
| 59
| 876
|
<methods>public non-sealed void <init>() <variables>private java.lang.Long id
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/EruptJobAutoConfiguration.java
|
EruptJobAutoConfiguration
|
run
|
class EruptJobAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptJobAutoConfiguration.class);
}
@Resource
private EruptDao eruptDao;
@Resource
private EruptJobService eruptJobService;
@Resource
private EruptJobProp eruptJobProp;
@Override
@SneakyThrows
public void run() {<FILL_FUNCTION_BODY>}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-job").build();
}
@Override
public List<MetaMenu> initMenus() {
List<MetaMenu> menus = new ArrayList<>();
menus.add(MetaMenu.createRootMenu("$job", "任务管理", "fa fa-cubes", 30));
menus.add(MetaMenu.createEruptClassMenu(EruptJob.class, menus.get(0), 0));
menus.add(MetaMenu.createEruptClassMenu(EruptJobLog.class, menus.get(0), 10));
menus.add(MetaMenu.createEruptClassMenu(EruptMail.class, menus.get(0), 20));
return menus;
}
}
|
if (eruptJobProp.isEnable()) {
for (EruptJob job : eruptDao.lambdaQuery(EruptJob.class).eq(EruptJob::getStatus, true).list()) {
eruptJobService.modifyJob(job);
}
} else {
log.info("Erupt job disable");
}
| 332
| 88
| 420
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/model/data_proxy/EruptJobDataProxy.java
|
EruptJobDataProxy
|
beforeAdd
|
class EruptJobDataProxy implements DataProxy<EruptJob>, OperationHandler<EruptJob, Void> {
@Transient
@Resource
private EruptJobService eruptJobService;
@Override
public void beforeAdd(EruptJob eruptJob) {<FILL_FUNCTION_BODY>}
@Override
public void beforeUpdate(EruptJob eruptJob) {
this.beforeAdd(eruptJob);
}
@Override
public void beforeDelete(EruptJob eruptJob) {
try {
eruptJobService.deleteJob(eruptJob);
} catch (SchedulerException e) {
throw new EruptWebApiRuntimeException(e.getMessage());
}
}
@Override
public String exec(List<EruptJob> eruptJob, Void param, String[] operationParam) {
try {
for (EruptJob job : eruptJob) eruptJobService.triggerJob(job);
return null;
} catch (Exception e) {
throw new EruptWebApiRuntimeException(e.getMessage());
}
}
}
|
if (null == eruptJob.getCode()) {
eruptJob.setCode(Erupts.generateCode());
}
try {
eruptJobService.modifyJob(eruptJob);
} catch (SchedulerException | ParseException e) {
throw new EruptWebApiRuntimeException(e.getMessage());
}
| 281
| 88
| 369
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/model/data_proxy/EruptMailDataProxy.java
|
EruptMailDataProxy
|
beforeAdd
|
class EruptMailDataProxy implements DataProxy<EruptMail> {
@Transient
@Autowired(required = false)
private JavaMailSenderImpl javaMailSender;
@SneakyThrows
@Override
public void beforeAdd(EruptMail eruptMail) {<FILL_FUNCTION_BODY>}
}
|
Erupts.requireNonNull(javaMailSender, "Sending mailbox not configured");
MimeMessage mimeMessage = javaMailSender.createMimeMessage();
MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true, StandardCharsets.UTF_8.name());
eruptMail.setCreateBy(MetaContext.getUser().getName());
eruptMail.setCreateTime(new Date());
helper.setSubject(eruptMail.getSubject());
helper.setTo(eruptMail.getRecipient());
helper.setFrom(Objects.requireNonNull(javaMailSender.getUsername()));
if (StringUtils.isNotBlank(eruptMail.getCc())) helper.setCc(eruptMail.getCc().split("\\|"));
helper.setText(eruptMail.getContent(), true);
try {
javaMailSender.send(mimeMessage);
eruptMail.setStatus(true);
} catch (Exception e) {
log.error("mail send error", e);
eruptMail.setStatus(false);
Optional.ofNullable(e.toString()).ifPresent(it -> eruptMail.setErrorInfo(it.substring(0, 5000)));
}
| 89
| 313
| 402
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/service/ChoiceFetchEruptJobHandler.java
|
ChoiceFetchEruptJobHandler
|
fetch
|
class ChoiceFetchEruptJobHandler implements ChoiceFetchHandler {
private static List<VLModel> loadedJobHandler;
@Override
public synchronized List<VLModel> fetch(String[] params) {<FILL_FUNCTION_BODY>}
}
|
if (null == loadedJobHandler) {
loadedJobHandler = new ArrayList<>();
EruptSpringUtil.scannerPackage(EruptApplication.getScanPackage(), new TypeFilter[]{new AssignableTypeFilter(EruptJobHandler.class)}, clazz -> {
EruptHandlerNaming eruptHandlerNaming = clazz.getAnnotation(EruptHandlerNaming.class);
loadedJobHandler.add(new VLModel(clazz.getName(), (null == eruptHandlerNaming) ? clazz.getSimpleName() : eruptHandlerNaming.value()));
});
}
return loadedJobHandler;
| 70
| 151
| 221
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/service/EruptJobAction.java
|
EruptJobAction
|
trigger
|
class EruptJobAction implements Job {
@Override
public void execute(JobExecutionContext ctx) {
JobDataMap jobDataMap = ctx.getJobDetail().getJobDataMap();
EruptJob eruptJob = (EruptJob) jobDataMap.get(ctx.getJobDetail().getKey().getName());
trigger(eruptJob, (JavaMailSenderImpl) jobDataMap.get(EruptJobService.MAIL_SENDER_KEY));
}
void trigger(EruptJob eruptJob, JavaMailSenderImpl javaMailSender) {<FILL_FUNCTION_BODY>}
}
|
String handler = eruptJob.getHandler();
EruptJobLog eruptJobLog = new EruptJobLog();
if (StringUtils.isNotBlank(handler)) {
eruptJobLog.setEruptJob(eruptJob);
eruptJobLog.setStartTime(new Date());
EruptJobHandler jobHandler = null;
try {
jobHandler = EruptSpringUtil.getBeanByPath(eruptJob.getHandler(), EruptJobHandler.class);
String result = jobHandler.exec(eruptJob.getCode(), eruptJob.getHandlerParam());
jobHandler.success(result, eruptJob.getHandlerParam());
eruptJobLog.setResultInfo(result);
eruptJobLog.setStatus(true);
} catch (Exception e) {
log.error(eruptJob.getName() + " job error", e);
eruptJobLog.setStatus(false);
String exceptionTraceStr = ExceptionUtils.getStackTrace(e);
eruptJobLog.setErrorInfo(exceptionTraceStr);
if (null != jobHandler) {
jobHandler.error(e, eruptJob.getHandlerParam());
}
//失败通知
if (StringUtils.isNotBlank(eruptJob.getNotifyEmails())) {
if (null == javaMailSender) {
log.warn("Sending mailbox not configured");
} else {
SimpleMailMessage message = new SimpleMailMessage();
message.setSubject(eruptJob.getName() + " job error ！！！");
message.setText(exceptionTraceStr);
message.setTo(eruptJob.getNotifyEmails().split("\\|"));
message.setFrom(Objects.requireNonNull(javaMailSender.getUsername()));
javaMailSender.send(message);
}
}
}
eruptJobLog.setHandlerParam(eruptJob.getHandlerParam());
eruptJobLog.setEndTime(new Date());
if (null == eruptJob.getRecordLog() || eruptJob.getRecordLog()) {
EruptSpringUtil.getBean(EruptJobService.class).saveJobLog(eruptJobLog);
}
}
| 153
| 547
| 700
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-job/src/main/java/xyz/erupt/job/service/EruptJobService.java
|
EruptJobService
|
deleteJob
|
class EruptJobService implements DisposableBean {
/**
* 执行任务线程.
*/
private static final String PROP_THREAD_COUNT = "org.quartz.threadPool.threadCount";
/**
* 执行任务线程数.
*/
private static final int DEFAULT_THREAD_COUNT = 1;
@Resource
private EruptDao eruptDao;
@Autowired(required = false)
private JavaMailSenderImpl javaMailSender;
public static final String MAIL_SENDER_KEY = "mailSensor";
private final Map<String, StdSchedulerFactory> schedulerFactoryMap = new HashMap<>();
public void triggerJob(EruptJob eruptJob) {
new EruptJobAction().trigger(eruptJob, javaMailSender);
}
public void modifyJob(EruptJob eruptJob) throws SchedulerException, ParseException {
String code = eruptJob.getCode();
if (schedulerFactoryMap.containsKey(code)) deleteJob(eruptJob);
if (eruptJob.getStatus()) {
StdSchedulerFactory ssf = new StdSchedulerFactory();
ssf.initialize(getSchedulerProp(code));
Scheduler scheduler = ssf.getScheduler();
// job
JobDetailImpl job = new JobDetailImpl();
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(code, eruptJob);
jobDataMap.put(MAIL_SENDER_KEY, javaMailSender);
job.setJobDataMap(jobDataMap);
job.setName(code);
job.setJobClass(EruptJobAction.class);
// trigger
CronTriggerImpl trigger = new CronTriggerImpl();
trigger.setName(code);
trigger.setCronExpression(eruptJob.getCron());
scheduler.scheduleJob(job, trigger);
scheduler.start();
schedulerFactoryMap.put(code, ssf);
}
}
public void deleteJob(EruptJob eruptJob) throws SchedulerException {<FILL_FUNCTION_BODY>}
private Properties getSchedulerProp(String schedulerName) {
Properties props = new Properties();
props.setProperty(StdSchedulerFactory.PROP_SCHED_MAKE_SCHEDULER_THREAD_DAEMON, "true");
props.setProperty(StdSchedulerFactory.PROP_SCHED_INTERRUPT_JOBS_ON_SHUTDOWN_WITH_WAIT, "true");
props.setProperty(StdSchedulerFactory.PROP_SCHED_INTERRUPT_JOBS_ON_SHUTDOWN, "true");
props.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_ID, "AUTO");
props.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, schedulerName);
props.setProperty(StdSchedulerFactory.PROP_THREAD_POOL_CLASS, SimpleThreadPool.class.getName());
props.setProperty(PROP_THREAD_COUNT, Integer.toString(DEFAULT_THREAD_COUNT));
return props;
}
@Transactional
public void saveJobLog(EruptJobLog eruptJobLog) {
eruptDao.persist(eruptJobLog);
}
@Override
public void destroy() throws SchedulerException {
for (StdSchedulerFactory value : schedulerFactoryMap.values()) {
value.getScheduler().shutdown();
}
}
}
|
SchedulerFactory sf = schedulerFactoryMap.get(eruptJob.getCode());
if (null != sf) {
Scheduler scheduler = sf.getScheduler();
scheduler.deleteJob(new JobKey(eruptJob.getCode()));
if (!scheduler.isShutdown()) scheduler.shutdown();
schedulerFactoryMap.remove(eruptJob.getCode());
}
| 910
| 107
| 1,017
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-magic-api/src/main/java/xyz/erupt/magicapi/EruptMagicApiAutoConfiguration.java
|
EruptMagicApiAutoConfiguration
|
initMenus
|
class EruptMagicApiAutoConfiguration implements EruptModule {
public static final String MAGIC_API_MENU_PREFIX = "ERUPT_MAGIC_";
public static final String DATASOURCE = "DATASOURCE";
public static final String FUNCTION = "FUNCTION";
static {
EruptModuleInvoke.addEruptModule(EruptMagicApiAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-magic-api").build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
String menuKey = "magic-api";
Map<Authorization, String> menus = new LinkedHashMap<>();
menus.put(Authorization.SAVE, "保存");
menus.put(Authorization.VIEW, "查看");
menus.put(Authorization.DELETE, "删除");
menus.put(Authorization.DOWNLOAD, "导出");
menus.put(Authorization.UPLOAD, "上传");
menus.put(Authorization.PUSH, "远程推送");
menus.put(Authorization.LOCK, "锁定");
menus.put(Authorization.UNLOCK, "解锁");
menus.put(Authorization.RELOAD, "资源重载");
AtomicInteger sort = new AtomicInteger();
List<MetaMenu> metaMenus = new ArrayList<>();
metaMenus.add(MetaMenu.createSimpleMenu(menuKey, "接口配置", MagicApiTpl.MAGIC_API_PERMISSION, null, 50, EruptTplService.TPL));
metaMenus.add(MetaMenu.createSimpleMenu(menuKey + "-" + FUNCTION.toLowerCase(), "函数", MAGIC_API_MENU_PREFIX + FUNCTION.toUpperCase(), metaMenus.get(0), sort.addAndGet(10), MenuTypeEnum.BUTTON.getCode()));
metaMenus.add(MetaMenu.createSimpleMenu(menuKey + "-" + DATASOURCE.toLowerCase(), "数据源", MAGIC_API_MENU_PREFIX + DATASOURCE.toUpperCase(), metaMenus.get(0), sort.addAndGet(10), MenuTypeEnum.BUTTON.getCode()));
menus.forEach((key, value) -> metaMenus.add(MetaMenu.createSimpleMenu(
menuKey + "-" + key.name().toLowerCase(), value,
MAGIC_API_MENU_PREFIX + key.name(),
metaMenus.get(0), sort.addAndGet(10),
MenuTypeEnum.BUTTON.getCode()
)));
return metaMenus;
| 178
| 546
| 724
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-magic-api/src/main/java/xyz/erupt/magicapi/action/MagicApiTpl.java
|
MagicApiTpl
|
magicApiAction
|
class MagicApiTpl {
public static final String MAGIC_API_PERMISSION = "magic-api.ftl";
@Resource
private MagicAPIProperties magicAPIProperties;
@Resource
private EruptContextService eruptContextService;
@TplAction(MAGIC_API_PERMISSION)
public Map<String, Object> magicApiAction() {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> map = new HashMap<>();
map.put("web", magicAPIProperties.getWeb());
map.put("token", eruptContextService.getCurrentToken());
map.put("v", EruptInformation.getEruptVersion());
map.put("hash", this.hashCode());
return map;
| 112
| 85
| 197
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-magic-api/src/main/java/xyz/erupt/magicapi/interceptor/EruptMagicAPIRequestInterceptor.java
|
EruptMagicAPIRequestInterceptor
|
allowVisit
|
class EruptMagicAPIRequestInterceptor implements RequestInterceptor, AuthorizationInterceptor {
private final EruptUserService eruptUserService;
private static final String NO_PERMISSION = "权限不足！";
private static final String LOGIN_EXPIRE = "登录凭证失效！";
/**
* 配置接口权限
*/
@Override
public Object preHandle(RequestEntity requestEntity) {
ApiInfo info = requestEntity.getApiInfo();
String permission = Objects.toString(info.getOptionValue(Options.PERMISSION), "");
String role = Objects.toString(info.getOptionValue(Options.ROLE), "");
String login = Objects.toString(info.getOptionValue(Options.REQUIRE_LOGIN), "");
boolean isLogin = eruptUserService.getCurrentUid() != null;
if (StringUtils.isNotBlank(login) && !isLogin) return new JsonBean<>(401, LOGIN_EXPIRE);
if (StringUtils.isNotBlank(role) || StringUtils.isNotBlank(permission)) {
// 未登录
if (!isLogin) {
return new JsonBean<Void>(401, LOGIN_EXPIRE);
} else {
MetaUserinfo metaUserInfo = eruptUserService.getSimpleUserInfo();
if (!metaUserInfo.isSuperAdmin()) {
// 权限判断
if (StringUtils.isNotBlank(permission) && eruptUserService.getEruptMenuByValue(permission) == null) {
return new JsonBean<Void>(403, NO_PERMISSION);
}
// 角色判断
if (StringUtils.isNotBlank(role) && metaUserInfo.getRoles().stream().noneMatch(role::equals)) {
return new JsonBean<Void>(403, NO_PERMISSION);
}
}
}
}
return null;
}
/**
* 配置UI界面不需要登录框
*/
@Override
public boolean requireLogin() {
return false;
}
@Override
@SneakyThrows
public MagicUser getUserByToken(String token) {
MetaUserinfo metaUserinfo = eruptUserService.getSimpleUserInfoByToken(token);
if (null == metaUserinfo) throw new MagicLoginException(LOGIN_EXPIRE);
return new MagicUser(metaUserinfo.getAccount(), metaUserinfo.getUsername(), token);
}
/**
* 配置UI鉴权
*/
@Override
public boolean allowVisit(MagicUser magicUser, MagicHttpServletRequest request, Authorization authorization) {
if (eruptUserService.getCurrentUid() == null) {
throw new EruptWebApiRuntimeException(LOGIN_EXPIRE);
} else if (null == eruptUserService.getEruptMenuByValue(EruptMagicApiAutoConfiguration.MAGIC_API_MENU_PREFIX + authorization.name())) {
throw new EruptWebApiRuntimeException(NO_PERMISSION);
}
return true;
}
@Override
public boolean allowVisit(MagicUser magicUser, MagicHttpServletRequest request, Authorization authorization, Group group) {
if (null == eruptUserService.getCurrentUid()) throw new EruptWebApiRuntimeException(LOGIN_EXPIRE);
MetaUserinfo metaUserinfo = eruptUserService.getSimpleUserInfo();
if (!metaUserinfo.isSuperAdmin()) {
if (!group.getOptions().isEmpty()) {
for (BaseDefinition option : group.getOptions()) {
if (null != option.getValue() && StringUtils.isNotBlank(option.getValue().toString())) {
if (Options.ROLE.getValue().equals(option.getName())) {
return metaUserinfo.getRoles().stream().anyMatch(it -> it.equals(option.getValue()));
} else if (Options.PERMISSION.getValue().equals(option.getName())) {
return null != eruptUserService.getEruptMenuByValue(option.getValue().toString());
}
}
}
}
}
return true;
}
@Override
public boolean allowVisit(MagicUser magicUser, MagicHttpServletRequest request, Authorization authorization, MagicEntity entity) {<FILL_FUNCTION_BODY>}
}
|
if (entity instanceof FunctionInfo) {
if (Authorization.SAVE == authorization || Authorization.DELETE == authorization) {
return eruptUserService.getEruptMenuByValue(EruptMagicApiAutoConfiguration.MAGIC_API_MENU_PREFIX + EruptMagicApiAutoConfiguration.FUNCTION) != null;
}
} else if (entity instanceof DataSourceInfo) {
if (Authorization.SAVE == authorization || Authorization.DELETE == authorization) {
return eruptUserService.getEruptMenuByValue(EruptMagicApiAutoConfiguration.MAGIC_API_MENU_PREFIX + EruptMagicApiAutoConfiguration.DATASOURCE) != null;
}
}
return AuthorizationInterceptor.super.allowVisit(magicUser, request, authorization, entity);
| 1,109
| 211
| 1,320
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-monitor/src/main/java/xyz/erupt/monitor/EruptMonitorAutoConfiguration.java
|
EruptMonitorAutoConfiguration
|
initMenus
|
class EruptMonitorAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptMonitorAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-monitor").build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
List<MetaMenu> metaMenus = new ArrayList<>();
metaMenus.add(MetaMenu.createRootMenu("monitor", "系统监控", "fa fa-bullseye", 10));
metaMenus.add(MetaMenu.createSimpleMenu("server.html", "服务监控", "server.html", metaMenus.get(0), 10, EruptTplService.TPL));
metaMenus.add(MetaMenu.createSimpleMenu("redis.html", "缓存监控", "redis.html", metaMenus.get(0), 20, EruptTplService.TPL));
return metaMenus;
| 106
| 160
| 266
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-monitor/src/main/java/xyz/erupt/monitor/controller/MonitorServerController.java
|
MonitorServerController
|
getPlatformInfo
|
class MonitorServerController {
@Resource
private EruptProp eruptProp;
@GetMapping("/info")
@EruptRouter(authIndex = 1, verifyType = EruptRouter.VerifyType.MENU)
public Server info() {
return new Server();
}
@GetMapping("/platform")
@EruptRouter(authIndex = 1, verifyType = EruptRouter.VerifyType.MENU)
public Platform getPlatformInfo() {<FILL_FUNCTION_BODY>}
}
|
Platform platform = new Platform();
AttachmentProxy attachmentProxy = EruptUtil.findAttachmentProxy();
platform.setUploadPath(null == attachmentProxy ? eruptProp.getUploadPath() : attachmentProxy.fileDomain());
platform.setSessionStrategy(eruptProp.isRedisSession() ? "redis" : "servlet");
platform.setEruptCount(EruptCoreService.getErupts().size());
platform.setEruptModules(EruptCoreService.getModules());
platform.setEruptVersion(EruptInformation.getEruptVersion());
return platform;
| 136
| 146
| 282
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-monitor/src/main/java/xyz/erupt/monitor/util/SystemUtil.java
|
SystemUtil
|
formatByte
|
class SystemUtil {
//换算单位
public static String formatByte(long byteNumber) {<FILL_FUNCTION_BODY>}
}
|
double FORMAT = 1024.0;
double kbNumber = byteNumber / FORMAT;
if (kbNumber < FORMAT) {
return new DecimalFormat("#.##KB").format(kbNumber);
}
double mbNumber = kbNumber / FORMAT;
if (mbNumber < FORMAT) {
return new DecimalFormat("#.##MB").format(mbNumber);
}
double gbNumber = mbNumber / FORMAT;
if (gbNumber < FORMAT) {
return new DecimalFormat("#.##GB").format(gbNumber);
}
double tbNumber = gbNumber / FORMAT;
return new DecimalFormat("#.##TB").format(tbNumber);
| 40
| 189
| 229
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-monitor/src/main/java/xyz/erupt/monitor/vo/Server.java
|
Server
|
zhDateDiff
|
class Server {
/**
* CPU相关信息
*/
private Cpu cpu;
/**
* 內存相关信息
*/
private Mem mem;
/**
* JVM相关信息
*/
private Jvm jvm;
/**
* 服务器相关信息
*/
private Sys sys;
/**
* 磁盘相关信息
*/
private List<SysFile> sysFiles;
private Date startupDate; //启动时间
private String runDay; //运行时长
public Server() {
SystemInfo si = new SystemInfo();
OperatingSystem os = si.getOperatingSystem();
this.setCpu(new Cpu(si));
this.setMem(new Mem(si));
this.setJvm(new Jvm());
this.setSys(new Sys());
long startupDate = EruptSpringUtil.getApplicationContext().getStartupDate();
this.setStartupDate(new Date(startupDate));
this.setRunDay(this.zhDateDiff(this.getStartupDate()));
sysFiles = os.getFileSystem().getFileStores().stream().map(SysFile::new).collect(Collectors.toList());
}
private String zhDateDiff(Date date) {<FILL_FUNCTION_BODY>}
}
|
long l = System.currentTimeMillis() - date.getTime();
long day = l / (24 * 60 * 60 * 1000);
long hour = (l / (60 * 60 * 1000) - day * 24);
long min = ((l / (60 * 1000)) - day * 24 * 60 - hour * 60);
return day + "天" + hour + "小时" + min + "分";
| 348
| 130
| 478
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-extra/erupt-monitor/src/main/java/xyz/erupt/monitor/vo/Sys.java
|
Sys
|
getServerIp
|
class Sys {
private String name; //系统名称
private String arch; //架构
private String hostName; //主机名称
private Date date; //服务器时间
@SneakyThrows
Sys() {
InetAddress addr = InetAddress.getLocalHost();
this.setHostName(addr.getHostName());
OperatingSystemMXBean osb = ManagementFactory.getOperatingSystemMXBean();
this.setName(osb.getName() + " " + osb.getVersion());
this.setArch(osb.getArch());
this.setDate(new Date());
}
//获取服务器IP地址
@SneakyThrows
public static String getServerIp() {<FILL_FUNCTION_BODY>}
}
|
Enumeration<NetworkInterface> netInterfaces = NetworkInterface.getNetworkInterfaces();
while (netInterfaces.hasMoreElements()) {
InetAddress addr = netInterfaces.nextElement().getInetAddresses().nextElement();
if (addr instanceof Inet4Address) {
if (addr.isSiteLocalAddress() && !addr.isLoopbackAddress()) {
return addr.getHostAddress();
}
}
}
return InetAddress.getLocalHost().getHostAddress();
| 207
| 126
| 333
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-security/src/main/java/xyz/erupt/security/config/MvcInterceptor.java
|
MvcInterceptor
|
registerAuthFilter
|
class MvcInterceptor implements WebMvcConfigurer {
@Resource
private EruptSecurityInterceptor eruptSecurityInterceptor;
@Resource
private EruptSuperInterceptor eruptSuperInterceptor;
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(eruptSuperInterceptor).addPathPatterns("/**");
registry.addInterceptor(eruptSecurityInterceptor).addPathPatterns(EruptRestPath.ERUPT_API + "/**");
}
@Bean
public FilterRegistrationBean<HttpServletRequestFilter> registerAuthFilter(EruptSecurityProp eruptSecurityProp) {<FILL_FUNCTION_BODY>}
}
|
FilterRegistrationBean<HttpServletRequestFilter> registration = new FilterRegistrationBean<>();
registration.setFilter(new HttpServletRequestFilter(eruptSecurityProp));
registration.addUrlPatterns(EruptRestPath.ERUPT_API + "/*");
registration.setName(HttpServletRequestFilter.class.getSimpleName());
registration.setOrder(1);
return registration;
| 187
| 97
| 284
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-security/src/main/java/xyz/erupt/security/interceptor/EruptSecurityInterceptor.java
|
EruptSecurityInterceptor
|
preHandle
|
class EruptSecurityInterceptor implements AsyncHandlerInterceptor {
@Resource
private EruptUserService eruptUserService;
@Resource
private EruptProp eruptProp;
@Resource
private EruptUpmsProp eruptUpmsProp;
@Resource
private OperationService operationService;
@Resource
private EruptSessionService sessionService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {<FILL_FUNCTION_BODY>}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
try {
if (HttpStatus.OK.value() == response.getStatus()) {
operationService.record(handler, ex);
} else {
operationService.record(handler, null == ex ? new RuntimeException(response.toString()) : ex);
}
} catch (Exception e) {
log.error("operation record error", e);
} finally {
MetaContext.remove();
}
}
}
|
EruptRouter eruptRouter = null;
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
eruptRouter = handlerMethod.getMethodAnnotation(EruptRouter.class);
}
if (null == eruptRouter) return true;
String token = null;
String eruptName = null;
String parentEruptName = null;
if (eruptRouter.verifyMethod() == EruptRouter.VerifyMethod.HEADER) {
token = request.getHeader(EruptReqHeaderConst.ERUPT_HEADER_TOKEN);
eruptName = request.getHeader(EruptReqHeaderConst.ERUPT_HEADER_KEY);
parentEruptName = request.getHeader(EruptReqHeaderConst.ERUPT_PARENT_HEADER_KEY);
} else if (eruptRouter.verifyMethod() == EruptRouter.VerifyMethod.PARAM) {
token = request.getParameter(EruptReqHeaderConst.URL_ERUPT_PARAM_TOKEN);
eruptName = request.getParameter(EruptReqHeaderConst.URL_ERUPT_PARAM_KEY);
parentEruptName = request.getHeader(EruptReqHeaderConst.URL_ERUPT_PARENT_PARAM_KEY);
}
if (eruptRouter.verifyType().equals(EruptRouter.VerifyType.ERUPT)) {
MetaContext.register(new MetaErupt(eruptName, eruptName));
EruptModel erupt = EruptCoreService.getErupt(eruptName);
if (null == erupt) {
response.setStatus(HttpStatus.NOT_FOUND.value());
return false;
}
if (!erupt.getErupt().authVerify()) return true;
}
if (null == token || null == sessionService.get(SessionKey.TOKEN_OLINE + token)) {
response.setStatus(HttpStatus.UNAUTHORIZED.value());
response.sendError(HttpStatus.UNAUTHORIZED.value());
return false;
}
MetaUserinfo metaUserinfo = eruptUserService.getSimpleUserInfo();
MetaContext.registerToken(token);
MetaContext.register(new MetaUser(metaUserinfo.getId() + "", metaUserinfo.getAccount(), metaUserinfo.getUsername()));
//权限校验
String authStr = request.getServletPath().split("/")[eruptRouter.skipAuthIndex() + eruptRouter.authIndex()];
switch (eruptRouter.verifyType()) {
case LOGIN:
break;
case MENU:
if (!eruptRouter.verifyHandler().isInterface()) {
authStr = EruptSpringUtil.getBean(eruptRouter.verifyHandler()).convertAuthStr(eruptRouter, request, authStr);
}
if (null == eruptUserService.getEruptMenuByValue(authStr)) {
response.setStatus(HttpStatus.FORBIDDEN.value());
response.sendError(HttpStatus.FORBIDDEN.value());
return false;
}
MetaContext.register(new MetaErupt(null, authStr));
break;
case ERUPT:
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
$ep:
if (StringUtils.isNotBlank(parentEruptName)) {
EruptModel eruptParentModel = EruptCoreService.getErupt(parentEruptName);
for (EruptFieldModel model : eruptParentModel.getEruptFieldModels()) {
if (eruptModel.getEruptName().equals(model.getFieldReturnName())) {
if (authStr.equals(eruptModel.getEruptName())) {
authStr = eruptParentModel.getEruptName();
}
eruptModel = eruptParentModel;
break $ep;
}
}
for (RowOperation operation : eruptParentModel.getErupt().rowOperation()) {
if (void.class != operation.eruptClass()) {
if (eruptModel.getEruptName().equals(operation.eruptClass().getSimpleName())) {
authStr = eruptParentModel.getEruptName();
eruptModel = eruptParentModel;
break $ep;
}
}
}
response.setStatus(HttpStatus.NOT_FOUND.value());
return false;
}
if (!authStr.equalsIgnoreCase(eruptModel.getEruptName())) {
response.setStatus(HttpStatus.NOT_FOUND.value());
return false;
}
if (null == eruptUserService.getEruptMenuByValue(eruptModel.getEruptName())) {
response.setStatus(HttpStatus.FORBIDDEN.value());
response.sendError(HttpStatus.FORBIDDEN.value());
return false;
}
break;
}
if (eruptProp.isRedisSessionRefresh()) {
for (String uk : SessionKey.USER_KEY_GROUP) {
sessionService.expire(uk + token, eruptUpmsProp.getExpireTimeByLogin(), TimeUnit.MINUTES);
}
}
return true;
| 273
| 1,330
| 1,603
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-security/src/main/java/xyz/erupt/security/interceptor/EruptSuperInterceptor.java
|
EruptSuperInterceptor
|
preHandle
|
class EruptSuperInterceptor implements AsyncHandlerInterceptor {
@Resource
private EruptSessionService sessionService;
@Resource
private EruptUserService eruptUserService;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {<FILL_FUNCTION_BODY>}
}
|
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
EruptLoginAuth eruptAuth = handlerMethod.getMethodAnnotation(EruptLoginAuth.class);
EruptMenuAuth eruptMenuAuth = handlerMethod.getMethodAnnotation(EruptMenuAuth.class);
if (null != eruptAuth || null != eruptMenuAuth) {
String token = request.getHeader(EruptReqHeaderConst.ERUPT_HEADER_TOKEN);
if (null == token || null == sessionService.get(SessionKey.TOKEN_OLINE + token)) {
response.setStatus(HttpStatus.UNAUTHORIZED.value());
response.sendError(HttpStatus.UNAUTHORIZED.value());
return false;
}
}
if (null != eruptMenuAuth) {
if (null == eruptUserService.getEruptMenuByValue(eruptMenuAuth.value())) {
response.setStatus(HttpStatus.FORBIDDEN.value());
response.sendError(HttpStatus.FORBIDDEN.value());
return false;
}
}
}
return true;
| 92
| 296
| 388
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-security/src/main/java/xyz/erupt/security/interceptor/HttpServletRequestFilter.java
|
EruptRequestWrapper
|
getInputStream
|
class EruptRequestWrapper extends HttpServletRequestWrapper {
private final String body;
@SneakyThrows
EruptRequestWrapper(HttpServletRequest request) {
super(request);
body = StreamUtils.copyToString(request.getInputStream(), StandardCharsets.UTF_8);
}
@Override
public ServletInputStream getInputStream() {<FILL_FUNCTION_BODY>}
@Override
public BufferedReader getReader() {
return new BufferedReader(new InputStreamReader(this.getInputStream(), StandardCharsets.UTF_8));
}
String getBody() {
return this.body;
}
}
|
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8));
return new ServletInputStream() {
@Override
public boolean isFinished() {
return false;
}
@Override
public boolean isReady() {
return false;
}
@Override
public void setReadListener(ReadListener readListener) {
}
@Override
public int read() {
return byteArrayInputStream.read();
}
};
| 167
| 131
| 298
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-security/src/main/java/xyz/erupt/security/service/OperationService.java
|
OperationService
|
record
|
class OperationService {
@Resource
private EntityManager entityManager;
@Resource
private EruptSecurityProp eruptSecurityProp;
@Resource
private HttpServletRequest request;
@Resource
private EruptContextService eruptContextService;
@Transactional
public void record(Object handler, Exception ex) {<FILL_FUNCTION_BODY>}
private String findRequestParamVal(HttpServletRequest request) {
if (request.getParameterMap().size() > 0) {
StringBuilder sb = new StringBuilder();
request.getParameterMap().forEach((key, value) -> sb.append(key).append("=").append(Arrays.toString(value)).append("\n"));
return sb.toString();
}
return null;
}
}
|
if (eruptSecurityProp.isRecordOperateLog()) {
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
Optional.ofNullable(handlerMethod.getMethodAnnotation(EruptRecordOperate.class)).ifPresent(eruptRecordOperate -> {
EruptOperateLog operate = new EruptOperateLog();
if (eruptRecordOperate.dynamicConfig().isInterface()) {
operate.setApiName(eruptRecordOperate.value());
} else {
String eruptName = request.getHeader(EruptReqHeaderConst.ERUPT_HEADER_KEY);
eruptName = Optional.ofNullable(eruptName).orElse(request.getParameter(EruptReqHeaderConst.URL_ERUPT_PARAM_KEY));
EruptRecordOperate.DynamicConfig dynamicConfig = EruptSpringUtil.getBean(eruptRecordOperate.dynamicConfig());
if (!dynamicConfig.canRecord(eruptName, handlerMethod.getMethod())) return;
operate.setApiName(dynamicConfig.naming(eruptRecordOperate.value(),
Optional.ofNullable(eruptContextService.getCurrentEruptMenu()).orElse(new EruptMenu()).getName(),
eruptName, handlerMethod.getMethod()));
}
operate.setIp(IpUtil.getIpAddr(request));
operate.setRegion(IpUtil.getCityInfo(operate.getIp()));
operate.setStatus(true);
operate.setReqMethod(request.getMethod());
operate.setReqAddr(request.getRequestURL().toString());
operate.setOperateUser(MetaContext.getUser().getName());
operate.setCreateTime(new Date());
operate.setTotalTime(operate.getCreateTime().getTime() - RequestBodyTL.get().getDate());
Optional.ofNullable(ex).ifPresent(e -> {
String errorInfo = ExceptionUtils.getStackTrace(e);
operate.setErrorInfo(errorInfo.length() > 4000 ? errorInfo.substring(0, 4000) : errorInfo);
operate.setStatus(false);
});
Object param = RequestBodyTL.get().getBody();
operate.setReqParam(null == param ? findRequestParamVal(request) : param.toString());
RequestBodyTL.remove();
entityManager.persist(operate);
});
}
}
| 199
| 603
| 802
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-toolkit/src/main/java/xyz/erupt/toolkit/handler/SqlChoiceFetchHandler.java
|
SqlChoiceFetchHandler
|
fetch
|
class SqlChoiceFetchHandler implements ChoiceFetchHandler {
@Resource
private JdbcTemplate jdbcTemplate;
private final EruptCache<List<VLModel>> eruptCache = new EruptCacheLRU<>(500);
@Override
public List<VLModel> fetch(String[] params) {<FILL_FUNCTION_BODY>}
}
|
EruptAssert.notNull(params, SqlChoiceFetchHandler.class.getSimpleName() + " → params not found");
return eruptCache.getAndSet(SqlChoiceFetchHandler.class.getName() + ":" + params[0],
params.length == 2 ? Long.parseLong(params[1]) : 3000,
() -> jdbcTemplate.query(params[0], (rs, i) -> {
if (rs.getMetaData().getColumnCount() == 1) {
return new VLModel(rs.getString(1), rs.getString(1));
} else {
return new VLModel(rs.getString(1), rs.getString(2));
}
})
);
| 97
| 186
| 283
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/controller/EruptTplController.java
|
EruptTplController
|
eruptTplPage
|
class EruptTplController implements EruptRouter.VerifyHandler {
static final String TPL = "/tpl";
private static final String HTML_MIME_TYPE = "text/html;charset=utf-8";
@Resource
private EruptTplService eruptTplService;
@GetMapping(value = "/**", produces = HTML_MIME_TYPE)
@EruptRouter(authIndex = 1, verifyType = EruptRouter.VerifyType.MENU, verifyHandler = EruptTplController.class,
verifyMethod = EruptRouter.VerifyMethod.PARAM)
public void eruptTplPage(HttpServletRequest request, HttpServletResponse response) throws Exception {<FILL_FUNCTION_BODY>}
@Override
public String convertAuthStr(EruptRouter eruptRouter, HttpServletRequest request, String authStr) {
return request.getRequestURI().split(ERUPT_API + EruptTplController.TPL + "/")[1];
}
@GetMapping(value = "/html-field/{erupt}/{field}", produces = HTML_MIME_TYPE)
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.MENU, verifyMethod = EruptRouter.VerifyMethod.PARAM)
public void eruptFieldHtml(@PathVariable("erupt") String eruptName, @PathVariable("field") String field, HttpServletResponse response) {
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
Tpl tpl = eruptModel.getEruptFieldMap().get(field).getEruptField().edit().tplType();
eruptTplService.tplRender(tpl, null, response);
}
/**
* 自定义按钮弹出层模板
*
* @param eruptName erupt
* @param code 模板标识
* @param ids ID标识
*/
@GetMapping(value = "/operation-tpl/{erupt}/{code}", produces = HTML_MIME_TYPE)
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT, verifyMethod = EruptRouter.VerifyMethod.PARAM)
public void operationTpl(@PathVariable("erupt") String eruptName, @PathVariable("code") String code,
@RequestParam(value = "ids", required = false) String[] ids, HttpServletResponse response) {
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
RowOperation operation = Arrays.stream(eruptModel.getErupt().rowOperation()).filter(it ->
it.code().equals(code)).findFirst().orElseThrow(EruptNoLegalPowerException::new);
Erupts.powerLegal(ExprInvoke.getExpr(operation.show()));
if (operation.tpl().engine() == Tpl.Engine.Native || operation.mode() == RowOperation.Mode.BUTTON) {
eruptTplService.tplRender(operation.tpl(), null, response);
return;
}
Map<String, Object> map = new HashMap<>();
map.put(EngineConst.INJECT_ROWS, Stream.of(ids).map(id -> DataProcessorManager.getEruptDataProcessor(eruptModel.getClazz())
.findDataById(eruptModel, EruptUtil.toEruptId(eruptModel, id))).collect(Collectors.toList()));
eruptTplService.tplRender(operation.tpl(), map, response);
}
/**
* 表格视图@View注解触发的TPL
*
* @param eruptName erupt
* @param field 字段
* @param id 当前行数据的主键
*/
@GetMapping(value = "/view-tpl/{erupt}/{field}/{id}", produces = HTML_MIME_TYPE)
@EruptRouter(authIndex = 2, verifyType = EruptRouter.VerifyType.ERUPT, verifyMethod = EruptRouter.VerifyMethod.PARAM)
public void viewTpl(@PathVariable("erupt") String eruptName, @PathVariable("field") String field,
@PathVariable("id") String id, HttpServletResponse response) {
EruptModel eruptModel = EruptCoreService.getErupt(eruptName);
Tpl tpl = null;
for (View view : eruptModel.getEruptFieldMap().get(field).getEruptField().views()) {
if (StringUtils.isNotBlank(view.tpl().path())) {
tpl = view.tpl();
break;
}
}
Map<String, Object> map = new HashMap<>();
map.put(EngineConst.INJECT_ROW, DataProcessorManager.getEruptDataProcessor(eruptModel.getClazz())
.findDataById(eruptModel, EruptUtil.toEruptId(eruptModel, id)));
eruptTplService.tplRender(tpl, map, response);
}
}
|
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
String path = request.getRequestURI().split(ERUPT_API + EruptTplController.TPL + "/")[1];
Method method = eruptTplService.getAction(path);
if (null == method) {
eruptTplService.tplRender(Tpl.Engine.Native, TPL + "/" + path, null, response.getWriter());
return;
}
Object obj = EruptSpringUtil.getBean(method.getDeclaringClass());
EruptTpl eruptTpl = obj.getClass().getAnnotation(EruptTpl.class);
TplAction tplAction = method.getAnnotation(TplAction.class);
path = TPL + "/" + path;
if (StringUtils.isNotBlank(tplAction.path())) {
path = tplAction.path();
}
eruptTplService.tplRender(eruptTpl.engine(), path, (Map) method.invoke(obj), response.getWriter());
| 1,287
| 266
| 1,553
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/BeetlEngine.java
|
BeetlEngine
|
init
|
class BeetlEngine extends EngineTemplate<GroupTemplate> {
@Override
public Tpl.Engine engine() {
return Tpl.Engine.Beetl;
}
@SneakyThrows
@Override
public GroupTemplate init() {<FILL_FUNCTION_BODY>}
@Override
public void render(GroupTemplate groupTemplate, String filePath, Map<String, Object> bindingMap, Writer out) {
Template template = groupTemplate.getTemplate(filePath);
template.binding(bindingMap);
template.renderTo(out);
}
}
|
ClasspathResourceLoader resourceLoader = new ClasspathResourceLoader("/");
Configuration cfg = Configuration.defaultConfiguration();
return new GroupTemplate(resourceLoader, cfg);
| 148
| 43
| 191
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public GroupTemplate getEngine() ,public abstract GroupTemplate init() ,public abstract void render(GroupTemplate, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(GroupTemplate) <variables>private GroupTemplate engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/EnjoyEngine.java
|
EnjoyEngine
|
init
|
class EnjoyEngine extends EngineTemplate<Engine> {
@Override
public Tpl.Engine engine() {
return Tpl.Engine.Enjoy;
}
@Override
public Engine init() {<FILL_FUNCTION_BODY>}
@Override
public void render(Engine engine, String filePath, Map<String, Object> bindingMap, Writer out) {
engine.getTemplate(filePath).render(bindingMap, out);
}
}
|
Engine eng = new Engine();
eng.addSharedMethod(StrKit.class);
eng.setDevMode(true);
return eng;
| 118
| 39
| 157
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public Engine getEngine() ,public abstract Engine init() ,public abstract void render(Engine, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(Engine) <variables>private Engine engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/FreemarkerEngine.java
|
FreemarkerEngine
|
init
|
class FreemarkerEngine extends EngineTemplate<Configuration> {
@Override
public Tpl.Engine engine() {
return Tpl.Engine.FreeMarker;
}
@Override
public Configuration init() {<FILL_FUNCTION_BODY>}
@SneakyThrows
@Override
public void render(Configuration configuration, String filePath, Map<String, Object> bindingMap, Writer out) {
configuration.getTemplate(filePath).process(bindingMap, out);
}
}
|
Configuration freemarkerConfig = new Configuration(Configuration.VERSION_2_3_29);
freemarkerConfig.setDefaultEncoding(StandardCharsets.UTF_8.name());
freemarkerConfig.setClassForTemplateLoading(this.getClass(), "/");
return freemarkerConfig;
| 130
| 78
| 208
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public Configuration getEngine() ,public abstract Configuration init() ,public abstract void render(Configuration, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(Configuration) <variables>private Configuration engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/NativeEngine.java
|
NativeEngine
|
render
|
class NativeEngine extends EngineTemplate<Void> {
public static final String baseDir = "${base}";
@Override
public Tpl.Engine engine() {
return Tpl.Engine.Native;
}
@Override
public Void init() {
return null;
}
@SneakyThrows
@Override
public void render(Void unused, String filePath, Map<String, Object> bindingMap, Writer out) {<FILL_FUNCTION_BODY>}
}
|
@Cleanup InputStream inputStream = this.getClass().getResourceAsStream(filePath);
String html = "";
if (null == inputStream) {
html = "<h1 align='center'>404 not found</h1>";
} else {
html = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8);
}
HttpServletRequest request = (HttpServletRequest) bindingMap.get(EngineConst.INJECT_REQUEST);
out.write(html.replace(baseDir, request.getContextPath()));
| 132
| 140
| 272
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public java.lang.Void getEngine() ,public abstract java.lang.Void init() ,public abstract void render(java.lang.Void, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(java.lang.Void) <variables>private java.lang.Void engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/ThymeleafEngine.java
|
ThymeleafEngine
|
init
|
class ThymeleafEngine extends EngineTemplate<TemplateEngine> {
@Override
public Tpl.Engine engine() {
return Tpl.Engine.Thymeleaf;
}
@Override
public TemplateEngine init() {<FILL_FUNCTION_BODY>}
@SneakyThrows
@Override
public void render(TemplateEngine templateEngine, String filePath, Map<String, Object> bindingMap, Writer out) {
Context ctx = new Context();
ctx.setVariables(bindingMap);
out.write(templateEngine.process(filePath, ctx));
}
}
|
ClassLoaderTemplateResolver resolver = new ClassLoaderTemplateResolver();
resolver.setCacheable(false);
resolver.setPrefix("/");
resolver.setTemplateMode(TemplateMode.HTML);
resolver.setCheckExistence(true);
resolver.setUseDecoupledLogic(true);
TemplateEngine templateEngine = new TemplateEngine();
templateEngine.addTemplateResolver(resolver);
return templateEngine;
| 153
| 108
| 261
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public TemplateEngine getEngine() ,public abstract TemplateEngine init() ,public abstract void render(TemplateEngine, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(TemplateEngine) <variables>private TemplateEngine engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/engine/VelocityTplEngine.java
|
VelocityTplEngine
|
init
|
class VelocityTplEngine extends EngineTemplate<VelocityEngine> {
@Override
public Tpl.Engine engine() {
return Tpl.Engine.Velocity;
}
@Override
public VelocityEngine init() {<FILL_FUNCTION_BODY>}
@Override
public void render(VelocityEngine velocityEngine, String filePath, Map<String, Object> bindingMap, Writer out) {
velocityEngine.getTemplate(filePath, StandardCharsets.UTF_8.name()).merge(new VelocityContext(bindingMap), out);
}
}
|
VelocityEngine ve = new VelocityEngine();
ve.setProperty(Velocity.INPUT_ENCODING, StandardCharsets.UTF_8);
ve.setProperty("file.resource.loader.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
ve.init();
return ve;
| 147
| 87
| 234
|
<methods>public non-sealed void <init>() ,public abstract xyz.erupt.annotation.sub_erupt.Tpl.Engine engine() ,public VelocityEngine getEngine() ,public abstract VelocityEngine init() ,public abstract void render(VelocityEngine, java.lang.String, Map<java.lang.String,java.lang.Object>, java.io.Writer) ,public void setEngine(VelocityEngine) <variables>private VelocityEngine engine
|
erupts_erupt
|
erupt/erupt-tpl/src/main/java/xyz/erupt/tpl/service/EruptTplService.java
|
EruptTplService
|
registerTpl
|
class EruptTplService {
public static String TPL = "tpl";
private static final Map<Tpl.Engine, EngineTemplate<Object>> tplEngines = new HashMap<>();
private static final Class<?>[] engineTemplates = {
NativeEngine.class,
FreemarkerEngine.class,
ThymeleafEngine.class,
VelocityTplEngine.class,
BeetlEngine.class,
EnjoyEngine.class
};
static {
for (Class<?> tpl : engineTemplates) {
try {
EngineTemplate<Object> engineTemplate = (EngineTemplate) tpl.newInstance();
engineTemplate.setEngine(engineTemplate.init());
tplEngines.put(engineTemplate.engine(), engineTemplate);
} catch (NoClassDefFoundError ignored) {
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
private final Map<String, Method> tplActions = new LinkedCaseInsensitiveMap<>();
private final Map<String, Method> tplMatcherActions = new LinkedCaseInsensitiveMap<>();
private final PathMatcher pathMatcher = new AntPathMatcher();
@Resource
private HttpServletRequest request;
@Resource
private HttpServletResponse response;
public void run() {
EruptSpringUtil.scannerPackage(EruptApplication.getScanPackage(),
new TypeFilter[]{new AnnotationTypeFilter(EruptTpl.class)},
this::registerTpl);
}
//注册模板
public void registerTpl(Class<?> tplClass) {<FILL_FUNCTION_BODY>}
//移除模板
public void unregisterTpl(Class<?> tplClass) {
Arrays.stream(tplClass.getDeclaredMethods()).forEach(
method -> Optional.ofNullable(method.getAnnotation(TplAction.class)).ifPresent(
it -> {
tplActions.remove(it.value());
tplMatcherActions.remove(it.value());
}
)
);
}
public Method getAction(String path) {
if (tplActions.containsKey(path)) {
return tplActions.get(path);
} else {
// 从模糊匹配中查询资源路径
for (Map.Entry<String, Method> entry : tplMatcherActions.entrySet()) {
if (pathMatcher.match(entry.getKey(), path)) {
return entry.getValue();
}
}
}
return null;
}
public Object getEngine(Tpl.Engine engine) {
return tplEngines.get(engine).getEngine();
}
@SneakyThrows
public void tplRender(Tpl tpl, Map<String, Object> map, HttpServletResponse response) {
response.setCharacterEncoding(StandardCharsets.UTF_8.name());
this.tplRender(tpl, map, response.getWriter());
}
public void tplRender(Tpl tpl, Map<String, Object> map, Writer writer) {
if (!tpl.tplHandler().isInterface()) {
Tpl.TplHandler tplHandler = EruptSpringUtil.getBean(tpl.tplHandler());
map = Optional.ofNullable(map).orElse(new HashMap<>());
tplHandler.bindTplData(map, tpl.params());
}
this.tplRender(tpl.engine(), tpl.path(), map, writer);
}
@SneakyThrows
public void tplRender(Tpl.Engine engine, String path, Map<String, Object> map, Writer writer) {
map = Optional.ofNullable(map).orElse(new HashMap<>());
map.put(EngineConst.INJECT_REQUEST, request);
map.put(EngineConst.INJECT_RESPONSE, response);
map.put(EngineConst.INJECT_BASE, request.getContextPath());
EngineTemplate<Object> engineAbstractTemplate = tplEngines.get(engine);
Assert.notNull(engineAbstractTemplate, engine.name() + " jar not found");
engineAbstractTemplate.render(engineAbstractTemplate.getEngine(), path, map, writer);
}
}
|
Arrays.stream(tplClass.getDeclaredMethods()).forEach(method -> Optional.ofNullable(method.getAnnotation(TplAction.class))
.ifPresent(it -> {
if (pathMatcher.isPattern(it.value())) {
tplMatcherActions.put(it.value(), method);
} else {
tplActions.put(it.value(), method);
}
}
));
| 1,082
| 111
| 1,193
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/EruptUpmsAutoConfiguration.java
|
EruptUpmsAutoConfiguration
|
initMenus
|
class EruptUpmsAutoConfiguration implements EruptModule {
static {
EruptModuleInvoke.addEruptModule(EruptUpmsAutoConfiguration.class);
}
@Override
public ModuleInfo info() {
return ModuleInfo.builder().name("erupt-upms").build();
}
@Override
public List<MetaMenu> initMenus() {<FILL_FUNCTION_BODY>}
}
|
List<MetaMenu> menus = new ArrayList<>();
menus.add(MetaMenu.createRootMenu("$manager", "系统管理", "fa fa-cogs", 1));
menus.add(MetaMenu.createSimpleMenu("$home", "首页", "/", null, 0, "fa fa-home", MenuTypeEnum.ROUTER.getCode(), MenuStatus.OPEN));
menus.add(MetaMenu.createEruptClassMenu(EruptMenu.class, menus.get(0), 0, MenuTypeEnum.TREE));
menus.add(MetaMenu.createEruptClassMenu(EruptRole.class, menus.get(0), 10));
menus.add(MetaMenu.createEruptClassMenu(EruptOrg.class, menus.get(0), 20, MenuTypeEnum.TREE));
menus.add(MetaMenu.createEruptClassMenu(EruptPost.class, menus.get(0), 30, MenuTypeEnum.TREE));
menus.add(MetaMenu.createEruptClassMenu(EruptUser.class, menus.get(0), 40));
menus.add(MetaMenu.createEruptClassMenu(EruptDict.class, menus.get(0), 50));
menus.add(MetaMenu.createEruptClassMenu(EruptDictItem.class, menus.get(0), 60, MenuStatus.HIDE));
menus.add(MetaMenu.createEruptClassMenu(EruptOnline.class, menus.get(0), 65));
menus.add(MetaMenu.createEruptClassMenu(EruptLoginLog.class, menus.get(0), 70));
menus.add(MetaMenu.createEruptClassMenu(EruptOperateLog.class, menus.get(0), 80));
return menus;
| 110
| 468
| 578
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/controller/EruptUserController.java
|
EruptUserController
|
login
|
class EruptUserController {
@Resource
private EruptUserService eruptUserService;
@Resource
private EruptSessionService sessionService;
@Resource
private EruptAppProp eruptAppProp;
@Resource
private EruptContextService eruptContextService;
@Resource
private HttpServletRequest request;
@Resource
private EruptUpmsProp eruptUpmsProp;
@GetMapping("/erupt-app")
public EruptAppProp eruptApp() {
eruptAppProp.setHash(this.hashCode());
eruptAppProp.setVersion(EruptInformation.getEruptVersion());
return eruptAppProp;
}
/**
* 登录
*
* @param account 用户名
* @param pwd 密码
* @param verifyCode 验证码
* @param verifyCodeMark 验证码标识
*/
@SneakyThrows
@GetMapping(value = "/login")
public LoginModel login(@RequestParam String account, @RequestParam String pwd,
@RequestParam(required = false) String verifyCode,
@RequestParam(required = false) String verifyCodeMark
) {<FILL_FUNCTION_BODY>}
//用户信息
@GetMapping("/userinfo")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptUserinfoVo userinfo() {
EruptUser eruptUser = eruptUserService.getCurrentEruptUser();
EruptUserinfoVo userinfoVo = new EruptUserinfoVo();
userinfoVo.setNickname(eruptUser.getName());
userinfoVo.setResetPwd(null == eruptUser.getResetPwdTime());
Optional.ofNullable(eruptUser.getEruptOrg()).ifPresent(it -> userinfoVo.setOrg(it.getCode()));
Optional.ofNullable(eruptUser.getEruptPost()).ifPresent(it -> userinfoVo.setPost(it.getCode()));
Optional.ofNullable(eruptUser.getRoles()).ifPresent(it -> userinfoVo.setRoles(it.stream().map(EruptRole::getCode).collect(Collectors.toList())));
Optional.ofNullable(eruptUser.getEruptMenu()).ifPresent(it -> {
userinfoVo.setIndexMenuType(it.getType());
userinfoVo.setIndexMenuValue(it.getValue());
});
return userinfoVo;
}
//获取菜单列表
@GetMapping("/menu")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public List<EruptMenuVo> getMenu() {
List<EruptMenuVo> menus = sessionService.get(SessionKey.MENU_VIEW + eruptContextService.getCurrentToken(), new TypeToken<List<EruptMenuVo>>() {
}.getType());
menus.forEach(it -> it.setName(I18nTranslate.$translate(it.getName())));
return menus;
}
//登出
@GetMapping(value = "/logout")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel logout(HttpServletRequest request) {
String token = eruptContextService.getCurrentToken();
LoginProxy loginProxy = EruptUserService.findEruptLogin();
Optional.ofNullable(loginProxy).ifPresent(it -> it.logout(token));
request.getSession().invalidate();
for (String uk : SessionKey.USER_KEY_GROUP) {
sessionService.remove(uk + token);
}
return EruptApiModel.successApi();
}
/**
* 修改密码
*
* @param pwd 旧密码
* @param newPwd 新密码
* @param newPwd2 确认新密码
*/
@GetMapping(value = "/change-pwd")
@EruptRouter(verifyType = EruptRouter.VerifyType.LOGIN)
public EruptApiModel changePwd(@RequestParam("pwd") String pwd, @RequestParam("newPwd") String newPwd, @RequestParam("newPwd2") String newPwd2) {
pwd = SecretUtil.decodeSecret(pwd, 3);
newPwd = SecretUtil.decodeSecret(newPwd, 3);
newPwd2 = SecretUtil.decodeSecret(newPwd2, 3);
return eruptUserService.changePwd(eruptUserService.getCurrentAccount(), pwd, newPwd, newPwd2);
}
/**
* 生成验证码
*
* @param mark 生成验证码标记值
* @param height 验证码高度
*/
@GetMapping("/code-img")
public void createCode(HttpServletResponse response, @RequestParam long mark,
@RequestParam(required = false, defaultValue = "38") Integer height) throws Exception {
response.setContentType("image/jpeg"); // 设置响应的类型格式为图片格式
response.setDateHeader("Expires", 0);
response.setHeader("Pragma", "no-cache"); // 禁止图像缓存
response.setHeader("Cache-Control", "no-cache");
Captcha captcha = new SpecCaptcha(150, height, 4);
sessionService.put(SessionKey.VERIFY_CODE + mark, captcha.text(), 60, TimeUnit.SECONDS);
captcha.out(response.getOutputStream());
}
}
|
if (!eruptUserService.checkVerifyCode(account, verifyCode, verifyCodeMark)) {
LoginModel loginModel = new LoginModel();
loginModel.setUseVerifyCode(true);
loginModel.setReason("验证码错误");
loginModel.setPass(false);
return loginModel;
}
LoginProxy loginProxy = EruptUserService.findEruptLogin();
LoginModel loginModel;
if (null == loginProxy) {
loginModel = eruptUserService.login(account, pwd);
} else {
loginModel = new LoginModel();
try {
EruptUser eruptUser = loginProxy.login(account, pwd);
if (null == eruptUser) {
loginModel.setReason("账号或密码错误");
loginModel.setPass(false);
} else {
loginModel.setEruptUser(eruptUser);
loginModel.setPass(true);
}
} catch (Exception e) {
if (0 == eruptAppProp.getVerifyCodeCount()) loginModel.setUseVerifyCode(true);
loginModel.setReason(e.getMessage());
loginModel.setPass(false);
}
}
if (loginModel.isPass()) {
request.getSession().invalidate();
EruptUser eruptUser = loginModel.getEruptUser();
loginModel.setToken(Erupts.generateCode(16));
loginModel.setExpire(this.eruptUserService.getExpireTime());
loginModel.setResetPwd(null == eruptUser.getResetPwdTime());
if (null != loginProxy) loginProxy.loginSuccess(eruptUser, loginModel.getToken());
sessionService.put(SessionKey.TOKEN_OLINE + loginModel.getToken(), eruptUser.getAccount(), eruptUpmsProp.getExpireTimeByLogin());
eruptUserService.cacheUserInfo(eruptUser, loginModel.getToken());
eruptUserService.saveLoginLog(eruptUser, loginModel.getToken()); //记录登录日志
}
return loginModel;
| 1,454
| 525
| 1,979
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/handler/DictChoiceFetchHandler.java
|
DictChoiceFetchHandler
|
fetch
|
class DictChoiceFetchHandler implements ChoiceFetchHandler {
@Resource
private EruptDao eruptDao;
private final EruptCache<List<VLModel>> dictCache = new EruptCacheLRU<>(500);
@Override
public List<VLModel> fetch(String[] params) {<FILL_FUNCTION_BODY>}
}
|
EruptAssert.notNull(params, DictChoiceFetchHandler.class.getSimpleName() + " → params[0] must dict → code");
return dictCache.getAndSet(DictChoiceFetchHandler.class.getName() + ":" + params[0],
params.length == 2 ? Long.parseLong(params[1]) : FetchConst.DEFAULT_CACHE_TIME, ()
-> eruptDao.lambdaQuery(EruptDictItem.class).eq(EruptDictItem::getCode, params[0]).orderBy(EruptDictItem::getSort).list()
.stream().map((item) -> new VLModel(item.getId(), item.getName())).collect(Collectors.toList()));
| 99
| 186
| 285
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/handler/DictCodeChoiceFetchHandler.java
|
DictCodeChoiceFetchHandler
|
fetch
|
class DictCodeChoiceFetchHandler implements ChoiceFetchHandler {
@Resource
private EruptDao eruptDao;
private final EruptCache<List<VLModel>> dictCache = new EruptCacheLRU<>(500);
@Override
public List<VLModel> fetch(String[] params) {<FILL_FUNCTION_BODY>}
}
|
EruptAssert.notNull(params, DictCodeChoiceFetchHandler.class.getSimpleName() + " → params[0] must dict → code");
return dictCache.getAndSet(DictCodeChoiceFetchHandler.class.getName() + ":" + params[0],
params.length == 2 ? Long.parseLong(params[1]) : FetchConst.DEFAULT_CACHE_TIME, () ->
eruptDao.lambdaQuery(EruptDictItem.class).eq(EruptDictItem::getCode, params[0]).orderBy(EruptDictItem::getSort).list()
.stream().map((item) -> new VLModel(item.getCode(), item.getName())).collect(Collectors.toList()));
| 100
| 189
| 289
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/handler/RoleMenuFilter.java
|
RoleMenuFilter
|
filter
|
class RoleMenuFilter implements FilterHandler {
@Resource
private EruptUserService eruptUserService;
@Resource
private EruptUpmsProp eruptUpmsProp;
@Override
public String filter(String condition, String[] params) {<FILL_FUNCTION_BODY>}
}
|
EruptUser eruptUser = eruptUserService.getCurrentEruptUser();
if (eruptUser.getIsAdmin() || !eruptUpmsProp.isStrictRoleMenuLegal()) {
return null;
} else {
Set<EruptMenu> menuSet = new HashSet<>();
eruptUser.getRoles().stream().filter(EruptRole::getStatus).map(EruptRole::getMenus).forEach(menuSet::addAll);
List<String> menus = menuSet.stream().map(it -> it.getId().toString()).collect(Collectors.toList());
return String.format("EruptMenu.id in (%s)", String.join(",", String.join(",", menus)));
}
| 80
| 185
| 265
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/handler/UpmsPowerHandler.java
|
UpmsPowerHandler
|
handler
|
class UpmsPowerHandler implements PowerHandler {
static {
PowerInvoke.registerPowerHandler(UpmsPowerHandler.class);
}
@Resource
private EruptUserService eruptUserService;
@Override
public void handler(PowerObject power) {<FILL_FUNCTION_BODY>}
private boolean powerOff(EruptFunPermissions eruptFunPermissions, Map<String, Boolean> permissionMap) {
return permissionMap.containsKey(UPMSUtil.getEruptFunPermissionsCode(MetaContext.getErupt().getName(), eruptFunPermissions).toLowerCase());
}
}
|
Map<String, Boolean> permissionMap = eruptUserService.getEruptMenuValuesMap();
if (power.isAdd()) {
power.setAdd(powerOff(EruptFunPermissions.ADD, permissionMap));
}
if (power.isDelete()) {
power.setDelete(powerOff(EruptFunPermissions.DELETE, permissionMap));
}
if (power.isEdit()) {
power.setEdit(powerOff(EruptFunPermissions.EDIT, permissionMap));
}
if (power.isViewDetails()) {
power.setViewDetails(powerOff(EruptFunPermissions.VIEW_DETAIL, permissionMap));
}
if (power.isExport()) {
power.setExport(powerOff(EruptFunPermissions.EXPORT, permissionMap));
}
if (power.isImportable()) {
power.setImportable(powerOff(EruptFunPermissions.IMPORTABLE, permissionMap));
}
| 155
| 243
| 398
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/handler/ViaMenuValueCtrl.java
|
ViaMenuValueCtrl
|
handler
|
class ViaMenuValueCtrl implements ExprBool.ExprHandler {
@Resource
private EruptUserService eruptUserService;
@Override
@Comment("params必填，值为菜单类型值")
public boolean handler(boolean expr, String[] params) {<FILL_FUNCTION_BODY>}
}
|
EruptAssert.notNull(params,ViaMenuValueCtrl.class.getSimpleName() + " → params[0] not found");
return null != eruptUserService.getEruptMenuByValue(params[0]);
| 83
| 59
| 142
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/looker/LookerOrg.java
|
Comp
|
beforeFetch
|
class Comp implements DataProxy<LookerOrg> {
@Resource
private EruptUserService eruptUserService;
@Override
public String beforeFetch(List<Condition> conditions) {<FILL_FUNCTION_BODY>}
@Override
public void beforeAdd(LookerOrg lookerOrg) {
lookerOrg.setCreateTime(new Date());
lookerOrg.setCreateUser(new EruptUserPostVo(eruptUserService.getCurrentUid()));
}
@Override
public void beforeUpdate(LookerOrg lookerOrg) {
lookerOrg.setUpdateTime(new Date());
lookerOrg.setUpdateUser(new EruptUserPostVo(eruptUserService.getCurrentUid()));
}
}
|
EruptUser eruptUser = eruptUserService.getCurrentEruptUser();
if (eruptUser.getIsAdmin()) return null;
if (null == eruptUser.getEruptOrg()) {
throw new EruptWebApiRuntimeException(eruptUser.getName() + " " + I18nTranslate.$translate("upms.no_bind_org"));
} else {
return MetaContext.getErupt().getName() + ".createUser.eruptOrg.id = " + eruptUser.getEruptOrg().getId();
}
| 202
| 142
| 344
|
<methods>public non-sealed void <init>() <variables>private java.lang.Long id
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/looker/LookerPostLevel.java
|
Comp
|
beforeFetch
|
class Comp implements DataProxy<LookerPostLevel> {
@Resource
private EruptUserService eruptUserService;
@Override
public String beforeFetch(List<Condition> conditions) {<FILL_FUNCTION_BODY>}
@Override
public void beforeAdd(LookerPostLevel lookerPostLevel) {
lookerPostLevel.setCreateTime(new Date());
lookerPostLevel.setCreateUser(new EruptUserPostVo(eruptUserService.getCurrentUid()));
}
@Override
public void beforeUpdate(LookerPostLevel lookerPostLevel) {
lookerPostLevel.setUpdateTime(new Date());
lookerPostLevel.setUpdateUser(new EruptUser(eruptUserService.getCurrentUid()));
}
}
|
EruptUser eruptUser = eruptUserService.getCurrentEruptUser();
if (eruptUser.getIsAdmin()) return null;
if (null == eruptUser.getEruptOrg() || null == eruptUser.getEruptPost()) {
throw new EruptWebApiRuntimeException(eruptUser.getName() + " " + I18nTranslate.$translate("upms.no_bind_post"));
}
String eruptName = MetaContext.getErupt().getName();
return "(" + eruptName + ".createUser.id = " + eruptUserService.getCurrentUid()
+ " or " + eruptName + ".createUser.eruptOrg.id = " + eruptUser.getEruptOrg().getId() + " and "
+ eruptName + ".createUser.eruptPost.weight < " + eruptUser.getEruptPost().getWeight() + ")";
| 198
| 229
| 427
|
<methods>public non-sealed void <init>() <variables>private java.lang.Long id
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/looker/LookerSelf.java
|
Comp
|
beforeFetch
|
class Comp implements DataProxy<Void> {
@Resource
private EruptUserService eruptUserService;
@Override
public String beforeFetch(List<Condition> conditions) {<FILL_FUNCTION_BODY>}
}
|
if (eruptUserService.getCurrentEruptUser().getIsAdmin()) return null;
return MetaContext.getErupt().getName() + ".createUser.id = " + eruptUserService.getCurrentUid();
| 64
| 57
| 121
|
<methods>public non-sealed void <init>() <variables>private java.util.Date createTime,private xyz.erupt.upms.model.EruptUserVo createUser
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/EruptMenu.java
|
EruptMenu
|
fromMetaMenu
|
class EruptMenu extends MetaModel {
public static final String CODE = "code";
@EruptField(
views = @View(title = "名称"),
edit = @Edit(
title = "名称",
notNull = true
)
)
private String name;
@EruptField(
edit = @Edit(
notNull = true,
title = "状态",
type = EditType.CHOICE,
choiceType = @ChoiceType(fetchHandler = MenuStatus.ChoiceFetch.class)
)
)
private Integer status;
@ManyToOne
@EruptField(
edit = @Edit(
title = "上级菜单",
type = EditType.REFERENCE_TREE,
referenceTreeType = @ReferenceTreeType(pid = "parentMenu.id", expandLevel = 3)
)
)
private EruptMenu parentMenu;
@EruptField(
edit = @Edit(
title = "菜单类型",
type = EditType.CHOICE,
choiceType = @ChoiceType(fetchHandler = MenuTypeEnum.ChoiceFetch.class)
)
)
private String type;
// @Column(name = "\"value\"")
@EruptField(
edit = @Edit(
title = "类型值"
)
)
private String value;
@EruptField(
edit = @Edit(
title = "顺序"
)
)
private Integer sort = 0;
@EruptField(
edit = @Edit(
title = "图标",
desc = "请参考图标库font-awesome"
)
)
private String icon;
@Column(length = AnnotationConst.CODE_LENGTH, unique = true)
@EruptField(
edit = @Edit(
title = "编码", readonly = @Readonly
)
)
private String code;
@Column(length = AnnotationConst.REMARK_LENGTH)
@EruptField(
edit = @Edit(
title = "自定义参数",
desc = "json格式，通过上下文获取，根据业务需求自助解析",
type = EditType.CODE_EDITOR,
codeEditType = @CodeEditorType(language = "json")
)
)
private String param;
public EruptMenu() {
}
public EruptMenu(String code, String name, String type, String value, Integer status, Integer sort, String icon, EruptMenu parentMenu) {
this.code = code;
this.name = name;
this.status = status;
this.type = type;
this.value = value;
this.sort = sort;
this.icon = icon;
this.parentMenu = parentMenu;
this.setCreateTime(LocalDateTime.now());
}
public EruptMenu(String code, String name, String type, String value, EruptMenu parentMenu, Integer sort) {
this.code = code;
this.name = name;
this.parentMenu = parentMenu;
this.type = type;
this.value = value;
this.sort = sort;
this.setStatus(MenuStatus.OPEN.getValue());
this.setCreateTime(LocalDateTime.now());
}
public static EruptMenu fromMetaMenu(MetaMenu metaMenu) {<FILL_FUNCTION_BODY>}
}
|
if (null == metaMenu) return null;
EruptMenu eruptMenu = new EruptMenu(metaMenu.getCode(),
metaMenu.getName(), null == metaMenu.getType() ? null : metaMenu.getType(),
metaMenu.getValue(), null == metaMenu.getStatus() ? null : metaMenu.getStatus().getValue(),
metaMenu.getSort(), metaMenu.getIcon(), fromMetaMenu(metaMenu.getParentMenu()));
eruptMenu.setId(metaMenu.getId());
return eruptMenu;
| 881
| 131
| 1,012
|
<methods>public non-sealed void <init>() <variables>private java.lang.String createBy,private java.time.LocalDateTime createTime,private java.lang.String updateBy,private java.time.LocalDateTime updateTime
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/EruptUser.java
|
EruptUser
|
filter
|
class EruptUser extends LookerSelf implements FilterHandler {
@Column(length = AnnotationConst.CODE_LENGTH, unique = true)
@EruptField(
views = @View(title = "用户名", sortable = true),
edit = @Edit(title = "用户名", desc = "登录用户名", notNull = true, search = @Search(vague = true))
)
private String account;
@EruptField(
views = @View(title = "姓名", sortable = true),
edit = @Edit(title = "姓名", notNull = true, search = @Search(vague = true))
)
private String name;
@EruptField(
views = @View(title = "账户状态", sortable = true),
edit = @Edit(
title = "账户状态",
search = @Search,
type = EditType.BOOLEAN,
notNull = true,
boolType = @BoolType(
trueText = "激活",
falseText = "锁定"
)
)
)
private Boolean status = true;
@EruptField(
edit = @Edit(title = "手机号码", search = @Search(vague = true), inputType = @InputType(regex = RegexConst.PHONE_REGEX))
)
private String phone;
@EruptField(
edit = @Edit(title = "邮箱", search = @Search(vague = true), inputType = @InputType(regex = RegexConst.EMAIL_REGEX))
)
private String email;
@EruptField(
views = @View(title = "超管用户", sortable = true),
edit = @Edit(
title = "超管用户", notNull = true, search = @Search(vague = true)
)
)
private Boolean isAdmin = false;
@ManyToOne
@EruptField(
views = @View(title = "首页菜单", column = "name"),
edit = @Edit(
title = "首页菜单",
type = EditType.REFERENCE_TREE,
referenceTreeType = @ReferenceTreeType(pid = "parentMenu.id"),
filter = @Filter(conditionHandler = EruptUser.class)
)
)
private EruptMenu eruptMenu;
@ManyToOne
@EruptField(
views = @View(title = "所属组织", column = "name"),
edit = @Edit(title = "所属组织", type = EditType.REFERENCE_TREE, referenceTreeType = @ReferenceTreeType(pid = "parentOrg.id"))
)
private EruptOrg eruptOrg;
@ManyToOne
@EruptField(
views = @View(title = "岗位", column = "name"),
edit = @Edit(title = "岗位", type = EditType.REFERENCE_TREE, search = @Search)
)
private EruptPost eruptPost;
@Transient
@EruptField(
edit = @Edit(title = "密码", type = EditType.DIVIDE)
)
private String pwdDivide;
private String password;
@Transient
@EruptField(
edit = @Edit(title = "密码", readonly = @Readonly(add = false))
)
private String passwordA;
@Transient
@EruptField(
edit = @Edit(title = "确认密码", readonly = @Readonly(add = false))
)
private String passwordB;
@EruptField(
views = @View(title = "重置密码时间", width = "130px", sortable = true)
)
private Date resetPwdTime;
@EruptField(
edit = @Edit(
title = "md5加密", type = EditType.BOOLEAN, notNull = true,
readonly = @Readonly(add = false),
boolType = @BoolType(
trueText = "加密",
falseText = "不加密"
)
)
)
private Boolean isMd5 = true;
@EruptField(
views = @View(title = "账号失效时间", sortable = true),
edit = @Edit(title = "账号失效时间")
)
private Date expireDate;
@ManyToMany(fetch = FetchType.EAGER)
@JoinTable(
name = "e_upms_user_role",
joinColumns = @JoinColumn(name = "user_id", referencedColumnName = "id"),
inverseJoinColumns = @JoinColumn(name = "role_id", referencedColumnName = "id")
)
@OrderBy
@EruptField(
views = @View(title = "所属角色"),
edit = @Edit(
title = "所属角色",
type = EditType.CHECKBOX
)
)
private Set<EruptRole> roles;
@Column(length = AnnotationConst.REMARK_LENGTH)
@EruptField(
edit = @Edit(
title = "ip白名单",
desc = "ip与ip之间使用换行符间隔，不填表示不鉴权",
type = EditType.TEXTAREA
)
)
private String whiteIp;
@Column(length = AnnotationConst.REMARK_LENGTH)
@EruptField(
edit = @Edit(
title = "备注",
type = EditType.TEXTAREA
)
)
private String remark;
public EruptUser() {
}
public EruptUser(Long id) {
this.setId(id);
}
@Override
public String filter(String condition, String[] params) {<FILL_FUNCTION_BODY>}
}
|
List<String> nts = new ArrayList<>();
nts.add(MenuTypeEnum.API.getCode());
nts.add(MenuTypeEnum.BUTTON.getCode());
return String.format("EruptMenu.type not in ('%s') or EruptMenu.type is null", String.join("','", nts));
| 1,488
| 86
| 1,574
|
<methods>public non-sealed void <init>() <variables>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/EruptUserDataProxy.java
|
EruptUserDataProxy
|
checkDataLegal
|
class EruptUserDataProxy implements DataProxy<EruptUser> {
@Resource
private EruptUserService eruptUserService;
@Override
public void beforeAdd(EruptUser eruptUser) {
this.checkDataLegal(eruptUser);
if (StringUtils.isBlank(eruptUser.getPasswordA())) {
throw new EruptApiErrorTip(EruptApiModel.Status.WARNING, I18nTranslate.$translate("upms.pwd_required"), EruptApiModel.PromptWay.MESSAGE);
}
if (eruptUser.getPasswordA().equals(eruptUser.getPasswordB())) {
if (eruptUser.getIsMd5()) {
eruptUser.setPassword(MD5Util.digest(eruptUser.getPasswordA()));
} else {
eruptUser.setPassword(eruptUser.getPasswordA());
}
} else {
throw new EruptWebApiRuntimeException(I18nTranslate.$translate("upms.pwd_two_inconsistent"));
}
}
@Override
public void beforeUpdate(EruptUser eruptUser) {
this.checkDataLegal(eruptUser);
}
private void checkDataLegal(EruptUser eruptUser) {<FILL_FUNCTION_BODY>}
}
|
if (eruptUser.getEruptPost() != null && eruptUser.getEruptOrg() == null)
throw new EruptWebApiRuntimeException(I18nTranslate.$translate("upms.position_no_org"));
EruptUser curr = eruptUserService.getCurrentEruptUser();
if (eruptUser.getIsAdmin()) {
if (null == curr.getIsAdmin() || !curr.getIsAdmin()) {
throw new EruptWebApiRuntimeException(I18nTranslate.$translate("upms.not_super_admin-unable_add"));
}
}
| 338
| 159
| 497
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/data_proxy/EruptRoleDataProxy.java
|
EruptRoleDataProxy
|
beforeFetch
|
class EruptRoleDataProxy implements DataProxy<EruptRole> {
@Resource
@Transient
private EruptUserService eruptUserService;
@Resource
@Transient
private EruptDao eruptDao;
@Override
public String beforeFetch(List<Condition> conditions) {<FILL_FUNCTION_BODY>}
@Override
public void addBehavior(EruptRole eruptRole) {
Integer max = (Integer) eruptDao.getEntityManager().createQuery("select max(sort) from " + EruptRole.class.getSimpleName()).getSingleResult();
if (null == max) {
eruptRole.setSort(10);
} else {
eruptRole.setSort(max + 10);
}
}
}
|
if (eruptUserService.getCurrentEruptUser().getIsAdmin()) return null;
return "EruptRole.createUser.id = " + eruptUserService.getCurrentUid();
| 204
| 50
| 254
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/input/ResetPasswordExec.java
|
ResetPasswordExec
|
exec
|
class ResetPasswordExec implements OperationHandler<EruptUser, ResetPassword> {
@Resource
private EruptDao eruptDao;
@Override
@Transactional
public String exec(List<EruptUser> data, ResetPassword resetPassword, String[] param) {<FILL_FUNCTION_BODY>}
}
|
EruptUser eruptUser = data.get(0);
if (resetPassword.getPassword().equals(resetPassword.getPassword2())) {
eruptUser.setResetPwdTime(null);
eruptUser.setIsMd5(resetPassword.getIsMd5());
if (resetPassword.getIsMd5()) {
eruptUser.setPassword(MD5Util.digest(resetPassword.getPassword()));
} else {
eruptUser.setPassword(resetPassword.getPassword());
}
eruptDao.merge(eruptUser);
} else {
throw new EruptWebApiRuntimeException(I18nTranslate.$translate("upms.pwd_two_inconsistent"));
}
return null;
| 86
| 190
| 276
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/log/EruptOperateLog.java
|
EruptOperateLog
|
afterFetch
|
class EruptOperateLog extends BaseModel implements DataProxy<EruptOperateLog> {
@EruptField(
views = @View(title = "操作人"),
edit = @Edit(title = "操作人", search = @Search(vague = true))
)
private String operateUser;
@EruptField(
views = @View(title = "IP地址"),
edit = @Edit(title = "IP地址", search = @Search)
)
private String ip;
@EruptField(
views = @View(title = "IP来源", desc = "格式：国家 | 大区 | 省份 | 城市 | 运营商", template = "value&&value.replace(/\\|/g,' | ')"),
edit = @Edit(title = "IP来源", search = @Search(vague = true))
)
private String region;
@EruptField(
views = @View(title = "功能名称"),
edit = @Edit(title = "功能名称", search = @Search(vague = true))
)
private String apiName;
@Lob
@Type(type = "org.hibernate.type.TextType")
@EruptField(
views = @View(title = "请求参数", type = ViewType.CODE),
edit = @Edit(title = "请求参数", type = EditType.CODE_EDITOR, codeEditType = @CodeEditorType(language = "json"))
)
private String reqParam;
@EruptField(
views = @View(title = "是否成功", sortable = true),
edit = @Edit(title = "是否成功", search = @Search)
)
private Boolean status;
@Column(length = 4000)
@EruptField(
views = @View(title = "错误信息", type = ViewType.HTML)
)
private String errorInfo;
@EruptField(
views = @View(title = "请求耗时", template = "value && value+'ms'", sortable = true),
edit = @Edit(title = "请求耗时", search = @Search(vague = true))
)
private Long totalTime;
@EruptField(
views = @View(title = "记录时间", sortable = true),
edit = @Edit(title = "记录时间", search = @Search(vague = true), dateType = @DateType(type = DateType.Type.DATE_TIME))
)
private Date createTime;
@Column(length = 4000)
@EruptField(
views = @View(title = "请求地址", type = ViewType.HTML)
)
private String reqAddr;
@Column(length = 64)
@EruptField(
views = @View(title = "请求方法")
)
private String reqMethod;
@Override
public void afterFetch(Collection<Map<String, Object>> list) {<FILL_FUNCTION_BODY>}
}
|
GsonBuilder builder = new GsonBuilder();
builder.setPrettyPrinting();
Gson gson = builder.create();
for (Map<String, Object> map : list) {
Object reqParam = map.get(LambdaSee.field(EruptOperateLog::getReqParam));
if (null != reqParam) {
try {
map.put(LambdaSee.field(EruptOperateLog::getReqParam), gson.toJson(gson.fromJson(reqParam.toString(), Object.class)));
} catch (Exception ignore) {
}
}
}
| 753
| 153
| 906
|
<methods>public non-sealed void <init>() <variables>private java.lang.Long id
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/online/EruptOnlineFilterHandler.java
|
EruptOnlineFilterHandler
|
filter
|
class EruptOnlineFilterHandler implements FilterHandler {
@Resource
private EruptProp eruptProp;
@Resource
private StringRedisTemplate stringRedisTemplate;
@Override
public String filter(String condition, String[] params) {<FILL_FUNCTION_BODY>}
}
|
if (eruptProp.isRedisSession()) {
Set<String> keys = stringRedisTemplate.keys(SessionKey.TOKEN_OLINE + "*");
if (keys != null && keys.size() > 0) {
StringBuilder sb = new StringBuilder(EruptOnline.class.getSimpleName() + ".token in (");
keys.forEach(it -> sb.append("'").append(it.substring(SessionKey.TOKEN_OLINE.length())).append("',"));
return sb.substring(0, sb.length() - 1) + ")";
}
return "1 = 2";
}
throw new EruptApiErrorTip(EruptApiModel.Status.INFO,
"Enable the RedisSession configuration to use this feature", EruptApiModel.PromptWay.NOTIFY);
| 76
| 210
| 286
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/model/online/LogOutOperationHandler.java
|
LogOutOperationHandler
|
exec
|
class LogOutOperationHandler implements OperationHandler<EruptOnline, Void> {
@Resource
private EruptProp eruptProp;
@Resource
private EruptSessionService eruptSessionService;
@Override
public String exec(List<EruptOnline> data, Void v, String[] param) {<FILL_FUNCTION_BODY>}
}
|
if (eruptProp.isRedisSession()) {
data.forEach(it -> {
for (String uk : SessionKey.USER_KEY_GROUP) {
eruptSessionService.remove(uk + it.getToken());
}
});
}
return null;
| 93
| 74
| 167
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/prop/EruptAppProp.java
|
EruptAppProp
|
setLocales
|
class EruptAppProp {
public static final String DEFAULT_LANG = "zh-CN";
//是否显示水印
private boolean waterMark = true;
//登录失败几次出现验证码，0表示一直要求输入验证码
private Integer verifyCodeCount = 2;
//登录密码是否加密传输
private Boolean pwdTransferEncrypt = true;
//自定义登录页路径，支持http网络路径
private String loginPagePath;
private Integer hash;
private String version;
//多语言配置
private String[] locales = {
"zh-CN", // 简体中文
"zh-TW", // 繁体中文
"en-US", // English
"fr-FR", // En français
"ja-JP", // 日本語
"ko-KR", // 한국어
"ru-RU", // русск
"es-ES" // español
};
//重置密码功能开关
private Boolean resetPwd = true;
public void setLocales(String[] locales) {<FILL_FUNCTION_BODY>}
}
|
if (null == locales || locales.length == 0) {
this.locales = new String[]{"zh-CN"};
} else {
this.locales = locales;
}
| 324
| 55
| 379
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/service/EruptContextService.java
|
EruptContextService
|
getCurrentEruptMenu
|
class EruptContextService {
@Resource
private HttpServletRequest request;
@Resource
private EruptSessionService sessionService;
//获取erupt上下文对象
@Deprecated
public Class<?> getContextEruptClass() {
return EruptCoreService.getErupt(MetaContext.getErupt().getName()).getClazz();
}
//获取当前请求token
public String getCurrentToken() {
String token = request.getHeader(EruptReqHeaderConst.ERUPT_HEADER_TOKEN);
return StringUtils.isNotBlank(token) ? token : request.getParameter(EruptReqHeaderConst.URL_ERUPT_PARAM_TOKEN);
}
//获取当前菜单对象
public EruptMenu getCurrentEruptMenu() {<FILL_FUNCTION_BODY>}
}
|
MetaErupt metaErupt = MetaContext.getErupt();
return sessionService.getMapValue(SessionKey.MENU_VALUE_MAP + getCurrentToken()
, (metaErupt.getMenuValue() == null ? metaErupt.getName() : metaErupt.getMenuValue()).toLowerCase(),
EruptMenu.class);
| 217
| 88
| 305
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/service/EruptMenuService.java
|
EruptMenuService
|
afterAdd
|
class EruptMenuService implements DataProxy<EruptMenu> {
@Resource
private EruptDao eruptDao;
@Resource
private EruptContextService eruptContextService;
public List<EruptMenuVo> geneMenuListVo(List<EruptMenu> menus) {
List<EruptMenuVo> list = new ArrayList<>();
menus.stream().filter(menu -> menu.getStatus() == MenuStatus.OPEN.getValue()).forEach(menu -> {
Long pid = null == menu.getParentMenu() ? null : menu.getParentMenu().getId();
list.add(new EruptMenuVo(menu.getId(), menu.getCode(), menu.getName(), menu.getType(), menu.getValue(), menu.getIcon(), pid));
});
return list;
}
public List<EruptMenu> getUserAllMenu(EruptUser eruptUser) {
if (null != eruptUser.getIsAdmin() && eruptUser.getIsAdmin()) {
return eruptDao.lambdaQuery(EruptMenu.class).orderBy(EruptMenu::getSort).list();
} else {
Set<EruptMenu> menuSet = new HashSet<>();
eruptUser.getRoles().stream().filter(EruptRole::getStatus).map(EruptRole::getMenus).forEach(menuSet::addAll);
return menuSet.stream().filter(it -> it.getStatus() != MenuStatus.DISABLE.getValue()).sorted(Comparator.comparing(EruptMenu::getSort, Comparator.nullsFirst(Integer::compareTo))).collect(Collectors.toList());
}
}
@Override
public void addBehavior(EruptMenu eruptMenu) {
Integer obj = (Integer) eruptDao.getEntityManager().createQuery("select max(sort) from " + EruptMenu.class.getSimpleName()).getSingleResult();
Optional.ofNullable(obj).ifPresent(it -> eruptMenu.setSort(it + 10));
eruptMenu.setStatus(MenuStatus.OPEN.getValue());
}
@Override
public void beforeAdd(EruptMenu eruptMenu) {
if (null == eruptMenu.getCode()) eruptMenu.setCode(Erupts.generateCode());
if (StringUtils.isNotBlank(eruptMenu.getType()) && StringUtils.isBlank(eruptMenu.getValue())) {
throw new EruptWebApiRuntimeException("When selecting a menu type, the type value cannot be empty");
} else if (StringUtils.isNotBlank(eruptMenu.getValue()) && StringUtils.isBlank(eruptMenu.getType())) {
throw new EruptWebApiRuntimeException("When has menu value, the menu type cannot be empty");
}
}
@Override
public void beforeUpdate(EruptMenu eruptMenu) {
this.beforeAdd(eruptMenu);
}
/**
* The reason for that:
* <p>
* The dependencies of some of the beans in the application context form a cycle:
* mvcInterceptor
* ↓
* eruptSecurityInterceptor
* ┌─────┐
* | eruptUserService
* ↑ ↓
* | eruptMenuService
* └─────┘
*/
private void flushCache() {
EruptUserService eruptUserService = EruptSpringUtil.getBean(EruptUserService.class);
eruptUserService.cacheUserInfo(eruptUserService.getCurrentEruptUser(), eruptContextService.getCurrentToken());
}
@Override
public void afterAdd(EruptMenu eruptMenu) {<FILL_FUNCTION_BODY>}
@Override
public void afterUpdate(EruptMenu eruptMenu) {
this.afterAdd(eruptMenu);
}
@Override
public void beforeDelete(EruptMenu eruptMenu) {
eruptDao.getJdbcTemplate().update("delete from e_upms_role_menu where menu_id = " + eruptMenu.getId());
}
@Override
public void afterDelete(EruptMenu eruptMenu) {
this.flushCache();
}
}
|
if (null != eruptMenu.getValue()) {
if (MenuTypeEnum.TABLE.getCode().equals(eruptMenu.getType()) || MenuTypeEnum.TREE.getCode().equals(eruptMenu.getType())) {
int i = 0;
Integer counter = eruptDao.getJdbcTemplate().queryForObject(
String.format("select count(*) from e_upms_menu where parent_menu_id = %d", eruptMenu.getId()), Integer.class
);
if (null != counter) {
if (counter > 0) {
// 查询有权限菜单
Integer realCounter = eruptDao.getJdbcTemplate().queryForObject(
String.format("select count(*) from e_upms_menu where parent_menu_id = %d and value like '%s@%%'", eruptMenu.getId(), eruptMenu.getValue()), Integer.class
);
// 如果没有查询出权限菜单，那么本次修改Value
if (null != realCounter && realCounter == 0) {
eruptDao.getJdbcTemplate().update(String.format("delete from e_upms_menu where parent_menu_id = %d and value like '%%@%%'", eruptMenu.getId()));
counter = 0;
}
}
if (counter <= 0) {
EruptModel eruptModel = EruptCoreService.getErupt(eruptMenu.getValue());
for (EruptFunPermissions value : EruptFunPermissions.values()) {
if (eruptModel == null || value.verifyPower(eruptModel.getErupt().power())) {
eruptDao.persist(new EruptMenu(
Erupts.generateCode(), value.getName(), MenuTypeEnum.BUTTON.getCode(),
UPMSUtil.getEruptFunPermissionsCode(eruptMenu.getValue(), value), eruptMenu, i += 10)
);
}
}
}
}
}
}
this.flushCache();
| 1,060
| 503
| 1,563
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/service/EruptSessionService.java
|
EruptSessionService
|
getMapValue
|
class EruptSessionService {
@Resource
private EruptProp eruptProp;
@Resource
private HttpServletRequest request;
@Resource
private StringRedisTemplate stringRedisTemplate;
private final Gson gson = GsonFactory.getGson();
public void put(String key, String str, long timeout) {
this.put(key, str, timeout, TimeUnit.MINUTES);
}
public void put(String key, String str, long timeout, TimeUnit timeUnit) {
if (eruptProp.isRedisSession()) {
stringRedisTemplate.opsForValue().set(key, str, timeout, timeUnit);
} else {
request.getSession().setAttribute(key, str);
}
}
public void remove(String key) {
if (eruptProp.isRedisSession()) {
stringRedisTemplate.delete(key);
} else {
request.getSession().removeAttribute(key);
}
}
//延长key过期时间
public void expire(String key, long timeout, final TimeUnit unit) {
if (eruptProp.isRedisSession()) {
stringRedisTemplate.expire(key, timeout, unit);
}
}
public Object get(String key) {
if (eruptProp.isRedisSession()) {
return stringRedisTemplate.opsForValue().get(key);
} else {
return request.getSession().getAttribute(key);
}
}
public <T> T get(String key, Type type) {
if (eruptProp.isRedisSession()) {
if (null == this.get(key)) {
return null;
} else {
return gson.fromJson(this.get(key).toString(), type);
}
} else {
return gson.fromJson(request.getSession().getAttribute(key).toString(), type);
}
}
public void putMap(String key, Map<String, Object> map, long expire) {
if (eruptProp.isRedisSession()) {
BoundHashOperations<?, String, Object> boundHashOperations = stringRedisTemplate.boundHashOps(key);
map.replaceAll((k, v) -> gson.toJson(v));
boundHashOperations.putAll(map);
boundHashOperations.expire(expire, TimeUnit.MINUTES);
} else {
request.getSession().setAttribute(key, map);
}
}
// public <T> Map<String, T> getMap(String key, Class<T> type) {
// if (eruptProp.isRedisSession()) {
// return stringRedisTemplate.boundHashOps(key).entries();
// } else {
// return (Map<String, T>) request.getSession().getAttribute(key);
// }
// }
//获取map的所有key
public List<String> getMapKeys(String key) {
if (eruptProp.isRedisSession()) {
Set<Object> set = stringRedisTemplate.opsForHash().keys(key);
return set.stream().map(Object::toString).collect(Collectors.toList());
} else {
Map<String, Object> map = (Map<String, Object>) request.getSession().getAttribute(key);
if (null == map) {
return null;
}
return new ArrayList<>(map.keySet());
}
}
public <T> T getMapValue(String key, String mapKey, Class<T> type) {<FILL_FUNCTION_BODY>}
}
|
if (eruptProp.isRedisSession()) {
Object obj = stringRedisTemplate.boundHashOps(key).get(mapKey);
if (null == obj) {
return null;
}
return gson.fromJson(obj.toString(), type);
} else {
Map<String, T> map = (Map<String, T>) request.getSession().getAttribute(key);
if (null == map) {
return null;
}
return map.get(mapKey);
}
| 923
| 134
| 1,057
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/service/UpmsDataLoadService.java
|
UpmsDataLoadService
|
run
|
class UpmsDataLoadService implements CommandLineRunner {
@Resource
private EruptDao eruptDao;
@Resource
private EruptProp eruptProp;
public static final String DEFAULT_ACCOUNT = "erupt";
@Transactional
@Override
public void run(String... args) {<FILL_FUNCTION_BODY>}
}
|
Optional.of(Integer.valueOf(eruptDao.getEntityManager().createNativeQuery("select count(*) from e_upms_user").getSingleResult().toString())).ifPresent(it -> {
if (it <= 0) {
try {
FileUtils.deleteDirectory(new File(System.getProperty("user.dir") + "/" + EruptConst.ERUPT_DIR));
} catch (IOException e) {
log.error("Table 'e_upms_user' no user data. Re-initialization failed ：" + e.getMessage());
}
}
});
if (InitMethodEnum.NONE != eruptProp.getInitMethodEnum()) {
EruptModuleInvoke.invoke(module -> Optional.ofNullable(module.initMenus()).ifPresent(metaMenus ->
new ProjectUtil().projectStartLoaded(module.info().getName(), first -> {
Runnable runnable = (() -> {
module.initFun();
for (MetaMenu metaMenu : metaMenus) {
EruptMenu eruptMenu = eruptDao.persistIfNotExist(EruptMenu.class, EruptMenu.fromMetaMenu(metaMenu), EruptMenu.CODE, metaMenu.getCode());
metaMenu.setId(eruptMenu.getId());
if (null != eruptMenu.getType() && null != eruptMenu.getValue()) {
if (MenuTypeEnum.TABLE.getCode().equals(eruptMenu.getType()) || MenuTypeEnum.TREE.getCode().equals(eruptMenu.getType())) {
AtomicInteger i = new AtomicInteger();
Optional.ofNullable(EruptCoreService.getErupt(eruptMenu.getValue())).ifPresent(it -> {
Power power = it.getErupt().power();
for (EruptFunPermissions value : EruptFunPermissions.values()) {
if (value.verifyPower(power)) {
eruptDao.persistIfNotExist(EruptMenu.class, new EruptMenu(
UPMSUtil.getEruptFunPermissionsCode(eruptMenu.getValue(), value),
value.getName(), MenuTypeEnum.BUTTON.getCode(),
UPMSUtil.getEruptFunPermissionsCode(eruptMenu.getValue(), value),
eruptMenu, i.addAndGet(10)
), EruptMenu.CODE, UPMSUtil.getEruptFunPermissionsCode(eruptMenu.getValue(), value));
}
}
});
}
}
}
});
switch (eruptProp.getInitMethodEnum()) {
case EVERY:
runnable.run();
break;
case FILE:
if (first) runnable.run();
break;
}
})
));
}
new ProjectUtil().projectStartLoaded("erupt-upms-user", first -> {
if (first) {
if (eruptDao.lambdaQuery(EruptUser.class).eq(EruptUser::getIsAdmin, true).list().isEmpty()) {
EruptUser eruptUser = new EruptUser();
eruptUser.setIsAdmin(true);
eruptUser.setIsMd5(true);
eruptUser.setStatus(true);
eruptUser.setCreateTime(new Date());
eruptUser.setAccount(DEFAULT_ACCOUNT);
eruptUser.setPassword(MD5Util.digest(DEFAULT_ACCOUNT));
eruptUser.setName(DEFAULT_ACCOUNT);
eruptDao.persistIfNotExist(EruptUser.class, eruptUser, LambdaSee.field(EruptUser::getAccount), eruptUser.getAccount());
}
}
});
| 96
| 936
| 1,032
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-upms/src/main/java/xyz/erupt/upms/util/IpUtil.java
|
IpUtil
|
getIpAddr
|
class IpUtil {
public static String getIpAddr(HttpServletRequest request) {<FILL_FUNCTION_BODY>}
private static byte[] fileByte;
static {
try (InputStream input = IpUtil.class.getClassLoader().getResourceAsStream("ip2region.db")) {
if (null == input) {
throw new RuntimeException("ip2region.db not found");
}
fileByte = StreamUtils.copyToByteArray(input);
} catch (IOException e) {
log.warn("ip2region load error", e);
}
}
@SneakyThrows
public static String getCityInfo(String ip) {
if (!Util.isIpAddress(ip)) {
log.warn("Error: Invalid ip address: {}", ip);
return "";
}
return new DbSearcher(new DbConfig(), fileByte).memorySearch(ip).getRegion();
}
}
|
try {
String ip = request.getHeader("x-forwarded-for");
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getHeader("WL-Proxy-Client-IP");
}
if (ip == null || ip.isEmpty() || "unknown".equalsIgnoreCase(ip)) {
ip = request.getRemoteAddr();
if ("127.0.0.1".equals(ip) || "0:0:0:0:0:0:0:1".equals(ip)) {
// 根据网卡取本机配置的IP
InetAddress inet = InetAddress.getLocalHost();
ip = inet.getHostAddress();
// 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
// "***.***.***.***".length()
if (ip != null && ip.length() > 15) {
// = 15
if (ip.indexOf(',') > 0) {
ip = ip.substring(0, ip.indexOf(','));
}
}
}
}
// "***.***.***.***".length()
if (ip != null && ip.length() > 15) {
// = 15
if (ip.indexOf(',') > 0) {
ip = ip.substring(0, ip.indexOf(','));
}
}
return ip;
} catch (Exception e) {
log.warn("get ip error " + e.getMessage());
return null;
}
| 241
| 438
| 679
|
<no_super_class>
|
erupts_erupt
|
erupt/erupt-web/src/main/java/xyz/erupt/web/EruptWebConfig.java
|
EruptWebConfig
|
index
|
class EruptWebConfig {
private final String passport;
public EruptWebConfig() throws IOException {
try (InputStream input = EruptWebConfig.class.getClassLoader().getResourceAsStream("public/index.html")) {
if (null == input) throw new RuntimeException("erupt-web resources not found");
this.passport = StreamUtils.copyToString(input, StandardCharsets.UTF_8);
}
}
@GetMapping(value = {"/", "/index.html"}, produces = {"text/html;charset=utf-8"})
public String index(HttpServletResponse response) {<FILL_FUNCTION_BODY>}
}
|
response.setHeader("Expires", "0");
response.setHeader("Pragma", "no-cache");
response.setHeader("Cache-Control", "no-cache, no-store");
return passport;
| 167
| 57
| 224
|
<no_super_class>
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/AsyncExecutionImpl.java
|
AsyncExecutionImpl
|
complete
|
class AsyncExecutionImpl<R> extends ExecutionImpl<R> implements AsyncExecutionInternal<R> {
// -- Cross-attempt state --
private final FailsafeFuture<R> future;
private final boolean asyncExecution;
// The outermost function that executions begin with
private Function<AsyncExecutionInternal<R>, CompletableFuture<ExecutionResult<R>>> outerFn;
// -- Per-attempt state --
// Whether a policy executor completed post execution
private final boolean[] policyPostExecuted = new boolean[policyExecutors.size()];
// Whether a result has been recorded
private volatile boolean recorded;
AsyncExecutionImpl(List<Policy<R>> policies, Scheduler scheduler, FailsafeFuture<R> future, boolean asyncExecution,
Function<AsyncExecutionInternal<R>, CompletableFuture<ExecutionResult<R>>> innerFn) {
super(policies);
this.future = future;
this.asyncExecution = asyncExecution;
outerFn = asyncExecution ? Functions.toExecutionAware(innerFn) : innerFn;
outerFn = Functions.toAsync(outerFn, scheduler, future);
for (PolicyExecutor<R> policyExecutor : policyExecutors)
outerFn = policyExecutor.applyAsync(outerFn, scheduler, future);
}
/**
* Create an async execution for a new attempt.
*/
private AsyncExecutionImpl(AsyncExecutionImpl<R> execution) {
super(execution);
outerFn = execution.outerFn;
future = execution.future;
asyncExecution = execution.asyncExecution;
}
@Override
public void complete() {
Assert.state(!recorded, "The most recent execution has already been recorded or completed");
recorded = true;
// Guard against race with a timeout being set
synchronized (future) {
ExecutionResult<R> result = this.result != null ? this.result : ExecutionResult.none();
complete(postExecute(result), null);
}
}
@Override
public boolean isComplete() {
return completed;
}
@Override
public void record(R result, Throwable exception) {
Assert.state(!recorded, "The most recent execution has already been recorded or completed");
recorded = true;
// Guard against race with a timeout being set
synchronized (future) {
if (!attemptRecorded) {
Assert.state(!completed, "Execution has already been completed");
record(new ExecutionResult<>(result, exception));
}
// Proceed with handling the recorded result
executeAsync();
}
}
@Override
public void recordResult(R result) {
record(result, null);
}
@Override
public void recordException(Throwable exception) {
record(null, exception);
}
@Override
public boolean isAsyncExecution() {
return asyncExecution;
}
@Override
public boolean isRecorded() {
return recorded;
}
@Override
public synchronized void setPostExecuted(int policyIndex) {
policyPostExecuted[policyIndex] = true;
}
@Override
public synchronized boolean isPostExecuted(int policyIndex) {
return policyPostExecuted[policyIndex];
}
@Override
public AsyncExecutionInternal<R> copy() {
return new AsyncExecutionImpl<>(this);
}
/**
* Performs an asynchronous execution.
*/
void executeAsync() {
outerFn.apply(this).whenComplete(this::complete);
}
private void complete(ExecutionResult<R> result, Throwable error) {<FILL_FUNCTION_BODY>}
}
|
if (result == null && error == null)
return;
completed = true;
if (!future.isDone()) {
if (result != null)
future.completeResult(result);
else {
if (error instanceof CompletionException)
error = error.getCause();
future.completeResult(ExecutionResult.exception(error));
}
}
| 931
| 98
| 1,029
|
<methods>public boolean cancel() ,public void cancel(PolicyExecutor<R>) ,public int getAttemptCount() ,public java.time.Duration getElapsedAttemptTime() ,public java.time.Duration getElapsedTime() ,public int getExecutionCount() ,public T getLastException() ,public R getLastResult() ,public R getLastResult(R) ,public ExecutionInternal<R> getLatest() ,public java.lang.Object getLock() ,public ExecutionResult<R> getResult() ,public java.time.Instant getStartTime() ,public boolean isCancelled() ,public boolean isCancelled(PolicyExecutor<R>) ,public boolean isFirstAttempt() ,public boolean isPreExecuted() ,public boolean isRetry() ,public void onCancel(dev.failsafe.function.CheckedRunnable) ,public synchronized void preExecute() ,public synchronized void record(ExecutionResult<R>) ,public synchronized void recordAttempt() ,public java.lang.String toString() <variables>volatile boolean attemptRecorded,private volatile java.time.Instant attemptStartTime,private final non-sealed java.util.concurrent.atomic.AtomicInteger attempts,volatile dev.failsafe.function.CheckedRunnable cancelCallback,volatile int cancelledIndex,volatile boolean completed,private final non-sealed java.util.concurrent.atomic.AtomicInteger executions,private final non-sealed AtomicReference<ExecutionInternal<R>> latest,final non-sealed List<PolicyExecutor<R>> policyExecutors,private volatile boolean preExecuted,private final non-sealed ExecutionResult<R> previousResult,volatile ExecutionResult<R> result,private volatile java.time.Instant startTime
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/CallImpl.java
|
CallImpl
|
cancel
|
class CallImpl<R> implements Call<R> {
private volatile SyncExecutionImpl<R> execution;
void setExecution(SyncExecutionImpl<R> execution) {
this.execution = execution;
}
@Override
public R execute() {
return execution.executeSync();
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {<FILL_FUNCTION_BODY>}
@Override
public boolean isCancelled() {
return execution.isCancelled();
}
}
|
boolean result = execution.cancel();
if (mayInterruptIfRunning)
execution.interrupt();
return result;
| 137
| 34
| 171
|
<no_super_class>
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/DelayablePolicyBuilder.java
|
DelayablePolicyBuilder
|
withDelay
|
class DelayablePolicyBuilder<S, C extends DelayablePolicyConfig<R>, R>
extends FailurePolicyBuilder<S, C, R> {
protected DelayablePolicyBuilder(C config) {
super(config);
}
/**
* Sets the {@code delay} to occur between execution attempts.
*
* @throws NullPointerException if {@code delay} is null
* @throws IllegalArgumentException if {@code delay} <= 0
*/
@SuppressWarnings("unchecked")
public S withDelay(Duration delay) {<FILL_FUNCTION_BODY>}
/**
* Sets the {@code delayFunction} that computes the next delay before allowing another execution.
*
* <p>
* The {@code delayFunction} must complete quickly, not have side-effects, and always return the same result for the
* same input. Exceptions thrown by the {@code delayFunction} method will <strong>not</strong> be handled and will
* cause Failsafe's execution to abort.
* </p>
* <p>
* Notes:
* <ul>
* <li>A negative return value will cause Failsafe to use a configured fixed or backoff delay
* <li>Any configured jitter is still applied to DelayFunction provided values
* <li>Any configured max duration is still applied to DelayFunction provided values
* <li>The {@link ExecutionContext} that is provided to the {@code delayFunction} may be {@code null} if the prior execution
* exception was manually recorded outside of a Failsafe execution.</li>
* </ul>
* </p>
*
* @throws NullPointerException if {@code delayFunction} is null
*/
@SuppressWarnings("unchecked")
public S withDelayFn(ContextualSupplier<R, Duration> delayFunction) {
Assert.notNull(delayFunction, "delayFunction");
config.delayFn = delayFunction;
return (S) this;
}
/**
* Sets the {@code delayFunction} that computes the next delay before allowing another execution. Delays will only
* occur for exceptions that are assignable from the {@code exception}.
* <p>
* The {@code delayFunction} must complete quickly, not have side-effects, and always return the same result for the
* same input. Exceptions thrown by the {@code delayFunction} method will <strong>not</strong> be handled and will
* cause Failsafe's execution to abort.
* </p>
* <p>
* Notes:
* <ul>
* <li>A negative return value will cause Failsafe to use a configured fixed or backoff delay
* <li>Any configured jitter is still applied to DelayFunction provided values
* <li>Any configured max duration is still applied to DelayFunction provided values
* <li>The {@link ExecutionContext} that is provided to the {@code delayFunction} may be {@code null} if the prior execution
* exception was manually recorded outside of a Failsafe execution.</li>
* </ul>
* </p>
*
* @param delayFunction the function to use to compute the delay before a next attempt
* @param exception the execution exception that is expected in order to trigger the delay
* @param <F> exception type
* @throws NullPointerException if {@code delayFunction} or {@code exception} are null
*/
@SuppressWarnings("unchecked")
public <F extends Throwable> S withDelayFnOn(ContextualSupplier<R, Duration> delayFunction, Class<F> exception) {
withDelayFn(delayFunction);
Assert.notNull(exception, "exception");
config.delayException = exception;
return (S) this;
}
/**
* Sets the {@code delayFunction} that computes the next delay before allowing another execution. Delays will only
* occur for results that equal the {@code result}.
* <p>
* The {@code delayFunction} must complete quickly, not have side-effects, and always return the same result for the
* same input. Exceptions thrown by the {@code delayFunction} method will <strong>not</strong> be handled and will
* cause Failsafe's execution to abort.
* </p>
* <p>
* Notes:
* <ul>
* <li>A negative return value will cause Failsafe to use a configured fixed or backoff delay
* <li>Any configured jitter is still applied to DelayFunction provided values
* <li>Any configured max duration is still applied to DelayFunction provided values
* <li>The {@link ExecutionContext} that is provided to the {@code delayFunction} may be {@code null} if the prior execution
* exception was manually recorded outside of a Failsafe execution.</li>
* </ul>
* </p>
*
* @param delayFunction the function to use to compute the delay before a next attempt
* @param result the execution result that is expected in order to trigger the delay
* @throws NullPointerException if {@code delayFunction} or {@code result} are null
*/
@SuppressWarnings("unchecked")
public S withDelayFnWhen(ContextualSupplier<R, Duration> delayFunction, R result) {
withDelayFn(delayFunction);
Assert.notNull(result, "result");
config.delayResult = result;
return (S) this;
}
}
|
Assert.notNull(delay, "delay");
Assert.isTrue(delay.toNanos() > 0, "delay must be greater than 0");
config.delay = delay;
return (S) this;
| 1,354
| 57
| 1,411
|
<methods>public S handle(Class<? extends java.lang.Throwable>) ,public final transient S handle(Class<? extends java.lang.Throwable>[]) ,public S handle(List<Class<? extends java.lang.Throwable>>) ,public S handleIf(CheckedPredicate<? extends java.lang.Throwable>) ,public S handleIf(CheckedBiPredicate<R,? extends java.lang.Throwable>) ,public S handleResult(R) ,public S handleResultIf(CheckedPredicate<R>) <variables>
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/ExecutionImpl.java
|
ExecutionImpl
|
cancel
|
class ExecutionImpl<R> implements ExecutionInternal<R> {
// -- Cross-attempt state --
final List<PolicyExecutor<R>> policyExecutors;
// When the first execution attempt was started
private volatile Instant startTime;
// Number of execution attempts
private final AtomicInteger attempts;
// Number of completed executions
private final AtomicInteger executions;
// The latest execution attenpt
private final AtomicReference<ExecutionInternal<R>> latest;
// -- Per-attempt state --
// The result of the previous execution attempt
private final ExecutionResult<R> previousResult;
// The result of the current execution attempt;
volatile ExecutionResult<R> result;
// When the most recent execution attempt was started
private volatile Instant attemptStartTime;
// The index of a PolicyExecutor that cancelled the execution. Integer.MIN_VALUE represents non-cancelled.
volatile int cancelledIndex = Integer.MIN_VALUE;
// The user-provided callback to be called when an execution is cancelled
volatile CheckedRunnable cancelCallback;
// Whether the execution has pre-executed indicating it has started
private volatile boolean preExecuted;
// Whether the execution attempt has been recorded
volatile boolean attemptRecorded;
// Whether the execution has been completed for all polices
volatile boolean completed;
/**
* Creates a new execution for the {@code policies}.
*/
ExecutionImpl(List<? extends Policy<R>> policies) {
policyExecutors = new ArrayList<>(policies.size());
attempts = new AtomicInteger();
executions = new AtomicInteger();
latest = new AtomicReference<>(this);
previousResult = null;
// Create policy executors
ListIterator<? extends Policy<R>> policyIterator = policies.listIterator(policies.size());
for (int i = 0; policyIterator.hasPrevious(); i++) {
Policy<R> policy = Assert.notNull(policyIterator.previous(), "policies");
PolicyExecutor<R> policyExecutor = policy.toExecutor(i);
policyExecutors.add(policyExecutor);
}
}
/**
* Create an execution for a new attempt.
*/
ExecutionImpl(ExecutionImpl<R> execution) {
policyExecutors = execution.policyExecutors;
startTime = execution.startTime;
attempts = execution.attempts;
executions = execution.executions;
latest = execution.latest;
latest.set(this);
previousResult = execution.result;
}
/** Used for testing purposes only */
ExecutionImpl(ExecutionResult<R> previousResult) {
policyExecutors = null;
attempts = new AtomicInteger();
executions = new AtomicInteger();
latest = new AtomicReference<>(this);
this.previousResult = previousResult;
}
@Override
public ExecutionResult<R> getResult() {
return result;
}
@Override
public void onCancel(CheckedRunnable cancelCallback) {
this.cancelCallback = cancelCallback;
}
@Override
public synchronized void preExecute() {
if (!preExecuted) {
attemptStartTime = Instant.now();
if (startTime == null)
startTime = attemptStartTime;
preExecuted = true;
}
}
@Override
public boolean isPreExecuted() {
return preExecuted;
}
@Override
public synchronized void recordAttempt() {
if (!attemptRecorded) {
attempts.incrementAndGet();
attemptRecorded = true;
}
}
@Override
public synchronized void record(ExecutionResult<R> result) {
if (preExecuted && !attemptRecorded) {
recordAttempt();
executions.incrementAndGet();
this.result = result;
}
}
/**
* Externally called. Records an execution and performs post-execution handling for the {@code result} against all
* configured policy executors. Returns whether the result is complete for all policies.
*
* @throws IllegalStateException if the execution is already complete
*/
synchronized ExecutionResult<R> postExecute(ExecutionResult<R> result) {
Assert.state(!completed, "Execution has already been completed");
record(result);
boolean allComplete = true;
for (PolicyExecutor<R> policyExecutor : policyExecutors) {
result = policyExecutor.postExecute(this, result);
allComplete = allComplete && result.isComplete();
}
completed = allComplete;
return result;
}
/** Called indirectly by users. */
@Override
public boolean cancel() {<FILL_FUNCTION_BODY>}
/** Called by policies. */
@Override
public void cancel(PolicyExecutor<R> policyExecutor) {
cancelledIndex = policyExecutor.getPolicyIndex();
if (cancelCallback != null) {
try {
cancelCallback.run();
} catch (Throwable ignore) {
}
}
}
@Override
public boolean isCancelled() {
return cancelledIndex > Integer.MIN_VALUE;
}
@Override
public boolean isCancelled(PolicyExecutor<R> policyExecutor) {
return cancelledIndex > policyExecutor.getPolicyIndex();
}
@Override
public Object getLock() {
return latest;
}
@Override
public ExecutionInternal<R> getLatest() {
return latest.get();
}
@Override
public Duration getElapsedTime() {
return startTime == null ? Duration.ZERO : Duration.between(startTime, Instant.now());
}
@Override
public Duration getElapsedAttemptTime() {
return attemptStartTime == null ? Duration.ZERO : Duration.between(attemptStartTime, Instant.now());
}
@Override
public int getAttemptCount() {
return attempts.get();
}
@Override
public int getExecutionCount() {
return executions.get();
}
@Override
@SuppressWarnings("unchecked")
public <T extends Throwable> T getLastException() {
ExecutionResult<R> r = result != null ? result : previousResult;
return r == null ? null : (T) r.getException();
}
@Override
public R getLastResult() {
ExecutionResult<R> r = result != null ? result : previousResult;
return r == null ? null : r.getResult();
}
@Override
public R getLastResult(R defaultValue) {
ExecutionResult<R> r = result != null ? result : previousResult;
return r == null ? defaultValue : r.getResult();
}
@Override
public Instant getStartTime() {
return startTime;
}
@Override
public boolean isFirstAttempt() {
return attempts.get() == (!attemptRecorded ? 0 : 1);
}
@Override
public boolean isRetry() {
return attempts.get() > (!attemptRecorded ? 0 : 1);
}
@Override
public String toString() {
return "[" + "attempts=" + attempts + ", executions=" + executions + ", lastResult=" + getLastResult()
+ ", lastException=" + getLastException() + ']';
}
}
|
boolean cancelled = isCancelled();
if (!cancelled) {
cancelledIndex = Integer.MAX_VALUE;
if (cancelCallback != null) {
try {
cancelCallback.run();
} catch (Throwable ignore) {
}
}
}
return !cancelled && !completed;
| 1,891
| 88
| 1,979
|
<no_super_class>
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/Failsafe.java
|
Failsafe
|
with
|
class Failsafe {
/**
* Creates and returns a new {@link FailsafeExecutor} instance that will handle failures according to the given {@code
* outerPolicy} and {@code policies}. The policies are composed around an execution and will handle execution results
* in reverse, with the last policy being applied first. For example, consider:
* <p>
* <pre>
* Failsafe.with(fallback, retryPolicy, circuitBreaker).get(supplier);
* </pre>
* </p>
* <p>
* This is equivalent to composition using the the {@link FailsafeExecutor#compose(Policy) compose} method:
* <pre>
* Failsafe.with(fallback).compose(retryPolicy).compose(circuitBreaker).get(supplier);
* </pre>
* </p>
* These result in the following internal composition when executing a {@code runnable} or {@code supplier} and
* handling its result:
* <p>
* <pre>
* Fallback(RetryPolicy(CircuitBreaker(Supplier)))
* </pre>
* </p>
* This means the {@code CircuitBreaker} is first to evaluate the {@code Supplier}'s result, then the {@code
* RetryPolicy}, then the {@code Fallback}. Each policy makes its own determination as to whether the result
* represents a failure. This allows different policies to be used for handling different types of failures.
*
* @param <R> result type
* @param <P> policy type
* @throws NullPointerException if {@code outerPolicy} is null
*/
@SafeVarargs
public static <R, P extends Policy<R>> FailsafeExecutor<R> with(P outerPolicy, P... policies) {
Assert.notNull(outerPolicy, "outerPolicy");
return new FailsafeExecutor<>(Lists.of(outerPolicy, policies));
}
/**
* Creates and returns a new {@link FailsafeExecutor} instance that will handle failures according to the given {@code
* policies}. The {@code policies} are composed around an execution and will handle execution results in reverse, with
* the last policy being applied first. For example, consider:
* <p>
* <pre>
* Failsafe.with(Arrays.asList(fallback, retryPolicy, circuitBreaker)).get(supplier);
* </pre>
* </p>
* This results in the following internal composition when executing a {@code runnable} or {@code supplier} and
* handling its result:
* <p>
* <pre>
* Fallback(RetryPolicy(CircuitBreaker(Supplier)))
* </pre>
* </p>
* This means the {@code CircuitBreaker} is first to evaluate the {@code Supplier}'s result, then the {@code
* RetryPolicy}, then the {@code Fallback}. Each policy makes its own determination as to whether the result
* represents a failure. This allows different policies to be used for handling different types of failures.
*
* @param <R> result type
* @throws NullPointerException if {@code policies} is null
* @throws IllegalArgumentException if {@code policies} is empty
*/
public static <R> FailsafeExecutor<R> with(List<? extends Policy<R>> policies) {<FILL_FUNCTION_BODY>}
/**
* Creates and returns a noop {@link FailsafeExecutor} instance that treats any exception as a failure for the
* purposes of calling event listeners, and provides no additional failure handling.
*
* @param <R> result type
* @throws NullPointerException if {@code policies} is null
* @throws IllegalArgumentException if {@code policies} is empty
*/
public static <R> FailsafeExecutor<R> none() {
return new FailsafeExecutor<>(Collections.emptyList());
}
}
|
Assert.notNull(policies, "policies");
Assert.isTrue(!policies.isEmpty(), "At least one policy must be supplied");
return new FailsafeExecutor<>(policies);
| 978
| 55
| 1,033
|
<no_super_class>
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/FailurePolicyBuilder.java
|
FailurePolicyBuilder
|
handleIf
|
class FailurePolicyBuilder<S, C extends FailurePolicyConfig<R>, R> extends PolicyBuilder<S, C, R> {
protected FailurePolicyBuilder(C config) {
super(config);
}
/**
* Specifies the exception to handle as a failure. Any exception that is assignable from the {@code exception} will be
* handled.
*
* @throws NullPointerException if {@code exception} is null
*/
public S handle(Class<? extends Throwable> exception) {
Assert.notNull(exception, "exception");
return handle(Arrays.asList(exception));
}
/**
* Specifies the exceptions to handle as failures. Any exceptions that are assignable from the {@code exceptions} will
* be handled.
*
* @throws NullPointerException if {@code exceptions} is null
* @throws IllegalArgumentException if exceptions is empty
*/
@SafeVarargs
public final S handle(Class<? extends Throwable>... exceptions) {
Assert.notNull(exceptions, "exceptions");
Assert.isTrue(exceptions.length > 0, "exceptions cannot be empty");
return handle(Arrays.asList(exceptions));
}
/**
* Specifies the exceptions to handle as failures. Any exceptions that are assignable from the {@code exceptions} will
* be handled.
*
* @throws NullPointerException if {@code exceptions} is null
* @throws IllegalArgumentException if exceptions is null or empty
*/
public S handle(List<Class<? extends Throwable>> exceptions) {
Assert.notNull(exceptions, "exceptions");
Assert.isTrue(!exceptions.isEmpty(), "exceptions cannot be empty");
config.exceptionsChecked = true;
config.failureConditions.add(failurePredicateFor(exceptions));
return (S) this;
}
/**
* Specifies that a failure has occurred if the {@code failurePredicate} matches the exception. Any exception thrown
* from the {@code failurePredicate} is treated as a {@code false} result.
*
* @throws NullPointerException if {@code failurePredicate} is null
*/
public S handleIf(CheckedPredicate<? extends Throwable> failurePredicate) {
Assert.notNull(failurePredicate, "failurePredicate");
config.exceptionsChecked = true;
config.failureConditions.add(failurePredicateFor(failurePredicate));
return (S) this;
}
/**
* Specifies that a failure has occurred if the {@code resultPredicate} matches the execution result. Any exception
* thrown from the {@code resultPredicate} is treated as a {@code false} result.
*
* @throws NullPointerException if {@code resultPredicate} is null
*/
@SuppressWarnings("unchecked")
public S handleIf(CheckedBiPredicate<R, ? extends Throwable> resultPredicate) {<FILL_FUNCTION_BODY>}
/**
* Specifies that a failure has occurred if the {@code result} matches the execution result. This method is only
* considered when a result is returned from an execution, not when an exception is thrown.
*/
public S handleResult(R result) {
config.failureConditions.add(resultPredicateFor(result));
return (S) this;
}
/**
* Specifies that a failure has occurred if the {@code resultPredicate} matches the execution result. This method is
* only considered when a result is returned from an execution, not when an exception is thrown. To handle results or
* exceptions with the same condition, use {@link #handleIf(CheckedBiPredicate)}. Any exception thrown from the {@code
* resultPredicate} is treated as a {@code false} result.
*
* @throws NullPointerException if {@code resultPredicate} is null
*/
public S handleResultIf(CheckedPredicate<R> resultPredicate) {
Assert.notNull(resultPredicate, "resultPredicate");
config.failureConditions.add(resultPredicateFor(resultPredicate));
return (S) this;
}
/**
* Returns a predicate that evaluates whether the {@code result} equals an execution result.
*/
static <R> CheckedBiPredicate<R, Throwable> resultPredicateFor(R result) {
return (t, u) -> result == null ? t == null && u == null : Objects.equals(result, t);
}
/**
* Returns a predicate that evaluates the {@code failurePredicate} against a failure.
*/
@SuppressWarnings("unchecked")
static <R> CheckedBiPredicate<R, Throwable> failurePredicateFor(
CheckedPredicate<? extends Throwable> failurePredicate) {
return (t, u) -> u != null && ((CheckedPredicate<Throwable>) failurePredicate).test(u);
}
/**
* Returns a predicate that evaluates the {@code resultPredicate} against a result, when present.
* <p>
* Short-circuits to false without invoking {@code resultPredicate}, when result is not present (i.e.
* BiPredicate.test(null, Throwable)).
*/
static <R> CheckedBiPredicate<R, Throwable> resultPredicateFor(CheckedPredicate<R> resultPredicate) {
return (t, u) -> {
if (u == null) {
return resultPredicate.test(t);
} else {
// resultPredicate is only defined over the success type.
// It doesn't know how to handle a failure of type Throwable,
// so we return false here.
return false;
}
};
}
/**
* Returns a predicate that returns whether any of the {@code failures} are assignable from an execution failure.
*/
static <R> CheckedBiPredicate<R, Throwable> failurePredicateFor(List<Class<? extends Throwable>> failures) {
return (t, u) -> {
if (u == null)
return false;
for (Class<? extends Throwable> failureType : failures)
if (failureType.isAssignableFrom(u.getClass()))
return true;
return false;
};
}
}
|
Assert.notNull(resultPredicate, "resultPredicate");
config.exceptionsChecked = true;
config.failureConditions.add((CheckedBiPredicate<R, Throwable>) resultPredicate);
return (S) this;
| 1,585
| 66
| 1,651
|
<methods>public S onFailure(EventListener<ExecutionCompletedEvent<R>>) ,public S onSuccess(EventListener<ExecutionCompletedEvent<R>>) <variables>protected C config
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/SyncExecutionImpl.java
|
SyncExecutionImpl
|
preExecute
|
class SyncExecutionImpl<R> extends ExecutionImpl<R> implements SyncExecutionInternal<R> {
// -- Cross-attempt state --
// An optional Failsafe executor
private final FailsafeExecutor<R> executor;
// An optional Failsafe call
private final CallImpl<R> call;
// The outermost function that executions begin with
private Function<SyncExecutionInternal<R>, ExecutionResult<R>> outerFn;
// The interruptable execution thread
private final Thread executionThread;
// Whether the execution is currently interruptable
private final AtomicBoolean interruptable;
// Whether the execution has been internally interrupted
private final AtomicBoolean interrupted;
// -- Per-attempt state --
// The delay time in nanoseconds
private volatile long delayNanos;
/**
* Create a standalone sync execution for the {@code policies}.
*/
SyncExecutionImpl(List<? extends Policy<R>> policies) {
super(policies);
executor = null;
call = null;
interruptable = new AtomicBoolean();
interrupted = new AtomicBoolean();
executionThread = Thread.currentThread();
preExecute();
}
/**
* Create a sync execution for the {@code executor}.
*/
SyncExecutionImpl(FailsafeExecutor<R> executor, Scheduler scheduler, CallImpl<R> call,
Function<SyncExecutionInternal<R>, ExecutionResult<R>> innerFn) {
super(executor.policies);
this.executor = executor;
this.call = call;
interruptable = new AtomicBoolean();
interrupted = new AtomicBoolean();
executionThread = Thread.currentThread();
if (call != null)
call.setExecution(this);
outerFn = innerFn;
for (PolicyExecutor<R> policyExecutor : policyExecutors)
outerFn = policyExecutor.apply(outerFn, scheduler);
}
/**
* Create a sync execution for a new attempt.
*/
private SyncExecutionImpl(SyncExecutionImpl<R> execution) {
super(execution);
executor = execution.executor;
call = execution.call;
interruptable = execution.interruptable;
interrupted = execution.interrupted;
executionThread = execution.executionThread;
if (call != null)
call.setExecution(this);
}
@Override
public void complete() {
postExecute(ExecutionResult.none());
}
@Override
public boolean isComplete() {
return completed;
}
@Override
public Duration getDelay() {
return Duration.ofNanos(delayNanos);
}
@Override
public void record(R result, Throwable exception) {
preExecute();
postExecute(new ExecutionResult<>(result, exception));
}
@Override
public void recordResult(R result) {
preExecute();
postExecute(new ExecutionResult<>(result, null));
}
@Override
public void recordException(Throwable exception) {
preExecute();
postExecute(new ExecutionResult<>(null, exception));
}
@Override
public synchronized void preExecute() {<FILL_FUNCTION_BODY>}
@Override
synchronized ExecutionResult<R> postExecute(ExecutionResult<R> result) {
result = super.postExecute(result);
delayNanos = result.getDelay();
return result;
}
@Override
public boolean isInterrupted() {
return interrupted.get();
}
@Override
public void setInterruptable(boolean interruptable) {
this.interruptable.set(interruptable);
}
@Override
public void interrupt() {
// Guard against race with the execution becoming uninterruptable
synchronized (getLock()) {
if (interruptable.get()) {
interrupted.set(true);
executionThread.interrupt();
}
}
}
private boolean isStandalone() {
return executor == null;
}
@Override
public SyncExecutionImpl<R> copy() {
return isStandalone() ? this : new SyncExecutionImpl<>(this);
}
/**
* Performs a synchronous execution.
*/
R executeSync() {
ExecutionResult<R> result = outerFn.apply(this);
completed = result.isComplete();
executor.completionHandler.accept(result, this);
Throwable exception = result.getException();
if (exception != null) {
if (exception instanceof RuntimeException)
throw (RuntimeException) exception;
if (exception instanceof Error)
throw (Error) exception;
throw new FailsafeException(exception);
}
return result.getResult();
}
}
|
if (isStandalone()) {
attemptRecorded = false;
cancelledIndex = Integer.MIN_VALUE;
interrupted.set(false);
}
super.preExecute();
interruptable.set(true);
| 1,235
| 60
| 1,295
|
<methods>public boolean cancel() ,public void cancel(PolicyExecutor<R>) ,public int getAttemptCount() ,public java.time.Duration getElapsedAttemptTime() ,public java.time.Duration getElapsedTime() ,public int getExecutionCount() ,public T getLastException() ,public R getLastResult() ,public R getLastResult(R) ,public ExecutionInternal<R> getLatest() ,public java.lang.Object getLock() ,public ExecutionResult<R> getResult() ,public java.time.Instant getStartTime() ,public boolean isCancelled() ,public boolean isCancelled(PolicyExecutor<R>) ,public boolean isFirstAttempt() ,public boolean isPreExecuted() ,public boolean isRetry() ,public void onCancel(dev.failsafe.function.CheckedRunnable) ,public synchronized void preExecute() ,public synchronized void record(ExecutionResult<R>) ,public synchronized void recordAttempt() ,public java.lang.String toString() <variables>volatile boolean attemptRecorded,private volatile java.time.Instant attemptStartTime,private final non-sealed java.util.concurrent.atomic.AtomicInteger attempts,volatile dev.failsafe.function.CheckedRunnable cancelCallback,volatile int cancelledIndex,volatile boolean completed,private final non-sealed java.util.concurrent.atomic.AtomicInteger executions,private final non-sealed AtomicReference<ExecutionInternal<R>> latest,final non-sealed List<PolicyExecutor<R>> policyExecutors,private volatile boolean preExecuted,private final non-sealed ExecutionResult<R> previousResult,volatile ExecutionResult<R> result,private volatile java.time.Instant startTime
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/event/ExecutionAttemptedEvent.java
|
ExecutionAttemptedEvent
|
toString
|
class ExecutionAttemptedEvent<R> extends ExecutionEvent {
private final R result;
private final Throwable exception;
public ExecutionAttemptedEvent(R result, Throwable exception, ExecutionContext<R> context) {
super(context);
this.result = result;
this.exception = exception;
}
/**
* Returns the failure that preceded the event, else {@code null} if there was none.
*/
public Throwable getLastException() {
return exception;
}
/**
* Returns the result that preceded the event, else {@code null} if there was none.
*/
public R getLastResult() {
return result;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "ExecutionAttemptedEvent[" + "result=" + result + ", exception=" + exception + ']';
| 206
| 31
| 237
|
<methods>public int getAttemptCount() ,public java.time.Duration getElapsedAttemptTime() ,public java.time.Duration getElapsedTime() ,public int getExecutionCount() ,public Optional<java.time.Instant> getStartTime() ,public boolean isFirstAttempt() ,public boolean isRetry() <variables>private final non-sealed ExecutionContext<?> context
|
failsafe-lib_failsafe
|
failsafe/core/src/main/java/dev/failsafe/event/ExecutionCompletedEvent.java
|
ExecutionCompletedEvent
|
toString
|
class ExecutionCompletedEvent<R> extends ExecutionEvent {
private final R result;
private final Throwable exception;
public ExecutionCompletedEvent(R result, Throwable exception, ExecutionContext<R> context) {
super(context);
this.result = result;
this.exception = exception;
}
/**
* Returns the failure that preceded the event, else {@code null} if there was none.
*/
public Throwable getException() {
return exception;
}
/**
* Returns the result that preceded the event, else {@code null} if there was none.
*/
public R getResult() {
return result;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "ExecutionCompletedEvent[" + "result=" + result + ", exception=" + exception + ']';
| 202
| 30
| 232
|
<methods>public int getAttemptCount() ,public java.time.Duration getElapsedAttemptTime() ,public java.time.Duration getElapsedTime() ,public int getExecutionCount() ,public Optional<java.time.Instant> getStartTime() ,public boolean isFirstAttempt() ,public boolean isRetry() <variables>private final non-sealed ExecutionContext<?> context
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.