package com.tcm.training.admin.live.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.tcm.training.admin.common.PageResponse;
|
import com.tcm.training.admin.live.dto.ExpertSaveRequest;
|
import com.tcm.training.admin.live.dto.ExpertStatusRequest;
|
import com.tcm.training.admin.live.entity.Expert;
|
import com.tcm.training.admin.live.entity.LiveCourse;
|
import com.tcm.training.admin.live.mapper.ExpertMapper;
|
import com.tcm.training.admin.live.mapper.LiveCourseMapper;
|
import com.tcm.training.admin.live.vo.ExpertDetailVO;
|
import com.tcm.training.admin.live.vo.ExpertItemVO;
|
import com.tcm.training.admin.live.vo.ExpertOptionVO;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.ArrayList;
|
import java.util.List;
|
|
@Service
|
public class ExpertAppService {
|
|
private final ExpertMapper expertMapper;
|
private final LiveCourseMapper liveCourseMapper;
|
|
public ExpertAppService(ExpertMapper expertMapper, LiveCourseMapper liveCourseMapper) {
|
this.expertMapper = expertMapper;
|
this.liveCourseMapper = liveCourseMapper;
|
}
|
|
public PageResponse<ExpertItemVO> page(int page, int pageSize, String keyword, Integer status) {
|
LambdaQueryWrapper<Expert> qw = new LambdaQueryWrapper<Expert>();
|
if (keyword != null && !keyword.trim().isEmpty()) {
|
qw.like(Expert::getName, keyword.trim());
|
}
|
if (status != null) {
|
qw.eq(Expert::getStatus, status);
|
}
|
qw.orderByDesc(Expert::getId);
|
|
IPage<Expert> p = expertMapper.selectPage(new Page<Expert>(page, pageSize), qw);
|
List<ExpertItemVO> list = new ArrayList<ExpertItemVO>();
|
for (Expert e : p.getRecords()) {
|
list.add(new ExpertItemVO(e.getId(), e.getName(), e.getAvatar(), e.getStatus(), e.getCreatedAt()));
|
}
|
return PageResponse.of(list, p.getTotal(), p.getCurrent(), p.getSize());
|
}
|
|
public ExpertDetailVO detail(Long id) {
|
Expert expert = requireExpert(id);
|
return toDetailVO(expert);
|
}
|
|
public List<ExpertOptionVO> options() {
|
List<Expert> experts = expertMapper.selectList(new LambdaQueryWrapper<Expert>()
|
.eq(Expert::getStatus, 1)
|
.eq(Expert::getDeleted, 0)
|
.orderByAsc(Expert::getId));
|
List<ExpertOptionVO> list = new ArrayList<ExpertOptionVO>();
|
for (Expert expert : experts) {
|
list.add(new ExpertOptionVO(expert.getId(), expert.getName(), expert.getAvatar()));
|
}
|
return list;
|
}
|
|
@Transactional
|
public ExpertDetailVO create(ExpertSaveRequest req) {
|
Expert expert = new Expert();
|
expert.setName(req.getName().trim());
|
expert.setAvatar(req.getAvatar().trim());
|
expert.setSpecialty(req.getSpecialty().trim());
|
expert.setIntro(req.getIntro().trim());
|
expert.setStatus(req.getStatus());
|
expert.setDeleted(0);
|
expertMapper.insert(expert);
|
return detail(expert.getId());
|
}
|
|
@Transactional
|
public ExpertDetailVO update(Long id, ExpertSaveRequest req) {
|
Expert expert = requireExpert(id);
|
expert.setName(req.getName().trim());
|
expert.setAvatar(req.getAvatar().trim());
|
expert.setSpecialty(req.getSpecialty().trim());
|
expert.setIntro(req.getIntro().trim());
|
expert.setStatus(req.getStatus());
|
expertMapper.updateById(expert);
|
return detail(id);
|
}
|
|
@Transactional
|
public ExpertDetailVO patchStatus(Long id, ExpertStatusRequest req) {
|
Expert expert = requireExpert(id);
|
expert.setStatus(req.getStatus());
|
expertMapper.updateById(expert);
|
return detail(id);
|
}
|
|
@Transactional
|
public void delete(Long id) {
|
requireExpert(id);
|
Long bindCount = liveCourseMapper.selectCount(new LambdaQueryWrapper<LiveCourse>()
|
.eq(LiveCourse::getExpertId, id)
|
.eq(LiveCourse::getDeleted, 0));
|
if (bindCount != null && bindCount > 0) {
|
throw new IllegalArgumentException("该授课专家已关联直播课程，暂不允许删除");
|
}
|
expertMapper.deleteById(id);
|
}
|
|
private Expert requireExpert(Long id) {
|
Expert expert = expertMapper.selectOne(new LambdaQueryWrapper<Expert>()
|
.eq(Expert::getId, id)
|
.eq(Expert::getDeleted, 0)
|
.last("limit 1"));
|
if (expert == null) {
|
throw new IllegalArgumentException("授课专家不存在");
|
}
|
return expert;
|
}
|
|
private ExpertDetailVO toDetailVO(Expert expert) {
|
ExpertDetailVO vo = new ExpertDetailVO();
|
vo.setId(expert.getId());
|
vo.setName(expert.getName());
|
vo.setAvatar(expert.getAvatar());
|
vo.setSpecialty(expert.getSpecialty());
|
vo.setIntro(expert.getIntro());
|
vo.setStatus(expert.getStatus());
|
vo.setCreatedAt(expert.getCreatedAt());
|
vo.setUpdatedAt(expert.getUpdatedAt());
|
return vo;
|
}
|
}
|
