修复依赖错误

hsweb-commons/hsweb-commons-service/hsweb-commons-service-api/src/main/java/org/hswebframework/web/service/TreeService.java

@@ -30,6 +30,13 @@ import java.util.List;
  */
 public interface TreeService<E extends TreeSupportEntity, PK> extends Service {
 
+    /**
+     * 查询所有父节点
+     * @param childId 子节点id
+     * @return 父节点集合
+     */
+    List<E> selectParentNode(PK childId);
+
     /**
      * 根据父节点id获取子节点数据
      *

hsweb-commons/hsweb-commons-service/hsweb-commons-service-simple/src/main/java/org/hswebframework/web/service/AbstractTreeSortService.java

@@ -38,6 +38,19 @@ import java.util.stream.Collectors;
 public abstract class AbstractTreeSortService<E extends TreeSortSupportEntity<PK>, PK>
         extends GenericEntityService<E, PK> implements TreeService<E, PK> {
 
+    @Override
+    @Transactional(readOnly = true)
+    public List<E> selectParentNode(PK childId) {
+        assertNotNull(childId);
+        E old = selectByPk(childId);
+        assertNotNull(old);
+        return createQuery()
+                .where()
+                // where ? like concat(path,'%')
+                .and("path$like$reverse$startWith", old.getPath())
+                .listNoPaging();
+    }
+
     @Override
     @Transactional(readOnly = true)
     public List<E> selectAllChildNode(PK parentId) {
@@ -103,8 +116,6 @@ public abstract class AbstractTreeSortService<E extends TreeSortSupportEntity<PK
         applyPath(entity);
         List<E> childrenList = new ArrayList<>();
         TreeSupportEntity.expandTree2List(entity, childrenList, getIDGenerator());
-//        super.insert(entity);
-//        childrenList.remove(entity);
         childrenList.forEach(this::saveOrUpdateForSingle);
         return entity.getId();
     }

hsweb-commons/hsweb-commons-service/hsweb-commons-service-simple/src/main/java/org/hswebframework/web/service/EnableCacheAllEvictTreeSortService.java

@@ -14,6 +14,12 @@ import java.util.List;
 public abstract class EnableCacheAllEvictTreeSortService<E extends TreeSortSupportEntity<PK>, PK>
         extends AbstractTreeSortService<E, PK> {
 
+    @Override
+    @Cacheable(key = "'parent:'+#parentId")
+    public List<E> selectParentNode(PK parentId) {
+        return super.selectParentNode(parentId);
+    }
+
     @Override
     @Cacheable(key = "'chidlren:'+#parentId")
     public List<E> selectChildNode(PK parentId) {

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-api/src/main/java/org/hswebframework/web/service/organizational/DepartmentService.java

@@ -33,6 +33,8 @@ public interface DepartmentService extends
 
     List<DepartmentEntity> selectByOrgId(String orgId);
 
+    List<DepartmentEntity> selectByOrgIds(List<String> orgId,boolean children,boolean parent);
+
     DepartmentEntity selectByCode(String code);
 
     List<DepartmentEntity> selectByName(String name);

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-api/src/main/java/org/hswebframework/web/service/organizational/PersonService.java

@@ -39,5 +39,17 @@ public interface PersonService extends CrudService<PersonEntity, String> {
 
     List<PersonEntity> selectByPositionId(String positionId);
 
+    List<PersonEntity> selectByPositionIds(List<String> positionId);
+
+    List<PersonEntity> selectByDepartmentId(List<String> departmentId);
+
+    List<PersonEntity> selectByOrgId(List<String> departmentId);
+
+    PersonEntity selectByUserId(String userId);
+
+    List<String> selectAllDepartmentId(List<String> personId);
+
+    List<String> selectAllOrgId(List<String> personId);
+
     List<PersonEntity> selectByRoleId(String roleId);
 }

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/DepartmentRelations.java

@@ -0,0 +1,27 @@
+package org.hswebframework.web.organizational.authorization.relation;
+
+
+public interface DepartmentRelations extends LinkedRelations<DepartmentRelations> {
+
+    /**
+     * 设置包含子级部门
+     *
+     * @return 部门关系链
+     */
+    DepartmentRelations andChildren();
+
+    /**
+     * 设置包含父级部门
+     *
+     * @return 部门关系链
+     */
+    DepartmentRelations andParents();
+
+    /**
+     * 获取部门下的人员关系链
+     *
+     * @return 人员关系链
+     */
+    PersonRelations persons();
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/LinkedRelations.java

@@ -0,0 +1,143 @@
+package org.hswebframework.web.organizational.authorization.relation;
+
+
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public interface LinkedRelations<C extends LinkedRelations>  {
+
+    /**
+     * 获取指定方向以及维度的关系链,如: 我是李四的经理,张三是我的经理
+     *
+     * @param direction 关系方向 {@link Relation.Direction}
+     * @param dimension 关系维度,如: position,由实现进行自定义
+     * @param relation  关系定义,如: 直属领导 {@link Relation#getRelation()}
+     * @return 关系链
+     * @see Relation#getRelation()
+     * @see Relation#getDirection()
+     */
+    C relations(Relation.Direction direction, String dimension, String relation);
+
+    /**
+     * 获取指定方向的所有维度的关系链.
+     * <pre>
+     *     正向: [我]是[张三]的[研发部(维度)][经理(关系)]
+     *     反向: [张三]是[我]的[研发部(维度)][经理(关系)]
+     *     双向: [正向]或者[反向]关系
+     * </pre>
+     *
+     * @param direction 方向
+     * @param relation  关系定义 {@link Relation#getRelation()}
+     * @return 关系链
+     * @see Relation#getRelation()
+     * @see Relation#getDirection()
+     * @see this#relations(Relation.Direction, String, String)
+     */
+    default C relations(Relation.Direction direction, String relation) {
+        return relations(direction, null, relation);
+    }
+
+    /**
+     * @see this#relations(Relation.Direction, String, String)
+     * @see Relation.Direction#REVERSE
+     */
+    default C relationsRev(String type, String relation) {
+        return relations(Relation.Direction.REVERSE, type, relation);
+    }
+
+    /**
+     * @see this#relations(Relation.Direction, String)
+     * @see Relation.Direction#REVERSE
+     */
+    default C relationsRev(String relation) {
+        return relations(Relation.Direction.REVERSE, relation);
+    }
+
+
+    /**
+     * @see this#relations(Relation.Direction, String, String)
+     * @see Relation.Direction#POSITIVE
+     */
+    default C relationsPos(String type, String relation) {
+        return relations(Relation.Direction.POSITIVE, type, relation);
+    }
+
+    /**
+     * @see this#relations(Relation.Direction, String)
+     * @see Relation.Direction#POSITIVE
+     */
+    default C relationsPos(String relation) {
+        return relations(Relation.Direction.POSITIVE, relation);
+    }
+
+    /**
+     * @see this#relations(Relation.Direction, String, String)
+     * @see Relation.Direction#ALL
+     */
+    default C relations(String type, String relation) {
+        return relations(Relation.Direction.ALL, type, relation);
+    }
+
+    /**
+     * @see this#relations(Relation.Direction, String)
+     * @see Relation.Direction#ALL
+     */
+    default C relations(String relation) {
+        return relations(Relation.Direction.ALL, relation);
+    }
+
+
+    /**
+     * 判断目标关系对象属性是否与值等于
+     *
+     * @param property 属性名称,如: name
+     * @param value    属性指,如: 张三
+     * @return 关系链
+     */
+    C is(String property, Object value);
+
+    /**
+     * 判断目标关系对象属性是否不等于值
+     *
+     * @param property 属性名称,如: name
+     * @param value    属性指,如: 张三
+     * @return 关系链
+     */
+    C not(String property, Object value);
+
+    /**
+     * 切换当前过滤逻辑为或则,如:
+     * <pre>
+     *     //获取姓名为张三或者李四的领导
+     *     me.relations("领导").is("name","张三").or().is("name","李四").all();
+     * </pre>
+     *
+     * @return 关系链
+     */
+    C or();
+
+    /**
+     * 切换当前过滤逻辑为并且
+     * <pre>
+     *     //获取status为1并且email不为空的领导
+     *     me.relations("领导").is("status",1).and().not("email","").all();
+     * </pre>
+     *
+     * @return 关系链
+     */
+    C and();
+
+    /**
+     * @return 全部关系信息集合
+     */
+    default List<Relation> all() {
+        return stream().collect(Collectors.toList());
+    }
+
+    /**
+     * @return 全部关系信息的stream
+     */
+    Stream<Relation> stream();
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/OrgRelations.java

@@ -0,0 +1,28 @@
+package org.hswebframework.web.organizational.authorization.relation;
+
+
+public interface OrgRelations extends LinkedRelations<OrgRelations> {
+
+    /**
+     * 设置包含子级机构
+     *
+     * @return 机构关系链
+     */
+    OrgRelations andChildren();
+
+    /**
+     * 设置包含父级机构
+     *
+     * @return 机构关系链
+     */
+    OrgRelations andParents();
+
+    /**
+     * 获取全部的部门关系链
+     *
+     * @return 部门关系链
+     */
+    DepartmentRelations departments();
+
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/PersonRelations.java

@@ -0,0 +1,17 @@
+package org.hswebframework.web.organizational.authorization.relation;
+
+public interface PersonRelations extends LinkedRelations<PersonRelations> {
+
+    /**
+     * @return 人员所在部门关系链
+     */
+    DepartmentRelations department();
+
+    /**
+     * @return 人员所在机构关系链
+     */
+    OrgRelations org();
+
+
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/Relation.java

@@ -32,9 +32,9 @@ public interface Relation extends Serializable {
     String TYPE_PERSON = "person";
 
     /**
-     * @return 关系类型，如:person,department
+     * @return 关系维度，如:person,department
      */
-    String getType();
+    String getDimension();
 
     /**
      * @return 关系，如: leader,member
@@ -47,13 +47,13 @@ public interface Relation extends Serializable {
     String getTarget();
 
     /**
-     * @return 关系目标对象，用于获取建立关系对象完整信息，返回值的类型可能随着{@link this#getType()}的不同而变化
+     * @return 关系目标对象，用于获取建立关系对象完整信息，返回值的类型可能随着{@link this#getDimension()}的不同而变化
      * @see RelationTargetSupplier
      */
     Serializable getTargetObject();
 
     /**
-     * @return 关系名称，与{@link this#getType()} 对应，如: 经理,员工
+     * @return 关系名称，与{@link this#getDimension()} 对应，如: 经理,员工
      */
     String getName();
 

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/Relations.java

@@ -37,7 +37,7 @@ public interface Relations extends Serializable {
     default boolean has(String relation, String type, String to, Relation.Direction direction) {
         return getAll().stream().anyMatch(rel ->
                 rel.getRelation().equals(relation)
-                        && rel.getType().equals(type)
+                        && rel.getDimension().equals(type)
                         && rel.getTarget().equals(to)
                         && rel.matchDirection(direction));
     }
@@ -45,7 +45,7 @@ public interface Relations extends Serializable {
     default boolean has(String relation, String type, Relation.Direction direction) {
         return getAll().stream().anyMatch(rel ->
                 rel.getRelation().equals(relation)
-                        && rel.getType().equals(type)
+                        && rel.getDimension().equals(type)
                         && rel.matchDirection(direction));
     }
 
@@ -139,15 +139,15 @@ public interface Relations extends Serializable {
     }
 
     /**
-     * 获取指定关系和类型的全部关系信息
+     * 获取指定关系和维度的全部关系信息
      *
      * @param relation 关系标识，例如: leader
-     * @param type     关系类型,例如：person
+     * @param type     关系维度,例如：person
      * @return 关系信息集合，如果关系不存在，返回空集合
      * @see this#find(Predicate)
      */
     default List<Relation> findAll(String relation, String type) {
-        return find(rel -> rel.getRelation().equals(relation) && rel.getType().equals(type));
+        return find(rel -> rel.getRelation().equals(relation) && rel.getDimension().equals(type));
     }
 
     /**
@@ -186,7 +186,7 @@ public interface Relations extends Serializable {
     default List<Relation> find(String relation, String type, Relation.Direction direction) {
         return find(rel ->
                 rel.getRelation().equals(relation)
-                        && rel.getType().equals(type)
+                        && rel.getDimension().equals(type)
                         && rel.matchDirection(direction));
     }
 
@@ -200,7 +200,7 @@ public interface Relations extends Serializable {
     /**
      * 查找关系
      * <pre>
-     *     findAll(rel->rel.getType().equals("person"))
+     *     findAll(rel->rel.getDimension().equals("person"))
      * </pre>
      *
      * @param predicate 查找的判断逻辑

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/RelationsManager.java

@@ -0,0 +1,16 @@
+package org.hswebframework.web.organizational.authorization.relation;
+
+import java.util.List;
+
+public interface RelationsManager {
+
+    PersonRelations getPersonRelationsByPersonId(String personId);
+
+    PersonRelations getPersonRelationsByUserId(String userId);
+
+    DepartmentRelations getDepartmentRelations(List<String> departmentIds);
+
+    OrgRelations getOrgRelations(List<String> orgIds);
+
+    LinkedRelations getRelations(List<String> target);
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-authorization/src/main/java/org/hswebframework/web/organizational/authorization/relation/SimpleRelation.java

@@ -11,7 +11,7 @@ import java.io.Serializable;
 public class SimpleRelation implements Relation {
     private static final long serialVersionUID = 1_0;
 
-    private String type;
+    private String dimension;
 
     private String relation;
 

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/pom.xml

@@ -34,5 +34,9 @@
             <artifactId>hsweb-commons-dao-mybatis</artifactId>
             <version>${project.version}</version>
         </dependency>
+        <dependency>
+            <groupId>io.vavr</groupId>
+            <artifactId>vavr</artifactId>
+        </dependency>
     </dependencies>
 </project>

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/SimpleDepartmentService.java

@@ -16,6 +16,7 @@
  */
 package org.hswebframework.web.service.organizational.simple;
 
+import org.apache.commons.collections.CollectionUtils;
 import org.hswebframework.web.BusinessException;
 import org.hswebframework.web.dao.organizational.DepartmentDao;
 import org.hswebframework.web.dao.organizational.PositionDao;
@@ -35,8 +36,8 @@ import org.springframework.cache.annotation.Cacheable;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * 默认的服务实现
@@ -68,19 +69,48 @@ public class SimpleDepartmentService
     }
 
     @Override
-    @Cacheable(cacheNames = "'org-id:'+#orgId")
+    @Cacheable(key = "'org-id:'+#orgId")
     public List<DepartmentEntity> selectByOrgId(String orgId) {
         return createQuery().where(DepartmentEntity.orgId, orgId).listNoPaging();
     }
 
     @Override
-    @Cacheable(cacheNames = "'name:'+#name")
+    @Cacheable(key = "'org-ids:'+#orgId==null?0:orgId.hashCode()+'_'+#children+'_'+#parent")
+    public List<DepartmentEntity> selectByOrgIds(List<String> orgId, boolean children, boolean parent) {
+        if (CollectionUtils.isEmpty(orgId)) {
+            return Collections.emptyList();
+        }
+        Set<String> allOrgId = new HashSet<>();
+
+        if (children) {
+            allOrgId.addAll(orgId.stream()
+                    .map(this::selectAllChildNode)
+                    .flatMap(Collection::stream)
+                    .map(DepartmentEntity::getId)
+                    .collect(Collectors.toSet()));
+
+        }
+        if (parent) {
+            allOrgId.addAll(orgId.stream()
+                    .map(this::selectParentNode)
+                    .flatMap(Collection::stream)
+                    .map(DepartmentEntity::getId)
+                    .collect(Collectors.toSet()));
+        }
+        return createQuery()
+                .where()
+                .in(DepartmentEntity.orgId, allOrgId)
+                .listNoPaging();
+    }
+
+    @Override
+    @Cacheable(key = "'name:'+#name")
     public List<DepartmentEntity> selectByName(String name) {
         return createQuery().where(DepartmentEntity.name, name).listNoPaging();
     }
 
     @Override
-    @Cacheable(cacheNames = "'code:'+#code")
+    @Cacheable(key = "'code:'+#code")
     public DepartmentEntity selectByCode(String code) {
         return createQuery().where(DepartmentEntity.code, code).single();
     }

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/SimplePersonService.java

@@ -189,6 +189,78 @@ public class SimplePersonService extends GenericEntityService<PersonEntity, Stri
         return personDao.selectByPositionId(positionId);
     }
 
+    @Override
+    public List<PersonEntity> selectByPositionIds(List<String> positionId) {
+        return createQuery()
+                .where(PersonEntity.id, "person-in-position", positionId)
+                .listNoPaging();
+    }
+
+    @Override
+    public List<PersonEntity> selectByDepartmentId(List<String> departmentId) {
+        return createQuery()
+                .where(PersonEntity.id, "person-in-department", departmentId)
+                .listNoPaging();
+    }
+
+    @Override
+    public List<PersonEntity> selectByOrgId(List<String> orgId) {
+        return createQuery()
+                .where(PersonEntity.id, "person-in-org", orgId)
+                .listNoPaging();
+    }
+
+    @Override
+    public PersonEntity selectByUserId(String userId) {
+        return createQuery().where(PersonEntity.userId,userId).single();
+    }
+
+    @Override
+    public List<String> selectAllDepartmentId(List<String> personId) {
+        if (CollectionUtils.isEmpty(personId)) {
+            return Collections.emptyList();
+        }
+        //所有的机构
+        List<String> positionId = DefaultDSLQueryService.createQuery(personPositionDao)
+                .where().in(PersonPositionEntity.personId, personId)
+                .listNoPaging()
+                .stream()
+                .map(PersonPositionEntity::getPositionId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .collect(Collectors.toList());
+
+        if (CollectionUtils.isEmpty(positionId)) {
+            return Collections.emptyList();
+        }
+        return DefaultDSLQueryService.createQuery(positionDao)
+                .where()
+                .in(PositionEntity.id, positionId)
+                .listNoPaging()
+                .stream()
+                .map(PositionEntity::getDepartmentId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    public List<String> selectAllOrgId(List<String> personId) {
+        List<String> departmentId = this.selectAllDepartmentId(personId);
+        if (CollectionUtils.isEmpty(departmentId)) {
+            return Collections.emptyList();
+        }
+        return DefaultDSLQueryService.createQuery(departmentDao)
+                .where()
+                .in(DepartmentEntity.id, departmentId)
+                .listNoPaging()
+                .stream()
+                .map(DepartmentEntity::getOrgId)
+                .filter(Objects::nonNull)
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
     @Override
     public List<PersonEntity> selectByRoleId(String roleId) {
         Objects.requireNonNull(roleId);
@@ -215,25 +287,6 @@ public class SimplePersonService extends GenericEntityService<PersonEntity, Stri
             logger.warn("userService not ready!");
             return;
         }
-//        //获取所有职位
-//        Set<String> positionIds = bindEntity.getPositionIds();
-//        Set<String> roleIds;
-//
-//        if (positionIds == null) {
-//            roleIds = null;
-//        } else if (positionIds.isEmpty()) {
-//            roleIds = new HashSet<>();
-//        } else {
-//            //获取职位实体
-//            List<PositionEntity> positionEntities = DefaultDSLQueryService.createQuery(positionDao)
-//                    .where().in(PositionEntity.id, positionIds)
-//                    .listNoPaging();
-//            roleIds = positionEntities.stream()
-//                    .map(PositionEntity::getRoles)
-//                    .filter(Objects::nonNull)
-//                    .flatMap(List::stream)
-//                    .collect(Collectors.toSet());
-//        }
         //获取用户是否存在
         UserEntity oldUser = userService.selectByUsername(bindEntity.getPersonUser().getUsername());
         if (null != oldUser) {
@@ -252,14 +305,6 @@ public class SimplePersonService extends GenericEntityService<PersonEntity, Stri
                             return oldUser.getId();
                         };
         UserEntity userEntity = entityFactory.newInstance(UserEntity.class);
-//
-//        if (roleIds != null) {
-//            BindRoleUserEntity tmp = entityFactory.newInstance(BindRoleUserEntity.class);
-//            tmp.setRoles(new ArrayList<>(roleIds));
-//            userEntity = tmp;
-//        } else {
-//            userEntity = entityFactory.newInstance(UserEntity.class);
-//        }
 
         userEntity.setUsername(bindEntity.getPersonUser().getUsername());
         userEntity.setPassword(bindEntity.getPersonUser().getPassword());
@@ -392,7 +437,7 @@ public class SimplePersonService extends GenericEntityService<PersonEntity, Stri
         List<Relation> relations = relationInfoList.stream()
                 .map(info -> {
                     SimpleRelation relation = new SimpleRelation();
-                    relation.setType(info.getRelationTypeFrom());
+                    relation.setDimension(info.getRelationTypeFrom());
                     relation.setTarget(info.getRelationTo());
                     relation.setRelation(info.getRelationId());
                     if (personId.equals(info.getRelationFrom())) {

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/SimpleRelationInfoService.java

@@ -53,7 +53,7 @@ public class SimpleRelationInfoService extends GenericEntityService<RelationInfo
         List<Relation> relations = relationInfoList.stream()
                 .map(info -> {
                     SimpleRelation relation = new SimpleRelation();
-                    relation.setType(info.getRelationTypeFrom());
+                    relation.setDimension(info.getRelationTypeFrom());
                     relation.setTarget(info.getRelationTo());
                     relation.setTargetObject(RelationTargetHolder
                             .get(info.getRelationTypeTo(), info.getRelationTo()).orElse(null));

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/DefaultDepartmentRelations.java

@@ -0,0 +1,219 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import org.hswebframework.ezorm.core.NestConditional;
+import org.hswebframework.ezorm.core.dsl.Query;
+import org.hswebframework.ezorm.core.param.TermType;
+import org.hswebframework.web.commons.entity.param.QueryParamEntity;
+import org.hswebframework.web.entity.organizational.DepartmentEntity;
+import org.hswebframework.web.entity.organizational.PersonEntity;
+import org.hswebframework.web.entity.organizational.PositionEntity;
+import org.hswebframework.web.organizational.authorization.relation.DepartmentRelations;
+import org.hswebframework.web.organizational.authorization.relation.PersonRelations;
+import org.hswebframework.web.organizational.authorization.relation.Relation;
+import org.hswebframework.web.organizational.authorization.relation.SimpleRelation;
+import org.springframework.util.CollectionUtils;
+
+import java.util.*;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DefaultDepartmentRelations extends DefaultLinkedRelations<DepartmentRelations> implements DepartmentRelations {
+
+    private boolean includeChildren;
+
+    private boolean includeParent;
+
+    private NestConditional<Query<DepartmentEntity, QueryParamEntity>> departmentQuery =
+            Query.<DepartmentEntity, QueryParamEntity>empty(new QueryParamEntity()).noPaging().nest();
+
+    private NestConditional<Query<PositionEntity, QueryParamEntity>> positionQuery =
+            Query.<PositionEntity, QueryParamEntity>empty(new QueryParamEntity()).noPaging().nest();
+
+
+    public DefaultDepartmentRelations(ServiceContext serviceContext, Supplier<List<String>> targetIdSupplier) {
+        super(serviceContext, targetIdSupplier);
+    }
+
+    @Override
+    public DepartmentRelations andChildren() {
+        includeChildren = true;
+        return this;
+    }
+
+    @Override
+    public DepartmentRelations andParents() {
+        includeParent = true;
+        return this;
+    }
+
+    @Override
+    public DepartmentRelations relations(Relation.Direction direction, String dimension, String relation) {
+
+        if (dimension == null && direction != Relation.Direction.REVERSE) {
+            //没指定维度,尝试获取岗位关系
+            positionQuery.is(PositionEntity.name, relation);
+        }
+
+        return super.relations(direction, dimension, relation);
+    }
+
+    @Override
+    public DepartmentRelations or() {
+        positionQuery.or();
+        departmentQuery.or();
+        return super.or();
+    }
+
+    @Override
+    public DepartmentRelations and() {
+        positionQuery.and();
+        departmentQuery.and();
+        return super.and();
+    }
+
+    @Override
+    public DepartmentRelations not(String property, Object value) {
+        departmentQuery.not(property, value);
+        positionQuery.not(property, value);
+
+        return super.not(property, value);
+    }
+
+    @Override
+    public DepartmentRelations is(String property, Object value) {
+        departmentQuery.is(property, value);
+        positionQuery.is(property, value);
+        return super.is(property, value);
+    }
+
+    @Override
+    public Stream<Relation> stream() {
+
+        Map<String, List<PersonEntity>> cache = new HashMap<>();
+
+
+        List<String> positionIdList = getAllPerson()
+                .stream()
+                .map(person -> serviceContext.getPersonService().selectAuthBindByPk(person.getId()))
+                .filter(bin -> !CollectionUtils.isEmpty(bin.getPositionIds()))
+                .flatMap(bind -> bind.getPositionIds().stream().peek(positionId -> cache.computeIfAbsent(positionId, i -> new ArrayList<>()).add(bind)))
+                .collect(Collectors.toList());
+
+        QueryParamEntity positionQueryParam = positionQuery.end().in(PositionEntity.id, positionIdList)
+                .getParam();
+
+        Stream<Relation> relationStream = serviceContext
+                .getPositionService()
+                .select(positionQueryParam).stream()
+                .flatMap(position -> {
+                    List<PersonEntity> personEntities = cache.get(position.getId());
+                    if (CollectionUtils.isEmpty(personEntities)) {
+                        return Stream.empty();
+                    }
+                    return personEntities
+                            .stream()
+                            .map(person -> {
+                                SimpleRelation relation = new SimpleRelation();
+                                relation.setName(position.getName());
+                                relation.setTarget(person.getId());
+                                relation.setTargetObject(person);
+                                relation.setDirection(Relation.Direction.REVERSE);
+                                relation.setDimension(Relation.TYPE_POSITION);
+                                relation.setRelation(position.getId());
+                                return (Relation) relation;
+                            });
+
+                });
+
+
+        return Stream.concat(relationStream, super.relationStream(allDepartmentId));
+    }
+
+    private Supplier<List<String>> allDepartmentId = createLazyIdSupplier(() -> {
+        Set<String> departmentId = new HashSet<>(targetIdSupplier.get());
+
+        Set<String> allParent = null, allChildren = null;
+        //包含父级
+        if (includeParent) {
+            allParent = departmentId.stream()
+                    .map(serviceContext.getDepartmentService()::selectParentNode)
+                    .flatMap(Collection::stream)
+                    .map(DepartmentEntity::getId)
+                    .collect(Collectors.toSet());
+        }
+        //包含子级
+        if (includeChildren) {
+
+            allChildren = departmentId.stream()
+                    .map(serviceContext.getDepartmentService()::selectAllChildNode)
+                    .flatMap(Collection::stream)
+                    .map(DepartmentEntity::getId)
+                    .collect(Collectors.toSet());
+        }
+        if (!CollectionUtils.isEmpty(allChildren)) {
+            departmentId.addAll(allChildren);
+        }
+        if (!CollectionUtils.isEmpty(allParent)) {
+            departmentId.addAll(allParent);
+        }
+
+        QueryParamEntity paramEntity = departmentQuery.end().getParam();
+        if (paramEntity.getTerms().isEmpty()) {
+            return new ArrayList<>(departmentId);
+        }
+        paramEntity.noPaging()
+                .includes(DepartmentEntity.id)
+                .and(DepartmentEntity.id, TermType.in, departmentId);
+
+        return serviceContext.getDepartmentService()
+                .select(paramEntity)
+                .stream()
+                .map(DepartmentEntity::getId)
+                .collect(Collectors.toList());
+    });
+
+
+    public List<PersonEntity> getAllPerson() {
+        List<String> departmentId = allDepartmentId.get();
+
+        QueryParamEntity positionQueryParam = positionQuery.end()
+                .in(PositionEntity.departmentId, departmentId)
+                .getParam();
+
+        List<String> positionIds = serviceContext
+                .getPositionService()
+                .select(positionQueryParam).stream()
+                .map(PositionEntity::getId)
+                .collect(Collectors.toList());
+        if (CollectionUtils.isEmpty(positionIds)) {
+
+            return Collections.emptyList();
+        }
+
+        return serviceContext
+                .getPersonService()
+                .selectByPositionIds(positionIds);
+
+
+    }
+
+    public List<String> getAllUserId() {
+        return getAllPerson().stream()
+                .map(PersonEntity::getUserId)
+                .collect(Collectors.toList());
+    }
+
+    public List<String> getAllPersonId() {
+        return getAllPerson()
+                .stream()
+                .map(PersonEntity::getId)
+                .collect(Collectors.toList());
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public PersonRelations persons() {
+        return new DefaultPersonRelations(serviceContext, createLazyIdSupplier(this::getAllPersonId));
+    }
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/DefaultLinkedRelations.java

@@ -0,0 +1,128 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import io.vavr.Lazy;
+import org.hswebframework.ezorm.core.NestConditional;
+import org.hswebframework.ezorm.core.dsl.Query;
+import org.hswebframework.web.commons.entity.param.QueryParamEntity;
+import org.hswebframework.web.entity.organizational.PersonEntity;
+import org.hswebframework.web.organizational.authorization.relation.LinkedRelations;
+import org.hswebframework.web.organizational.authorization.relation.Relation;
+import org.hswebframework.web.organizational.authorization.relation.RelationTargetHolder;
+import org.hswebframework.web.organizational.authorization.relation.SimpleRelation;
+
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+@SuppressWarnings("all")
+public class DefaultLinkedRelations<C extends LinkedRelations> implements LinkedRelations<C> {
+
+    protected Supplier<List<String>> targetIdSupplier;
+
+    protected transient NestConditional<Query<PersonEntity, QueryParamEntity>> query;
+
+    protected transient ServiceContext serviceContext;
+
+    public DefaultLinkedRelations(ServiceContext serviceContext, Supplier<List<String>> targetIdSupplier) {
+        this.serviceContext = serviceContext;
+        this.targetIdSupplier = targetIdSupplier;
+        query = Query.<PersonEntity, QueryParamEntity>empty(new QueryParamEntity()).nest();
+    }
+
+    @Override
+    public C relations(Relation.Direction direction, String dimension, String relation) {
+        switch (direction) {
+            case REVERSE:
+                query.nest().is("relationTypeTo", dimension).is("relationId", relation).end();
+                break;
+            case POSITIVE:
+                query.nest().is("relationTypeFrom", dimension).is("relationId", relation).end();
+                break;
+            case ALL:
+                query
+                        .nest()
+                            .nest()
+                                 .is("relationTypeFrom", dimension).is("relationId", relation)
+                            .end()
+                        .or()
+                            .nest()
+                                 .is("relationTypeTo", dimension).is("relationId", relation)
+                            .end()
+                        .end();
+                break;
+
+        }
+
+        return (C) this;
+    }
+
+    @Override
+    public C is(String property, Object value) {
+        query.is(property, value);
+        return (C) this;
+    }
+
+    @Override
+    public C not(String property, Object value) {
+        query.not(property, value);
+        return (C) this;
+    }
+
+    @Override
+    public C or() {
+        query.or();
+        return (C) this;
+    }
+
+    @Override
+    public C and() {
+        query.and();
+        return (C) this;
+    }
+
+    public Supplier<List<String>> createLazyIdSupplier(Supplier<List<String>> idSupplier) {
+        return Lazy.val(() -> {
+            List<String> ids = idSupplier.get();
+
+            return (Supplier) () -> ids;
+        }, Supplier.class);
+    }
+
+    public Stream<Relation> relationStream(Supplier<List<String>> supplier) {
+
+        List<String> personIdList = supplier.get();
+
+        QueryParamEntity queryParamEntity = query.end()
+                .and()
+                .nest()
+                .in("relationFrom", personIdList)
+                .or()
+                .in("relationTo", personIdList)
+                .end()
+                .getParam();
+
+
+        return serviceContext.getRelationInfoService().select(queryParamEntity).stream()
+                .map(info -> {
+                    SimpleRelation relation = new SimpleRelation();
+
+                    relation.setTarget(info.getRelationTo());
+                    relation.setTargetObject(RelationTargetHolder.get(info.getRelationTypeTo(), info.getRelationTo()).orElse(null));
+                    relation.setRelation(info.getRelationId());
+
+                    if (personIdList.contains(info.getRelationFrom())) {
+                        relation.setDimension(info.getRelationTypeFrom());
+                        relation.setDirection(Relation.Direction.POSITIVE);
+                    } else {
+                        relation.setDimension(info.getRelationTypeTo());
+                        relation.setDirection(Relation.Direction.REVERSE);
+                    }
+                    return relation;
+                });
+    }
+
+    @Override
+    public Stream<Relation> stream() {
+        return relationStream(targetIdSupplier);
+    }
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/DefaultOrgRelations.java

@@ -0,0 +1,42 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import org.hswebframework.web.entity.organizational.DepartmentEntity;
+import org.hswebframework.web.organizational.authorization.relation.DepartmentRelations;
+import org.hswebframework.web.organizational.authorization.relation.OrgRelations;
+
+import java.util.List;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+public class DefaultOrgRelations extends DefaultLinkedRelations<OrgRelations> implements OrgRelations {
+
+    private boolean includeChildren;
+
+    private boolean includeParents;
+
+    public DefaultOrgRelations(ServiceContext serviceContext, Supplier<List<String>> targetIdSupplier) {
+        super(serviceContext, targetIdSupplier);
+    }
+
+    @Override
+    public OrgRelations andChildren() {
+        includeChildren = true;
+        return this;
+    }
+
+    @Override
+    public OrgRelations andParents() {
+        includeParents = true;
+        return this;
+    }
+
+    @Override
+    public DepartmentRelations departments() {
+        return new DefaultDepartmentRelations(serviceContext, () -> serviceContext
+                .getDepartmentService()
+                .selectByOrgIds(targetIdSupplier.get(),includeChildren,includeParents)
+                .stream()
+                .map(DepartmentEntity::getId)
+                .collect(Collectors.toList()));
+    }
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/DefaultPersonRelations.java

@@ -0,0 +1,37 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import org.hswebframework.web.organizational.authorization.relation.*;
+import org.hswebframework.web.service.authorization.UserService;
+import org.hswebframework.web.service.organizational.PersonService;
+import org.hswebframework.web.service.organizational.RelationInfoService;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Supplier;
+
+public class DefaultPersonRelations extends DefaultLinkedRelations<PersonRelations> implements PersonRelations {
+
+
+    public DefaultPersonRelations(ServiceContext serviceContext, Supplier<List<String>> personIdListSupplier) {
+        super(serviceContext, personIdListSupplier);
+    }
+
+    protected List<String> getAllOrg() {
+        return serviceContext.getPersonService().selectAllOrgId(targetIdSupplier.get());
+    }
+
+    protected List<String> getAllDepartment() {
+        return serviceContext.getPersonService().selectAllDepartmentId(targetIdSupplier.get());
+    }
+
+    @Override
+    public DepartmentRelations department() {
+        return new DefaultDepartmentRelations(serviceContext, createLazyIdSupplier(this::getAllDepartment));
+    }
+
+    @Override
+    public OrgRelations org() {
+        return new DefaultOrgRelations(serviceContext, createLazyIdSupplier(this::getAllOrg));
+    }
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/DefaultRelationsManager.java

@@ -0,0 +1,48 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import org.hswebframework.web.entity.organizational.PersonEntity;
+import org.hswebframework.web.organizational.authorization.relation.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+@Component
+public class DefaultRelationsManager implements RelationsManager {
+
+    @Autowired
+    private ServiceContext context;
+
+    @Override
+    public PersonRelations getPersonRelationsByPersonId(String personId) {
+        return new DefaultPersonRelations(context, () -> Collections.singletonList(personId));
+    }
+
+    @Override
+    public PersonRelations getPersonRelationsByUserId(String userId) {
+
+        return new DefaultPersonRelations(context, () -> Optional
+                .ofNullable(context.getPersonService().selectByUserId(userId))
+                .map(PersonEntity::getId)
+                .map(Collections::singletonList)
+                .orElseGet(Collections::emptyList));
+    }
+
+    @Override
+    public DepartmentRelations getDepartmentRelations(List<String> departmentIds) {
+        return new DefaultDepartmentRelations(context, () -> departmentIds);
+    }
+
+    @Override
+    public OrgRelations getOrgRelations(List<String> orgIds) {
+        return new DefaultOrgRelations(context, () -> orgIds);
+    }
+
+    @Override
+    public LinkedRelations getRelations(List<String> target) {
+
+        return new DefaultLinkedRelations(context, () -> target);
+    }
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/relations/ServiceContext.java

@@ -0,0 +1,31 @@
+package org.hswebframework.web.service.organizational.simple.relations;
+
+import lombok.Getter;
+import org.hswebframework.web.service.authorization.UserService;
+import org.hswebframework.web.service.organizational.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Getter
+@Component
+public class ServiceContext {
+
+    @Autowired
+    private PersonService personService;
+
+    @Autowired
+    private PositionService positionService;
+
+    @Autowired
+    private DepartmentService departmentService;
+
+    @Autowired
+    private OrganizationalService organizationalService;
+
+    @Autowired
+    private RelationInfoService relationInfoService;
+
+    @Autowired
+    private RelationDefineService relationDefineService;
+
+}

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/terms/UserInDepartmentSqlTerm.java

@@ -36,23 +36,23 @@ public class UserInDepartmentSqlTerm extends UserInSqlTerm {
     public SqlAppender accept(String wherePrefix, Term term, RDBColumnMetaData column, String tableAlias) {
         ChangedTermValue termValue = createChangedTermValue(term);
 
-        Dialect dialect=column.getTableMetaData().getDatabaseMetaData().getDialect();
+        Dialect dialect = column.getTableMetaData().getDatabaseMetaData().getDialect();
 
         SqlAppender appender = new SqlAppender();
         appender.addSpc(not ? "not" : "", "exists(select 1 from s_person_position _tmp,s_position _pos,s_person _person");
-        if (isChild()) {
+        if (isChild() || isParent()) {
             appender.addSpc(",s_department _dept");
         }
         appender.addSpc("where _person.u_id=_tmp.person_id and _tmp.position_id = _pos.u_id and _person.u_id=_tmp.person_id"
                 , "and", createColumnName(column, tableAlias), "=", isForPerson() ? "_tmp.person_id" : "_person.user_id");
-        if (isChild()) {
+        if (isChild() || isParent()) {
             appender.addSpc("and _dept.u_id=_pos.department_id");
         }
 
         List<Object> positionIdList = BoostTermTypeMapper.convertList(column, termValue.getOld());
         if (!positionIdList.isEmpty()) {
             appender.addSpc("and");
-            termValue.setValue(appendCondition(positionIdList, wherePrefix, appender, "_pos.department_id",dialect));
+            termValue.setValue(appendCondition(positionIdList, wherePrefix, appender, "_pos.department_id", dialect));
         }
 
         appender.add(")");

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/terms/UserInDistSqlTerm.java

@@ -39,12 +39,12 @@ public class UserInDistSqlTerm extends UserInSqlTerm {
 
         SqlAppender appender = new SqlAppender();
         appender.addSpc(not ? "not" : "", "exists(select 1 from s_person_position _tmp,s_position _pos,s_person _person,s_department _dept,s_organization _org");
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc(",s_district _dist");
         }
         appender.addSpc("where _person.u_id=_tmp.person_id and _tmp.position_id = _pos.u_id and _person.u_id=_tmp.person_id and _dept.u_id=_pos.department_id and _org.u_id=_dept.org_id"
                 , "and", createColumnName(column, tableAlias), "=", isForPerson() ? "_tmp.person_id" : "_person.user_id");
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc("and _org.district_id=_dist.u_id");
         }
         List<Object> positionIdList = BoostTermTypeMapper.convertList(column, termValue.getOld());

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/terms/UserInOrgSqlTerm.java

@@ -39,12 +39,12 @@ public class UserInOrgSqlTerm extends UserInSqlTerm {
 
         SqlAppender appender = new SqlAppender();
         appender.addSpc(not ? "not" : "", "exists(select 1 from s_person_position _tmp,s_position _pos,s_department _dept,s_person _person");
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc(",s_organization _org");
         }
         appender.addSpc("where _person.u_id=_tmp.person_id and _tmp.position_id = _pos.u_id and _person.u_id=_tmp.person_id and _dept.u_id=_pos.department_id"
                 , "and", createColumnName(column, tableAlias), "=", isForPerson() ? "_tmp.person_id" : "_person.user_id");
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc("and _org.u_id=_dept.org_id");
         }
         List<Object> positionIdList = BoostTermTypeMapper.convertList(column, termValue.getOld());

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/terms/UserInPositionSqlTerm.java

@@ -39,7 +39,7 @@ public class UserInPositionSqlTerm extends UserInSqlTerm {
 
         SqlAppender appender = new SqlAppender();
         appender.addSpc(not ? "not" : "", "exists(select 1 from s_person_position _tmp");
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc(",s_position _pos");
         }
         if (!isForPerson()) {
@@ -50,7 +50,7 @@ public class UserInPositionSqlTerm extends UserInSqlTerm {
                 createColumnName(column, tableAlias), "=",
                 isForPerson() ? " _tmp.person_id" : "_person.user_id and _person.u_id=_tmp.person_id");
 
-        if (isChild()) {
+        if (isChild()||isParent()) {
             appender.addSpc("and _pos.u_id=_tmp.position_id");
         }
 

hsweb-system/hsweb-system-organizational/hsweb-system-organizational-local/src/main/java/org/hswebframework/web/service/organizational/simple/terms/UserInSqlTerm.java

@@ -66,7 +66,7 @@ public abstract class UserInSqlTerm<PK> extends AbstractSqlTermCustomer {
 
 
     protected Object appendCondition(List<Object> values, String wherePrefix, SqlAppender appender, String column, Dialect dialect) {
-        if (!child) {
+        if (!child&&!parent) {
             appender.addSpc(column);
             return super.appendCondition(values, wherePrefix, appender);
         } else {

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/dimension/DefaultCandidateDimensionParser.java

@@ -22,7 +22,7 @@ public class DefaultCandidateDimensionParser implements CandidateDimensionParser
     @Override
     public CandidateDimension parse(DimensionContext context, String jsonConfig) {
         JSONObject jsonObject = JSON.parseObject(jsonConfig);
-        String type = jsonObject.getString("type");
+        String type = jsonObject.getString("dimension");
         CandidateDimensionParserStrategy.StrategyConfig config = jsonObject
                 .toJavaObject(CandidateDimensionParserStrategy.StrategyConfig.class);
         if (config.getConfig() == null) {

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/dimension/parser/RelationCandidateDimensionParserStrategy.java

@@ -1,5 +1,6 @@
 package org.hswebframework.web.workflow.dimension.parser;
 
+import lombok.extern.slf4j.Slf4j;
 import org.hswebframework.web.organizational.authorization.PersonnelAuthentication;
 import org.hswebframework.web.organizational.authorization.PersonnelAuthenticationManager;
 import org.hswebframework.web.organizational.authorization.relation.Relations;
@@ -13,6 +14,7 @@ import java.util.List;
  * @author zhouhao
  * @since 3.0.0-RC
  */
+@Slf4j
 public class RelationCandidateDimensionParserStrategy implements CandidateDimensionParserStrategy {
 
     @Autowired
@@ -48,14 +50,18 @@ public class RelationCandidateDimensionParserStrategy implements CandidateDimens
         if (null == authentication) {
             return Collections.emptyList();
         }
+
         Relations relations = authentication.getRelations();
 
+        if (relations == null || relations.getAll().isEmpty()) {
+            return Collections.emptyList();
+        }
 
 
         return Collections.emptyList();
     }
 
-    public static class RelationInfo{
+    public static class RelationInfo {
 
     }
 }

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/service/imp/BpmActivityServiceImp.java

@@ -70,12 +70,12 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
     @Override
     public List<ActivityImpl> getUserTasksByProcDefId(String procDefId) {
 
-        return findActivities(procDefId, activity -> "userTask".equals(activity.getProperty("type")));
+        return findActivities(procDefId, activity -> "userTask".equals(activity.getProperty("dimension")));
 
 //        ProcessDefinitionEntity pde = getProcessDefinition(procDefId);
 //        List<ActivityImpl> activityList = new ArrayList<>();
 //        for (ActivityImpl activity : pde.getActivities()) {
-//            if (activity.getProperty("type").equals("userTask"))
+//            if (activity.getProperty("dimension").equals("userTask"))
 //                activityList.add(activity);
 //        }
 //        return activityList;
@@ -85,12 +85,12 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
     public List<ActivityImpl> getUserTasksByProcDefKey(String procDefKey) {
         ProcessDefinition definition = repositoryService.createProcessDefinitionQuery().processDefinitionKey(procDefKey).orderByProcessDefinitionVersion().desc().list().get(0);
         String procDefId = definition.getId();
-        List<ActivityImpl> activities = findActivities(procDefId, activity -> "userTask".equals(activity.getProperty("type")));
+        List<ActivityImpl> activities = findActivities(procDefId, activity -> "userTask".equals(activity.getProperty("dimension")));
 //
 //        ProcessDefinitionEntity pde = getProcessDefinition(procDefId);
 //        List<ActivityImpl> activities = new ArrayList<>();
 //        for (ActivityImpl activity : pde.getActivities()) {
-//            if (activity.getProperty("type").equals("userTask"))
+//            if (activity.getProperty("dimension").equals("userTask"))
 //                activities.add(activity);
 //        }
         if (null != activities) {
@@ -130,7 +130,7 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
     public List<TaskDefinition> getTaskDefinition(ActivityImpl activityImpl, String elString) {
         List<TaskDefinition> taskDefinitionList = new ArrayList<>();
         List<TaskDefinition> nextTaskDefinition;
-        if ("userTask".equals(activityImpl.getProperty("type"))) {
+        if ("userTask".equals(activityImpl.getProperty("dimension"))) {
             TaskDefinition taskDefinition = ((UserTaskActivityBehavior) activityImpl.getActivityBehavior()).getTaskDefinition();
             taskDefinitionList.add(taskDefinition);
         } else {
@@ -138,7 +138,7 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
             List<PvmTransition> outTransitionsTemp;
             for (PvmTransition tr : pvmTransitions) {
                 PvmActivity pvmActivity = tr.getDestination(); //获取线路的终点节点
-                if ("exclusiveGateway".equals(pvmActivity.getProperty("type")) || "parallelGateway".equals(pvmActivity.getProperty("type"))) {
+                if ("exclusiveGateway".equals(pvmActivity.getProperty("dimension")) || "parallelGateway".equals(pvmActivity.getProperty("dimension"))) {
                     outTransitionsTemp = pvmActivity.getOutgoingTransitions();
                     if (outTransitionsTemp.size() == 1) {
                         nextTaskDefinition = getTaskDefinition((ActivityImpl) outTransitionsTemp.get(0).getDestination(), elString);
@@ -152,7 +152,7 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
                             }
                         }
                     }
-                } else if ("userTask".equals(pvmActivity.getProperty("type"))) {
+                } else if ("userTask".equals(pvmActivity.getProperty("dimension"))) {
                     taskDefinitionList.add(((UserTaskActivityBehavior) ((ActivityImpl) pvmActivity).getActivityBehavior()).getTaskDefinition());
                 }
             }
@@ -184,12 +184,12 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
 
     @Override
     public ActivityImpl getStartEvent(String procDefId) {
-        return findActivity(procDefId, activity -> "startEvent".equals(activity.getProperty("type")));
+        return findActivity(procDefId, activity -> "startEvent".equals(activity.getProperty("dimension")));
 
 //        List<ActivityImpl> activities = getActivitiesById(procDefId, null);
 //        ActivityImpl activity = null;
 //        for (ActivityImpl a : activities) {
-//            if (a.getProperty("type").equals("startEvent")) {
+//            if (a.getProperty("dimension").equals("startEvent")) {
 //                activity = a;
 //            }
 //        }
@@ -221,7 +221,7 @@ public class BpmActivityServiceImp extends AbstractFlowableService implements Bp
 
     @Override
     public ActivityImpl getEndEvent(String procDefId) {
-        return findActivity(procDefId, activity -> "endEvent".equals(activity.getProperty("type")));
+        return findActivity(procDefId, activity -> "endEvent".equals(activity.getProperty("dimension")));
     }
 
     /**

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/service/imp/BpmTaskServiceImp.java

@@ -322,7 +322,7 @@ public class BpmTaskServiceImp extends AbstractFlowableService implements BpmTas
         List<ActivityImpl> activities = entity.getActivities();
         return activities
                 .stream()
-                .filter(activity -> "userTask".equals(activity.getProperty("type")) && activity.getProperty("name").equals(task.getName()))
+                .filter(activity -> "userTask".equals(activity.getProperty("dimension")) && activity.getProperty("name").equals(task.getName()))
                 .findFirst()
                 .orElseThrow(() -> new NotFoundException("获取节点信息失败"));
     }

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/service/imp/BpmUtilsServiceImp.java

@@ -41,17 +41,17 @@ public class BpmUtilsServiceImp implements BpmUtilsService {
 //        assertOrgModuleReady();
 //        List<String> list = new ArrayList<>();
 //        // 根据配置类型  获取人员信息 设置待办人
-//        if ("person".equals(actDefEntity.getType())) { // 矩阵
-//            List<Relation> relations = relationInfoService.getRelations(actDefEntity.getType(), userId).findPos(actDefEntity.getDefId());
+//        if ("person".equals(actDefEntity.getDimension())) { // 矩阵
+//            List<Relation> relations = relationInfoService.getRelations(actDefEntity.getDimension(), userId).findPos(actDefEntity.getDefId());
 //            for (Relation relation : relations) {
 //                list.add(relation.getTarget());
 //            }
-//        } else if ("position".equals(actDefEntity.getType())) { // 岗位
+//        } else if ("position".equals(actDefEntity.getDimension())) { // 岗位
 //            List<PersonEntity> personEntities = personService.selectByPositionId(actDefEntity.getDefId());
 //            for(PersonEntity personEntity:personEntities){
 //                list.add(personEntity.getUserId());
 //            }
-//        } else if ("role".equals(actDefEntity.getType())) {  // 角色
+//        } else if ("role".equals(actDefEntity.getDimension())) {  // 角色
 //            List<PersonEntity> personEntities = personService.selectByRoleId(actDefEntity.getDefId());
 //            for(PersonEntity personEntity:personEntities){
 //                list.add(personEntity.getUserId());

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/web/FlowableModelManagerController.java

@@ -173,7 +173,7 @@ public class FlowableModelManagerController {
             // 处理异常
             if (bpmnModel.getMainProcess() == null) {
                 response.setStatus(HttpStatus.UNPROCESSABLE_ENTITY.value());
-                response.getOutputStream().println("no main process, can't export for type: " + type);
+                response.getOutputStream().println("no main process, can't export for dimension: " + type);
                 response.flushBuffer();
                 return;
             }
@@ -209,7 +209,7 @@ public class FlowableModelManagerController {
             response.flushBuffer();
             in.close();
         } catch (Exception e) {
-            log.error("导出model的xml文件失败：modelId={}, type={}", modelId, type, e);
+            log.error("导出model的xml文件失败：modelId={}, dimension={}", modelId, type, e);
         }
     }
 

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/main/java/org/hswebframework/web/workflow/web/FlowableUtilsController.java

@@ -39,11 +39,11 @@ public class FlowableUtilsController {
         List<ActivityImpl> activities = bpmActivityService.getActivitiesById(procDefId, null);
         for (ActivityImpl activity : activities) {
             Map<String, Object> map = new HashMap<>();
-            if ("startEvent".equals(activity.getProperty("type"))) {
+            if ("startEvent".equals(activity.getProperty("dimension"))) {
                 map.put("id", activity.getId());
                 map.put("name", "流程发起者");
 //                map.put("info", actDefService.selectSingle(single(ActDefEntity.actId, activity.getId())));
-            } else if ("userTask".equals(activity.getProperty("type"))) {
+            } else if ("userTask".equals(activity.getProperty("dimension"))) {
                 map.put("id", activity.getId());
                 map.put("name", activity.getProperty("name").toString());
 //                map.put("info", actDefService.selectSingle(single(ActDefEntity.actId, activity.getId())));

hsweb-system/hsweb-system-workflow/hsweb-system-workflow-local/src/test/java/org/hswebframework/web/workflow/dimension/DefaultCandidateDimensionParserTest.groovy

@@ -21,7 +21,7 @@ class DefaultCandidateDimensionParserTest extends Specification {
 
     def "Test Parse User"() {
         setup:
-        def config = """ {"type":"user","idList":["admin"]} """
+        def config = """ {"dimension":"user","idList":["admin"]} """
         and:
         def dimension = parser.parse(null,config)
         expect:
@@ -33,7 +33,7 @@ class DefaultCandidateDimensionParserTest extends Specification {
 
     def "Test Parse Role"() {
         setup:
-        def config = """ {"type":"role","idList":["admin"]} """
+        def config = """ {"dimension":"role","idList":["admin"]} """
         and:
         def dimension = parser.parse(null,config)
         expect:
@@ -45,7 +45,7 @@ class DefaultCandidateDimensionParserTest extends Specification {
 
     def "Test Parse Position"() {
         setup:
-        def config = """ {"type":"position","idList":["test"],"tree":"parent"} """
+        def config = """ {"dimension":"position","idList":["test"],"tree":"parent"} """
         and:
         def dimension = parser.parse(null,config)
         expect:
@@ -56,7 +56,7 @@ class DefaultCandidateDimensionParserTest extends Specification {
 
     def "Test Parse Department"() {
         setup:
-        def config = """ {"type":"department","idList":["test"]} """
+        def config = """ {"dimension":"department","idList":["test"]} """
         and:
         def dimension = parser.parse(null,config)
         expect:
@@ -67,7 +67,7 @@ class DefaultCandidateDimensionParserTest extends Specification {
 
     def "Test Parse Org"() {
         setup:
-        def config = """ {"type":"org","idList":["test"]} """
+        def config = """ {"dimension":"org","idList":["test"]} """
         and:
         def dimension = parser.parse(null,config)
         expect: