feat(ai): 添加会员角色知识点配置功能

Administrator

12 hours ago 490bceb5d9e911a5c4f687dd6570b6699ca11915

 src/main/java/cc/mrbird/febs/ai/service/impl/AiProductServiceImpl.java

@@ -1,16 +1,29 @@
package cc.mrbird.febs.ai.service.impl;

import cc.mrbird.febs.ai.entity.AiProduct;
import cc.mrbird.febs.ai.entity.*;
import cc.mrbird.febs.ai.mapper.AiProductMapper;
import cc.mrbird.febs.ai.service.AiProductService;
import cc.mrbird.febs.ai.req.AdminMoveChooseInfoDto;
import cc.mrbird.febs.ai.service.*;
import cc.mrbird.febs.ai.util.UUID;
import cc.mrbird.febs.common.entity.FebsResponse;
import cc.mrbird.febs.common.entity.QueryRequest;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * AI产品表 Service实现类
@@ -24,138 +37,222 @@
public class AiProductServiceImpl extends ServiceImpl<AiProductMapper, AiProduct> implements AiProductService {

    private final AiProductMapper aiProductMapper;
    private final AiProductCategoryService aiProductCategoryService;
    private final AiProductPointLinkService aiProductPointLinkService;
    private final AiProductRoleLinkService aiProductRoleLinkService;
    private final AiProductQuestionLinkService aiProductQuestionLinkService;

    @Override
    public AiProduct getById(String id) {
        return this.getById(id);
        return aiProductMapper.selectById(id);
    }

    @Override
    public List<AiProduct> getByCompanyId(String companyId) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getCompanyId, companyId);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }
    public IPage<AiProduct> listInPage(AiProduct dto, QueryRequest request) {

    @Override
    public AiProduct getByCode(String code) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getCode, code);
        return this.getOne(queryWrapper);
    }

    @Override
    public List<AiProduct> getByName(String name) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.like(AiProduct::getName, name);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<AiProduct> getByProductCategoryId(String productCategoryId) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getProductCategoryId, productCategoryId);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<AiProduct> getByState(Integer state) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getState, state);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<AiProduct> getByHotState(Integer hotState) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getHotState, hotState);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<AiProduct> getByCompanyIdAndState(String companyId, Integer state) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getCompanyId, companyId);
        queryWrapper.eq(AiProduct::getState, state);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    public List<AiProduct> getByCompanyIdAndHotState(String companyId, Integer hotState) {
        LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(AiProduct::getCompanyId, companyId);
        queryWrapper.eq(AiProduct::getHotState, hotState);
        queryWrapper.orderByDesc(AiProduct::getSort);
        queryWrapper.orderByDesc(AiProduct::getCreatedTime);
        return this.list(queryWrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveProduct(AiProduct aiProduct) {
        try {
            return this.save(aiProduct);
        } catch (Exception e) {
            log.error("保存AI产品失败: ", e);
            return false;
        Page<AiProduct> page = new Page<>(request.getPageNum(), request.getPageSize());
        LambdaQueryWrapper<AiProduct> query = Wrappers.lambdaQuery(AiProduct.class);
        if (StrUtil.isNotEmpty(dto.getProductCategoryId())){
            query.eq(AiProduct::getProductCategoryId, dto.getProductCategoryId());
        }
        if (StrUtil.isNotEmpty(dto.getCompanyId())){
            query.eq(AiProduct::getCompanyId, dto.getCompanyId());
        }
        query.ne(AiProduct::getState, 2);
        query.orderByDesc(AiProduct::getHotState);
        query.orderByAsc(AiProduct::getSort);
        Page<AiProduct> pages = aiProductMapper.selectPage(page, query);
        List<AiProduct> records = pages.getRecords();
        if (CollUtil.isNotEmpty( records)){
            Set<String> collect = records.stream().map(AiProduct::getProductCategoryId).collect(Collectors.toSet());
            if(CollUtil.isNotEmpty( collect)){
                Map<String,AiProductCategory> map = aiProductCategoryService.selectMapByIds(collect);
                for (AiProduct record : records){
                    AiProductCategory orDefault = map.getOrDefault(record.getProductCategoryId(), null);
                    if(ObjectUtil.isNotNull(orDefault)){
                        record.setProductCategoryName(orDefault.getName());
                    }
                }
            }
        }
        return pages;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean saveBatchProducts(List<AiProduct> products) {
        try {
            return this.saveBatch(products);
        } catch (Exception e) {
            log.error("批量保存AI产品失败: ", e);
            return false;
    public FebsResponse changeState(String id, Integer type, Integer state) {

        AiProduct entity = this.getById(id);
        if(ObjectUtil.isNotNull(entity)){
            if(1 == type){
                aiProductMapper.update(null,
                        Wrappers.lambdaUpdate(AiProduct.class)
                                .set(AiProduct::getState, state)
                                .eq(AiProduct::getId, id)
                );
            }
            if(2 == type){
                aiProductMapper.update(null,
                        Wrappers.lambdaUpdate(AiProduct.class)
                                .set(AiProduct::getHotState, state)
                                .eq(AiProduct::getId, id)
                );
            }
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateProduct(AiProduct aiProduct) {
        try {
            return this.updateById(aiProduct);
        } catch (Exception e) {
            log.error("更新AI产品失败: ", e);
            return false;
        }
    public FebsResponse add(AiProduct dto) {
        AiProduct entity = new AiProduct();
        entity.setId(UUID.getSimpleUUIDString());
        entity.setCompanyId(dto.getCompanyId());
        entity.setCode(dto.getCode());
        entity.setName(dto.getName());
        entity.setBackImg(dto.getBackImg());
        entity.setIconImg(dto.getIconImg());
        entity.setSort(dto.getSort());
        entity.setProductCategoryId(dto.getProductCategoryId());
        entity.setScene(dto.getScene());
        entity.setTarget(dto.getTarget());
        entity.setDescription(dto.getDescription());
        entity.setQuestionCount(dto.getQuestionCount());
        entity.setCreatedTime(new Date());
        this.save(entity);
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteById(String id) {
        try {
            return this.removeById(id);
        } catch (Exception e) {
            log.error("删除AI产品失败: ", e);
            return false;
    public FebsResponse update(AiProduct dto) {
        String id = dto.getId();
        AiProduct entity = this.getById(id);
        if (ObjectUtil.isNotNull( entity)){
            this.update(null,
                    Wrappers.lambdaUpdate(AiProduct.class)
                            .set(AiProduct::getCode, dto.getCode())
                            .set(AiProduct::getName, dto.getName())
                            .set(AiProduct::getBackImg, dto.getBackImg())
                            .set(AiProduct::getIconImg, dto.getIconImg())
                            .set(AiProduct::getSort, dto.getSort())
                            .set(AiProduct::getProductCategoryId, dto.getProductCategoryId())
                            .set(AiProduct::getScene, dto.getScene())
                            .set(AiProduct::getTarget, dto.getTarget())
                            .set(AiProduct::getDescription, dto.getDescription())
                            .set(AiProduct::getQuestionCount, dto.getQuestionCount())
                            .set(AiProduct::getUpdatedTime, new Date())
                            .eq(AiProduct::getId, id)
            );
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteByCompanyId(String companyId) {
        try {
            LambdaQueryWrapper<AiProduct> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AiProduct::getCompanyId, companyId);
            return this.remove(queryWrapper);
        } catch (Exception e) {
            log.error("根据公司ID删除AI产品失败: ", e);
            return false;
    public FebsResponse delete(String id) {

        AiProduct entity = this.getById(id);
        if(ObjectUtil.isNotNull( entity)){
            this.update(null,
                    Wrappers.lambdaUpdate(AiProduct.class)
                            .set(AiProduct::getState, 2)
                            .set(AiProduct::getUpdatedTime, new Date())
                            .eq(AiProduct::getId, id));

        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public List<AiProduct> selectList(String companyId) {
        LambdaQueryWrapper<AiProduct> query = Wrappers.lambdaQuery(AiProduct.class);
        if (StrUtil.isNotEmpty(companyId)){
            query.eq(AiProduct::getCompanyId, companyId);
        }
        query.ne(AiProduct::getState, 2);
        return aiProductMapper.selectList(query);
    }

    @Override
    public FebsResponse productSet(AdminMoveChooseInfoDto dto) {

        String chooseId = dto.getChooseId();
        List<String> chooseIds = dto.getChooseIds();
        AiProduct aiProduct = this.getById(chooseId);
        if (ObjectUtil.isNotNull(aiProduct)) {
            String companyId = aiProduct.getCompanyId();
            aiProductPointLinkService.deleteByQuery(
                    Wrappers.lambdaQuery(AiProductPointLink.class)
                            .eq(AiProductPointLink::getProductId,chooseId)
                            .eq(AiProductPointLink::getCompanyId,companyId)
            );
            if(CollUtil.isNotEmpty(chooseIds)){
                Date createdTime = new Date();
                for (String item : chooseIds){
                    AiProductPointLink entity = new AiProductPointLink();
                    entity.setId(UUID.getSimpleUUIDString());
                    entity.setCompanyId(companyId);
                    entity.setProductId(chooseId);
                    entity.setProductPointId(item);
                    entity.setCreatedTime(createdTime);
                    aiProductPointLinkService.getBaseMapper().insert(entity);
                }
            }
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse productRoleSet(AdminMoveChooseInfoDto dto) {

        String chooseId = dto.getChooseId();
        List<String> chooseIds = dto.getChooseIds();
        AiProduct aiProduct = this.getById(chooseId);
        if (ObjectUtil.isNotNull(aiProduct)) {
            String companyId = aiProduct.getCompanyId();
            aiProductRoleLinkService.deleteByQuery(
                    Wrappers.lambdaQuery(AiProductRoleLink.class)
                            .eq(AiProductRoleLink::getProductId,chooseId)
                    .eq(AiProductRoleLink::getCompanyId,companyId)
            );
            if(CollUtil.isNotEmpty(chooseIds)){
                Date createdTime = new Date();
                for (String item : chooseIds){
                    AiProductRoleLink entity = new AiProductRoleLink();
                    entity.setId(UUID.getSimpleUUIDString());
                    entity.setCompanyId(companyId);
                    entity.setProductId(chooseId);
                    entity.setProductRoleId(item);
                    entity.setCreatedTime(createdTime);
                    aiProductRoleLinkService.getBaseMapper().insert(entity);
                }
            }
        }
        return new FebsResponse().success().message("操作成功");
    }

    @Override
    public FebsResponse productQuestionSet(AdminMoveChooseInfoDto dto) {
        String chooseId = dto.getChooseId();
        List<String> chooseIds = dto.getChooseIds();
        AiProduct aiProduct = this.getById(chooseId);
        if (ObjectUtil.isNotNull(aiProduct)) {
            String companyId = aiProduct.getCompanyId();
            aiProductQuestionLinkService.deleteByQuery(
                    Wrappers.lambdaQuery(AiProductQuestionLink.class)
                            .eq(AiProductQuestionLink::getProductId,chooseId)
                    .eq(AiProductQuestionLink::getCompanyId,companyId)
            );
            if(CollUtil.isNotEmpty(chooseIds)){
                Date createdTime = new Date();
                for (String item : chooseIds){
                    AiProductQuestionLink entity = new AiProductQuestionLink();
                    entity.setId(UUID.getSimpleUUIDString());
                    entity.setCompanyId(companyId);
                    entity.setProductId(chooseId);
                    entity.setProductQuestionId(item);
                    entity.setCreatedTime(createdTime);
                    aiProductQuestionLinkService.getBaseMapper().insert(entity);
                }
            }
        }
        return new FebsResponse().success().message("操作成功");
    }
}