APP端冥想首页相关接口

mitao

2024-09-07 2862c3e4da3adbb4bea43151514f0c43b86476d6

 xinquan-modules/xinquan-meditation/src/main/java/com/xinquan/meditation/service/impl/MeditationServiceImpl.java

@@ -1,9 +1,46 @@
package com.xinquan.meditation.service.impl;

import com.xinquan.meditation.domain.Meditation;
import com.xinquan.meditation.mapper.MeditationMapper;
import com.xinquan.meditation.service.MeditationService;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xinquan.common.core.constant.SecurityConstants;
import com.xinquan.common.core.enums.DisabledEnum;
import com.xinquan.common.core.exception.ServiceException;
import com.xinquan.common.core.utils.page.BeanUtils;
import com.xinquan.common.core.utils.page.CollUtils;
import com.xinquan.common.core.utils.page.PageDTO;
import com.xinquan.common.security.utils.SecurityUtils;
import com.xinquan.meditation.domain.Meditation;
import com.xinquan.meditation.domain.MeditationCategory;
import com.xinquan.meditation.domain.MeditationMusic;
import com.xinquan.meditation.domain.MeditationQuestion;
import com.xinquan.meditation.domain.MeditationQuestionLike;
import com.xinquan.meditation.domain.MeditationUserFavorite;
import com.xinquan.meditation.domain.vo.ClientMeditationAndCateVO;
import com.xinquan.meditation.domain.vo.ClientMeditationCategoryVO;
import com.xinquan.meditation.domain.vo.ClientMeditationDetailsVO;
import com.xinquan.meditation.domain.vo.ClientMeditationQuestionVO;
import com.xinquan.meditation.domain.vo.ClientMeditationVO;
import com.xinquan.meditation.mapper.MeditationCategoryMapper;
import com.xinquan.meditation.mapper.MeditationMapper;
import com.xinquan.meditation.mapper.MeditationMusicMapper;
import com.xinquan.meditation.mapper.MeditationQuestionMapper;
import com.xinquan.meditation.service.MeditationQuestionLikeService;
import com.xinquan.meditation.service.MeditationService;
import com.xinquan.meditation.service.MeditationUserFavoriteService;
import com.xinquan.user.api.domain.AppUser;
import com.xinquan.user.api.domain.dto.AppUserDTO;
import com.xinquan.user.api.feign.RemoteAppUserService;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

/**
@@ -15,6 +52,296 @@
 * @since 2024-08-21
 */
@Service
@RequiredArgsConstructor
public class MeditationServiceImpl extends ServiceImpl<MeditationMapper, Meditation> implements MeditationService {

    private final RemoteAppUserService remoteAppUserService;
    private final MeditationCategoryMapper meditationCategoryMapper;
    private final MeditationMusicMapper meditationMusicMapper;
    private final MeditationQuestionMapper meditationQuestionMapper;
    private final MeditationQuestionLikeService meditationQuestionLikeService;
    private final MeditationUserFavoriteService meditationUserFavoriteService;

    /**
     * 获取私人订制
     *
     * @return 冥想列表
     */
    @Override
    public List<ClientMeditationVO> getPersonalityPlan() {
        List<ClientMeditationVO> voList = null;
        // 获取当前登录用户id
        AppUser appUser = getCurrentUser();
        if (Optional.ofNullable(appUser.getTagId()).isPresent()) {
            String tagId = appUser.getTagId();
            Integer sanskritFlag = appUser.getSanskritFlag();
            Set<Long> tagIdSet = Arrays.stream(tagId.split(",")).map(Long::parseLong)
                    .collect(Collectors.toSet());
            // 查询冥想列表
            voList = baseMapper.getMeditationListByTagId(tagIdSet, sanskritFlag);
        }
        return voList;
    }

    /**
     * 根据分类id获取冥想列表
     *
     * @param cateId 分类id
     * @return 冥想列表
     */
    @Override
    public List<ClientMeditationVO> getMeditationListByCateId(Long cateId) {
        List<ClientMeditationVO> voList = null;
        // 获取当前登录用户id
        AppUser appUser = getCurrentUser();
        // 查询
        List<Meditation> list = this.lambdaQuery().eq(Meditation::getCateId, cateId)
                .eq(Meditation::getSanskrit, appUser.getSanskritFlag())
                .orderByDesc(Meditation::getSortNum).last("limit 8").list();
        if (CollUtils.isNotEmpty(list)) {
            // 对象拷贝
            voList = BeanUtils.copyList(list, ClientMeditationVO.class);
        }
        return voList;
    }

    /**
     * 获取当前登录用户
     *
     * @return AppUser
     */
    private AppUser getCurrentUser() {
        Long userId = SecurityUtils.getUserId();
        return remoteAppUserService.getUserByCondition(
                AppUserDTO.builder().id(userId).build(),
                SecurityConstants.INNER).getData();
    }

    /**
     * 获取全部的冥想及分类列表
     *
     * @return 冥想和分类列表
     */
    @Override
    public List<ClientMeditationAndCateVO> getMeditationAndCateList() {
        // 获取当前登录用户
        AppUser appUser = getCurrentUser();
        List<ClientMeditationAndCateVO> voList = CollUtils.newArrayList();
        // 查询分类列表
        List<MeditationCategory> cateList = meditationCategoryMapper.selectList(
                Wrappers.lambdaQuery(MeditationCategory.class)
                        .orderByDesc(MeditationCategory::getSortNum));
        if (CollUtils.isNotEmpty(cateList)) {
            for (MeditationCategory cate : cateList) {
                ClientMeditationAndCateVO vo = new ClientMeditationAndCateVO();
                vo.setClientMeditationCategoryVO(
                        BeanUtils.copyBean(cateList, ClientMeditationCategoryVO.class));
                vo.setClientMeditationVOList(getMeditationListByCateId(cate.getId()));
                voList.add(vo);
            }
        }
        return voList;
    }

    /**
     * 根据分类id获取冥想列表-分页
     *
     * @param cateId   分类id
     * @param pageCurr 当前页码
     * @param pageSize 每页数量
     * @return 冥想列表
     */
    @Override
    public PageDTO<ClientMeditationVO> getMeditationPageByCateId(Long cateId, Integer pageCurr,
            Integer pageSize) {
        PageDTO<ClientMeditationVO> pageDTO = PageDTO.empty(0L, 0L);
        // 获取当前登录用户id
        AppUser appUser = getCurrentUser();
        // 查询
        Page<Meditation> page = this.lambdaQuery().eq(Meditation::getCateId, cateId)
                .eq(Meditation::getSanskrit, appUser.getSanskritFlag())
                .orderByDesc(Meditation::getSortNum)
                .page(new Page<>(pageCurr, pageSize));
        // 如果没有查到数据直接返回
        if (Optional.ofNullable(page.getRecords()).isPresent()) {
            return pageDTO;
        }
        // 将实体类转换为VO
        pageDTO = PageDTO.of(page, ClientMeditationVO.class);
        return pageDTO;
    }

    /**
     * 首页搜索首页
     *
     * @param condition 搜索条件
     * @param pageCurr  当前页码
     * @param pageSize  每页数量
     * @return 冥想列表
     */
    @Override
    public PageDTO<ClientMeditationVO> search(String condition, Integer pageCurr,
            Integer pageSize) {
        PageDTO<ClientMeditationVO> pageDTO = PageDTO.empty(0L, 0L);
        // 获取当前登录用户id
        AppUser appUser = getCurrentUser();
        // 查询
        Page<Meditation> page = this.lambdaQuery()
                .like(Meditation::getMeditationTitle, condition).or()
                .eq(Meditation::getSanskrit, appUser.getSanskritFlag())
                .orderByDesc(Meditation::getSortNum)
                .page(new Page<>(pageCurr, pageSize));
        // 如果没有查到数据直接返回
        if (Optional.ofNullable(page.getRecords()).isPresent()) {
            return pageDTO;
        }
        // 音频链接加密
    /*    page.getRecords().forEach(meditation -> {
            try {
                meditation.setTutorAudioUrl(DES.encryptDES(meditation.getTutorAudioUrl()));
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        });*/
        // 将实体类转换为VO
        pageDTO = PageDTO.of(page, ClientMeditationVO.class);
        return pageDTO;
    }

    /**
     * 获取冥想音频详情
     *
     * @param id 冥想音频id
     * @return 客户端冥想详情视图对象
     */
    @Override
    public ClientMeditationDetailsVO getMeditationDetails(Long id) {
        // 查询冥想音频
        Meditation meditation = this.getById(id);
        ClientMeditationDetailsVO vo = BeanUtils.copyBean(meditation,
                ClientMeditationDetailsVO.class);
        // 查询冥想音频
        List<MeditationMusic> meditationMusics = meditationMusicMapper.selectList(
                Wrappers.lambdaQuery(MeditationMusic.class)
                        .eq(MeditationMusic::getMeditationId, id));
        if (CollUtils.isNotEmpty(meditationMusics)) {
            // 获取音频链接
            List<String> musicUrlList = meditationMusics.stream()
                    .map(MeditationMusic::getMusicUrl).collect(Collectors.toList());
            vo.setMeditationMusicList(musicUrlList);
        }
        // 查询收藏记录
        vo.setFavorite(meditationUserFavoriteService.lambdaQuery()
                .eq(MeditationUserFavorite::getMeditationId, id)
                .eq(MeditationUserFavorite::getAppUserId, SecurityUtils.getUserId())
                .count() > 0 ? 1 : 2);
        return vo;
    }

    /**
     * 收藏/取消收藏
     *
     * @param id 冥想音频id
     */
    @Override
    public void favorite(Long id) {
        Meditation meditation = this.getById(id);
        if (Objects.isNull(meditation)) {
            throw new ServiceException("该冥想音频不存在");
        }
        // 查询收藏记录
        Optional<MeditationUserFavorite> userOperationOpt = meditationUserFavoriteService.lambdaQuery()
                .eq(MeditationUserFavorite::getMeditationId, id)
                .eq(MeditationUserFavorite::getAppUserId, SecurityUtils.getUserId())
                .last("limit 1").oneOpt();
        if (userOperationOpt.isPresent()) {
            meditationUserFavoriteService.removeById(userOperationOpt.get());
            // 增加收藏数
            meditation.setFavoriteCount(meditation.getFavoriteCount() - 1);
        } else {
            // 增加收藏记录
            MeditationUserFavorite meditationUserFavorite = new MeditationUserFavorite();
            meditationUserFavorite.setMeditationId(id);
            meditationUserFavorite.setAppUserId(SecurityUtils.getUserId());
            meditationUserFavoriteService.save(meditationUserFavorite);
            // 减少收藏数
            meditation.setFavoriteCount(meditation.getFavoriteCount() + 1);
        }
        this.updateById(meditation);
    }

    /**
     * 获取冥想音频提问列表-分页
     *
     * @param id       冥想音频id
     * @param pageCurr 当前页码
     * @param pageSize 每页数量
     * @return 冥想音频提问分页列表
     */
    @Override
    public PageDTO<ClientMeditationQuestionVO> getMeditationQuestionPage(Long id,
            Integer pageCurr, Integer pageSize) {
        // 查询冥想提问列表
        Page<MeditationQuestion> questionPage = meditationQuestionMapper.selectPage(
                new Page<>(pageCurr, pageSize),
                Wrappers.lambdaQuery(MeditationQuestion.class)
                        .eq(MeditationQuestion::getMeditationId, id)
                        .eq(MeditationQuestion::getShowFlag, DisabledEnum.YES)
                        .orderByDesc(MeditationQuestion::getPublishTime)
        );

        if (CollUtils.isEmpty(questionPage.getRecords())) {
            return PageDTO.empty(questionPage);
        }

        // 将 questionPage 转换为 PageDTO
        PageDTO<ClientMeditationQuestionVO> pageDTO = PageDTO.of(
                questionPage, ClientMeditationQuestionVO.class);
        List<ClientMeditationQuestionVO> questionVOList = pageDTO.getList();

        // 提取用户ID集合
        Set<Long> appUserIdSet = questionVOList.stream()
                .map(ClientMeditationQuestionVO::getAppUserId)
                .collect(Collectors.toSet());

        // 远程调用，获取APP用户信息
        Map<Long, AppUser> appUserMap = Collections.emptyMap();
        if (!appUserIdSet.isEmpty()) {
            List<AppUser> appUserList = remoteAppUserService.getAppUserList(appUserIdSet,
                            SecurityConstants.INNER)
                    .getData();
            appUserMap = appUserList.stream()
                    .collect(Collectors.toMap(AppUser::getId, Function.identity()));
        }

        // 封装用户信息
        for (ClientMeditationQuestionVO questionVO : questionVOList) {
            AppUser appUser = appUserMap.get(questionVO.getAppUserId());
            if (appUser != null) {
                questionVO.setNickname(appUser.getNickname());
                questionVO.setAvatar(appUser.getAvatar());
            }
        }

        // 获取当前登录用户ID
        Long userId = SecurityUtils.getUserId();

        // 查询用户已点赞提问列表
        Set<Long> likedQuestionIds = meditationQuestionLikeService.lambdaQuery()
                .eq(MeditationQuestionLike::getAppUserId, userId)
                .list()
                .stream()
                .map(MeditationQuestionLike::getMeditationQuestionId)
                .collect(Collectors.toSet());

        // 设置问题的点赞状态
        questionVOList.forEach(question -> {
            if (likedQuestionIds.contains(question.getId())) {
                question.setLike(DisabledEnum.YES.getCode());
            }
        });

        return pageDTO;
    }

}