代码编织梦想

文件系统的实现描述

技术栈运用

后端技术栈 springboot + mybatis
数据库 mysql 5.7
前端 vue cli3.0 (axios、element ui)
分布式文件存储系统 FastDFS

功能实现

前台

前台展示用户上传的经过审核之后的文件相关信息,通过下拉框确定搜索的条件,进行相关内容的模糊查询,根据定位的相关信息,可以预览查看文件相关的详细信息,以及进行附件的下载操作(下载会判断五文件的属性,是否为非公开文件,公开的可以直接下载,反之需要进行登录认证操作,并记录日志)

  • 多维度条件搜索(下拉框实现)

在这里插入图片描述

  • 页面跳转详情预览
    在这里插入图片描述
  • 预览文件
    在这里插入图片描述
  • 文件下载
    在这里插入图片描述

后台

后台分为六个板块:

  • 用户管理:新增用户(校验用户昵称是否系统重复),维护用户的登录名称,登录密码,以及真实名称,部门信息,可以删除用户,修改用户密码,(会校验用户的旧密码,进行新密码的修改)
  • 文档管理:新增文档信息(包括上传附件),详情查看(预览附件信息),信息修改,管理端可以对用户上传的文件进行(审核、下线)操作,用户端文档信息上传(区分不同用户只能看到自己上传的文件)
  • 操作日志:记录前台用户下载附件的操作信息
  • 文件类型、标准管理:基本的增删改查操作
  • 部门信息:该部分通过树形结构,可以维护三级部门信息,删除操作会校验部门的引用信息,以及下级部门引用,控制上级部门的删除操作
  • 统计信息管理:该功能为了根据文件类型、文件标准两个维度去统计用户上传的文件数量
  • 用户管理模板
    在这里插入图片描述

  • 文档管理
    在这里插入图片描述

  • 操作日志
    在这里插入图片描述

  • 部门管理

在这里插入图片描述

  • 标准等级管理
    在这里插入图片描述
  • 标准层级管理
    在这里插入图片描述
  • 数据统计管理
    在这里插入图片描述

核心功能代码

部门管理

package com.core.doc.controller.dept;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.doc.DTO.DeptInfoToReg;
import com.core.doc.DTO.DeptShowInfo;
import com.core.doc.entity.DeptInfo;
import com.core.doc.entity.Login;
import com.core.doc.entity.UserInfo;
import com.core.doc.mapper.DeptInfoMapper;
import com.core.doc.mapper.LoginMapper;
import com.core.doc.mapper.UserInfoMapper;
import com.core.doc.response.Result;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/dept")
public class DeptContorller {


    @Autowired
    DeptInfoMapper deptInfoMapper;

    @Autowired
    UserInfoMapper usermapper;

    @ApiOperation(value = "增加部门信息")
    @PostMapping("/add")
    public Result getDetail(@RequestBody DeptInfo deptInfo){
        int insert = deptInfoMapper.insert(deptInfo);
        System.out.println(deptInfo.getDeptid());

        if(insert > 0){
            return Result.ok();
        }
        return Result.error();
    }

    @ApiOperation(value = "删除部门信息")
    @PostMapping("/del")
    public Result del(Integer id){
        QueryWrapper<UserInfo> userQuery = new QueryWrapper<>();
        userQuery.eq("deptId",id);

        Integer check = usermapper.selectCount(userQuery);
        if(check > 0){
            return Result.error();
        }
        QueryWrapper<DeptInfo> wrapper = new QueryWrapper<>();;
        wrapper.eq("parent",id);
        int count = 0;
        List<DeptInfo> list = deptInfoMapper.selectList(wrapper);
        System.out.println(list);
        if(list != null && list.size() >0){
            Set<Integer> set = list.stream().map(x -> x.getDeptid()).collect(Collectors.toSet());
            Map<String, Set<Integer>> map = new HashMap<>();
            map.put("parent",set);
            wrapper.or()
                    .in("parent",set)
                    .or()
                    .eq("deptId",id);
            List<DeptInfo> deptInfos = deptInfoMapper.selectList(wrapper);
            Set<Integer> deptscollect = deptInfos.stream().map(x -> x.getDeptid()).collect(Collectors.toSet());
            userQuery.or().in("deptId",deptscollect);
            check = usermapper.selectCount(userQuery);
            if(check > 0){
                return Result.error();
            }
            count = deptInfoMapper.delete(wrapper);
        }else {
            QueryWrapper<DeptInfo>  newwrapper = new QueryWrapper<>();
            newwrapper.eq("deptId",id);
            count = deptInfoMapper.delete(newwrapper);
        }

        if(count > 0){
            return Result.ok();
        }
        return Result.error();
    }

    @ApiOperation(value = "查询部门信息")
    @PostMapping("/detail")
    public Result getDetail(Integer id){
        DeptInfo deptInfo = deptInfoMapper.selectByPrimaryKey(id);
        return Result.ok().data("msg",deptInfo);
    }

    @ApiOperation(value = "修改部门信息")
    @PostMapping("/updata")
    public Result updatainfo(@RequestBody DeptInfo deptInfo){
        int i = deptInfoMapper.updateById(deptInfo);
        if (i > 0){
            return Result.ok().data("msg",deptInfo);
        }else {
            return Result.error();
        }
    }

    @ApiOperation(value = "获取所有的部门信息")
    @PostMapping("/info")
    public Result getAllDeptInfo(){
        List<DeptInfo> deptInfos = deptInfoMapper.selectList(null);
        // level_id : parent_id
        Map<Integer,Integer> allmap =  transform(deptInfos);

        List<DeptShowInfo> level1 = new ArrayList<>();
        List<DeptShowInfo> level2 = new ArrayList<>();

        for (DeptInfo info : deptInfos) {
            DeptShowInfo resData = new DeptShowInfo();
            resData.setEdit(false);
            resData.setId(info.getDeptid());
            resData.setDeptid(info.getDeptid());
            resData.setLabel(info.getDeptname());
            if(info.getParent() == 0){
                level1.add(resData);
            }else {
                level2.add(resData);
            }
        }
        DeptShowInfo[] deptShowInfos = new DeptShowInfo[level1.size()];
        Map<Integer,DeptShowInfo> lis = transtoMap(level2);
        Map<Integer,DeptShowInfo> temp1map =  transform1(level1);
        Map<Integer,DeptShowInfo> temp2map =  transform1(level2);

        for (DeptShowInfo info : level2) {

            Integer parentid = allmap.get(info.getId());
            if (temp1map.get(parentid) !=null){
                if(temp1map.get(parentid).getChildren() ==null){
                    List<DeptShowInfo> infos = new ArrayList<>();
                    infos.add(info);
                    temp1map.get(parentid).setChildren(infos);
                }else {
                    temp1map.get(parentid).getChildren().add(info);
                }
            }
            if (temp2map.get(parentid) !=null){
                if(temp2map.get(parentid).getChildren() ==null){
                    List<DeptShowInfo> infos = new ArrayList<>();
                    infos.add(info);
                    temp2map.get(parentid).setChildren(infos);
                }else {
                    temp2map.get(parentid).getChildren().add(info);
                }
            }

        }


        return Result.ok().data("msg",level1.toArray());
    }

    private Map<Integer, DeptShowInfo> transtoMap(List<DeptShowInfo> level2) {
        Map<Integer, DeptShowInfo> map = new HashMap<>();
        for (DeptShowInfo info : level2) {
            map.put(info.getId(),info);
        }
        return map;
    }

    private Map<Integer, Integer> transform(List<DeptInfo> deptInfos) {
        Map<Integer,Integer> map = new HashMap<>();
        for (DeptInfo info : deptInfos) {
            map.put(info.getDeptid(),info.getParent());
        }
        return map;
    }

    private Map<Integer, DeptShowInfo> transform1(List<DeptShowInfo> deptInfos) {
        Map<Integer,DeptShowInfo> map = new HashMap<>();
        for (DeptShowInfo info : deptInfos) {
            map.put(info.getId(),info);
        }
        return map;
    }

    @ApiOperation(value = "获取部门的信息用于用户的信息注册")
    @PostMapping("/deptinfotoregis")
    public Result getAllDeptInfoToRegist(){
        List<DeptInfo> deptInfos = deptInfoMapper.selectList(null);
        List<DeptInfoToReg> regs = new ArrayList<>();
        for (DeptInfo info : deptInfos) {
            regs.add(new DeptInfoToReg(info.getDeptid(), info.getDeptname()));
        }
        return Result.ok().data("msg",regs);
    }

}

统计数据

package com.core.doc.project;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.doc.entity.FileInfo;
import com.core.doc.entity.FileLevel;
import com.core.doc.entity.FileType;
import com.core.doc.mapper.FileInfoMapper;
import com.core.doc.mapper.FileLevelMapper;
import com.core.doc.mapper.FileTypeMapper;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;
import java.util.stream.Collectors;

//import org.springframework.util.ObjectUtils;
@RestController
@RequestMapping("/query")
public class QueryController {

    @Autowired
    FileLevelMapper fileLevelMapper;

    @Autowired
    FileTypeMapper fileTypeMapper;

    @Autowired
    FileInfoMapper fileInfoMapper;

    public static List<FTobj> toA() {
        FTobj l1 = new FTobj(1, "ZSA");
        FTobj l2 = new FTobj(2, "LSA");
        FTobj l3 = new FTobj(3, "WWA");
        FTobj l4 = new FTobj(4, "ZZA");
        List<FTobj> list = new LinkedList<>();
        list.add(l1);
        list.add(l2);
        list.add(l3);
        list.add(l4);
        return list;
    }

    public static List<FTobj> toB() {
        FTobj l1 = new FTobj(11, "ZSB");
        FTobj l2 = new FTobj(22, "LSB");
        FTobj l3 = new FTobj(33, "WWB");
        FTobj l4 = new FTobj(44, "ZZB");
        List<FTobj> list = new LinkedList<>();
        list.add(l1);
        list.add(l2);
        list.add(l3);
        list.add(l4);
        return list;
    }

    public List<ResutlData> toData(Map<String, Set<String>> map) {
        for (Map.Entry<String, Set<String>> entry : map.entrySet()) {
            for (String s : entry.getValue()) {
//                System.out.println(entry.getKey() + ":" + s);
            }
        }
        List<ResutlData> resutlData = new LinkedList<>();
        List<FileInfo> list = fileInfoMapper.selectList(null);
//        Map<Integer, Integer> collect = list.stream().collect(Collectors.toMap(FileInfo::getFiletypeid, FileInfo::getFilestandardid));
        HashMap<Integer, Map<Integer, Integer>> listHashMap = new LinkedHashMap<>();

        for (FileInfo info : list) {
           Map<Integer, Integer> mapList =  listHashMap.get(info.getFiletypeid());
            if(mapList == null){
                HashMap<Integer, Integer> map1 = new HashMap<>();
                map1.put(info.getFilestandardid(),1);
                listHashMap.put(info.getFiletypeid(),map1);
            }else {
                Integer integer = mapList.get(info.getFilestandardid());
                if (integer == null){
                    mapList.put(info.getFilestandardid(),1);
                }
                else {
                    Integer count = mapList.get(info.getFilestandardid());
                    mapList.put(info.getFilestandardid(),count + 1);
                }
            }
        }
//        System.out.println();
        for (Map.Entry<Integer, Map<Integer, Integer>> entry : listHashMap.entrySet()) {
            for (Map.Entry<Integer, Integer> integerEntry : entry.getValue().entrySet()) {
                resutlData.add(new ResutlData(entry.getKey(), integerEntry.getKey(), integerEntry.getValue()));
            }
        }


       /* for (FileInfo info : list) {
            resutlData.add(new ResutlData(info.getFiletypeid(), info.getFilestandardid(), 3));
        }*/
//        System.out.println(resutlData);
        return resutlData;
    }


    @RequestMapping("/info")
    public List<ShowObj> queryMethod() {
        Map<String, Set<String>> map = new HashMap<>();
        QueryWrapper<FileType> fileTypeQueryWrapper = new QueryWrapper<>();
        fileTypeQueryWrapper.orderByAsc("filetypeid");
        QueryWrapper<FileLevel> FileLevelQueryWrapper = new QueryWrapper<>();
        FileLevelQueryWrapper.orderByAsc("filelevelid");
        List<FileType> obja = fileTypeMapper.selectList(fileTypeQueryWrapper);
        List<FileLevel> objb = fileLevelMapper.selectList(FileLevelQueryWrapper);


//        List<FTobj> obja = toA();
//        List<FTobj> objb = toB();
        // 使用示例
        Map<Long, String> collectA = obja.stream().collect(Collectors.toMap(FileType::getFiletypeid, FileType::getFiletypename));
        Map<Integer, String> collectB = objb.stream().collect(Collectors.toMap(FileLevel::getFilelevelid, FileLevel::getFilelevelname));

//        System.out.println(collectA);
        Set<String> collect = objb.stream().map(x -> x.getFilelevelname()).collect(Collectors.toSet());
        for (FileType a : obja) {
            map.put(a.getFiletypename(), collect);
        }

        List<ResutlData> resutlData = toData(map);

        Map<String, ShowObj> tempmap = null;
        for (ResutlData data : resutlData) {
            String s1 = collectA.get(data.getNum1().longValue());
//            System.out.println("+==="+s1);
            String s2 = collectB.get(data.getNum2());
            Integer coun = data.getCoun();
            List<FileTypeDTO> fillist = null;
            if (tempmap == null) {
                tempmap = new HashMap<>();
                fillist = new ArrayList<>();
                FileTypeDTO dto = new FileTypeDTO(s2, coun);
                fillist.add(dto);
                tempmap.put(s1, new ShowObj(s1, fillist));
            } else {
                ShowObj showObj = tempmap.get(s1);
                if (showObj != null) {
                    List<FileTypeDTO> count = showObj.getCount();
                    if (count != null && count.size() > 0) {
                        FileTypeDTO dto = new FileTypeDTO(s2, coun);
                        count.add(dto);
                    }
                } else {
                    fillist = new ArrayList<>();
                    FileTypeDTO dto = new FileTypeDTO(s2, coun);
                    fillist.add(dto);
                    tempmap.put(s1, new ShowObj(s1, fillist));
                }

            }

        }
        // 去填充所有的结果集
        Set<String> tempSetA = collectA.entrySet().stream().map(x -> x.getValue()).collect(Collectors.toSet());
        Set<String> tempSetB = collectB.entrySet().stream().map(x -> x.getValue()).collect(Collectors.toSet());


//        System.out.println("========");
//        System.out.println(tempSetB);

        for (String num1 : tempSetA) {
            List<FileTypeDTO> fillist = null;
            ShowObj showObj = tempmap.get(num1);
            if (showObj == null) {
                fillist = new ArrayList<>();
                for (String num2 : tempSetB) {
                    FileTypeDTO dto = new FileTypeDTO(num2, 0);

                    fillist.add(dto);
                }

                tempmap.put(num1, new ShowObj(num1, fillist));
            }else {
                fillist = showObj.getCount();
                Set<String> set = fillist.stream().map(x -> x.getStandardtype()).collect(Collectors.toSet());
                for (String s : tempSetB) {
                    boolean flag = false;
                    for (String s1 : set) {
                        if(s1.equals(s)){
                            flag = true;
                        }
                    }
                    if(!flag){
                        FileTypeDTO dto = new FileTypeDTO(s, 0);
                        fillist.add(dto);
                    }
                }

            }
        }


        Set<ShowObj> collect1 = tempmap.entrySet().stream().map(x -> x.getValue()).collect(Collectors.toSet());


        System.out.println(collect1);
        System.out.println("=====");
        System.out.println(tempSetA);
        System.out.println(tempSetB);
        // 排序
//        Map<String, ShowObj> resmap = new LinkedHashMap<>();
        LinkedList<ShowObj> list = new LinkedList<>();
        for (String key1 : tempSetA) {
            List<FileTypeDTO> newlist = new LinkedList<>();
            for (String key2 : tempSetB) {
                List<FileTypeDTO> templist = tempmap.get(key1).getCount();
                for (FileTypeDTO dto : templist) {
                    if (dto.getStandardtype().equals(key2)){
                        FileTypeDTO fileTypeDTO = new FileTypeDTO(key2, dto.getCount());
                        newlist.add(fileTypeDTO);
                    }
                }
            }
            list.add(new ShowObj(key1,newlist));
        }


        return list;
    }

}

相关功能实现

Vue+Springboot实现数据表格合并列(附前后端代码实现)

记录springboot+vue+fastdfs实现简易的文件(上传、下载、删除、预览)操作

源码下载:GIT

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/weixin_44763595/article/details/129824797

电商项目的介绍及其框架搭建-爱代码爱编程

文章目录 电商项目的介绍及其框架搭建一、项目介绍二、项目架构缩略图三、系统架构说明四、项目搭建4.1 技术选型4.2 开发环境4.3 域名五、后台环境的搭建5.1 创建统一的父工程:excellent5.2 搭建 EurekaServer5.3 搭建 Zuul 网关5.4 创建商品微服务5.4.1 微服务的结构5.4.2 搭建商品微服务【`聚合模块

亿级(无限级)并发,没那么难-爱代码爱编程

肉眼品世界导读: 小编曾经看到高并发几个字也是欣喜若狂,如今变得淡定了,到底多高并发就是高并发了,TPS,QPS是指什么?亿级,千亿级并发真的那么难实现吗?互联网高并发架构设计的原则是什么,看遍了大厂小厂无数架构,是否可以发现都大同小异,万变不离其宗?好,我们就一起来揭秘吧;你懂的,市面上很少有这么完善和透彻的,觉得不错就点赞转发吧       

Java系统学习,最全路线。全面系统学习Java-爱代码爱编程

第一阶段 JavaSE Java编程语言概述Java基础语法Java数组计算机语言介绍流程控制语句的介绍static 修饰符Java语言的前世今生Java 编译器执行流程通类的成员之代码块Java技术体系平台if 分支结构静态代码块与非静态代码块Java核心机制与JVM运行原理switch 选择结构与相关规则单例 (Singleton) 设计模式搭建 J

学习总结-爱代码爱编程

学习总结 一、学习目标简介 ​ 宠物联盟这个项目是一个o2o模式项目。它是以宠物为中心,提供宠物领养,寻主的基本功能,还提供了宠物洗澡、修理毛发等宠物服务还有宠物粮食、玩具等宠物物品的购买,还提供了宠物相关知识学习等功能一个综合性平台。它主要有组织机构,系统,用户,服务,宠物,订单,支付等模块。它是使用前后端分离开发模式,前端使用的是vue技术栈,后台

Docker安装Jenkins+Shell脚本自动化部署项目-爱代码爱编程

点击上方蓝色字体,选择“标星公众号” 优质文章,第一时间送达 关注公众号后台回复pay或mall获取实战项目资料+视频 作者:程序员柳大侠 toutiao.com/i6891617717334475271 “ Jenkins是一款开源的CI&CD软件, 提供超过1000个插件来支持构建、部署、自动化,

码云上面优秀的java项目_秒建一个后台管理系统?用这5个开源免费的Java项目就够了...-爱代码爱编程

以下推荐项目都是码云上的优质项目,并且都是项目快速开发脚手架,代码质量什么的无法保证能有多好,毕竟很多也是个人开发,或多或少也有个人色彩影响。 不过既然开源出来,这么多人参与,一般情况下项目整体质量可以说是非常不错的了。另外,下面推荐的项目几乎都是码云上面选出来的最有价值的开源项目。后面,可能会单独再推荐一期 Github 上的 Java 项目快速开

java架构师系列课程-目录-爱代码爱编程

设计模式         01 设计模式(Design Patterns)简介         02-1 工厂模式 数据结构与算法        力扣刷题-01-深搜         数据结构基础01 队列         算法01 深度优先搜索(DFS)&广度优先搜索(BFS)         leetcode 字符串_3无重复字符

Java学习体系(骨灰级详细)-爱代码爱编程

一颗小草,一个学生。因为没有在这里看到我想见的内容,那便自己写。发表一下自己对于Java的拙见。(待完善:1/10) 预计有五个阶段,目前待完善。 一,Java基础 第一阶段(Java基础) 01-环境搭建(Java基础)         1.java的体系与特点         2.java的JVM与GC         3.JDK与JRE   

vue有两种生成二维码的方式,qrcode、vue-qr(有icon);-爱代码爱编程

生成二维码 1. 使用qrcode生成二维码1.1 安装1.2 引入1.3 使用 2. 使用vue-qr生成二维码(有icon)2.1 安装2.2 引入2.3 使用2.4 文档 vue

vue中名词解释-爱代码爱编程

No名称略写作用应用场景其他1 单页面应用 (Single-page application) SPA 1,控制整个页面 2,抓取更新数据 3,无需加载,进行页面切换 丰富的交互,复杂的业务逻辑的web前端一般要求后端提供api数据接口2  单文件组件 Single-File  Components (也被称为*.vue文件) SFC将js,html,cs

使用chatgpt实现数字自增动画_num-爱代码爱编程

num-auto-add:数字自增动画 序言 我们经常在一些好的网站上遇到数字自增的动画效果,为用户提供了更加丰富的交互体验,看起来非常酷。 我之前也有写过,为了方便以后使用,打算将它优化,并上传到npm中。 首

前端vue实现导出pdf文件报告组件_vue生成网页报告-爱代码爱编程

大屏项目有一个需求,需要对展示的内容进行文件导出,但是目前后台没有相关的逻辑,所以只能前端硬上,在参考了其他许多的逻辑之后,目前我自己这边做了一套比较笨的组件,通过拼接标签这种方法来实现对你想需要的地方进行文件导出,并且呈现

vue3+ts 开发效率提升_vite+vue3+ts项目开发过程中编译慢-爱代码爱编程

1、vite + pnpm项目初始化         pnpm: 比npm或yarn快10倍         pnpm与其他包管理器(如npm和Yarn)的不同之处在于它使用一种称为“硬链接”的独特安装方法。当你使用PNPM安装一个包时,它并不会将包的文件复制到每个项目的node_modules目录中,而是在一个中心存储位置创建硬链接。这意味着多

vue3为什么要使用组合式api——vue3的组合式api和vue2的选项式api的优缺点_vue3用选项式还是组合式-爱代码爱编程

Vue3为什么要使用组合式API——Vue3的组合式API和Vue2的选项式API的优缺点 1、Vue2为什么使用选项式API2、Vue2如何使用组合式API3、组合式API Vs 选项式API4、vue3当中

vue路由中component的动态引入(import、require的各种写法)_import动态导入-爱代码爱编程

vue路由中component的动态引入(import、require的各种写法) 常用import写法(如下图): 常用写发,先用import通过路径引入组件对象,再赋给component。 稍微高级一点 直接“