AdvisorServer/src/main/java/com/syzb/course/service/MainTabService.java

package com.syzb.course.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.google.common.collect.Lists;
import com.hazelcast.map.IMap;
import com.syzb.advisor.service.AdvisorInfoService;
import com.syzb.advisor.vo.AdvisorBasicVO;
import com.syzb.common.config.cache.CacheKey;
import com.syzb.common.constant.IsDisplay;
import com.syzb.common.constant.ProductType;
import com.syzb.common.handler.BizException;
import com.syzb.common.query.OnlyIdQuery;
import com.syzb.common.result.ResponseStatus;
import com.syzb.common.service.CacheService;
import com.syzb.common.vo.BackendUserVO;
import com.syzb.course.entity.MainTab;
import com.syzb.course.mapper.MainTabMapper;
import com.syzb.course.query.MainTabQuery;
import com.syzb.course.query.SaveMainTabListQuery;
import com.syzb.course.vo.MainTabVO;
import com.syzb.rbac.service.AuthService;
import com.syzb.video.constant.VideoUserType;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class MainTabService {

    @Resource
    private MainTabMapper mainTabMapper;

    @Resource
    private AuthService authService;

    @Resource
    private AdvisorInfoService advisorInfoService;

    @Resource
    private CourseCommonService courseCommonService;

    @Resource
    private CacheService cacheService;

    @Resource
    private IMap<String, Object> courseCache;

    private static final List<MainTabVO> defaultMainTabList;

    static {
        defaultMainTabList = Lists.newArrayList(
                new MainTabVO(ProductType.VIDEO_SINGLE, "直播", 1, IsDisplay.YES.value),
//                new MainTabVO(ProductType.SHORT_VIDEO, "短视频", 2, IsDisplay.YES.value),
                new MainTabVO(ProductType.COURSE_SINGLE, "课程", 3, IsDisplay.YES.value),
//                new MainTabVO(ProductType.LIVE, "图文", 4, IsDisplay.YES.value),
//                new MainTabVO(ProductType.COURSE_PACKAGE, "甄选服务", 5, IsDisplay.YES.value)
                new MainTabVO(ProductType.GROUP, "圈子", 6, IsDisplay.YES.value)
        );
    }

    /**
     * 保存首页Tab
     *
     * @param query         查询对象
     * @param backendUserVO 后台用户
     */
    @Transactional(rollbackFor = Exception.class)
    public void save(SaveMainTabListQuery query, BackendUserVO backendUserVO) {
        validateMainTabList(query);
        // 全量删除
        LambdaQueryWrapper<MainTab> wrapper = Wrappers.<MainTab>lambdaQuery()
                .eq(MainTab::getAdvisorId, query.getAdvisorId());
        mainTabMapper.delete(wrapper);
        // 批量插入
        Integer advisorId = courseCommonService.getAdvisorId(query.getAdvisorId(), backendUserVO);
        List<MainTab> list = query.toPOList(advisorId);
        mainTabMapper.insertBatchSomeColumn(list);
        clearCache(advisorId);
    }

    /**
     * 查询首页Tab列表
     *
     * @param query         查询对象
     * @param backendUserVO 后台用户
     * @return 首页Tab列表
     */
    public List<MainTabVO> list(OnlyIdQuery query, BackendUserVO backendUserVO, Integer status) {
        // 检查数据权限
        courseCommonService.checkAdvisorId(query.getId(), backendUserVO);
        LambdaQueryWrapper<MainTab> wrapper = Wrappers.<MainTab>lambdaQuery()
                .eq(MainTab::getAdvisorId, query.getId())
                .eq(status != null, MainTab::getStatus, status)
                .orderByAsc(MainTab::getSort);
        List<MainTab> list = mainTabMapper.selectList(wrapper);
        // 如果没有配置，返回默认配置
        if (list.isEmpty()) {
            return defaultMainTabList;
        }
        return list.stream().map(MainTabVO::new).collect(Collectors.toList());
    }

    /**
     * 查询投顾列表
     *
     * @param backendUserVO 后台用户
     * @return 投顾列表
     */
    public List<AdvisorBasicVO> listAdvisor(BackendUserVO backendUserVO) {
        Set<Integer> authSet = authService.getAuthByUserType(VideoUserType.MANAGER_USER, backendUserVO, true);
        if (authSet == null) {
            return Collections.emptyList();
        }
        Map<Integer, AdvisorBasicVO> advisorVOMap = advisorInfoService.getAdvisorVoMap();
        return authSet.stream().map(advisorVOMap::get).collect(Collectors.toList());
    }

    /**
     * app查询首页Tab列表
     *
     * @param query 查询对象
     * @return 首页Tab列表
     */
    public List<MainTabVO> listForApp(OnlyIdQuery query) {
        return cacheService.get(CacheKey.COURSE, CacheKey.CourseKey.MAIN_TAB + query.getId(), () -> list(query, null, IsDisplay.YES.value));
    }

    private void clearCache(Integer advisorId) {
        courseCache.delete(CacheKey.CourseKey.MAIN_TAB + advisorId);
    }

    private void validateMainTabList(SaveMainTabListQuery query) {
        // 校验sort字段是否重复
        List<MainTabQuery> list = query.getTabList();
        Set<Integer> sortSet = new HashSet<>();
        for (MainTabQuery mainTabQuery : list) {
            if (!sortSet.add(mainTabQuery.getSort())) {
                throw new BizException(ResponseStatus.PARM_ERROR, "sort字段重复");
            }
        }
        // 校验productType字段是否缺失
        Set<Integer> productTypeSet = list.stream().map(MainTabQuery::getProductType).collect(Collectors.toSet());
        Set<Integer> missingProductTypeSet = defaultMainTabList.stream()
                .map(MainTabVO::getProductType)
                .filter(p -> !productTypeSet.contains(p))
                .collect(Collectors.toSet());
        if (!missingProductTypeSet.isEmpty()) {
            throw new BizException(ResponseStatus.PARM_ERROR, "缺少产品类型:" + missingProductTypeSet);
        }
    }

}