From 8810305839eb5eb0b0cdf0d065fb3a5edc793d65 Mon Sep 17 00:00:00 2001 From: MiratowA <2635891552@qq.com> Date: Wed, 9 Aug 2023 11:29:01 +0000 Subject: [PATCH] =?UTF-8?q?add=20Java/DetailUtil.=20=E5=90=8C=E4=BA=8B?= =?UTF-8?q?=E5=B0=81=E8=A3=85=E7=9A=84Util=E7=B1=BB=EF=BC=8C=E5=A6=82?= =?UTF-8?q?=E4=BD=95=E8=AF=84=E4=BB=B7=EF=BC=9F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: MiratowA <2635891552@qq.com> --- Java/DetailUtil | 296 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 Java/DetailUtil diff --git a/Java/DetailUtil b/Java/DetailUtil new file mode 100644 index 0000000..b6ad6b9 --- /dev/null +++ b/Java/DetailUtil @@ -0,0 +1,296 @@ +package com.manxiang.project_server.utils; + +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.manxiang.project_server.service.IProductDetailService; +import lombok.experimental.UtilityClass; +import lombok.val; +import org.dromara.hutool.core.collection.CollUtil; +import org.dromara.streamquery.stream.core.collection.Lists; +import org.dromara.streamquery.stream.core.collection.Maps; +import org.dromara.streamquery.stream.core.collection.Sets; +import org.dromara.streamquery.stream.core.optional.Opp; +import org.dromara.streamquery.stream.core.stream.Steam; +import org.dromara.streamquery.stream.plugin.mybatisplus.Database; +import org.dromara.streamquery.stream.plugin.mybatisplus.OneToMany; +import org.dromara.streamquery.stream.plugin.mybatisplus.WrapperHelper; +import org.jeecg.common.enums.type.DetailDomainEnum; +import org.jeecg.common.enums.type.EditTypeEnum; +import org.jeecg.common.enums.type.ProductDetailTypeEnum; +import org.jeecg.common.enums.type.YesOrNoEnum; +import org.jeecg.common.pojo.bo.RelationBO; +import org.jeecg.common.pojo.dto.DetailSyncDTO; +import org.jeecg.common.pojo.dto.ProductDetailDTO; +import org.jeecg.common.pojo.po.*; +import org.jeecg.common.pojo.vo.*; +import org.jeecg.common.util.ConvertUtil; +import org.jeecg.common.util.JacksonUtil; +import org.jeecg.common.util.MpUtil; +import org.jeecg.common.util.SpringContextHolder; + +import java.math.BigDecimal; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.function.Function; + +import static java.util.Comparator.*; +import static org.dromara.hutool.core.text.CharSequenceUtil.contains; +import static org.dromara.streamquery.stream.core.lambda.function.SerFunc.entryFunc; +import static org.dromara.streamquery.stream.core.stream.collector.Collective.entryToMap; +import static org.dromara.streamquery.stream.core.stream.collector.Collective.groupingBy; + +/** + * @author VampireAchao + * @since 2022/12/1 10:46 + */ +@UtilityClass +public class DetailUtil { + + private static final IProductDetailService PRODUCT_DETAIL_SERVICE = SpringContextHolder.getBean(IProductDetailService.class); + public static final String BRACKET_PATTERN = "（[^()]*）"; + + public static List findFormValues(ProductDetailVO detailVO) { + final Steam cardSteam = Opp.of(detailVO) + .map(ProductDetailVO::getCardList).map(Steam::of).orElseGet(Steam::empty); + return cardSteam.flat(ProductDetailCardVO::getDataList) + .flat(ProductDetailSectionVO::getFormValues).map(ProductDetailFormVO::getValue).toList(); + } + + public static String findFormMatchValue(ProductDetailVO detailVO) { + return Opp.ofColl(findFormValues(detailVO)).map(l -> l.get(0)).get(); + } + + public static BigDecimal findCalcValue(ProductDetailVO detailVO) { + return Opp.of(findFormMatchValue(detailVO)) + .flatMap(val -> Opp.ofTry(() -> new BigDecimal(val))).orElse(null); + } + + public static Map> + getChapterIdDetailTitleValueMap(List chapterIds, List titlesToLike) { + if (CollUtil.isEmpty(chapterIds) || CollUtil.isEmpty(titlesToLike)) { + return Maps.empty(); + } + val chapterIdTitleDetailMap = getTypeRelationIdTitleDetailMap(Lists.empty(), + chapterIds, titlesToLike) + .getOrDefault(ProductDetailTypeEnum.CHAPTER, Maps.empty()); + final Map> chapterIdDetailTitleValueMap = + Steam.of(chapterIdTitleDetailMap).map(entryFunc((chapterId, titleDetailMap) -> + Maps.entry(chapterId, Steam.of(titleDetailMap).map(entryFunc((title, detail) -> { + if (Objects.nonNull(title)) { + title = title.replaceAll(BRACKET_PATTERN, "").trim(); + } + return Maps.entry(title, DetailUtil.findFormMatchValue(detail)); + })).collect(entryToMap())))).collect(entryToMap()); + return chapterIdDetailTitleValueMap; + } + + public static T getDetailByTitle(Map titleDetailMap, String detailTitle) { + if (CollUtil.isEmpty(titleDetailMap)) { + return null; + } + final T detail = titleDetailMap.get(detailTitle); + if (detail != null) { + return detail; + } + final String title = Steam.of(titleDetailMap.keySet()) + .findFirst(t -> contains(t, detailTitle) || + contains(detailTitle, t)).orElse(detailTitle); + return titleDetailMap.get(title); + } + + public static void saveDepart(List vos) { + MpUtil.saveRelation(new RelationBO() {{ + setMainList(vos); + setMainKey(ProductDetailVO::getId); + setAttachKey(SysDepartVO::getDepartId); + setAttachGetter(ProductDetailVO::getDepartments); + setRelationMain(DepartProductDetail::getDetailId); + setRelationAttach(DepartProductDetail::getDepartId); + }}).execute(); + } + + public static void savePosition(List vos) { + MpUtil.saveRelation(new RelationBO() {{ + setMainList(vos); + setMainKey(ProductDetailVO::getId); + setAttachKey(PositionVO::getPositionId); + setAttachGetter(ProductDetailVO::getPositions); + setRelationMain(PositionProductDetail::getDetailId); + setRelationAttach(PositionProductDetail::getPositionId); + setAttachCompares(Lists.of(PositionVO::getType)); + setRelationCompares(Lists.of(PositionProductDetail::getType)); + }}).execute(); + } + + public static void saveStage(List vos) { + MpUtil.saveRelation(new RelationBO() {{ + setMainList(vos); + setMainKey(ProductDetailVO::getId); + setAttachKey(DetailStageVO::getStageId); + setAttachGetter(ProductDetailVO::getStages); + setRelationMain(StageProductDetail::getDetailId); + setRelationAttach(StageProductDetail::getStageId); + setAttachCompares(Lists.of(DetailStageVO::getType)); + setRelationCompares(Lists.of(StageProductDetail::getType)); + }}).execute(); + } + + public static boolean isRequire(ProductDetailVO detail) { + if (Objects.isNull(detail)) { + return false; + } + return Steam.of(detail.getCardList()).flat(ProductDetailCardVO::getDataList) + .anyMatch(section -> YesOrNoEnum.YES.equals(section.getValueRequired())); + } + + public static Map>> + getTypeRelationIdTitleDetailMap(List productIds, + List chapterIds, + List titlesToLike) { + if (Lists.isEmpty(productIds) && Lists.isEmpty(chapterIds)) { + return Maps.empty(); + } + val detailWrapper = Wrappers.lambdaQuery(ProductDetail.class) + .eq(ProductDetail::getDomain, DetailDomainEnum.PRODUCT_DETAIL) + .or().eq(ProductDetail::getDomain, DetailDomainEnum.TASK_DETAIL) + .orderByAsc(ProductDetail::getSort); + if (Lists.isNotEmpty(titlesToLike)) { + WrapperHelper.multi(detailWrapper, titlesToLike, + (wrap, title) -> wrap.or().like(ProductDetail::getTitle, title)); + } + val details = ConvertUtil.convertList( + Database.list(detailWrapper), + ProductDetailVO.class); + PRODUCT_DETAIL_SERVICE.resolveAdditional(details, new ProductDetailDTO()); + val idDetailMap = Steam.of(details).toMap(ProductDetailVO::getId); + val typeRelationIdDetailIdSectionIdFormValuesMap = OneToMany + .of(ProductDetailForm::getType) + .condition(wrapper -> wrapper.isNotNull(ProductDetailForm::getValue) + .ne(ProductDetailForm::getValue, "") + .nested(wrap -> wrap.nested(Lists.isNotEmpty(productIds), + w -> w + .eq(ProductDetailForm::getType, ProductDetailTypeEnum.PRODUCT) + .in(ProductDetailForm::getRelationId, Sets.ofColl(productIds))) + .or(Lists.isNotEmpty(chapterIds), + w -> w + .eq(ProductDetailForm::getType, ProductDetailTypeEnum.CHAPTER) + .in(ProductDetailForm::getRelationId, + Sets.ofColl(chapterIds))))) + .value(new ProductDetailFormVO().converter()) + .query(HashMap::new, groupingBy(ProductDetailForm::getRelationId, + groupingBy(ProductDetailForm::getDetailId, + groupingBy(ProductDetailForm::getSectionId)))); + return Steam.of(typeRelationIdDetailIdSectionIdFormValuesMap) + .map(entryFunc((type, relationIdDetailIdSectionIdFormValuesMap) -> + Maps.entry(type, Steam.of(relationIdDetailIdSectionIdFormValuesMap) + .map(entryFunc((relationId, detailIdSectionIdFormValuesMap) -> + Maps.entry(relationId, Steam.of(detailIdSectionIdFormValuesMap) + .map(entryFunc((detailId, sectionIdFormValuesMap) -> { + val detail = + JacksonUtil.clone(idDetailMap.get(detailId)); + if (Objects.isNull(detail)) { + return null; + } + Steam.of(detail.getCardList()) + .forEach(card -> Steam.of(card.getDataList()) + .forEach(section -> section.setFormValues( + sectionIdFormValuesMap + .getOrDefault(section.getId() + , Lists.empty()) + ))); + return Maps.entry(detail.getTitle(), detail); + })).nonNull().collect(entryToMap())))) + .collect(entryToMap())))) + .collect(entryToMap()); + } + + public static Map> getChapterIdDetailsMap(List chapterIds) { + val detailWrapper = Wrappers.lambdaQuery(ProductDetail.class) + .eq(ProductDetail::getDomain, DetailDomainEnum.PRODUCT_DETAIL) + .or().eq(ProductDetail::getDomain, DetailDomainEnum.TASK_DETAIL); + val details = ConvertUtil.convertList( + Database.list(detailWrapper), ProductDetailVO.class); + PRODUCT_DETAIL_SERVICE.resolveAdditional(details, new ProductDetailDTO() {{ + setEditType(EditTypeEnum.TASK); + }}); + val relationIdDetailIdSectionIdFormValuesMap = + OneToMany.of(ProductDetailForm::getRelationId).in(chapterIds) + .condition(wrapper -> wrapper.isNotNull(ProductDetailForm::getValue) + .ne(ProductDetailForm::getValue, "")) + .value(new ProductDetailFormVO().converter()) + .query(HashMap::new, + groupingBy(ProductDetailForm::getDetailId, + groupingBy(ProductDetailForm::getSectionId))); + return Steam.of(chapterIds).toMap(Function.identity(), chapterId -> { + val detailIdSectionIdFormValuesMap = relationIdDetailIdSectionIdFormValuesMap + .getOrDefault(chapterId, Maps.empty()); + return Steam.of(details).map(detail -> { + val sectionIdFormValuesMap = detailIdSectionIdFormValuesMap + .getOrDefault(detail.getId(), Maps.empty()); + detail = JacksonUtil.clone(detail); + Steam.of(detail.getCardList()).forEach(card -> Steam.of(card.getDataList()) + .forEach(section -> section.setFormValues( + sectionIdFormValuesMap.getOrDefault(section.getId(), Lists.empty())))); + return detail; + }).toList(); + }); + } + + public static void + appendForm(List formValues, + Map>> typeRelationIdTitleDetaiMap, + ProductDetailTypeEnum type, Integer relationId, String title, String value) { + val detailOpt = Steam.of(typeRelationIdTitleDetaiMap.getOrDefault(type, Maps.empty()) + .getOrDefault(relationId, Maps.empty()).values()) + .sorted(comparing(ProductDetailVO::getSort, + nullsLast(naturalOrder()))) + .findFirst(d -> d.getTitle().contains(title)); + if (!detailOpt.isPresent()) { + return; + } + val detail = detailOpt.get(); + if (Lists.isEmpty(detail.getCardList())) { + return; + } + val card = detail.getCardList().get(0); + if (Lists.isEmpty(card.getDataList())) { + return; + } + val section = card.getDataList().get(0); + final ProductDetailFormVO formValue; + if (Lists.isNotEmpty(section.getFormValues())) { + formValue = section.getFormValues().get(0); + } else { + formValue = new ProductDetailFormVO() {{ + setType(type); + setRelationId(relationId); + setDetailId(detail.getId()); + setSectionId(section.getId()); + }}; + section.setFormValues(Lists.of(formValue)); + } + formValue.setValue(value); + formValues.add(formValue); + } + + + public static void sync(DetailSyncDTO dto) { + if (dto.getDetailTitleValueMap().isEmpty()) { + return; + } + val typeRelationIdTitleDetailMap = + DetailUtil.getTypeRelationIdTitleDetailMap( + Lists.of(dto.getProductionId()), + Lists.of(dto.getChapterId()), + Lists.ofColl(dto.getDetailTitleValueMap().keySet())); + final List formValues = Lists.of(); + dto.getDetailTitleValueMap().forEach((title, detailValue) -> { + DetailUtil.appendForm(formValues, typeRelationIdTitleDetailMap, + ProductDetailTypeEnum.PRODUCT, dto.getProductionId(), title, detailValue); + DetailUtil.appendForm(formValues, typeRelationIdTitleDetailMap, + ProductDetailTypeEnum.CHAPTER, dto.getChapterId(), title, detailValue); + }); + Database.saveOrUpdateFewSql(formValues); + } +} -- Gitee