SSM+Vue在线OA办公系统

         在线办公分三个用户登录，管理员，经理，员工。   SSM架构，maven管理工具，数据库Mysql，系统有文档，可有偿安装调试及讲解，项目保证质量。需要划到 最底 下可以联系到我。
 
功能如下：
1.个人信息修改
2.部门管理
3.财务报账类型管理
4.帖子类管理
5.公文类型管理
6.新闻类型管理
8.请假类型管理
9.日程类型管理
10邮件类型管理
11.职位管理
12.部门任命管理
13.考勤管理
14.论坛管理
15.公文管理
16.新闻管理
17.请假管理
18日程管理
19.薪资管理
20.邮件管理
21.经理管理
22.员工管理

部分实体设计：

部分表设计

服务表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	yuangong_id	Integer	员工	是
3	fuwu_uuid_number	String	服务唯一编号	是
4	fuwu_name	String	服务名称	是
5	fuwu_types	Integer	服务类型	是
6	fuwu_content	String	服务详情	是
7	chuli_types	Integer	是否处理	是
8	insert_time	Date	添加时间	是
9	create_time	Date	创建时间	是

公告信息表

序号	列名	数据类型	说明	允许空
1	Id	Int	id	否
2	gonggao_name	String	公告名称	是
3	gonggao_photo	String	公告图片	是
4	gonggao_types	Integer	公告类型	是
5	insert_time	Date	公告发布时间	是
6	gonggao_content	String	公告详情	是
7	create_time	Date	创建时间	是

代码示例：
出业务接口

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.ChuqinEntity;
import com.entity.YonghuEntity;
import com.entity.view.ChuqinView;
import com.service.ChuqinService;
import com.service.DictionaryService;
import com.service.YonghuService;
import com.utils.PageUtils;
import com.utils.PoiUtil;
import com.utils.R;
import com.utils.StringUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.net.URL;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 考勤
 * 后端接口
 */
@RestController
@Controller
@RequestMapping("/chuqin")
public class ChuqinController {
    private static final Logger logger = LoggerFactory.getLogger(ChuqinController.class);
    @Autowired
    private ChuqinService chuqinService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service
    @Autowired
    private YonghuService yonghuService;


    /**
     * 后端列表
     */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request) {
        logger.debug("page方法:,,Controller:{},,params:{}", this.getClass().getName(), JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if (false)
            return R.error(511, "永不会进入");
        else if ("维修人员".equals(role))
            params.put("weixiurenyuanId", request.getSession().getAttribute("userId"));
        else if ("员工".equals(role))
            params.put("yonghuId", request.getSession().getAttribute("userId"));
        if (params.get("orderBy") == null || params.get("orderBy") == "") {
            params.put("orderBy", "id");
        }
        PageUtils page = chuqinService.queryPage(params);

        //字典表数据转换
        List<ChuqinView> list = (List<ChuqinView>) page.getList();
        for (ChuqinView c : list) {
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
     * 后端详情
     */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request) {
        logger.debug("info方法:,,Controller:{},,id:{}", this.getClass().getName(), id);
        ChuqinEntity chuqin = chuqinService.selectById(id);
        if (chuqin != null) {
            //entity转view
            ChuqinView view = new ChuqinView();
            BeanUtils.copyProperties(chuqin, view);//把实体数据重构到view中

            //级联表
            YonghuEntity yonghu = yonghuService.selectById(chuqin.getYonghuId());
            if (yonghu != null) {
                BeanUtils.copyProperties(yonghu, view, new String[]{"id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
                view.setYonghuId(yonghu.getId());
            }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        } else {
            return R.error(511, "查不到数据");
        }

    }

    /**
     * 后端保存
     */
    @RequestMapping("/save")
    public R save(@RequestBody ChuqinEntity chuqin, HttpServletRequest request) {
        logger.debug("save方法:,,Controller:{},,chuqin:{}", this.getClass().getName(), chuqin.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if (false)
            return R.error(511, "永远不会进入");
        else if ("员工".equals(role))
            chuqin.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));

        Wrapper<ChuqinEntity> queryWrapper = new EntityWrapper<ChuqinEntity>()
                .eq("yonghu_id", chuqin.getYonghuId())
                .eq("chuqin_types", chuqin.getChuqinTypes())
                .eq("overtimeNumber", chuqin.getOvertimeNumber())
                .eq("insert_time", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));

        logger.info("sql语句:" + queryWrapper.getSqlSegment());
        ChuqinEntity chuqinEntity = chuqinService.selectOne(queryWrapper);
        if (chuqinEntity == null) {
            chuqin.setInsertTime(new Date());
            chuqin.setCreateTime(new Date());
            chuqinService.insert(chuqin);
            return R.ok();
        } else {
            return R.error(511, "表中有相同数据");
        }
    }

    /**
     * 后端修改
     */
    @RequestMapping("/update")
    public R update(@RequestBody ChuqinEntity chuqin, HttpServletRequest request) {
        logger.debug("update方法:,,Controller:{},,chuqin:{}", this.getClass().getName(), chuqin.toString());
        //根据字段查询是否有相同数据
        Wrapper<ChuqinEntity> queryWrapper = new EntityWrapper<ChuqinEntity>()
                .notIn("id", chuqin.getId())
                .andNew()
                .eq("yonghu_id", chuqin.getYonghuId())
                .eq("chuqin_types", chuqin.getChuqinTypes())
                .eq("overtimeNumber", chuqin.getOvertimeNumber())
                .eq("insert_time", new SimpleDateFormat("yyyy-MM-dd").format(chuqin.getInsertTime()));

        logger.info("sql语句:" + queryWrapper.getSqlSegment());
        ChuqinEntity chuqinEntity = chuqinService.selectOne(queryWrapper);
        if (chuqinEntity == null) {
            chuqinService.updateById(chuqin);//根据id更新
            return R.ok();
        } else {
            return R.error(511, "表中有相同数据");
        }
    }


    /**
     * 删除
     */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids) {
        logger.debug("delete:,,Controller:{},,ids:{}", this.getClass().getName(), ids.toString());
        chuqinService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save(String fileName, HttpServletRequest request) {
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}", this.getClass().getName(), fileName);
        try {
            List<ChuqinEntity> chuqinList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields = new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if (lastIndexOf == -1) {
                return R.error(511, "该文件没有后缀");
            } else {
                String suffix = fileName.substring(lastIndexOf);
                if (!".xls".equals(suffix)) {
                    return R.error(511, "只支持后缀为xls的excel文件");
                } else {
                    URL resource = this.getClass().getClassLoader().getResource("../../upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if (!file.exists()) {
                        return R.error(511, "找不到上传文件，请联系管理员");
                    } else {
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for (List<String> data : dataList) {
                            //循环
                            ChuqinEntity chuqinEntity = new ChuqinEntity();
                            chuqinList.add(chuqinEntity);
                            //把要查询是否重复的字段放入map中
                        }
                        //查询是否重复
                        chuqinService.insertBatch(chuqinList);
                        return R.ok();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            return R.error(511, "批量插入数据异常，请联系管理员");
        }
    }

    /**
     * 打卡
     */
    @RequestMapping("/clockIn")
    public R clockIn(String flag, HttpServletRequest request) {
        logger.debug("clockIn方法:,,Controller:{},,flag:{}", this.getClass().getName(), flag);
        try {
            Integer id = (Integer) request.getSession().getAttribute("userId");
            String role = String.valueOf(request.getSession().getAttribute("role"));
            if (StringUtil.isEmpty(role) || "管理员".equals(role)) {
                return R.error(511, "没有打卡权限");
            }
            Date d = new Date();
            SimpleDateFormat format1 = new SimpleDateFormat("yyyy-MM-dd");
            String date = format1.format(d);
            List<ChuqinEntity> chuqinList = new ArrayList<ChuqinEntity>();//要生成的list数据
            List<String> s = new ArrayList<>();
            s.add("yonghu_id+0");
            Wrapper<ChuqinEntity> queryWrapper3 = new EntityWrapper<ChuqinEntity>().eq("yonghu_id", id).orderDesc(s);
            List<ChuqinEntity> oldChuqinList = chuqinService.selectList(queryWrapper3);
            if ("1".equals(flag)) {
                //上班卡
                Date date1 = new Date();
                date1.setHours(8);
                date1.setMinutes(0);
                date1.setSeconds(0);
                
                //上班打卡
                //新增前先查看当前用户最大打卡时间
                if (oldChuqinList != null && oldChuqinList.size() > 0) {
                    ChuqinEntity entity = oldChuqinList.get(0);
                    Date todayTime = entity.getInsertTime();//获取出勤表最大出勤
                    String today = format1.format(todayTime);
                    //把日期加一天
                    Calendar calendar = new GregorianCalendar();
                    calendar.setTime(todayTime);
                    calendar.add(calendar.DATE, 1);
                    String newToday = format1.format(calendar.getTime());
                    if (date.equals(today)) {
                        return R.error(511, "已经打过上班卡了");
                    } else if (!date.equals(newToday)) {//当天日期 不是出勤最大日期加一天的话   就是补充缺勤日期
                        chuqinList = this.getQueQin(d, format1, today, id);
                    }
                    if (chuqinList != null && chuqinList.size() > 0) {
                        chuqinService.insertBatch(chuqinList);
                    }

                    //插入当天的上班卡
                    ChuqinEntity chuqin = new ChuqinEntity();
                    chuqin.setOnTime(d);
                    if (d.compareTo(date1) > 0) {//当前时间d 大于规定时间date1
                        chuqin.setChuqinTypes(6);//设置为迟到
                    } else if (d.compareTo(date1) <= 0) {//当前时间d 小于等于规定时间date1
                        chuqin.setChuqinTypes(3);//设置为未打下班卡
                    }
                    chuqin.setCreateTime(d);
                    chuqin.setInsertTime(format1.parse(date));
                    chuqin.setYonghuId(id);
                    chuqinService.insert(chuqin);
                } else {
                    //第一次打卡
                    ChuqinEntity chuqin = new ChuqinEntity();
                    chuqin.setOnTime(d);
                    if (d.compareTo(date1) > 0) {//当前时间d 大于规定时间date1
                        chuqin.setChuqinTypes(6);//设置为迟到
                    } else if (d.compareTo(date1) <= 0) {//当前时间d 小于等于规定时间date1
                        chuqin.setChuqinTypes(3);//设置为未打下班卡
                    }
                    chuqin.setCreateTime(d);
                    chuqin.setInsertTime(format1.parse(date));
                    chuqin.setYonghuId(id);
                    chuqinService.insert(chuqin);
                }

            } else if ("2".equals(flag)) {
                //下班打卡的地方
                Date date1 = new Date();
                date1.setHours(19);
                date1.setMinutes(00);
                date1.setSeconds(0);
                Date date2 = new Date();
                date2.setHours(18);
                date2.setMinutes(00);
                date2.setSeconds(0);
                //下班打卡
                if (oldChuqinList != null) {//不是第一次打卡
                    //查询当前用户是否生成了上班打卡
                    Wrapper<ChuqinEntity> queryWrapper = new EntityWrapper<ChuqinEntity>().eq("yonghu_id", id).eq("insert_time", date).orderDesc(s);
                    ChuqinEntity chuqinEntity = chuqinService.selectOne(queryWrapper);
                    if (chuqinEntity != null) {//生成了上班打卡
                        chuqinEntity.setDownTime(d);
                        if ("6".equals(String.valueOf(chuqinEntity.getChuqinTypes()))) {
                        } else if (d.compareTo(date1) > 0) {//当前时间d 大于规定时间   加班
                            int hours = d.getHours();
                            int i = hours - 19 + 1;
                            if (i > 0) {
                                chuqinEntity.setOvertimeNumber(i);
                            }
                            chuqinEntity.setChuqinTypes(5);//设置为迟到
                        } else if (d.compareTo(date2) < 0) {//当前时间d 小于等于规定时间 早退
                            chuqinEntity.setChuqinTypes(7);//设置为未打下班卡
                        } else {
                            chuqinEntity.setChuqinTypes(1);
                        }
                        chuqinService.updateById(chuqinEntity);
                    } else {
                        //当天上午没有生成上班打卡,要防止用户昨天及之前没有生成打卡记录
                        Wrapper<ChuqinEntity> queryWrapper1 = new EntityWrapper<ChuqinEntity>().eq("yonghu_id", id).orderDesc(s);
                        List<ChuqinEntity> list = chuqinService.selectList(queryWrapper1);
                        if (list != null && list.size() > 0) {
                            ChuqinEntity entity = list.get(0);
                            Date todayTime = entity.getInsertTime();//获取出勤表最大出勤
                            String today = format1.format(todayTime);
                            Calendar calendar = new GregorianCalendar();
                            calendar.setTime(todayTime);
                            calendar.add(calendar.DATE, 1);
                            String newToday = format1.format(calendar.getTime());
                            if (date.equals(today)) {
                                //昨天id+1  等于今天的话  就是直接新增下午打卡
                                ChuqinEntity chuqin = new ChuqinEntity();
                                chuqin.setDownTime(d);
                                chuqin.setChuqinTypes(2);
                                chuqinService.insert(chuqin);
                            } else if (!date.equals(newToday)) {//当天日期 不是出勤最大日期加一天的话   就是补充缺勤日期
                                chuqinList = this.getQueQin(d, format1, today, id);
                            }

                            if (chuqinList != null && chuqinList.size() > 0) {
                                chuqinService.insertBatch(chuqinList);
                            }
                        }
                    }
                } else {
                    //第一次打卡
                    ChuqinEntity chuqin = new ChuqinEntity();
                    chuqin.setDownTime(d);
                    chuqin.setChuqinTypes(2);
                    chuqinService.insert(chuqin);
                }
            } else {
                return R.error(511, "未知错误");
            }
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return R.ok();
    }

    /**
     * 补充缺勤和未打的情况
     *
     * @param d        当前日期
     * @param format1  "yyyy-MM-dd"
     * @param newToday 数据库存的最大打卡日期 加一天
     * @param id       打卡人id
     * @return
     * @throws ParseException
     */
    public static List<ChuqinEntity> getQueQin(Date d, SimpleDateFormat format1, String newToday, Integer id) throws ParseException {
        List<ChuqinEntity> list = new ArrayList<>();
        // 返回的日期集合
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date start = dateFormat.parse(newToday);//缺勤那天
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(d);
        calendar.add(calendar.DATE, -1); //当前时间减去一天，即一天前的时间
        Date end = dateFormat.parse(format1.format(calendar.getTime()));

        Calendar tempStart = Calendar.getInstance();
        tempStart.setTime(start);

        Calendar tempEnd = Calendar.getInstance();
        tempEnd.setTime(end);
        tempEnd.add(Calendar.DATE, +1);// 日期加1(包含结束)
        while (tempStart.before(tempEnd)) {
            ChuqinEntity chuqinEntity = new ChuqinEntity();
            chuqinEntity.setYonghuId(id);
            chuqinEntity.setInsertTime(tempStart.getTime());
            chuqinEntity.setCreateTime(d);
            chuqinEntity.setChuqinTypes(4);
            list.add(chuqinEntity);
            tempStart.add(Calendar.DAY_OF_YEAR, 1);
        }
        return list;
    }
}

出勤实体类

import com.entity.ChuqinEntity;
import com.baomidou.mybatisplus.annotations.TableName;
import org.apache.commons.beanutils.BeanUtils;

import java.lang.reflect.InvocationTargetException;

import org.springframework.format.annotation.DateTimeFormat;
import com.fasterxml.jackson.annotation.JsonFormat;

import java.io.Serializable;
import java.util.Date;

/**
 * 考勤
 * 后端返回视图实体辅助类
 * （通常后端关联的表或者自定义的字段需要返回使用）
 */
@TableName("chuqin")
@Date
public class ChuqinView extends ChuqinEntity {
    /**
     * 打卡类型的值
     */
    private String chuqinValue;
	
    //级联表 yonghu
    /**
     * 员工编号
     */
    private String yonghuUuidNumber;
    /**
     * 员工姓名
     */
    private String yonghuName;
    /**
     * 员工手机号
     */
    private String yonghuPhone;
    /**
     * 员工身份证号
     */
    private String yonghuIdNumber;
    /**
     * 员工头像
     */
    private String yonghuPhoto;
    /**
     * 电子邮箱
     */
    private String yonghuEmail;
    /**
     * 部门
     */
    private Integer bumenTypes;
    /**
     * 部门的值
     */
    private String bumenValue;
    /**
     * 职位
     */
    private Integer zhiweiTypes;
    /**
     * 职位的值
     */
    private String zhiweiValue;
}

需要加我私聊即可：