taphole/taphole-warn/src/main/java/com/sckj/warn/service/impl/TAudioServiceImpl.java

package com.sckj.warn.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.yulichang.query.MPJQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.sckj.common.TapholeAdminThreadLocal;
import com.sckj.common.core.AjaxResult;
import com.sckj.common.validate.commons.PageValidate;
import com.sckj.warn.service.ITAudioService;
import com.sckj.warn.validate.TAudioCreateValidate;
import com.sckj.warn.validate.TAudioUpdateValidate;
import com.sckj.warn.validate.TAudioSearchValidate;
import com.sckj.warn.vo.TAudioListedVo;
import com.sckj.warn.vo.TAudioDetailVo;
import com.sckj.common.config.GlobalConfig;
import com.sckj.common.core.PageResult;
import com.sckj.warn.entity.TAudio;
import com.sckj.warn.mapper.TAudioMapper;
import com.sckj.common.util.ListUtils;
import com.sckj.common.util.TimeUtils;
import com.sckj.common.util.UrlUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 音频实现类
 * @author zhanghao
 */
@Service
public class TAudioServiceImpl implements ITAudioService {

    @Resource
    TAudioMapper tAudioMapper;

    /**
     * 音频列表
     *
     * @author zhanghao
     * @param pageValidate 分页参数
     * @param searchValidate 搜索参数
     * @return PageResult<TAudioListedVo>
     */
    @Override
    public PageResult<TAudioListedVo> list(PageValidate pageValidate, TAudioSearchValidate searchValidate) {
        Integer page  = pageValidate.getPageNo();
        Integer limit = pageValidate.getPageSize();

        QueryWrapper<TAudio> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("del_flag", "1");
        queryWrapper.orderByDesc("id");

        tAudioMapper.setSearch(queryWrapper, searchValidate, new String[]{
            "=:createBy@create_by:str",
            "=:updateBy@update_by:str",
            "like:name:str",
            "=:exceptionType@exception_type:str",
            "=:exceptionLevel@exception_level:str",
            "=:path:str",
            "=:status:str",
        });

        IPage<TAudio> iPage = tAudioMapper.selectPage(new Page<>(page, limit), queryWrapper);

        List<TAudioListedVo> list = new LinkedList<>();
        for(TAudio item : iPage.getRecords()) {
            TAudioListedVo vo = new TAudioListedVo();
            BeanUtils.copyProperties(item, vo);
            vo.setPath("http://localhost:28080/api/uploads/" + vo.getPath());
            vo.setCreateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(item.getCreateTime()));
            if (item.getUpdateTime() != null){
                vo.setUpdateTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(item.getUpdateTime()));
            }
            list.add(vo);
        }

        return PageResult.iPageHandle(iPage.getTotal(), iPage.getCurrent(), iPage.getSize(), list);
    }

    /**
     * 音频详情
     *
     * @author zhanghao
     * @param id 主键参数
     * @return TAudio
     */
    @Override
    public TAudioDetailVo detail(Integer id) {
        TAudio model = tAudioMapper.selectOne(
                new QueryWrapper<TAudio>()
                        .eq("id", id)
                        .eq("del_flag", "1")
                        .last("limit 1"));

        Assert.notNull(model, "数据不存在");

        TAudioDetailVo vo = new TAudioDetailVo();
        BeanUtils.copyProperties(model, vo);
        return vo;
    }

    /**
     * 音频新增
     *
     * @author zhanghao
     * @param createValidate 参数
     */
    @Override
    public void add(TAudioCreateValidate createValidate) {
        TAudio model = new TAudio();
        model.setCreateTime(new Date(System.currentTimeMillis()));
        model.setCreateBy(String.valueOf(TapholeAdminThreadLocal.getAdminUsername()));
        model.setName(createValidate.getName());
        model.setPath(createValidate.getPath());
        model.setDuration(createValidate.getDuration());
        model.setExceptionType(createValidate.getExceptionType());
        model.setExceptionLevel(createValidate.getExceptionLevel());
        //默认新增的音频初始状态为停用
        model.setStatus("0");
        tAudioMapper.insert(model);
    }

    /**
     * 音频编辑
     *
     * @author zhanghao
     * @param updateValidate 参数
     */
    @Override
    public int edit(TAudioUpdateValidate updateValidate) {
        TAudio model = tAudioMapper.selectOne(
                new QueryWrapper<TAudio>()
                    .eq("id",  updateValidate.getId()).eq("del_flag", "1")
                    .last("limit 1"));

        if (model == null){
            return 0;
        }
        model.setUpdateTime(new Date(System.currentTimeMillis()));
        model.setUpdateBy(String.valueOf(TapholeAdminThreadLocal.getAdminUsername()));
        model.setName(updateValidate.getName());
        model.setPath(updateValidate.getPath());
        model.setDuration(updateValidate.getDuration());
        model.setExceptionType(updateValidate.getExceptionType());
        model.setExceptionLevel(updateValidate.getExceptionLevel());
        tAudioMapper.updateById(model);
        return 1;
    }

    /**
     * 音频音频启用状态修改
     *
     * @author zhanghao
     * @param updateValidate 参数
     */
    @Override
    public AjaxResult<Object> status(TAudioUpdateValidate updateValidate) {
        TAudio model = tAudioMapper.selectOne(
                new QueryWrapper<TAudio>()
                        .eq("id",  updateValidate.getId()).eq("del_flag", "1")
                        .last("limit 1"));
        if (model == null){
            return AjaxResult.failed("未找到该音频");
        }
        /*如果将要修改的状态值和原来的值不同，且修改音频状态为启用*/
        if (!model.getStatus().equals(updateValidate.getStatus()) && updateValidate.getStatus().equals("1")){
            //首先查找是否存在同异常类型同危害程度的已启用音频
            TAudio tAudio = tAudioMapper.selectOne(
                    new QueryWrapper<TAudio>()
                            .eq("exception_type",  updateValidate.getExceptionType())
                            .eq("exception_level",  updateValidate.getExceptionLevel())
                            .eq("status",  "1")
                            .last("limit 1"));
            //存在冲突
            if (tAudio != null){
                return AjaxResult.failed("存在已启用的同类音频，禁止修改");
            }
        }
        /*未修改音频状态或停用音频或不存在启用状态冲突*/
        model.setUpdateTime(new Date(System.currentTimeMillis()));
        model.setUpdateBy(String.valueOf(TapholeAdminThreadLocal.getAdminUsername()));
        model.setStatus(updateValidate.getStatus());
        tAudioMapper.updateById(model);
        return AjaxResult.success();
    }

    /**
     * 音频删除
     *
     * @author zhanghao
     * @param id 主键ID
     */
    @Override
    public void del(Integer id) {
        TAudio model = tAudioMapper.selectOne(
                new QueryWrapper<TAudio>()
                    .eq("id", id)
                    .last("limit 1"));

        Assert.notNull(model, "数据不存在!");

        model.setDelFlag("0");

        tAudioMapper.updateById(model);
    }

    /**
     * 音频地址查询
     *
     * @author zhanghao
     * @param id 主键ID
     */
    public String searchPath(Long id){
        TAudio model = tAudioMapper.selectOne(
                new QueryWrapper<TAudio>()
                        .eq("id",  id).eq("del_flag", "1")
                        .last("limit 1"));

        Assert.notNull(model, "数据不存在!");
        return model.getPath();
    }

    /**
     * 音频批量删除
     *
     * @author zhanghao
     * @param ids 主键数组
     */
    @Override
    public AjaxResult<Object> del_ex(List<Long> ids) {
        List<TAudio> models = tAudioMapper.selectList(
                new QueryWrapper<TAudio>()
                        .in("id", ids));

        if (CollectionUtils.isEmpty(models)){
            return AjaxResult.failed("数据不存在");
        }
        TAudio model = new TAudio();
        model.setDelFlag("0");
        tAudioMapper.update(model, new QueryWrapper<TAudio>().in("id", ids));
        return AjaxResult.success();
    }

}