blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
zxl
9 分钟以前 3b0516a2959e25576e4f3fda697a3b025d06c8c9 
 ycl-server/src/main/java/com/ycl/platform/service/impl/YwPeopleServiceImpl.java


@@ -1,25 +1,43 @@


package com.ycl.platform.service.impl;




import com.ycl.platform.domain.entity.YwPeople;


import com.ycl.platform.domain.entity.YwUnit;


import com.ycl.platform.mapper.YwPeopleMapper;


import com.ycl.platform.mapper.YwUnitMapper;


import com.ycl.platform.service.YwPeopleService;


import com.ycl.system.Result;


import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;


import com.ycl.platform.domain.form.YwPeopleForm;


import com.ycl.platform.domain.vo.YwPeopleVO;


import com.ycl.platform.domain.query.YwPeopleQuery;




import java.util.Collections;


import java.util.Date;


import java.util.List;




import com.baomidou.mybatisplus.core.metadata.IPage;


import com.ycl.system.domain.SysUserRole;


import com.ycl.system.entity.SysRole;


import com.ycl.system.entity.SysUser;


import com.ycl.system.mapper.SysConfigMapper;


import com.ycl.system.mapper.SysRoleMapper;


import com.ycl.system.mapper.SysUserMapper;


import com.ycl.system.mapper.SysUserRoleMapper;


import com.ycl.system.page.PageUtil;


import com.ycl.utils.SecurityUtils;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.security.crypto.password.PasswordEncoder;


import org.springframework.stereotype.Service;


import org.springframework.beans.BeanUtils;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.util.Assert;




import java.util.Objects;


import java.util.stream.Collectors;




import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;


import lombok.RequiredArgsConstructor;


import org.springframework.util.StringUtils;




/**


 * 运维人员 服务实现类


@@ -32,19 +50,57 @@


public class YwPeopleServiceImpl extends ServiceImpl<YwPeopleMapper, YwPeople> implements YwPeopleService {




    private final YwPeopleMapper ywPeopleMapper;




    private final YwUnitMapper ywUnitMapper;


    private final SysUserMapper sysUserMapper;


    private final SysUserRoleMapper sysUserRoleMapper;


    private final SysRoleMapper sysRoleMapper;


    private final SysConfigMapper sysConfigMapper;


    /**


     * 添加


     * @param form


     * @return


     */


    @Override


    @Transactional(rollbackFor = Exception.class)


    public Result add(YwPeopleForm form) {


        // 为运维人员添加账号


        SysUser sysUser = new SysUser();


        fullUser(sysUser, form);


        sysUserMapper.insertUser(sysUser);


        // 获取运维人员角色


        SysRole sysRole = sysRoleMapper.selectRoleByKey("yw_user");


        if (Objects.isNull(sysRole)) { return Result.error("运维角色不存在"); }


        // 绑定账号角色关系


        SysUserRole sysUserRole = new SysUserRole();


        sysUserRole.setRoleId(sysRole.getRoleId());


        sysUserRole.setUserId(sysUser.getUserId());


        sysUserRoleMapper.batchUserRole(Collections.singletonList(sysUserRole));




        YwPeople entity = YwPeopleForm.getEntityByForm(form, null);


        entity.setUserId(sysUser.getUserId());


        entity.setAddWay("manual");


        Date now = new Date();


        entity.setCreateTime(now);


        entity.setUpdateTime(now);


        if(baseMapper.insert(entity) > 0) {


            return Result.ok("添加成功");


        }


        return Result.error("添加失败");


    }




    /**


     * 赋值user


     * @param sysUser


     * @param form


     */


    public void fullUser(SysUser sysUser, YwPeopleForm form) {


        sysUser.setUserName(form.getYwPersonAccount());


        String password = sysConfigMapper.checkConfigKeyUnique("sys.user.initPassword").getConfigValue();


        sysUser.setPassword(SecurityUtils.encryptPassword(password));


        sysUser.setStatus("0");


        sysUser.setFirstLogin((short) 0);


        sysUser.setNickName(form.getYwPersonName());


        sysUser.setUnitId(form.getBelongUnit());


    }




    /**


@@ -53,13 +109,21 @@


     * @return


     */


    @Override


    @Transactional(rollbackFor = Exception.class)


    public Result update(YwPeopleForm form) {




        YwPeople entity = baseMapper.selectById(form.getId());




        // 为空抛IllegalArgumentException，做全局异常处理


        Assert.notNull(entity, "记录不存在");




        SysUser sysUser = sysUserMapper.selectUserById(entity.getUserId());


        sysUser.setUserName(form.getYwPersonAccount());


        sysUser.setNickName(form.getYwPersonName());


        sysUserMapper.updateUser(sysUser);




        BeanUtils.copyProperties(form, entity);


        Date now = new Date();


        entity.setUpdateTime(now);


        if (baseMapper.updateById(entity) > 0) {


            return Result.ok("修改成功");


        }


@@ -72,11 +136,19 @@


     * @return


     */


    @Override


    @Transactional(rollbackFor = Exception.class)


    public Result remove(List<String> ids) {


        if(baseMapper.deleteBatchIds(ids) > 0) {


            return Result.ok("删除成功");


        List<YwPeople> list = new LambdaQueryChainWrapper<>(baseMapper)


                .select(YwPeople::getUserId)


                .in(YwPeople::getId, ids)


                .list();


        List<Long> userIds = list.stream().map(YwPeople::getUserId).collect(Collectors.toList());


        baseMapper.deleteBatchIds(ids);


        if (!userIds.isEmpty()) {


            sysUserRoleMapper.deleteUserRoleByUserIds(userIds);


            sysUserMapper.deleteUserByIds(userIds.toArray(new Long[0]));


        }


        return Result.error("删除失败");


        return Result.ok("删除成功");


    }




    /**


@@ -85,11 +157,12 @@


     * @return


     */


    @Override


    @Transactional(rollbackFor = Exception.class)


    public Result removeById(String id) {


        if(baseMapper.deleteById(id) > 0) {


            return Result.ok("删除成功");


        }


        return Result.error("删除失败");


        YwPeople ywPeople = baseMapper.selectById(id);


        sysUserMapper.deleteUserById(ywPeople.getUserId());


        baseMapper.deleteById(id);


        return Result.ok("删除成功");


    }




    /**


@@ -101,12 +174,25 @@


    public Result page(YwPeopleQuery query) {




        IPage<YwPeople> page = new LambdaQueryChainWrapper<>(baseMapper)


                .eq(StringUtils.hasText(query.getYwPersonCode()), YwPeople::getYwPersonCode, query.getYwPersonCode())


                .like(StringUtils.hasText(query.getYwPersonName()), YwPeople::getYwPersonName, query.getYwPersonName())


                .eq(Objects.nonNull(query.getBelongUnit()), YwPeople::getBelongUnit, query.getBelongUnit())


                .orderByDesc(YwPeople::getCreateTime)


                .page(PageUtil.getPage(query, YwPeople.class));




        List<YwPeopleVO> vos = page.getRecords().stream()


                .map(


                        entity -> YwPeopleVO.getVoByEntity(entity, null)


                        entity -> {


                            YwPeopleVO vo = YwPeopleVO.getVoByEntity(entity, null);


                            YwUnit unit = new LambdaQueryChainWrapper<>(ywUnitMapper)


                                    .eq(YwUnit::getId, vo.getBelongUnit())


                                    .select(YwUnit::getUnitName)


                                    .one();


                            if (Objects.nonNull(unit)) {


                                vo.setBelongUnitName(unit.getUnitName());


                            }


                            return vo;


                        }


                )


                .collect(Collectors.toList());


        return Result.ok().data(vos).total(page.getTotal());


@@ -140,4 +226,12 @@


                .collect(Collectors.toList());


        return Result.ok().data(vos);


    }




    @Override


    public Result getPeopleByUnitId(String id) {


        List<YwPeople> entities = new LambdaQueryChainWrapper<>(baseMapper)


                .eq(YwPeople::getBelongUnit, id)


                .list();


        return Result.ok().data(entities);


    }


}