AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

天然气工程建设项目管理系统--业务子系统

2023-12-24 40
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
云数据库 Tair（兼容Redis），内存型 2GB
推荐场景：
通过缓存加速数据库访问
Redis 开源版，标准版 2GB
推荐场景：
搭建游戏排行榜
简介： 天然气工程建设项目管理系统--业务子系统

项目编号：BS-XX-168

一，环境介绍

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

开发技术：Springboot+Vue

二，项目简介

对于工程建设而言，目前也越来越多的通过信息化技术和网络技术的应用，来更多的解决信息的传播和业务数据的管理问题。传统的工程建设行业，更多的是通过人工管理这些工程建设中涉及到的各种业务数据和流程，不仅管理繁琐，人员的沟通效率也十分低下，甚至涉及一些索贿受贿的不规范操作。通过信息化的流程化的应用，可以大大提高审批和管理效率，减少中间沟通环节，让所有的业务流程管理更加透明化。

本课题主要研究如何基于软件开发技术实现项目管理系统的开发，主要运用JAVA开发语言的相关技术和前端的技术来实现一个前后端分离的业务管理系统。系统的后台开发主要运用Springboot和Mybatisplus框架来开发实现相关服务接口，前端用主要运用VUE+ElementUI来实现前端开发，通过业务接口对接来实现前后端的交互，数据交互使用JSON的数据格式来实现数据封装，在业务数据存储方面主要使用MYSQL数据库和REDIS缓存数据库进行数据存储。

 

2.1 功能性需求分析

 根据系统功能，系统共（确定）分为9种角色，分别是：

 1、系统管理员（基本信息维护）

 2、用户服务部（可以查询所有项目）

 3、分公司（施工单位）（有可能是多个）（只能查询自己负责的项目）（技术员、材料员2个角色）

 4、安全质量部（可以查询所有项目）

 5、技术设备部（可以查询所有项目）

 6、经营计划部（可以查询所有项目）

 7、财务部（可以查询所有项目）

 8、查询者（登录后可以查询到除“经营计划部”、“财务部”以外的数据）

 各用户角色对应的主要业务操作功能如下：

1.系统管理员的主要功能

  1）分公司管理

  增加、修改、删除分公司。

  涉及的数据项：公司编号（隐藏）、公司名字、备注，3项信息。

  2）用户管理（包含授权）

  增加、修改、删除用户。

  涉及的数据项：用户编号（隐藏）、用户名（建议使用手机号）、姓名、所在公司（或部门）、电话、密码（隐藏）、备注，6项信息。

  3）使用材料管理

  涉及的数据项：材料编号（隐藏）、工程分类（居民、非居民、中压等）、材料名字、材料规格、材料单价、计量单位、备注，7项信息。

2.用户服务部功能

 1）项目查询

 可以在系统中查询全部项目，多条件查询，查看项目详细信息，导出项目到Excel表。

 2）增加项目

 用户点击“增加项目”按钮，弹出窗口，填写项目详细信息，保存即可。

 3）修改项目

 修改的信息项同增加项目时的信息项

 4）删除项目

 将项目“项目状态”修改为“删除”，项目状态为“删除”的项目，其他部门不能查询或修改信息。

 3.分公司（施工单位）功能

 技术人员操作公能：

 1）技术员查询项目

查询范围：自己负责的（当前登录用户负责的项目）项目。（项目在增加时已经指定了“施工公司技术人”）。

 2）技术员填写项目信息字段

 3）技术员填写项目用到的计划领用材料单

 技术员增加、修改、删除用到的材料。

 ①增加：选择材料名字（管理员已经设置好）、填写领用数量、（其他项目）转入数量、备注即可，单价、计量单位自动同步。

 ②修改：只能修改领用数量、转入数量、备注。

 ③删除：删除该项目的这个材料即可。

 材料员操作功能：

 1）材料员查询项目

查询范围：自己所在分公司的全部项目。

 2）完善项目用料管理

选择某一个项目后，在弹出窗口，可以填写该项目的材料的实际用量、流转去向  2个字段，并保存。“工程材料确认单”在该步骤导出。

 3）填写项目材料票交接日期

 4.安全质量部功能

 1）项目查询

  可以在系统中查询全部项目，多条件查询，查看项目详细信息，可以导出数据到Excel表格。

 2）修改项目中对应本部门的字段

 5.技术设备部功能

 1）项目查询（可能有特殊统计功能）

可以在系统中查询全部项目，多条件查询，查看项目详细信息，可以导出数据到Excel表格。

 2）修改项目中对应本部门的字段

6.经营计划部功能

 1）项目查询

可以在系统中查询全部项目，多条件查询，查看项目详细信息，可以导出数据到Excel表格。

 2）修改项目中对应本部门的字段

  7.财务部功能

  1）项目查询

  可以在系统中查询全部项目，多条件查询，查看项目详细信息，可以导出数据到Excel表格。

  2）修改项目中对应本部门的字段

2.2 非功能需求分析

非功能需求从实际运行和使用环境进行分析，主要包括以下两点：

（1）系统页面需求：本系统是业务系统，网页美观大方，简洁朴素，符合业务系统的特征即可。

（2）系统的拓展性需求。系统在设计时要分层设计，后台可以在原有的基础上进行功能增加，方便以后系统的功能拓展。

（3）稳定性需求：本系统要运行稳定，在服务器上运行要保证稳定，运行不能卡顿，操作要流畅。

（4）系统安全性需求。本系统在设计时需要对公司的业务数据保证安全，对数据库必要字段加密，数据要经常备份。

三，系统展示

用户登录

用户管理

角色管理

项目 管理

材料展示

四，核心代码展示

package cn.zwz.data.controller;
import cn.zwz.basics.exception.ZwzException;
import cn.zwz.basics.log.LogType;
import cn.zwz.basics.log.SystemLog;
import cn.zwz.basics.utils.*;
import cn.zwz.data.entity.Setting;
import cn.zwz.data.entity.User;
import cn.zwz.data.service.IFileService;
import cn.zwz.data.service.ISettingService;
import cn.zwz.data.service.IUserService;
import cn.zwz.data.utils.ZwzFileUtils;
import cn.zwz.data.utils.ZwzNullUtils;
import cn.zwz.basics.baseVo.PageVo;
import cn.zwz.basics.baseVo.Result;
import cn.zwz.data.entity.File;
import cn.hutool.core.util.StrUtil;
import cn.zwz.data.vo.OssSettingVo;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.transaction.annotation.Transactional;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
/**
 * 系统文件
 * @author me
 */
@Slf4j
@Controller
@Api(tags = "文件管理")
@RequestMapping("/zwz/file")
@Transactional
public class FileController {
    @Autowired
    private ZwzFileUtils zwzFileUtils;
    @Autowired
    private IUserService iUserService;
    @Autowired
    private IFileService iFileService;
    @Autowired
    private ISettingService iSettingService;
    @PersistenceContext
    private EntityManager entityManager;
    @SystemLog(about = "查询系统文件", type = LogType.DATA_CENTER,doType = "FILE-01")
    @RequestMapping(value = "/getByCondition", method = RequestMethod.GET)
    @ApiOperation(value = "查询系统文件")
    @ResponseBody
    public Result<IPage<File>> getByCondition(@ModelAttribute File file,@ModelAttribute PageVo page) {
        QueryWrapper<File> qw = new QueryWrapper<>();
        if(!ZwzNullUtils.isNull(file.getFKey())) {
            qw.eq("f_key",file.getFKey());
        }
        if(!ZwzNullUtils.isNull(file.getType())) {
            qw.eq("type",file.getType());
        }
        if(!ZwzNullUtils.isNull(file.getName())) {
            qw.eq("name",file.getName());
        }
        IPage<File> fileList = iFileService.page(PageUtil.initMpPage(page),qw);
        OssSettingVo os = getOssSetting();
        Map<String, String> map = new HashMap<>(16);
        for(File e : fileList.getRecords()) {
            if (e.getLocation() != null && Objects.equals(0,e.getLocation())) {
                String url = os.getFileHttp() + os.getFileView() + "/";
                entityManager.detach(e);
                e.setUrl(url + e.getId());
            }
            if (StrUtil.isNotBlank(e.getCreateBy())) {
                if (!map.containsKey(e.getCreateBy())) {
                    QueryWrapper<User> userQw = new QueryWrapper<>();
                    userQw.eq("username",e.getCreateBy());
                    User u = iUserService.getOne(userQw);
                    if (u != null) {
                        e.setNickname(u.getNickname());
                    }
                    map.put(e.getCreateBy(), u.getNickname());
                } else {
                    e.setNickname(map.get(e.getCreateBy()));
                }
            }
        }
        map = null;
        return new ResultUtil<IPage<File>>().setData(fileList);
    }
    @SystemLog(about = "文件复制", type = LogType.DATA_CENTER,doType = "FILE-02")
    @RequestMapping(value = "/copy", method = RequestMethod.POST)
    @ApiOperation(value = "文件复制")
    @ResponseBody
    public Result<Object> copy(@RequestParam String id,@RequestParam String key) {
        File file = iFileService.getById(id);
        if(file.getLocation() == null){
            file.setLocation(0);
        }
        String toKey = "副本_" + key;
        key = file.getUrl();
        String newUrl = zwzFileUtils.copyFile(key, toKey);
        File newFile = new File().setName(file.getName()).setFKey(toKey).setSize(file.getSize()).setType(file.getType()).setLocation(file.getLocation()).setUrl(newUrl);
        iFileService.saveOrUpdate(newFile);
        return ResultUtil.data();
    }
    @SystemLog(about = "文件重命名", type = LogType.DATA_CENTER,doType = "FILE-03")
    @RequestMapping(value = "/rename", method = RequestMethod.POST)
    @ApiOperation(value = "文件重命名")
    @ResponseBody
    public Result<Object> upload(@RequestParam String id, @RequestParam String newKey, @RequestParam String newName) {
        File file = iFileService.getById(id);
        if(file.getLocation() == null){
            file.setLocation(0);
        }
        String newUrl = "";
        String oldKey = file.getFKey();
        if(!Objects.equals(newKey,oldKey)){
            oldKey = file.getUrl();
            newUrl = zwzFileUtils.renameFile(oldKey, newKey);
        }
        file.setName(newName);
        file.setFKey(newKey);
        if(!oldKey.equals(newKey)) {
            file.setUrl(newUrl);
        }
        iFileService.saveOrUpdate(file);
        return ResultUtil.data();
    }
    @SystemLog(about = "文件重命名", type = LogType.DATA_CENTER,doType = "FILE-04")
    @RequestMapping(value = "/delete", method = RequestMethod.POST)
    @ApiOperation(value = "文件重命名")
    @ResponseBody
    public Result<Object> delete(@RequestParam String[] ids) {
        for(String id : ids) {
            File file = iFileService.getById(id);
            if(file.getLocation() == null){
                file.setLocation(0);
            }
            String key = file.getUrl();
            zwzFileUtils.deleteFile(key);
            iFileService.removeById(id);
        }
        return ResultUtil.data();
    }
    @SystemLog(about = "预览文件", type = LogType.DATA_CENTER,doType = "FILE-05")
    @RequestMapping(value = "/view/{id}", method = RequestMethod.GET)
    @ApiOperation(value = "预览文件")
    public void view(@PathVariable String id,@RequestParam(required = false) String filename,@RequestParam(required = false, defaultValue = "false") Boolean preview,HttpServletResponse httpServletResponse) throws IOException {
        File selectFile = iFileService.getById(id);
        if(selectFile == null){
            throw new ZwzException("文件不存在");
        }
        if(ZwzNullUtils.isNull(filename)){
            filename =  selectFile.getFKey();
        }
        if(!preview){
            httpServletResponse.addHeader("Content-Disposition", "attachment; filename=" + URLEncoder.encode(filename, "UTF-8"));
        }
        httpServletResponse.setContentLengthLong(selectFile.getSize());
        httpServletResponse.setContentType(selectFile.getType());
        httpServletResponse.addHeader("Accept-Ranges", "bytes");
        if(selectFile.getSize() != null && selectFile.getSize() > 0){
            httpServletResponse.addHeader("Content-Range", "bytes " + 0 + "-" + (selectFile.getSize()-1) + "/" + selectFile.getSize());
        }
        zwzFileUtils.view(selectFile.getUrl(), httpServletResponse);
    }
    public OssSettingVo getOssSetting() {
        Setting s1 = iSettingService.getById("FILE_VIEW");
        Setting s2 = iSettingService.getById("FILE_HTTP");
        Setting s3 = iSettingService.getById("FILE_PATH");
        if(s1 == null || s1 == null || s1 == null) {
            return null;
        }
        return new OssSettingVo(s1.getValue(),s2.getValue(),s3.getValue());
    }
}
package cn.zwz.data.controller;
import cn.zwz.basics.log.SystemLog;
import cn.zwz.basics.redis.RedisTemplateHelper;
import cn.zwz.basics.utils.*;
import cn.zwz.basics.security.SecurityUserDetails;
import cn.zwz.basics.parameter.CommonConstant;
import cn.zwz.basics.log.LogType;
import cn.zwz.basics.exception.ZwzException;
import cn.zwz.basics.baseVo.PageVo;
import cn.zwz.basics.baseVo.Result;
import cn.zwz.data.entity.*;
import cn.zwz.data.service.*;
import cn.zwz.data.utils.ZwzNullUtils;
import cn.zwz.data.vo.PermissionDTO;
import cn.zwz.data.vo.RoleDTO;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.validation.Valid;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.util.*;
import java.util.stream.Collectors;
/**
 * 用户
 * @author me
 */
@RestController
@Api(tags = "用户接口")
@RequestMapping("/zwz/user")
@CacheConfig(cacheNames = "user")
@Transactional
public class UserController {
    @Autowired
    private IUserService iUserService;
    @Autowired
    private IDepartmentService iDepartmentService;
    @Autowired
    private IRoleService iRoleService;
    @Autowired
    private IUserRoleService iUserRoleService;
    @Autowired
    private IDepartmentHeaderService iDepartmentHeaderService;
    @Autowired
    private IRolePermissionService iRolePermissionService;
    @Autowired
    private RedisTemplateHelper redisTemplateHelper;
    @Autowired
    private IPermissionService iPermissionService;
    @PersistenceContext
    private EntityManager entityManager;
    @Autowired
    private SecurityUtil securityUtil;
    @Autowired
    private StringRedisTemplate redisTemplate;
    private static final String REDIS_PRE_1 = "userRole::";
    private static final String REDIS_PRE_2 = "userRole::depIds:";
    private static final String REDIS_PRE_3 = "permission::userMenuList:";
    private static final String REDIS_PRE_4 = "user::";
    @SystemLog(about = "获取当前登录用户", type = LogType.DATA_CENTER,doType = "USER-02")
    @RequestMapping(value = "/info", method = RequestMethod.GET)
    @ApiOperation(value = "获取当前登录用户")
    public Result<User> getUserInfo(){
        User u = securityUtil.getCurrUser();
        entityManager.clear();
        u.setPassword(null);
        return new ResultUtil<User>().setData(u);
    }
    @RequestMapping(value = "/regist", method = RequestMethod.POST)
    @ApiOperation(value = "注册用户")
    public Result<Object> regist(@Valid User u){
        u.setEmail(u.getMobile() + "@qq.com");
        QueryWrapper<User> userQw = new QueryWrapper<>();
        userQw.and(wrapper -> wrapper.eq("username", u.getUsername()).or().eq("mobile",u.getMobile()));
        if(iUserService.count(userQw) > 0L) {
            return ResultUtil.error("登陆账号/手机号重复");
        }
        String encryptPass = new BCryptPasswordEncoder().encode(u.getPassword());
        u.setPassword(encryptPass).setType(0);
        iUserService.saveOrUpdate(u);
        QueryWrapper<Role> roleQw = new QueryWrapper<>();
        roleQw.eq("default_role",true);
        List<Role> roleList = iRoleService.list(roleQw);
        if(roleList.size() > 0){
            for(Role role : roleList) {
                iUserRoleService.saveOrUpdate(new UserRole().setUserId(u.getId()).setRoleId(role.getId()));
            }
        }
        return ResultUtil.data(u);
    }
    @SystemLog(about = "解锁验证密码", type = LogType.DATA_CENTER,doType = "USER-03")
    @RequestMapping(value = "/unlock", method = RequestMethod.POST)
    @ApiOperation(value = "解锁验证密码")
    public Result<Object> unLock(@RequestParam String password){
        User u = securityUtil.getCurrUser();
        if(!new BCryptPasswordEncoder().matches(password, u.getPassword())){
            return ResultUtil.error("密码不正确");
        }
        return ResultUtil.data(null);
    }
    @SystemLog(about = "重置密码", type = LogType.DATA_CENTER,doType = "USER-04")
    @RequestMapping(value = "/resetPass", method = RequestMethod.POST)
    @ApiOperation(value = "重置密码")
    public Result<Object> resetPass(@RequestParam String[] ids){
        for(String id : ids){
            User userForReset = iUserService.getById(id);
            if(userForReset == null) {
                return ResultUtil.error("不存在");
            }
            userForReset.setPassword(new BCryptPasswordEncoder().encode("123456"));
            iUserService.saveOrUpdate(userForReset);
            redisTemplate.delete(REDIS_PRE_4 + userForReset.getUsername());
        }
        return ResultUtil.success();
    }
    @SystemLog(about = "修改用户资料", type = LogType.DATA_CENTER,doType = "USER-05")
    @RequestMapping(value = "/edit", method = RequestMethod.POST)
    @ApiOperation(value = "修改用户资料",notes = "用户名密码不会修改 需要username更新缓存")
    @CacheEvict(key = "#u.username")
    public Result<Object> editOwn(User u){
        User old = securityUtil.getCurrUser();
        u.setUsername(old.getUsername());
        u.setPassword(old.getPassword());
        iUserService.saveOrUpdate(u);
        return ResultUtil.success("修改成功");
    }
    @SystemLog(about = "修改密码", type = LogType.DATA_CENTER,doType = "USER-06")
    @RequestMapping(value = "/modifyPass", method = RequestMethod.POST)
    @ApiOperation(value = "修改密码")
    public Result<Object> modifyPass(@RequestParam String password,@RequestParam String newPass,@RequestParam String passStrength){
        User user = securityUtil.getCurrUser();
        if(!new BCryptPasswordEncoder().matches(password, user.getPassword())){
            return ResultUtil.error("原密码不正确");
        }
        String newEncryptPass= new BCryptPasswordEncoder().encode(newPass);
        user.setPassword(newEncryptPass);
        user.setPassStrength(passStrength);
        iUserService.saveOrUpdate(user);
        redisTemplate.delete(REDIS_PRE_4 + user.getUsername());
        return ResultUtil.success();
    }
    @SystemLog(about = "查询用户", type = LogType.DATA_CENTER,doType = "USER-07")
    @RequestMapping(value = "/getUserList", method = RequestMethod.GET)
    @ApiOperation(value = "查询用户")
    public Result<IPage<User>> getUserList(@ModelAttribute User user, @ModelAttribute PageVo page) {
        QueryWrapper<User> userQw = new QueryWrapper<>();
        if(!ZwzNullUtils.isNull(user.getNickname())) {
            userQw.like("nickname",user.getNickname());
        }
        if(!ZwzNullUtils.isNull(user.getDepartmentId())) {
            userQw.eq("department_id",user.getDepartmentId());
        }
        IPage<User> userData = iUserService.page(PageUtil.initMpPage(page),userQw);
        for(User u: userData.getRecords()) {
            QueryWrapper<Role> roleQw = new QueryWrapper<>();
            roleQw.inSql("id","SELECT role_id FROM a_user_role WHERE user_id = '" + u.getId() + "'");
            List<Role> list = iRoleService.list(roleQw);
            List<RoleDTO> roleDTOList = list.stream().map(e->{
                return new RoleDTO().setId(e.getId()).setName(e.getName()).setDescription(e.getDescription());
            }).collect(Collectors.toList());
            u.setRoles(roleDTOList);
            entityManager.detach(u);
            u.setPassword(null);
        }
        return new ResultUtil<IPage<User>>().setData(userData);
    }
    @SystemLog(about = "根据部门查询用户", type = LogType.DATA_CENTER,doType = "USER-08")
    @RequestMapping(value = "/getByDepartmentId", method = RequestMethod.GET)
    @ApiOperation(value = "根据部门查询用户")
    public Result<List<User>> getByCondition(@RequestParam String departmentId){
        QueryWrapper<User> userQw = new QueryWrapper<>();
        userQw.eq("department_id", departmentId);
        List<User> list = iUserService.list(userQw);
        entityManager.clear();
        list.forEach(u -> {
            u.setPassword(null);
        });
        return new ResultUtil<List<User>>().setData(list);
    }
    @SystemLog(about = "模拟搜索用户", type = LogType.DATA_CENTER,doType = "USER-09")
    @RequestMapping(value = "/searchByName/{username}", method = RequestMethod.GET)
    @ApiOperation(value = "模拟搜索用户")
    public Result<List<User>> searchByName(@PathVariable String username) throws UnsupportedEncodingException {
        QueryWrapper<User> userQw = new QueryWrapper<>();
        userQw.eq("username", URLDecoder.decode(username, "utf-8"));
        userQw.eq("status", 0);
        List<User> list = iUserService.list(userQw);
        entityManager.clear();
        list.forEach(u -> {
            u.setPassword(null);
        });
        return new ResultUtil<List<User>>().setData(list);
    }
    @SystemLog(about = "查询全部用户", type = LogType.DATA_CENTER,doType = "USER-10")
    @RequestMapping(value = "/getAll", method = RequestMethod.GET)
    @ApiOperation(value = "查询全部用户")
    public Result<List<User>> getAll(){
        List<User> userList = iUserService.list();
        for(User user: userList){
            entityManager.clear();
            user.setPassword(null);
        }
        return new ResultUtil<List<User>>().setData(userList);
    }
    @SystemLog(about = "管理员修改资料", type = LogType.DATA_CENTER,doType = "USER-11")
    @RequestMapping(value = "/admin/edit", method = RequestMethod.POST)
    @ApiOperation(value = "管理员修改资料")
    @CacheEvict(key = "#u.username")
    public Result<Object> edit(User u,@RequestParam(required = false) String[] roleIds){
        User customaryUser = iUserService.getById(u.getId());
        // 登陆账号和密码不能发生变更
        u.setUsername(customaryUser.getUsername());
        u.setPassword(customaryUser.getPassword());
        if(!Objects.equals(customaryUser.getMobile(),u.getMobile())) {
            QueryWrapper<User> customaryUserQw = new QueryWrapper<>();
            customaryUserQw.ne("id",customaryUser.getId());
            customaryUserQw.eq("mobile",u.getMobile());
            long customaryUserCount = iUserService.count(customaryUserQw);
            if(customaryUserCount > 0) {
                return ResultUtil.error("手机号重复");
            }
        }
        if(!ZwzNullUtils.isNull(u.getDepartmentId())) {
            Department department = iDepartmentService.getById(u.getDepartmentId());
            if(department != null) {
                u.setDepartmentTitle(department.getTitle());
            }
        } else {
            u.setDepartmentId("");
            u.setDepartmentTitle("");
        }
        // 吃哦就花
        iUserService.saveOrUpdate(u);
        QueryWrapper<UserRole> userRoleQw = new QueryWrapper<>();
        userRoleQw.eq("user_id",u.getId());
        iUserRoleService.remove(userRoleQw);
        if(roleIds != null && roleIds.length > 0) {
            for (String roleId : roleIds) {
                UserRole ur = new UserRole();
                ur.setUserId(u.getId());
                ur.setRoleId(roleId);
                iUserRoleService.saveOrUpdate(ur);
            }
        }
        redisTemplate.delete(REDIS_PRE_1 + u.getId());
        redisTemplate.delete(REDIS_PRE_2 + u.getId());
        redisTemplate.delete(REDIS_PRE_3 + u.getId());
        return ResultUtil.success();
    }
    @SystemLog(about = "添加用户", type = LogType.DATA_CENTER,doType = "USER-12")
    @RequestMapping(value = "/admin/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加用户")
    public Result<Object> add(@Valid User u,@RequestParam(required = false) String[] roleIds) {
        QueryWrapper<User> userQw = new QueryWrapper<>();
        userQw.and(wrapper -> wrapper.eq("username", u.getUsername()).or().eq("mobile",u.getMobile()));
        if(iUserService.count(userQw) > 0L) {
            return ResultUtil.error("登陆账号/手机号重复");
        }
        if(!ZwzNullUtils.isNull(u.getDepartmentId())){
            Department department = iDepartmentService.getById(u.getDepartmentId());
            if(department != null){
                u.setDepartmentTitle(department.getTitle());
            }
        }else{
            u.setDepartmentId("");
            u.setDepartmentTitle("");
        }
        u.setPassword(new BCryptPasswordEncoder().encode(u.getPassword()));
        iUserService.saveOrUpdate(u);
        if(roleIds != null && roleIds.length > 0) {
            for (String roleId : roleIds) {
                UserRole userRole = new UserRole();
                userRole.setUserId(u.getId());
                userRole.setRoleId(roleId);
                iUserRoleService.saveOrUpdate(userRole);
            }
        }
        return ResultUtil.success();
    }
    @SystemLog(about = "禁用用户", type = LogType.DATA_CENTER,doType = "USER-13")
    @RequestMapping(value = "/disable", method = RequestMethod.POST)
    @ApiOperation(value = "禁用用户")
    public Result<Object> disable( @RequestParam String id){
        User user = iUserService.getById(id);
        if(user == null){
            return ResultUtil.error("用户不存在");
        }
        user.setStatus(CommonConstant.USER_STATUS_LOCK);
        iUserService.saveOrUpdate(user);
        redisTemplate.delete("user::"+user.getUsername());
        return ResultUtil.success();
    }
    @SystemLog(about = "启用用户", type = LogType.DATA_CENTER,doType = "USER-14")
    @RequestMapping(value = "/enable", method = RequestMethod.POST)
    @ApiOperation(value = "启用用户")
    public Result<Object> enable(@RequestParam String id){
        User user = iUserService.getById(id);
        if(user==null){
            return ResultUtil.error("用户不存在");
        }
        user.setStatus(CommonConstant.USER_STATUS_NORMAL);
        iUserService.saveOrUpdate(user);
        redisTemplate.delete("user::"+user.getUsername());
        return ResultUtil.success();
    }
    @SystemLog(about = "删除用户", type = LogType.DATA_CENTER,doType = "USER-15")
    @RequestMapping(value = "/delByIds", method = RequestMethod.POST)
    @ApiOperation(value = "删除用户")
    public Result<Object> delByIds(@RequestParam String[] ids) {
        for(String id:ids){
            User u = iUserService.getById(id);
            redisTemplate.delete("user::" + u.getUsername());
            redisTemplate.delete("userRole::" + u.getId());
            redisTemplate.delete("userRole::depIds:" + u.getId());
            redisTemplate.delete("permission::userMenuList:" + u.getId());
            Set<String> keys = redisTemplateHelper.keys("department::*");
            redisTemplate.delete(keys);
            iUserService.removeById(id);
            QueryWrapper<UserRole> urQw = new QueryWrapper<>();
            urQw.eq("user_id",id);
            iUserRoleService.remove(urQw);
            QueryWrapper<DepartmentHeader> dhQw = new QueryWrapper<>();
            dhQw.eq("user_id",id);
            iDepartmentHeaderService.remove(dhQw);
        }
        return ResultUtil.success();
    }
    @SystemLog(about = "导入用户", type = LogType.DATA_CENTER,doType = "USER-16")
    @RequestMapping(value = "/importData", method = RequestMethod.POST)
    @ApiOperation(value = "导入用户")
    public Result<Object> importData(@RequestBody List<User> users){
        List<Integer> errors = new ArrayList<>();
        List<String> reasons = new ArrayList<>();
        int count = 0;
        for(User u: users){
            count++;
            if(StrUtil.isBlank(u.getUsername())||StrUtil.isBlank(u.getPassword())){
                errors.add(count);
                reasons.add("账号密码为空");
                continue;
            }
            QueryWrapper<User> userQw = new QueryWrapper<>();
            userQw.eq("username",u.getUsername());
            if(iUserService.count(userQw) > 0L) {
                errors.add(count);
                reasons.add("用户名已存在");
                continue;
            }
            u.setPassword(new BCryptPasswordEncoder().encode(u.getPassword()));
            if(StrUtil.isNotBlank(u.getDepartmentId())){
                Department department = iDepartmentService.getById(u.getDepartmentId());
                if(department == null) {
                    errors.add(count);
                    reasons.add("部门不存在");
                    continue;
                }
            }
            if(u.getStatus()==null){
                u.setStatus(CommonConstant.USER_STATUS_NORMAL);
            }
            iUserService.saveOrUpdate(u);
            if(u.getDefaultRole() != null && u.getDefaultRole()==1) {
                QueryWrapper<Role> roleQw = new QueryWrapper<>();
                roleQw.eq("default_role",true);
                List<Role> roleList = iRoleService.list(roleQw);
                if(roleList!=null&&roleList.size()>0){
                    for(Role role : roleList){
                        UserRole ur = new UserRole().setUserId(u.getId()).setRoleId(role.getId());
                        iUserRoleService.saveOrUpdate(ur);
                    }
                }
            }
        }
        int successCount = users.size() - errors.size();
        String successMessage = "成功导入 " + successCount + " 位用户";
        String failMessage = "成功导入 " + successCount + " 位用户，失败 " + errors.size() + " 位用户。<br>" +"第 " + errors.toString() + " 行数据导入出错，错误原因是为 <br>" + reasons.toString();
        String message = null;
        if(errors.size() == 0){
            message = successMessage;
        }else{
            message = failMessage;
        }
        return ResultUtil.success(message);
    }
    @ApiOperation(value = "添加用户的角色和菜单信息")
    public User userToDTO(User user) {
        if(user == null) {
            return null;
        }
        // 角色
        QueryWrapper<UserRole> urQw = new QueryWrapper<>();
        urQw.eq("user_id", user.getId());
        List<UserRole> roleList = iUserRoleService.list(urQw);
        List<RoleDTO> roleDTOList = new ArrayList<>();
        for (UserRole userRole : roleList) {
            Role role = iRoleService.getById(userRole.getRoleId());
            if(role != null) {
                roleDTOList.add(new RoleDTO().setId(role.getId()).setName(role.getName()));
            }
        }
        user.setRoles(roleDTOList);
        // 菜单
        List<String> permissionIdList = new ArrayList<>();
        for (RoleDTO dto : roleDTOList) {
            QueryWrapper<RolePermission> rpQw = new QueryWrapper<>();
            rpQw.eq("role_id",dto.getId());
            List<RolePermission> list = iRolePermissionService.list(rpQw);
            for (RolePermission rp : list) {
                boolean flag = true;
                for (String id : permissionIdList) {
                    if(Objects.equals(id,rp.getPermissionId())) {
                        flag = false;
                        break;
                    }
                }
                if(flag) {
                    permissionIdList.add(rp.getPermissionId());
                }
            }
        }
        List<PermissionDTO> permissionDTOList = new ArrayList<>();
        for (String id : permissionIdList) {
            Permission permission = iPermissionService.getById(id);
            if(permission != null) {
                if(Objects.equals(permission.getType(),CommonConstant.PERMISSION_OPERATION)) {
                    continue;
                }
                permissionDTOList.add(new PermissionDTO().setTitle(permission.getTitle()).setPath(permission.getPath()));
            }
        }
        user.setPermissions(permissionDTOList);
        return user;
    }
}

五，相关作品展示

基于Java开发、Python开发、PHP开发、C#开发等相关语言开发的实战项目

基于Nodejs、Vue等前端技术开发的前端实战项目

基于微信小程序和安卓APP应用开发的相关作品

基于51单片机等嵌入式物联网开发应用

基于各类算法实现的AI智能应用

基于大数据实现的各类数据管理和推荐系统

文章标签：
云数据库 Tair（兼容 Redis）
项目管理
前端开发
Java
安全
数据库
相关实践学习
基于Redis实现在线游戏积分排行榜
本场景将介绍如何基于Redis数据库实现在线游戏中的游戏玩家积分排行榜功能。
云数据库 Redis 版使用教程
云数据库Redis版是兼容Redis协议标准的、提供持久化的内存数据库服务，基于高可靠双机热备架构及可无缝扩展的集群架构，满足高读写性能场景及容量需弹性变配的业务需求。 产品详情：https://www.aliyun.com/product/kvstore &nbsp; &nbsp; ------------------------------------------------------------------------- 阿里云数据库体验：数据库上云实战 开发者云会免费提供一台带自建MySQL的源数据库&nbsp;ECS 实例和一台目标数据库&nbsp;RDS实例。跟着指引，您可以一步步实现将ECS自建数据库迁移到目标数据库RDS。 点击下方链接，领取免费ECS&amp;RDS资源，30分钟完成数据库上云实战！https://developer.aliyun.com/adc/scenario/51eefbd1894e42f6bb9acacadd3f9121?spm=a2c6h.13788135.J_3257954370.9.4ba85f24utseFl
编程指南针
目录
相关文章
Echo_Wish
|
6月前
|
监控 供应链 物联网
ERP系统中的在制品管理与工艺路线规划
ERP系统中的在制品管理与工艺路线规划
Echo_Wish
202 2
高端源码库
|
3月前
|
传感器 监控 安全
智慧建造综合管理平台系统，智慧工地施工现场解决方案
智慧工地解决方案针对建筑行业安全管理难、用工管理难等痛点，采用AI、物联网、BIM等技术，实现工地全方位管理。通过BIM大屏可视化、塔吊监测、吊钩可视化、升降机监测等手段，加强施工安全预警；智能识别技术确保人员、设备安全；用水用电、环境监测等模块实现资源节约；地磅、车辆管理和实名制考勤提升管理效率，共同构建安全、高效、精益的施工环境。
高端源码库
146 1
智慧建造综合管理平台系统，智慧工地施工现场解决方案
河北稳控科技
|
5月前
|
安全
地下综合管廊工程是一种将各类地下管线集中管理的工程
地下综合管廊工程是一种将各类地下管线集中管理的工程
河北稳控科技
35 2
地下综合管廊工程是一种将各类地下管线集中管理的工程
源码星辰
|
6月前
|
人工智能 监控 安全
Springcloud数字化物联网智慧工地综合平台源码 劳务管理、设备管理、绿色施工
Springcloud数字化物联网智慧工地综合平台源码 劳务管理、设备管理、绿色施工
源码星辰
140 3
明月看潮生
|
6月前
|
存储
制造企业产品成本核算功能设计实例
制造企业产品成本核算功能设计实例
明月看潮生
88 4
编程千纸鹤
|
6月前
|
前端开发 安全 Java
天然气工程建设项目管理系统--业务子系统
天然气工程建设项目管理系统--业务子系统
编程千纸鹤
47 0
源码星辰
|
6月前
|
传感器 人工智能 监控
智慧工地管理系统加快推进工程建设项目全生命周期数字化
智慧工地管理系统加快推进工程建设项目全生命周期数字化
源码星辰
875 0
开源MES
|
传感器 运维 监控
制造业工厂万界星空科技云MES系统中的设备管理模块
随时工厂数字化建设的大力推进，设备管理的效率得到了很大的提升，特别是作为机加工企业，设备是整个企业非常重要的核心资产。
开源MES
81 0
高端源码库
|
监控 安全 物联网
智慧工地云平台源码 项目工程管理
通过运用物联网、大数据、云计算、BIM 、5G等技术，搭建由劳务管理、质量安全数据预警、施工现场视频实时监控、重大危险源和绿色文明施工监控等板块构成的模块化、一站式的信息化管理平台。平台可实现施工现场数据采集、数据综合统计及分析、手机App 应用等，现场数据分层次呈现给施工现场项目部、建筑企业、政府主管部门及监督机构等，以进行决策参考。
高端源码库
244 0
开发者小助理
|
数据可视化 BI
【一键启用】生产跟踪｜解决制造企业生产管理难题
生产跟踪是一款适用于离散型生产制造企业实现智能生产管理的模板。针对性解决生产进度无从知晓、任务分工不透明、生产过程管控效率低、各类生产报表统计费时费力等痛点问题。
开发者小助理
225 0
【一键启用】生产跟踪｜解决制造企业生产管理难题

热门文章

最新文章

  • 1
    《UVM实战》——3.3节field automation机制
  • 2
    QSqlDatabase: QMYSQL driver not loaded 解决方案
  • 3
    关于规则引擎的选型和疑惑思考
  • 4
    揭秘2017双11背后的网络－双11的网络产品和技术概览
  • 5
    前端开发：遇到This relative module was not found 的解决方法
  • 6
    Spring装配Bean---使用xml配置
  • 7
    SCDPM2012配置及客户端安装（二)
  • 8
    Ext.Ajax.request和formPanel.getForm().submit两种提交方法的异同
  • 9
    IBatis.Net学习笔记七--日志处理
  • 10
    一个实用的PHP缓存类
  • 1
    修改JAR文件工具
    32
  • 2
    鸿蒙开发：自定义一个动态输入框
    23
  • 3
    《C++ 人工智能模型邂逅云平台：集成之路的策略与要点全解析》
    27
  • 4
    《C++与人工智能在工业自动化故障诊断中的“智慧融合”大揭秘》
    29
  • 5
    【Azure 环境】使用Azure bicep对多个ServicePrinciple 进行role assignment分配
    25
  • 6
    锁膨胀
    21
  • 7
    官宣！杭州市地铁集团与阿里云达成战略合作
    19
  • 8
    最新！阿里云入选福布斯·出海全球化品牌Top30
    20
  • 9
    无影领衔！阿里云四项核心技术荣获科技进步一等奖
    83
  • 10
    阿里云携手天津医保局，荣获2024全国智慧医保大赛一等奖！
    26

    • 相关课程

    更多
  • 软件用户使用服务及供应商进阶管理
  • 企业运维监控平台架构设计与实现
  • 软件供应商发布服务实操
  • 瓴羊数据荟——Dataphin零售企业质量管理
  • 项目管理与高效沟通协作
  • 企业级互联网分布式系统应用架构学习

    • 相关电子书

    更多
  • 电子签约如何驱动 企业高效运营
  • 破壁计划--顺丰IT运维转型的最初一公里
  • 数据运营系统实现方案浅析

    • 相关实验场景

    更多
  • 快速开发光伏电站数字孪生运维系统
  • 物联网设备安全：实时检测7类安全风险（Agentless）
  • 【企业数据中台交付】数据回刷实验
  • 汽车产线生产管控实操
  • 新能源电动车监控数据上报
  • 应对智慧医保复杂的业务结算
    • 下一篇
    无影云桌面