package com.product.admin.service;
|
|
import cn.hutool.core.bean.BeanUtil;
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.product.admin.config.CmnConst;
|
import com.product.common.lang.StringUtils;
|
import com.product.core.cache.util.RedisUtil;
|
import com.product.core.entity.DataTableEntity;
|
import com.product.core.entity.FieldSetEntity;
|
import com.product.core.service.support.AbstractBaseService;
|
import org.springframework.stereotype.Service;
|
import redis.clients.jedis.Jedis;
|
|
import java.nio.charset.StandardCharsets;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author cheng
|
* @Date 2022/5/10 17:59
|
* @Desc 组织机构缓存
|
*/
|
@Service
|
public class OrganizationCacheService extends AbstractBaseService {
|
protected final static String ORG_CACHE_KEY = "system:org:";
|
protected final static String ORG_UUID_CACHE_KEY = "system:org:uuid:";
|
protected final static String POST_DEPT_CACHE_KEY = "system:post:";
|
protected final static String POST_UUID_CACHE_KEY = "system:post:uuid:";
|
protected final static String DEPT_STAFF_CACHE_KEY = "system:user:dept:";
|
protected final static String POST_STAFF_CACHE_KEY = "system:user:post:";
|
protected final static String USER_STAFF_CACHE_KEY = "system:user:id:";
|
|
|
/**
|
* 获取hash缓存 所有的value
|
*
|
* @param cacheKey
|
* @param streamFilter
|
* @return
|
*/
|
private static DataTableEntity getHashCache(String cacheKey, StreamFilter streamFilter) {
|
DataTableEntity values = new DataTableEntity();
|
// 在redis 中模糊获取key
|
try (Jedis jedis = RedisUtil.getJedis();) {
|
Set<byte[]> keyBytes = jedis.keys((cacheKey + "*").getBytes(StandardCharsets.UTF_8));
|
if (!CollectionUtil.isEmpty(keyBytes)) {
|
// 将key 序列化翻转 过滤不需要的key 转为数组
|
String[] keys = keyBytes.stream().map(item -> new String(item, StandardCharsets.UTF_8))
|
.filter(f -> streamFilter.keyFilter(f)).toArray(String[]::new);
|
for (String key : keys) {
|
//循环取出数据
|
Map<String, Object> result = RedisUtil.getHash(key);
|
//将map.value（Object) 转为 List (FieldSetEntity)
|
List<FieldSetEntity> collect = result.values().stream().map(item -> ((FieldSetEntity) item))
|
.filter(item -> streamFilter.itemFilter(item)).collect(Collectors.toList());
|
if (collect != null) {
|
if (values.getRows() <= 0) {
|
values.setData(collect);
|
} else {
|
values.getData().addAll(collect);
|
}
|
}
|
}
|
}
|
|
if (!DataTableEntity.isEmpty(values) && !StringUtils.isEmpty(values.getData().get(0).getString(CmnConst.SEQUENCE))) {
|
//如果 f.getInteger = null ,default value =Integer.MAX_VALUE
|
values.getData().sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
|
}
|
values.setData(values.getData());
|
return values;
|
}
|
}
|
|
|
/**
|
* 获取指定类型的机构缓存
|
*
|
* @param type 机构类型 1 = 公司 2=部门
|
* @return
|
*/
|
public static DataTableEntity getOrgData(String type) {
|
return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
|
@Override
|
public boolean keyFilter(String f) {
|
return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
|
}
|
|
@Override
|
public boolean itemFilter(FieldSetEntity f) {
|
if (FieldSetEntity.isEmpty(f)) {
|
return false;
|
}
|
if (!StringUtils.isEmpty(type) && !type.equals(f.getString("type"))) {
|
return false;
|
}
|
return true;
|
}
|
});
|
}
|
|
/**
|
* 获取所有机构的缓存
|
*
|
* @return
|
*/
|
public static DataTableEntity getOrgData() {
|
return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
|
@Override
|
public boolean keyFilter(String f) {
|
return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
|
}
|
});
|
}
|
|
/**
|
* 获取所有岗位缓存
|
*
|
* @return
|
*/
|
public static DataTableEntity getPostData() {
|
|
return getHashCache(POST_DEPT_CACHE_KEY, new StreamFilter() {
|
@Override
|
public boolean keyFilter(String f) {
|
return !(f == null || f.startsWith(POST_UUID_CACHE_KEY));
|
}
|
});
|
}
|
|
/**
|
* 获取岗位缓存根据部门
|
*
|
* @param deptUuid
|
* @return
|
*/
|
public static DataTableEntity getPostDataByDept(String deptUuid) {
|
List<FieldSetEntity> postCache = getPostCache(deptUuid);
|
DataTableEntity dataTableEntity = new DataTableEntity();
|
if (postCache != null) {
|
dataTableEntity.setData(postCache);
|
}
|
return dataTableEntity;
|
}
|
|
/**
|
* 获取所有用户
|
*
|
* @return
|
*/
|
public static DataTableEntity getUserData() {
|
return getHashCache(DEPT_STAFF_CACHE_KEY, new StreamFilter() {
|
});
|
}
|
|
/**
|
* 获取部门根据公司
|
*
|
* @param org_level_uuid
|
* @return
|
*/
|
public static DataTableEntity getDeptDataByCompany(String org_level_uuid) {
|
return getHashCache(ORG_CACHE_KEY, new StreamFilter() {
|
@Override
|
public boolean keyFilter(String f) {
|
return !(f == null || f.startsWith(ORG_UUID_CACHE_KEY));
|
}
|
|
@Override
|
public boolean itemFilter(FieldSetEntity f) {
|
return org_level_uuid != null && org_level_uuid.equals(f.getString("parent_uuid")) && "2".equals(f.getString("type"));
|
}
|
});
|
}
|
|
|
/**
|
* 获取用户根据部门
|
*
|
* @param deptUuid
|
* @return
|
*/
|
public static DataTableEntity getUserDataByDept(String deptUuid) {
|
List<FieldSetEntity> staffCacheByDept = getStaffCacheByDept(deptUuid);
|
DataTableEntity dataTableEntity = new DataTableEntity();
|
if (staffCacheByDept != null) {
|
staffCacheByDept.sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
|
dataTableEntity.setData(staffCacheByDept);
|
}
|
return dataTableEntity;
|
}
|
|
/**
|
* 获取用户根据岗位
|
*
|
* @param postUuid
|
* @return
|
*/
|
|
public static DataTableEntity getUserDataByPost(String postUuid) {
|
List<FieldSetEntity> staffCacheByPost = getStaffCacheByPost(postUuid);
|
DataTableEntity dataTableEntity = new DataTableEntity();
|
if (staffCacheByPost != null) {
|
staffCacheByPost.sort(Comparator.comparing(f -> Optional.ofNullable(f.getInteger(CmnConst.SEQUENCE)).orElse(Integer.MAX_VALUE)));
|
dataTableEntity.setData(staffCacheByPost);
|
}
|
return dataTableEntity;
|
}
|
|
|
interface StreamFilter {
|
default boolean keyFilter(String f) {
|
return true;
|
}
|
|
default boolean itemFilter(FieldSetEntity f) {
|
return true;
|
}
|
|
}
|
|
public void cacheOrganization(String uuid) {
|
StringBuilder sql = new StringBuilder();
|
sql.append("\n SELECT ");
|
sql.append("\n a.uuid, ");
|
sql.append("\n a.client_uuid, ");
|
sql.append("\n a.org_level_uuid, ");
|
sql.append("\n a.org_level_name, ");
|
sql.append("\n a.org_level_all,b.uuid parent_uuid, ");
|
sql.append("\n a.org_level_code, ");
|
sql.append("\n a.org_level_type + 1 type,a.sequence, ");
|
sql.append("\n b.org_level_all parent_org_level_all, ");
|
sql.append("\n case when length(a.org_level_code_parent)>0 then b.org_level_type+1 ");
|
sql.append("\n else null end as parent_type, ");
|
sql.append("\n CASE ");
|
sql.append("\n WHEN a.org_level_type = 0 THEN ");
|
sql.append("\n ifnull(( SELECT 1 FROM product_sys_org_levels c WHERE c.org_level_code_parent = a.org_level_code AND c.org_level_type = 0 and c.org_level_status=0 LIMIT 1 ), 0 ) ELSE 0 ");
|
sql.append("\n END childrenCompany, ");
|
sql.append("\n ifnull(( SELECT 1 FROM product_sys_org_levels WHERE org_level_code_parent = a.org_level_code AND org_level_type = 1 and org_level_status=0 LIMIT 1 ), 0 ) childrenDept, ");
|
sql.append("\n case when a.org_level_type=1 then ifnull((select 1 from product_sys_staff_user_v where dept_uuid=a.uuid and `status`=1 limit 1 ),0) else 0 end childrenStaff, ");
|
sql.append("\n CASE WHEN a.org_level_type=1 then ifnull((select 1 from product_sys_job_posts where is_used=1 and dept_uuid=a.uuid limit 1 ),0) else 0 end childrenPost, ");
|
sql.append("\n CASE ");
|
sql.append("\n WHEN length( a.org_level_code_parent )> 0 THEN ");
|
sql.append("\n a.org_level_code_parent ELSE a.client_uuid ");
|
sql.append("\n END org_level_code_parent, ");
|
sql.append("\n a.org_level_type ");
|
sql.append("\n FROM ");
|
sql.append("\n product_sys_org_levels a ");
|
sql.append("\n LEFT JOIN product_sys_org_levels b on b.org_level_status=0 ");
|
sql.append("\n and (a.org_level_code_parent=b.org_level_code )");
|
sql.append("\n where a.org_level_status=0 ");
|
|
Object[] params = null;
|
if (!StringUtils.isEmpty(uuid)) {
|
sql.append(" AND a.uuid=? ");
|
params = new Object[]{uuid};
|
} else {
|
RedisUtil.del(this.ORG_CACHE_KEY);
|
}
|
DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
|
if (!DataTableEntity.isEmpty(dt)) {
|
for (int i = 0; i < dt.getRows(); i++) {
|
FieldSetEntity fse = dt.getFieldSetEntity(i);
|
addOrgCache(fse);
|
}
|
}
|
|
}
|
|
public void cachePost() {
|
this.cachePost(null);
|
}
|
|
public void cachePost(String uuid) {
|
StringBuilder sql = new StringBuilder();
|
sql.append("\n select a.sequence,3 type,a.uuid,a.job_post_name,a.dept_uuid,b.org_level_all,org_level_code, ");
|
sql.append("\n (select 1 from product_sys_staff_user_v c where a.uuid=job_post_uuid and c.`status`=1 limit 1 ) childrenStaff ");
|
sql.append("\n from product_sys_job_posts a ");
|
sql.append("\n join product_sys_org_levels b on a.dept_uuid=b.uuid and b.org_level_type=1 ");
|
Object[] params = null;
|
if (!StringUtils.isEmpty(uuid)) {
|
sql.append(" where a.uuid=? ");
|
params = new Object[]{uuid};
|
} else {
|
RedisUtil.del(this.POST_DEPT_CACHE_KEY);
|
}
|
DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
|
for (int i = 0; !DataTableEntity.isEmpty(dt) && i < dt.getRows(); i++) {
|
addPostCache(dt.getFieldSetEntity(i));
|
}
|
}
|
|
public void cacheStaff() {
|
this.cacheStaff(null);
|
}
|
|
public void cacheStaff(String uuid) {
|
StringBuilder sql = new StringBuilder();
|
sql.append("\n SELECT ");
|
sql.append("\n staff.user_id,users.uuid,staff.sequence,staff.sex, ");
|
sql.append("\n staff.uuid staff_uuid, ");
|
sql.append("\n user_name, user_name show_name,user_account, ");
|
sql.append("\n dept_uuid,org.org_level_code, ");
|
sql.append("\n job_post_uuid,staff.org_level_uuid,org.org_level_all, ");
|
sql.append("\n 4 type ");
|
sql.append("\n FROM ");
|
sql.append("\n product_sys_staffs staff ");
|
sql.append("\n JOIN product_sys_users users ON staff.user_id = users.user_id ");
|
sql.append("\n AND users.`status` =1 ");
|
Object[] params = null;
|
if (!StringUtils.isEmpty(uuid)) {
|
sql.append(" and users.uuid=? ");
|
params = new Object[]{uuid};
|
} else {
|
RedisUtil.del(this.POST_STAFF_CACHE_KEY);
|
RedisUtil.del(this.DEPT_STAFF_CACHE_KEY);
|
RedisUtil.del(this.USER_STAFF_CACHE_KEY);
|
}
|
|
sql.append("\n JOIN product_sys_org_levels org on org.uuid=staff.dept_uuid and org.org_level_type=1 and org_level_status=0 ");
|
DataTableEntity dt = getBaseDao().listTable(sql.toString(), params);
|
for (int i = 0; !DataTableEntity.isEmpty(dt) && i < dt.getRows(); i++) {
|
addStaffCache(dt.getFieldSetEntity(i));
|
}
|
|
}
|
|
/**
|
* 员工缓存
|
*
|
* @param fse
|
*/
|
public void addStaffCache(FieldSetEntity fse) {
|
if (!FieldSetEntity.isEmpty(fse)) {
|
RedisUtil.setHash(this.DEPT_STAFF_CACHE_KEY + fse.getString(CmnConst.DEPT_UUID), fse.getUUID(), fse);
|
RedisUtil.setHash(this.POST_STAFF_CACHE_KEY + fse.getString("job_post_uuid"), fse.getUUID(), fse);
|
RedisUtil.setHash(this.USER_STAFF_CACHE_KEY, fse.getString("user_id"), fse);
|
}
|
}
|
|
public static List<FieldSetEntity> getStaffCacheByDept(String dept_uuid) {
|
if (!StringUtils.isEmpty((dept_uuid)) && RedisUtil.exists(DEPT_STAFF_CACHE_KEY + dept_uuid)) {
|
Collection<Object> values = RedisUtil.getHash(DEPT_STAFF_CACHE_KEY + dept_uuid).values();
|
return BeanUtil.copyToList(values, FieldSetEntity.class);
|
}
|
return null;
|
}
|
|
public static FieldSetEntity getStaffCacheByUserId(String userId) {
|
if (StringUtils.isEmpty(userId)) {
|
return null;
|
}
|
return (FieldSetEntity) RedisUtil.getHash(USER_STAFF_CACHE_KEY, userId);
|
}
|
|
public static List<FieldSetEntity> getStaffCacheByPost(String post_uuid) {
|
if (!StringUtils.isEmpty((post_uuid)) && RedisUtil.exists(POST_STAFF_CACHE_KEY + post_uuid)) {
|
Collection<Object> values = RedisUtil.getHash(POST_STAFF_CACHE_KEY + post_uuid).values();
|
return BeanUtil.copyToList(values, FieldSetEntity.class);
|
}
|
return null;
|
}
|
|
/**
|
* 岗位缓存
|
*
|
* @param fse
|
*/
|
public void addPostCache(FieldSetEntity fse) {
|
if (!FieldSetEntity.isEmpty(fse) && !StringUtils.isEmpty(fse.getUUID())) {
|
RedisUtil.setHash(POST_DEPT_CACHE_KEY + fse.getString(CmnConst.DEPT_UUID), fse.getUUID(), fse);
|
RedisUtil.set(POST_UUID_CACHE_KEY + fse.getUUID(), new Object[]{fse.getString("job_post_name"), fse.getString(CmnConst.DEPT_UUID)});
|
}
|
}
|
|
public static List<FieldSetEntity> getPostCache(String dept_uuid) {
|
if (!StringUtils.isEmpty((dept_uuid)) && RedisUtil.exists(POST_DEPT_CACHE_KEY + dept_uuid)) {
|
Collection<Object> values = RedisUtil.getHash(POST_DEPT_CACHE_KEY + dept_uuid).values();
|
return BeanUtil.copyToList(values, FieldSetEntity.class);
|
}
|
return null;
|
}
|
|
public static Object[] getPostCacheByUUID(String uuid) {
|
if (!StringUtils.isEmpty((uuid)) && RedisUtil.exists(POST_UUID_CACHE_KEY + uuid)) {
|
Object[] values = (Object[]) RedisUtil.get(POST_UUID_CACHE_KEY + uuid);
|
return values;
|
}
|
return null;
|
}
|
|
/**
|
* 组织机构表缓存
|
*
|
* @param fse
|
*/
|
public void addOrgCache(FieldSetEntity fse) {
|
if (!FieldSetEntity.isEmpty(fse) && !StringUtils.isEmpty(fse.getUUID())) {
|
RedisUtil.setHash(this.ORG_CACHE_KEY + fse.getString(CmnConst.ORG_LEVEL_CODE_PARENT), fse.getUUID(), fse);
|
Map<String, Object> orgMap = new HashMap<>();
|
orgMap.put(CmnConst.ORG_LEVEL_NAME, fse.getString(CmnConst.ORG_LEVEL_NAME));
|
orgMap.put(CmnConst.ORG_LEVEL_CODE, fse.getString(CmnConst.ORG_LEVEL_CODE));
|
orgMap.put(CmnConst.ORG_LEVEL_CODE_PARENT, fse.getString(CmnConst.ORG_LEVEL_CODE_PARENT));
|
orgMap.put(CmnConst.ORG_LEVEL_UUID, fse.getString(CmnConst.ORG_LEVEL_UUID));
|
orgMap.put(CmnConst.ORG_LEVEL_ALL, fse.getString(CmnConst.ORG_LEVEL_ALL));
|
orgMap.put("uuid", fse.getUUID());
|
orgMap.put("parent_uuid", fse.getString("parent_uuid"));
|
orgMap.put("parent_type", fse.getString("parent_type"));
|
RedisUtil.set(this.ORG_UUID_CACHE_KEY + fse.getUUID(), orgMap);
|
|
}
|
}
|
|
public static Map<String, Object> getOrgCacheByUuid(String uuid) {
|
if (!StringUtils.isEmpty(uuid) && RedisUtil.exists(ORG_UUID_CACHE_KEY + uuid)) {
|
return (Map<String, Object>) RedisUtil.get(ORG_UUID_CACHE_KEY + uuid);
|
}
|
return null;
|
}
|
|
|
public static List<FieldSetEntity> getOrgCache(String org_level_code_parent) {
|
if (!StringUtils.isEmpty((org_level_code_parent)) && RedisUtil.exists(ORG_CACHE_KEY + org_level_code_parent)) {
|
Collection<Object> values = RedisUtil.getHash(ORG_CACHE_KEY + org_level_code_parent).values();
|
return BeanUtil.copyToList(values, FieldSetEntity.class);
|
}
|
return null;
|
}
|
}
|
