package com.jsh.erp.utils.array;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description: 超级前台 业务处理 StringUtils
* @Author: linjinyu
* @CreateDate: 5/28/20 5:58 PM
* @UpdateUser: linjinyu
* @UpdateDate: 5/28/20 5:58 PM
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class SuperdeskStringUtils {
/**
* usage : List<Long> searchVirtIds = SuperdeskStringUtils.strArrayConvertToLongList(event.getVirtIds(), ";");
*
* @param ids
* @param splitChat
* @return
*/
public static List<Long> stringArrayConvertToLongList(String ids, String splitChat) {
if (StringUtils.isNotBlank(ids)) {
String[] idArray = ids.split(splitChat);
return Arrays.stream(idArray)
.map(s -> Long.parseLong(s.trim())).collect(Collectors.toList());
} else {
return new ArrayList<>();
}
}
public static List<String> stringArrayConvertToStringList(String ids, String splitChat) {
if (StringUtils.isNotBlank(ids)) {
String[] idArray = ids.split(splitChat);
return Arrays.stream(idArray)
.map(s -> s.trim()).collect(Collectors.toList());
} else {
return new ArrayList<>();
}
}
/**
* @param input
* @return
*/
public static String stringListConvertToString(List<String> input) {
String output = "";
if (CollectionUtils.isNotEmpty(input)) {
output = input.stream().collect(Collectors.joining(","));
}
return output;
}
}
sampleSupTotal = dataList.stream().map(diEx -> diEx.getAllprice()).reduce(BigDecimal.ZERO, BigDecimal::add);
if (codeCurrGroupStatistics.get("HKD") != null) {
sampleSupTotalHKD = dataList.stream().map(diEx -> new BigDecimal(df.format(diEx.getUnitPriceCurr().multiply(diEx.getOpernumber())))).reduce(BigDecimal.ZERO, BigDecimal::add);
} else {
sampleSupTotalHKD = sampleSupTotal.divide(rate, 2);
}
// 以币种 分组统计
Map<String, Long> codeCurrGroupStatistics = dataList.stream().collect(
Collectors.groupingBy(
DepotItemVo4WithInfoEx::getCodeCurr,
Collectors.counting()
)
);
此分组方式有 大作用 , 例程为 Bean 1 or N 字段 的 分组 , 如果以Id来分组为怎样, 很糖吧
Map<String, List<DepotItem>> groupByCodeCurr = result.parallelStream()
.collect(Collectors.groupingBy(DepotItem::getCodeCurr, Collectors.toList()));
// .collect(Collectors.groupingBy(e -> fetchGroupKeyByCodeCurr(e), Collectors.toList()));
private static String fetchGroupKeyById(InvoiceApplyExportExcelForceScore invoiceApplyExportExcelForceScore) {
return invoiceApplyExportExcelForceScore.getInvoiceApplyId() +
"_" + invoiceApplyExportExcelForceScore.getAccountingOrderId() +
"_" + invoiceApplyExportExcelForceScore.getUnifiedOrderGoodsId();
}
private static String fetchGroupKeyByName(InvoiceApplyExportExcelForceScore invoiceApplyExportExcelForceScore) {
return invoiceApplyExportExcelForceScore.getInvoiceNo() +
"_" + invoiceApplyExportExcelForceScore.getAccountingOrderSn() +
"_" + invoiceApplyExportExcelForceScore.getCreditName() +
"_" + invoiceApplyExportExcelForceScore.getGoodsName();
}
private static String[] fieldHeadMode1Static = {"发票申请编号", "对账单编号", "销售单据编号",
"购方名称", "购方税号", "购方地址电话", "购方银行账号", "备注",
"税收编码",
"货品名称", // 侨城汇要改成 货品名称 20200826 周可军 胡军知悉
"规格型号", "计量单位", "商品数量", "销售单价", "积分类型", "结算金额", "税率", "折扣金额",
"供应商"
// "商品信息", "商品编码", "商品规格", "商品数量", "商品单价(折扣后)",
// "商品价格(折扣后)", "商品单位", "财务代码", "收货人姓名", "收货人手机号", "发货时间", "运费", "快递公司", "快递单号", "完成时间", "回款状态", "发票号", "开票时间", "发票状态", "开票申请编号", "开票申请备注", "发票抬头", "发票类型"
};
private static String[] fieldValueMode1Static = {"invoiceNo", "accountingOrderSn", "orderSn",
"enterpriseName", "companyName", "invoiceBank", "invoiceAccount", "remark",
"unifiedOrderGoodsTaxCode",
"goodsName",
"cateNameLv3", "unit", "quantity", "price", "creditName", "balance", "unifiedOrderGoodsTaxRate", "",
"saleName"
};
/**
* 可行 再合并
*
* @param result
* @return
*/
private HSSFWorkbook mergeResultByExcelDebugAndCreateWorkbook(List<InvoiceApplyExportExcelForceScore> result) {
HSSFWorkbook workbook = new HSSFWorkbook();
if (CollectionUtils.isEmpty(result)) {
return workbook;
}
// 得出当前数据 发票申请的 id -> sn
Map<Long, String> invoiceApplyMap = result.stream().collect(Collectors.toMap(
/*key*/InvoiceApplyExportExcelForceScore::getInvoiceApplyId,
/*value*/InvoiceApplyExportExcelForceScore::getInvoiceNo,
/*key重复时*/(key1, key2) -> key2,
LinkedHashMap::new
));
// 因为是可以多选的 所以先按 发票申请Id 分组
Map<Long, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyId = result.parallelStream()
.collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getInvoiceApplyId, Collectors.toList()));
// .collect(Collectors.groupingBy(e -> fetchGroupKey(e), Collectors.toList()));
List<InvoiceApplyExportExcelForceScore> transferListBySheet = null;
List<InvoiceApplyExportExcelForceScore> transferListBySheetMerge = null;
// 因为是可以多选的 所以先按 发票申请Id 分组 每个 entry 是 一份
for (Map.Entry<Long, List<InvoiceApplyExportExcelForceScore>> entry : transferMapGrouopByInvoiceApplyId.entrySet()) {
transferListBySheet = new ArrayList<>();
transferListBySheetMerge = new ArrayList<>();
Map<String, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyIdGroupBy = entry.getValue().parallelStream()
.collect(Collectors.groupingBy(e -> fetchGroupKeyByName(e), Collectors.toList()));
for (Map.Entry<String, List<InvoiceApplyExportExcelForceScore>> _entry : transferMapGrouopByInvoiceApplyIdGroupBy.entrySet()) {
log.info("_groupKey : {} _size : {}", _entry.getKey(), _entry.getValue().size());
if (_entry.getValue().size() > 1) {
// log.info("\n{}", JsonUtils.toJson(_entry.getValue()));
// TODO 处理 合并
InvoiceApplyExportExcelForceScore _merge = new InvoiceApplyExportExcelForceScore();
BeanUtil.copyProperties(_entry.getValue().get(0), _merge);
// 商品数量
_merge.setQuantity(_entry.getValue().stream()
.map(item -> item.getQuantity() == null ? 0 : item.getQuantity())
.reduce(0, Integer::sum));
// // 销售单价
// _merge.setPrice(_entry.getValue().stream()
// .map(item -> item.getPrice() == null ? BigDecimal.ZERO : item.getPrice())
// .reduce(BigDecimal.ZERO, BigDecimal::add));
// 结算金额(积分)
_merge.setBalance(_entry.getValue().stream()
.map(item -> item.getBalance() == null ? BigDecimal.ZERO : item.getBalance())
.reduce(BigDecimal.ZERO, BigDecimal::add));
// 累加
// BigDecimal::add
transferListBySheetMerge.add(_merge);
} else {
transferListBySheetMerge.addAll(_entry.getValue());
}
transferListBySheet.addAll(_entry.getValue());
}
try {
ExcelUtils.createSheetByWorkbook(transferListBySheet, fieldHeadMode1Static, fieldValueMode1Static, workbook, invoiceApplyMap.get(entry.getKey()).toString() + "");
ExcelUtils.createSheetByWorkbook(transferListBySheetMerge, fieldHeadMode1Static, fieldValueMode1Static, workbook, invoiceApplyMap.get(entry.getKey()).toString() + "_合并");
} catch (Exception e) {
}
}
return workbook;
}
/**
* @param result
* @return
*/
private List<InvoiceApplyExportExcelForceScore> mergeResultByExcelDebug(List<InvoiceApplyExportExcelForceScore> result) {
// 因为是可以多选的 所以先按 发票申请Id 分组
Map<Long, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyId = result.parallelStream()
.collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getInvoiceApplyId, Collectors.toList()));
// .collect(Collectors.groupingBy(e -> fetchGroupKey(e), Collectors.toList()));
List<InvoiceApplyExportExcelForceScore> transferList = new ArrayList<>();
// 因为是可以多选的 所以先按 发票申请Id 分组 每个 entry 是 一份
for (Map.Entry<Long, List<InvoiceApplyExportExcelForceScore>> entry : transferMapGrouopByInvoiceApplyId.entrySet()) {
Map<String, List<InvoiceApplyExportExcelForceScore>> transferMapGrouopByInvoiceApplyIdGroupBy = entry.getValue().parallelStream()
.collect(Collectors.groupingBy(e -> fetchGroupKeyById(e), Collectors.toList()));
for (Map.Entry<String, List<InvoiceApplyExportExcelForceScore>> _entry : transferMapGrouopByInvoiceApplyIdGroupBy.entrySet()) {
log.info("_groupKey : {} _size : {}", _entry.getKey(), _entry.getValue().size());
if (_entry.getValue().size() > 1) {
log.info("\n{}", JsonUtils.toJson(_entry.getValue()));
}
transferList.addAll(_entry.getValue());
}
}
return transferList;
}
// TODO
private void mergeResultByExcel(List<InvoiceApplyExportExcelForceScore> result) {
result.parallelStream()
// .collect(Collectors.groupingBy(InvoiceApplyExportExcelForceScore::getUnifiedOrderGoodsId, Collectors.toList()))
.collect(Collectors.groupingBy(e -> fetchGroupKeyById(e), Collectors.toList()))
.forEach((groupKey, transferList) -> {
InvoiceApplyExportExcelForceScore mergeRow = new InvoiceApplyExportExcelForceScore();
log.info("\ngroupKey : {}\ntransferList : {}", groupKey, JsonUtils.toJson(transferList));
// authorizedStationInfo.setStationId(k);
// List<AuthorizedPileInfo> authorizedPileInfos = new ArrayList<>();
// v.parallelStream().collect(Collectors.groupingBy(CrmAuthorizedInfo::getPileId, Collectors.toList())).forEach((k1, v1) -> {
// AuthorizedPileInfo authorizedPileInfo = new AuthorizedPileInfo();
// authorizedPileInfo.setPileId(k1);
// authorizedPileInfo.setGunIds(v1.stream().map(CrmAuthorizedInfo::getGunId).collect(Collectors.toList()));
// authorizedPileInfos.add(authorizedPileInfo);
// });
// authorizedStationInfo.setPileIds(authorizedPileInfos);
// authorizedStationInfos.add(authorizedStationInfo);
});
}
// 处理分页
// 方法1、 总页数 = (总记录数 + 每页数据大小 - 1) / 每页数据大小
// 方法2、 可使用Math.ceil()函数,该函数需要强类型转换(向上取整是指:浮点数取整)
// 总页数 = (int) Math.ceil(总记录数/每页大小)
Integer pageSize = 22;
if (midReceiptItemListUp.size() > pageSize) {
Integer pageTotal = (midReceiptItemListUp.size() + pageSize - 1) / pageSize;
for (Integer pageNum = 1; pageNum <= pageTotal; pageNum++) {
log.info("处理分页 pageNum {} pageTotal {} pageSize {} itemTotal {} ", pageNum, pageTotal, pageSize, midReceiptItemListUp.size());
MonthlySettlementReceiptVo monthlySettlementReceiptVoPage = new MonthlySettlementReceiptVo();
BeanUtil.copyProperties(monthlySettlementReceiptVo, monthlySettlementReceiptVoPage);
monthlySettlementReceiptVoPage.setPageNum(pageNum);
monthlySettlementReceiptVoPage.setPageSize(pageSize);
monthlySettlementReceiptVoPage.setPageTotal(pageTotal);
List<DepotHeadVo4StatementAccount> pageData = midReceiptItemListUp.stream().skip(pageSize * (pageNum - 1)).limit(pageSize).collect(Collectors.toList());
monthlySettlementReceiptVoPage.setList(pageData);
receiptVos.add(monthlySettlementReceiptVoPage);
}
} else {
monthlySettlementReceiptVo.setPageNum(1);
monthlySettlementReceiptVo.setPageSize(pageSize);
monthlySettlementReceiptVo.setPageTotal(1);
receiptVos.add(monthlySettlementReceiptVo);
}
package cn.superdesk.app.core.service;
import cn.superdesk.app.base.exception.ExceptionCode;
import cn.superdesk.app.common.dao.entity.ServiceAppMenuConfigEntity;
import cn.superdesk.app.common.dao.entity.ServiceOrgConfigEntity;
import cn.superdesk.app.common.dao.mapper.ServiceAppMenuConfigEntityMapper;
import cn.superdesk.app.common.dao.mapper.ServiceOrgConfigEntityMapper;
import cn.superdesk.app.core.constants.GlobalConstant;
import cn.superdesk.app.core.dao.entity.AppMenuEntity;
import cn.superdesk.app.core.dao.entity.AppRoleEntity;
import cn.superdesk.app.core.dao.entity.AppRoleFunctionEntity;
import cn.superdesk.app.core.dao.mapper.AppMenuEntityMapper;
import cn.superdesk.app.core.dao.mapper.AppRoleEntityMapper;
import cn.superdesk.app.core.dao.mapper.AppRoleFunctionEntityMapper;
import cn.superdesk.libs.common.SuperdeskBaseException;
import cn.superdesk.libs.common.json.JsonUtils;
import cn.superdesk.libs.common.util.CollectionUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
/**
* @Description: 后台用户与角色
* 整合两个功能
* 1. 现有业务界面 首页 -> 系统管理 -> 管理用户配置 -> 新增用户 -> 项目管理员时 会创建对映或关联项目管理员角色
* 2. 新做业务界面 搜索出 XXX角色 批量 按照 蓝本角色数据(系统级别) 覆盖 按企业X服务X权限 插入 得出最终的 XXX角色权限
* @Author: linjinyu
* @CreateDate: 12/25/19 2:48 PM
* @UpdateUser: linjinyu
* @UpdateDate: 12/25/19 2:48 PM
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
@Slf4j
@Service
public class AppUserAppRoleSupplyService {
@Autowired
private AppRoleEntityMapper appRoleEntityMapper;
@Autowired
private AppRoleService appRoleService;
@Autowired
private AppRoleFunctionEntityMapper appRoleFunctionEntityMapper;
@Autowired
private AppMenuEntityMapper appMenuEntityMapper;
@Autowired
private ServiceOrgConfigEntityMapper serviceOrgConfigEntityMapper;
@Autowired
private ServiceAppMenuConfigEntityMapper serviceAppMenuConfigEntityMapper;
private List<AppRoleFunctionEntity> appRoleXFunctionSample;
/**
* 初始化 蓝本
*
* @param sampleAppRoleId
*/
private void initAppRoleXFunctionSample(Integer sampleAppRoleId) {
if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
appRoleXFunctionSample = selectAppRoleXAppMenuByAppRoleId(sampleAppRoleId);
if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
throw new SuperdeskBaseException(ExceptionCode.RECORD_NOT_EXIST.code, "项目管理员角色 蓝本 权限为空");
}
}
// 如果 样品的数据为空 throw 出错误
}
/**
* 一键 全部 项目管理员 角色 设置 权限
* 1. 获取全部 项目管理员角色
* 2. iterator -> 系统权限 蓝本 -> 业务权限 蓝本
*/
public void oneKeySettingAppRoleType3OrganisationAdministrators() {
List<AppRoleEntity> todoResult = selectAppRoleByAppRoleType3();
todoResult.forEach(appRoleEntity -> {
initAppRoleBySample(appRoleEntity.getId(), null);
});
}
/**
* 第一步 得到 全部 项目管理员 角色
*
* @return
*/
public List<AppRoleEntity> selectAppRoleByAppRoleType3() {
/**
* 角色类型
* 超级管理员=>1
* 系统管理员=>2
* 项目管理员=>3
* 项目普通管理员=>4
* 运营中心管理员=>6
* 运营中心普通管理员=>7
* 运营商管理员=>20
* 渠道商管理员=>21
* 运营商操作员=>22
* 渠道商操作员=>23
*/
// List<AppRoleEntity> appUserXRoleResult = appRoleEntityMapper.findAppRoleByAppUserIdAndRoleType(GlobalConstant.UserType.ORG_TYPE.type, null);
// return appUserXRoleResult;
// SELECT
// id,org_id,type,sys_code,name,description,is_init,floor_repair,status,created_by,created_at,updated_by,updated_at,enabled
// FROM tb_app_role
// WHERE
// org_id >0 and type = 3
// ORDER BY `tb_app_role`.`org_id` ASC
// AppRoleEntity conditions = new AppRoleEntity();
// conditions.setType(GlobalConstant.UserType.ORG_TYPE.type);
// List<AppRoleEntity> appRoleResult = appRoleEntityMapper.select(conditions);
List<AppRoleEntity> appRoleResult = appRoleEntityMapper.selectAppRoleByAppRoleType(GlobalConstant.UserType.ORG_TYPE.type);
return appRoleResult;
}
/**
* 初始化 角色 的 权限 根据 样本 角色id(appRole.id)
*
* @param targetAppRoleId
* @param sampleAppRoleId
*/
public void initAppRoleBySample(
/*目标要初始化的 appUserId*/Integer targetAppRoleId,
/*样品 appUserId*/Integer sampleAppRoleId
) {
// TODO 为了测试 先写死一个吧 环境 dev
// 正式
// * ac : quanx
// * pw : a12345678
// * app_user_id : 1508
// * app_role_id : 10231
// 测试
// * ac : tquanx
// * pw : a12345678
// * app_user_id : 2920
// * app_role_id : 5
if (null == sampleAppRoleId) {
// sampleAppRoleId = 5;
AppRoleEntity sampleAppRole = appRoleService.getRoleByTypeSample(GlobalConstant.UserType.ORG_TYPE.type);
sampleAppRoleId = sampleAppRole.getId();
}
if (null == sampleAppRoleId && sampleAppRoleId.intValue() > 0) {
log.info("sampleAppRoleId:{} 不合法, 初始化失败 ", sampleAppRoleId);
}
if (null == targetAppRoleId && targetAppRoleId.intValue() > 0) {
log.info("targetAppRoleId:{} 不合法, 初始化失败 ", targetAppRoleId);
}
if (targetAppRoleId.equals(sampleAppRoleId)) {
log.info("targetAppRoleId:{} 不要与 sampleAppRoleId:{} 相等, 初始化失败 ", targetAppRoleId, sampleAppRoleId);
}
// 初始化 蓝本
initAppRoleXFunctionSample(sampleAppRoleId);
// 查找出 targetAppRole by Id
AppRoleEntity appRoleEntity = appRoleEntityMapper.selectByPrimaryKey(targetAppRoleId);
log.info("处理 app_role info\n{}", JsonUtils.toJson(appRoleEntity));
// TODO 处理系统权限
processSystemRole(targetAppRoleId);
// TODO 处理业务权限
processBusinessRole(targetAppRoleId);
}
/**
* 处理系统权限
*
* @param targetAppRoleId
*/
private void processSystemRole(Integer targetAppRoleId) {
// 如果蓝本数据 为空 直接 返回 没有什么好处理的
if (CollectionUtils.isEmpty(appRoleXFunctionSample)) {
return;
}
// 原本的 app_user 对映的 app_role 的 菜单权限
List<AppRoleFunctionEntity> appRoleXFunctionResult = selectAppRoleXAppMenuByAppRoleId(targetAppRoleId);
log.info("当前角色权限 app_role X app_menu by app_role_id({}) => app_menu_id.size({})\n{}", targetAppRoleId, appRoleXFunctionResult.size(), JsonUtils.toJson(appRoleXFunctionResult));
// 删除原来 app_role x app_menu
if (CollectionUtils.isNotEmpty(appRoleXFunctionResult)) {
// List<Integer> 转 int[]
// deleteRoleIds.stream().mapToInt(Integer::intValue).toArray()
List<Integer> deleteRoleIds = appRoleXFunctionResult.stream().map(e -> e.getRoleId()).collect(Collectors.toList());
appRoleFunctionEntityMapper.deleteBatch(deleteRoleIds.toArray(new Integer[deleteRoleIds.size()]));
}
// TODO 处理系统级权限
/* ---------------- 插入样本权限 start -------------- */
List<AppRoleFunctionEntity> insertAppRoleFunction = new ArrayList<>();
appRoleXFunctionSample.forEach(appRoleFunctionEntity -> {
AppRoleFunctionEntity sample = new AppRoleFunctionEntity();
sample.setRoleId(targetAppRoleId);
sample.setFunctionId(appRoleFunctionEntity.getFunctionId());
insertAppRoleFunction.add(sample);
});
/* ---------------- 插入样本权限 end -------------- */
appRoleFunctionEntityMapper.insertList(insertAppRoleFunction);
}
/**
* TODO 处理业务权限
*
* @param targetAppRoleId
* @return
*/
private void processBusinessRole(Integer targetAppRoleId) {
List<AppMenuEntity> result = new ArrayList<>();
// 为了简单 没有传入 orgId
// 根据 targetAppRoleId 查出 appRole 得到 orgId
AppRoleEntity appRoleEntity = appRoleEntityMapper.selectByPrimaryKey(targetAppRoleId);
log.info("处理业务权限 targetAppRoleId:{}\n{}", targetAppRoleId, JsonUtils.toJson(appRoleEntity));
// 根据 orgId 得到 服务(上架的)
List<ServiceOrgConfigEntity> serviceXOrgnization = selectServiceConfigByOrgnizationId(appRoleEntity.getOrgId());
log.info("根据 orgId:{}, 得到 服务(上架的) \n {}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceXOrgnization));
List<Integer> serviceTypeInfoIds = serviceXOrgnization.stream().map(e -> e.getServiceTypeId()).collect(Collectors.toList());
log.info("项目:{} \n服务上线情况为:\n{}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceTypeInfoIds));
// 如果 项目 服务上架 情况为空 直接 返回 没什么好处理的
if (CollectionUtils.isEmpty(serviceTypeInfoIds)) {
return;
}
// 根据 服务集合 -> service_type_info_ids 得到 serviceAppMenuConfig 集合
List<ServiceAppMenuConfigEntity> serviceAppMenuConfigEntityList = serviceAppMenuConfigEntityMapper.queryByServiceTypeInfoIds(serviceTypeInfoIds);
log.info("项目:{} \n服务上线X权限为:\n{}", appRoleEntity.getOrgId(), JsonUtils.toJson(serviceAppMenuConfigEntityList));
// 如果 项目有 对映的 服务上线 但这个 服务对映的权限是空的 直接 返回 没什么好处理的
if (CollectionUtils.isEmpty(serviceAppMenuConfigEntityList)) {
return;
}
// 拼装成 AppMenuEntity List 返回
// TODO 处理业务级权限 是有点多余 先接上吧
/* ---------------- 插入业务权限 start -------------- */
List<AppRoleFunctionEntity> insertAppRoleFunction = new ArrayList<>();
serviceAppMenuConfigEntityList.forEach(serviceAppMenuConfigEntity -> {
AppRoleFunctionEntity sample = new AppRoleFunctionEntity();
sample.setRoleId(targetAppRoleId);
sample.setFunctionId(serviceAppMenuConfigEntity.getFunctionId());
insertAppRoleFunction.add(sample);
});
/* ---------------- 插入业务权限 start -------------- */
appRoleFunctionEntityMapper.insertList(insertAppRoleFunction);
}
// private List<AppMenuEntity> processBusinessRole(AppRoleEntity appRoleEntity) {
//
// // init return
// List<AppMenuEntity> sourceAppMenuList = new ArrayList<>();
// List<AppMenuEntity> deDuplicationAppMenuList = new ArrayList<>();
// // app_user -> orgnization -> service -> service2app_menu -> app_menu
//
//
//// orgnization X service
//
// // 查出来的数据 不是全部都有权限的
// List<ServiceOrgConfigEntity> serviceXOrgnization = selectServiceConfigByOrgnizationId(appRoleEntity.getOrgId());
//
// if (CollectionUtils.isNotEmpty(serviceXOrgnization)) {
// serviceXOrgnization.forEach(serviceOrgConfigEntity -> {
//
// // service x service2app_menu
// if (serviceId2AppMenuId.containsKey(serviceOrgConfigEntity.getServiceTypeId())) {
//
// List<Integer> appMenuIdRootList = serviceId2AppMenuId.get(serviceOrgConfigEntity.getServiceTypeId());
//
// appMenuIdRootList.forEach(appMenuId -> {
//
// sourceAppMenuList.addAll(filterAppMenu2Tree(appMenuId));
// });
//
// log.info("service type id{} => app menu ids{}");
//
// } else {
// log.info("service type id {} 没有后台权限");
// }
// });
// }
//
//// log.info(JsonUtils.toPrettyJson(serviceId2AppMenuId));
// log.info("到得菜单权限为 size({}) \n{}", sourceAppMenuList.size(), JsonUtils.toJson(sourceAppMenuList));
//
//
// deDuplicationAppMenuList = filterAppRole(sourceAppMenuList);
// log.info("过滤菜单权限为 size({}) \n{}", deDuplicationAppMenuList.size(), JsonUtils.toJson(deDuplicationAppMenuList));
//
// return deDuplicationAppMenuList;
//
// }
// private List<AppMenuEntity> filterAppRole(List<AppMenuEntity> maybeRepeat) {
//
// // 临时存储
// List<Integer> tempIds = new ArrayList<>();
//
// return maybeRepeat.stream().filter(entity -> {
// boolean isExist = !tempIds.contains(entity.getId());
// tempIds.add(entity.getId());
// return isExist;
// }).collect(Collectors.toList());
//
//
// }
// /**
// * 第一步 得到 全部 项目管理员 角色
// *
// * @return
// */
// private List<AppRoleEntity> selectAppRoleByAppRoleType3() {
// /**
// * 角色类型
// * 超级管理员=>1
// * 系统管理员=>2
// * 项目管理员=>3
// * 项目普通管理员=>4
// * 运营中心管理员=>6
// * 运营中心普通管理员=>7
// * 运营商管理员=>20
// * 渠道商管理员=>21
// * 运营商操作员=>22
// * 渠道商操作员=>23
// */
//// List<AppRoleEntity> appUserXRoleResult = appRoleEntityMapper.findAppRoleByAppUserIdAndRoleType(GlobalConstant.UserType.ORG_TYPE.type, null);
//// return appUserXRoleResult;
//
//
// AppRoleEntity conditions = new AppRoleEntity();
// conditions.setType(GlobalConstant.UserType.ORG_TYPE.type);
// List<AppRoleEntity> appRoleResult = appRoleEntityMapper.select(conditions);
//
// return appRoleResult;
// }
/**
* 查出 app_role x app_menu
*
* @param appRoleId
* @return
*/
private List<AppRoleFunctionEntity> selectAppRoleXAppMenuByAppRoleId(Integer appRoleId) {
// SELECT * FROM `tb_app_role_function` WHERE `role_id` = 9143 ORDER BY function_id ASC
AppRoleFunctionEntity conditions = new AppRoleFunctionEntity();
conditions.setRoleId(appRoleId);
List<AppRoleFunctionEntity> appRoleXFunctionResult = appRoleFunctionEntityMapper.select(conditions);
return appRoleXFunctionResult;
}
// private static List<AppMenuEntity> appMenuTable;
// private static Map<Integer, List<AppMenuEntity>> subAppMenuTree = new HashMap<>();
//
// private void initAppMenuTable() {
//
// if (CollectionUtils.isEmpty(appMenuTable)) {
// appMenuTable = appMenuEntityMapper.selectAll();
// }
//
//
// }
/**
* 业务权限 时
*
* @param orgnizationId
* @return
*/
private List<ServiceOrgConfigEntity> selectServiceConfigByOrgnizationId(Integer orgnizationId) {
// SELECT * FROM `tb_service_org_config`
ServiceOrgConfigEntity conditions = new ServiceOrgConfigEntity();
conditions.setOrgId(orgnizationId);
/**
* 状态:0-下线;1-上线;2-灰度
*/
conditions.setStatus(1);
/**
* 类型:0-项目;1-企业
*/
conditions.setType(0);
conditions.setEnabled(1);
List<ServiceOrgConfigEntity> result = serviceOrgConfigEntityMapper.select(conditions);
return result;
}
// SELECT * FROM `tb_service_type_info` WHERE `link_url_type` = 0
// SELECT soc.id,soc.service_type_id,sti.* FROM `tb_service_org_config` soc
// LEFT JOIN tb_service_type_info sti ON soc.`service_type_id` = sti.id AND sti.`link_url_type` = 0
// WHERE
// soc.`status` = 1
// AND soc.`type` = 0
// ORDER BY soc.org_id ASC
/**
* 某 app_menu 树根 的全部节点
* @param appMenuidRoot
* @return
*/
// private List<AppMenuEntity> filterAppMenu2Tree(Integer appMenuidRoot) {
//
// // 查出所有菜单放入内存
// initAppMenuTable();
//
// if (subAppMenuTree.containsKey(appMenuidRoot)) {
//
// return subAppMenuTree.get(appMenuidRoot);
//
// } else {
//
// List<AppMenuEntity> result = new ArrayList<>();
//
// List<AppMenuEntity> level1 = new ArrayList<>();
// List<AppMenuEntity> level2 = new ArrayList<>();
// List<AppMenuEntity> level3 = new ArrayList<>();
//
// // 目录
// level1.addAll(appMenuTable.stream().filter(e -> e.getId().equals(appMenuidRoot)).collect(Collectors.toList()));
// // 菜单
// level2.addAll(appMenuTable.stream().filter(e -> e.getParentCode().equals(appMenuidRoot)).collect(Collectors.toList()));
// // 操作
// level2.forEach(appMenuEntity -> {
// level3.addAll(appMenuTable.stream().filter(e -> e.getParentCode().equals(appMenuEntity.getId())).collect(Collectors.toList()));
// });
//
// result.addAll(level1);
// result.addAll(level2);
// result.addAll(level3);
//
// subAppMenuTree.put(appMenuidRoot, result);
//
// return result;
// }
//
//
// }
}
package cn.superdesk.uniorder.utils.lamda;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
/**
* @Description: LamdaUtils
* @Author: linjinyu
* @CreateDate: 6/23/20 5:14 PM
* @UpdateUser: linjinyu
* @UpdateDate: 6/23/20 5:14 PM
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
public class LamdaUtils {
/**
* distinctByKey 自己定义 针对属性去重
* <p>
* usage:
* List<InvoiceOrder> invoiceOrderList = invoiceOrderMapper.selectByExample(example);
* <p>
* if (CollectionUtils.isNotEmpty(invoiceOrderList)) {
* // 得出受影响的对账单 ids
* affectedAccountingOrderIds = invoiceOrderList.stream().filter(LamdaUtils.distinctByKey(o -> o.getDzId())).map(o -> o.getDzId()).collect(Collectors.toList());
* }
*
* @param keyExtractor
* @param <T>
* @return
*/
public static <T> Predicate<T> distinctByKey(Function<? super T, Object> keyExtractor) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
}
public static <T extends Object> T filter(List<T> objs, Predicate<T> predicate) {
return objs.stream()
.filter(predicate)
.findAny()
.orElse(null);
}
/**
* 根据多个判断条件, 对list数据按优先级排序
* list 需要过滤的数据
* predicates 多个判断条件
*/
public static <T extends Object> List<T> filters(List<T> list, List<Predicate<T>> predicates) {
List<T> resultList = new ArrayList();
Stream<T> stream = list.stream();
// 循环判断条件list
for (int i = 0, psize = predicates.size(), lsize = list.size(); resultList.size() < lsize && i < psize; i++) {
Predicate<T> predicate = predicates.get(i);
// stream.filter 过滤掉 符合条件的, 同时把符合条件的添加到 待返回的list
stream = stream.filter(e -> {
if (predicate.test(e)) {
resultList.add(e);
return false;
}
return true;
});
}
long count = stream.count();
return resultList;
}
}
package cn.superdesk.uniorder.service.base;
import cn.superdesk.libs.common.json.JsonUtils;
import cn.superdesk.libs.common.util.CollectionUtils;
import cn.superdesk.uniorder.dao.entity.base.*;
import cn.superdesk.uniorder.dao.mapper.base.UnifiedOrderCreditMapper;
import cn.superdesk.uniorder.dao.mapper.base.UnifiedOrderGoodsMapper;
import cn.superdesk.uniorder.utils.lamda.LamdaUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.function.Predicate;
/**
* @Description: 重构 处理 合并数据 不写 interface
* @Author: linjinyu
* @CreateDate: 9/15/20 5:03 PM
* @UpdateUser: linjinyu
* @UpdateDate: 9/15/20 5:03 PM
* @UpdateRemark: 修改内容
* @Version: 1.0
*/
@Slf4j
@Service
public class CommonOrderProcessService {
@Autowired
private UnifiedOrderGoodsMapper unifiedOrderGoodsMapper;
@Autowired
private UnifiedOrderCreditMapper unifiedOrderCreditMapper;
/**
* 处理 kdfka 重推单 问题
*
* @param unifiedOrderEntity
* @param processUnifiedOrderGoodsList
*/
public void processUnifiedOrderGoodsBykafkaPushOrderReceive(UnifiedOrder unifiedOrderEntity, List<UnifiedOrderGoods> processUnifiedOrderGoodsList) {
// 一般订单
// 有订单时 先删除在保存商品
// unifiedOrderGoodsMapperEx.deleteBySn(unifiedOrder.getOrderSn());
// for (UnifiedOrderGoods unifiedOrderGoods : unifiedOrderGoodsList) {
// unifiedOrderGoodsMapper.insertSelective(unifiedOrderGoods);
// }
// 积分订单
// 之前是先删除再 插入
// UnifiedOrderGoodsExample scoreOrderGoodsExample4Delete = new UnifiedOrderGoodsExample();
// scoreOrderGoodsExample4Delete.createCriteria()
// .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
// unifiedOrderGoodsMapper.deleteByExample(scoreOrderGoodsExample4Delete);
// processUnifiedOrderGoodsList.forEach(unifiedOrderGoods -> {
// unifiedOrderGoodsMapper.insert(unifiedOrderGoods);
// });
UnifiedOrderGoodsExample orderGoodsExample4SaveOrUpdate = new UnifiedOrderGoodsExample();
orderGoodsExample4SaveOrUpdate.createCriteria()
.andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
List<UnifiedOrderGoods> existsUnifiedOrderGoodsList = unifiedOrderGoodsMapper.selectByExample(orderGoodsExample4SaveOrUpdate);
log.error("\n\n\nOrderGoods: \n已存在数据 : \n{}\n过来的数据 : \n{}\n\n\n",
JsonUtils.toJson(existsUnifiedOrderGoodsList),
JsonUtils.toJson(processUnifiedOrderGoodsList)
);
List<UnifiedOrderGoods> finalUnifiedOrderGoodsList = new ArrayList<>();
for (UnifiedOrderGoods processOrderGoods : processUnifiedOrderGoodsList) {
/****************************************** 兼容 情况 ******************************************/
// 新过来的数据在老的是不是存在 因为在 同一个 order_sn 下 goods_id 是唯一的 ,所以成立
// TODO 问题点 如果有 附件 赠品 就会有问题
UnifiedOrderGoods isExistsOrderGoods = null;
boolean isRetry = false;
// 逻辑是 运费 必定是不成立
if (processOrderGoods.getOutSnapshotOrderGoodsId() != null && !processOrderGoods.getOutSnapshotOrderGoodsId().equals(0L)) {
isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getOutSnapshotOrderGoodsId().equals(r.getOutSnapshotOrderGoodsId()));
if (null == isExistsOrderGoods) {
isRetry = true;
}
} else {
// 运费的补刀
isRetry = true;
}
if (isRetry) {
if(null != processOrderGoods.getGoodsId()){
isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getGoodsId().equals(r.getGoodsId()));
}
// 再补 202009151941 by linjinyu 发现 生产环境上 unified_order_goods.goods_id 是NULL 数据
if (null == isExistsOrderGoods) {
isExistsOrderGoods = LamdaUtils.filter(existsUnifiedOrderGoodsList, r -> processOrderGoods.getGoodsName().equals(r.getGoodsName()));
}
}
/****************************************** 兼容 情况 ******************************************/
// 存在
if (null != isExistsOrderGoods) {
// TODO 要更新什么信息 从而没问题?
isExistsOrderGoods.setOutSnapshotOrderGoodsId(processOrderGoods.getOutSnapshotOrderGoodsId());
isExistsOrderGoods.setGoodsId(processOrderGoods.getGoodsId());
isExistsOrderGoods.setCateIdLv1(processOrderGoods.getCateIdLv1());
isExistsOrderGoods.setCateIdLv1(processOrderGoods.getCateIdLv2());
isExistsOrderGoods.setCateIdLv3(processOrderGoods.getCateIdLv3());
isExistsOrderGoods.setCateNameLv1(processOrderGoods.getCateNameLv1());
isExistsOrderGoods.setCateNameLv2(processOrderGoods.getCateNameLv2());
isExistsOrderGoods.setCateNameLv3(processOrderGoods.getCateNameLv3());
isExistsOrderGoods.setUnit(processOrderGoods.getUnit());
isExistsOrderGoods.setTaxRate(processOrderGoods.getTaxRate());
isExistsOrderGoods.setTaxCode(processOrderGoods.getTaxCode());
isExistsOrderGoods.setFiscalCode(processOrderGoods.getFiscalCode());
// unifiedOrderGoodsMapper.updateByPrimaryKeySelective(isExistsOrderGoods);
finalUnifiedOrderGoodsList.add(isExistsOrderGoods);
} else {
// unifiedOrderGoodsMapper.insert(processOrderGoods);
finalUnifiedOrderGoodsList.add(processOrderGoods);
}
}
UnifiedOrderGoodsExample scoreOrderGoodsExample4Delete = new UnifiedOrderGoodsExample();
scoreOrderGoodsExample4Delete.createCriteria()
.andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
unifiedOrderGoodsMapper.deleteByExample(scoreOrderGoodsExample4Delete);
finalUnifiedOrderGoodsList.forEach(unifiedOrderGoods -> {
unifiedOrderGoodsMapper.insert(unifiedOrderGoods);
});
}
/**
* 处理 kdfka 重推单 问题
* <p>
* 处理方法
* kafkaUnifiedOrderReceive
* kafkaScoreOrderReceive
*
* @param unifiedOrderEntity
* @param processUnifiedOrderCreditList
*/
public void processUnifiedOrderCreditBykafkaPushOrderReceive(UnifiedOrder unifiedOrderEntity, List<UnifiedOrderCredit> processUnifiedOrderCreditList) {
// 积分订单
// 之前是先删除再 插入
// UnifiedOrderCreditExample scoreOrderCreditExample4Delete = new UnifiedOrderCreditExample();
// scoreOrderCreditExample4Delete.createCriteria()
// .andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
// unifiedOrderCreditMapper.deleteByExample(scoreOrderCreditExample4Delete);
// processUnifiedOrderCreditList.forEach(unifiedOrderCredit -> {
// unifiedOrderCreditMapper.insert(unifiedOrderCredit);
// });
UnifiedOrderCreditExample scoreOrderCreditExample4SaveOrUpdate = new UnifiedOrderCreditExample();
scoreOrderCreditExample4SaveOrUpdate.createCriteria()
.andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
List<UnifiedOrderCredit> existsUnifiedOrderCreditList = unifiedOrderCreditMapper.selectByExample(scoreOrderCreditExample4SaveOrUpdate);
log.error("\n\n\nOrderCredit: \n已存在数据 : \n{}\n过来的数据 : \n{}\n\n\n",
JsonUtils.toJson(existsUnifiedOrderCreditList),
JsonUtils.toJson(processUnifiedOrderCreditList)
);
List<UnifiedOrderCredit> finalUnifiedOrderCreditList= new ArrayList<>();
for (UnifiedOrderCredit processOrderCredit : processUnifiedOrderCreditList) {
/****************************************** 情况1 ******************************************/
// 新过来的数据在老的是不是存在
List<UnifiedOrderCredit> isExistsOrderCreditList = null;
UnifiedOrderCredit isExistsOrderCredit = null;
boolean isRetry = false;
if (processOrderCredit.getOutSnapshotOrderCreditId() != null && !processOrderCredit.getOutSnapshotOrderCreditId().equals(0L)) {
isExistsOrderCredit = LamdaUtils.filter(existsUnifiedOrderCreditList, r -> processOrderCredit.getOutSnapshotOrderCreditId().equals(r.getOutSnapshotOrderCreditId()));
if (null == isExistsOrderCredit) {
isRetry = true;
}
} else {
isRetry = true;
}
if (isRetry) {
// // 查询条件 如果 goods_id 为 0 条数大于 1 是会有问题 0 默认只有运费 , 如果 附件与赠品过来的情况 就会有问题,具体的问题再写吧
List<Predicate<UnifiedOrderCredit>> predicates = new ArrayList();
predicates.add(r -> processOrderCredit.getCreditType().equals(r.getCreditType()));
predicates.add(r -> processOrderCredit.getCreditName().equals(r.getCreditName()));
predicates.add(r -> processOrderCredit.getGoodsId().equals(r.getGoodsId()));
// predicates.add(r -> processOrderCredit.getBalance().equals(r.getBalance()));
// predicates.add(r -> NumberUtil.compare(processOrderCredit.getBalance(),r.getBalance()));
predicates.add(r -> processOrderCredit.getBalance().compareTo(r.getBalance()) == 0);
predicates.add(r -> processOrderCredit.getBatchs().equals(r.getBatchs()));
//
// // 新过来的数据在老的是不是存在
isExistsOrderCreditList = LamdaUtils.filters(existsUnifiedOrderCreditList, predicates);
// isExistsOrderCredit = LamdaUtils.filter(existsUnifiedOrderCreditList, r -> processOrderCredit.getGoodsId().equals(r.getGoodsId()));
}
/****************************************** 情况1 ******************************************/
// 存在
if (null != isExistsOrderCredit) {
// TODO 好像没什么好更新的
isExistsOrderCredit.setCreditType(processOrderCredit.getCreditType());
isExistsOrderCredit.setCreditName(processOrderCredit.getCreditName());
isExistsOrderCredit.setOutSnapshotOrderCreditId(processOrderCredit.getOutSnapshotOrderCreditId());
isExistsOrderCredit.setGoodsId(processOrderCredit.getGoodsId());
isExistsOrderCredit.setDailyAccountType(processOrderCredit.getDailyAccountType());
isExistsOrderCredit.setBatchs(processOrderCredit.getBatchs());
isExistsOrderCredit.setBalance(processOrderCredit.getBalance());
isExistsOrderCredit.setEnterpriseId(processOrderCredit.getEnterpriseId());
isExistsOrderCredit.setMemberId(processOrderCredit.getMemberId());
processOrderCredit.setPayStatus(processOrderCredit.getPayStatus());
processOrderCredit.setPayType(processOrderCredit.getPayType());
isExistsOrderCredit.setUpdateUserId(2L);
isExistsOrderCredit.setUpdateTime(new Date());
// unifiedOrderCreditMapper.updateByPrimaryKeySelective(isExistsOrderCredit);
finalUnifiedOrderCreditList.add(isExistsOrderCredit);
} else {
// unifiedOrderCreditMapper.insert(processOrderCredit);
//
finalUnifiedOrderCreditList.add(processOrderCredit);
}
if (CollectionUtils.isNotEmpty(isExistsOrderCreditList) && isRetry) {
// TODO 怎样合并呢?
if (isExistsOrderCreditList.size() > 1) {
} else if (isExistsOrderCreditList.size() == 1){
isExistsOrderCredit = isExistsOrderCreditList.get(0);
isExistsOrderCredit.setCreditName(processOrderCredit.getCreditName());
isExistsOrderCredit.setOutSnapshotOrderCreditId(processOrderCredit.getOutSnapshotOrderCreditId());
isExistsOrderCredit.setUpdateUserId(3L);
isExistsOrderCredit.setUpdateTime(new Date());
// unifiedOrderCreditMapper.updateByPrimaryKeySelective(isExistsOrderCredit);
finalUnifiedOrderCreditList.add(isExistsOrderCredit);
}
}
}
UnifiedOrderCreditExample scoreOrderCreditExample4Delete = new UnifiedOrderCreditExample();
scoreOrderCreditExample4Delete.createCriteria()
.andOrderSnEqualTo(unifiedOrderEntity.getOrderSn());
unifiedOrderCreditMapper.deleteByExample(scoreOrderCreditExample4Delete);
finalUnifiedOrderCreditList.forEach(unifiedOrderCredit -> {
unifiedOrderCreditMapper.insert(unifiedOrderCredit);
});
}
}
未标明原创文章均为采集,版权归作者所有,转载无需和我联系,请注明原出处,南摩阿彌陀佛,知识,不只知道,要得到
最新评论