@TOC
ssm038汽车养护管理系统+jsp
绪论
1.1 研究背景
当前社会各行业领域竞争压力非常大，随着当前时代的信息化，科学化发展，让社会各行业领域都争相使用新的信息技术，对行业内的各种相关数据进行科学化，规范化管理。这样的大环境让那些止步不前，不接受信息改革带来的信息技术的企业随时面临被淘汰，被取代的风险。所以当今，各个行业领域，不管是传统的教育行业，餐饮行业，还是旅游行业，医疗行业等领域都将使用新的信息技术进行信息革命，改变传统的纸质化，需要人手工处理工作事务的办公环境。软件信息技术能够覆盖社会各行业领域是时代的发展要求，各种数据以及文件真正实现电子化是信息社会发展的不可逆转的必然趋势。本汽车养护管理系统也是紧跟科学技术的发展，运用当今一流的软件技术实现软件系统的开发，让房屋租住信息完全通过管理系统实现科学化，规范化，程序化管理。从而帮助信息管理者节省事务处理的时间，降低数据处理的错误率，对于基础数据的管理水平可以起到促进作用，也从一定程度上对随意的业务管理工作进行了避免，同时，汽车养护管理系统的数据库里面存储的各种动态信息，也为上层管理人员作出重大决策提供了大量的事实依据。总之，汽车养护管理系统是一款可以真正提升管理者的办公效率的软件系统。
1.2 目的和意义
信息数据的处理完全依赖人工进行操作，会耗费大量的人工成本，特别是面对大量的数据信息时，传统人工操作不仅不能对数据的出错率进行保证，还容易出现各种信息资源的低利用率与低安全性问题。更有甚者，耽误大量的宝贵时间，尤其是对信息的更新，归纳与统计更是耗财耗力的过程。所以电子化信息管理的出现就能缓解以及改变传统人工方式面临的处境，一方面可以确保信息数据在短时间被高效处理，还能节省人力成本，另一方面可以确保信息数据的安全性，可靠性，并可以实现信息数据的快速检索与修改操作，这些优点是之前的旧操作模式无法比拟的。因此汽车养护管理系统为数据信息的管理模式的升级与改革提供了重要的窗口。
1.3 论文结构安排
为了帮助用户更好的了解和理解程序的开发流程与相关内容，本文将通过六个章节进行内容阐述。
第一章：描述了程序的开发背景，程序运用于现实生活的目的与意义，以及程序文档的结构安排信息；
第二章：描述了程序的开发环境，包括程序开发涉及到的技术，程序开发使用的数据存储工具等信息；
第三章：描述了程序着手进行开发时，会面临的可行性问题，并对程序功能以及性能要求进行描述；
第四章：描述了程序大功能模块下的功能细分信息，以及存储程序数据的数据库表文件结构的设计信息等；
第五章：描述了程序的功能实现界面的内容，也对程序操作人员操作的部分功能进行了描述；
第六章：描述了程序功能的测试内容，并介绍了系统测试的概念与方法。
2 相关技术
2.1 SSM框架介绍
本课题程序开发使用到的框架技术，英文名称缩写是SSM，在JavaWeb开发中使用的流行框架有SSH、SSM、SpringMVC等，作为一个课题程序采用SSH框架也可以，SSM框架也可以，SpringMVC也可以。SSH框架是属于重量级别的框架，配置繁琐，不够灵活，修改程序需要修改好多个文件，并且运行起来也占用内存较高，CPU使用率相对也高，SpringMVC是Spring开发的一套MVC架构，更灵活更好用，SSM框架取中间值，既没有SSH臃肿，也没有SpringMVC简化，属于中间级别的，在配置过程和使用过程中更能编写和理解。MyBatis框架取代Hibernate框架是因为它更灵活，不需要完全在框架里操作，它在数据操作上可以写出更灵活的代码，它的性能也比Hibernate框架更稳定。总的来说，使用SSM框架是通过综合考虑而使用的，网上有很多的使用教程和心得体会，而且SSM又是这么的流行，用SSM框架开发是顺其自然的。
2.2 B/S结构介绍
在早期，一些使用HTML语言编写的文件，再集合一些其它资源文件就可以组成一个最简单的Web程序，了解了Web程序也需要了解Web站点，它们之间的关系就是一个或者多个Web程序可以放在Internet上的一个Web站点（Web服务器）中进行使用。可以说Web应用程序的开发也带动了B/S这种网络结构模式的兴起。B是Brower（浏览器）的首字母，S是Server（服务器）的首字母，两个首字母进行组合就成了网络结构模式的简称B/S。由于这种结构模式通过安装在客户端的浏览器进行服务器的访问，可以把程序的核心功能安排在服务器中进行处理，给程序的开发，后期使用和维护省去了许多工作。图2.1展示的就是使用这种架构开发的程序的工作原理。
图2.1 B/S架构的工作原理图
2.3 Mysql数据库介绍
开发的程序面向用户的只是程序的功能界面，让用户操作程序界面的各个功能，那么很多人就会问，用户使用程序功能生成的数据信息放在哪里的？这个就需要涉及到数据库的知识了，一般来说，程序开发通常就会对常用数据存储工具的特点进行分析比对，比如Mysql数据库的特点与优势，Access数据库的特点与优势，Sqlserver数据库的特点与优势等，最终看哪个数据库与需要开发的程序比较匹配，也符合程序功能运行需要的数据存储要求，比如，需要开发商业级别的程序，存储的数据对数据库要求较高，可以选用Oracle，如果只是比较简单的程序，对数据存储没有过多要求，可以选用微软旗下的Access，当开发程序要求数据库占用空间小，并能满足程序数据存储要求时，就可以考虑Oracle公司从瑞典MySQL AB公司在很早之前就收购过一个关系型数据库，它是现在的Mysql数据库。在数据库工具里面它是最受认可的其中一个应用软件。需要说明的信息就是，本程序的开发就运用到了此数据库。它将程序数据通过使用不同的数据表格进行保存，在增加了程序数据的存储速度的时候，也提高了数据库的灵活性。 图2.2展示的就是MySQL的架构图。
图2.2 MySQL数据库架构图
3 系统分析
当用户确定开发一款程序时，是需要遵循下面的顺序进行工作，概括为：系统分析-->系统设计-->系统开发-->系统测试，无论这个过程是否有变更或者迭代，都是按照这样的顺序开展工作的。系统分析就是分析系统需要做什么的问题，主要目的就是确定系统的功能，这也为接下来的工作做了一个好的开端。
3.1 系统可行性分析
开发一款程序软件不仅需要时间，也需要人力，物力资源。而进行可行性分析这个环节就是解决用户这方面的疑问，看看程序在当前的条件下是否可以进行开发。
3.1.1 技术可行性分析
此程序选用的开发语言是Java，这种编程语言有着丰富的数据类型，在指令控制语句上也比较完善，更重要的就是对类与对象的大力支持，这些优点为程序开发者提供了技术保障，尤其是现在代码都逐渐模块化，有关系统功能开发的源码在网络上都公开展示了，所以让具备一定计算机开发基础的开发人员独立开发系统在技术上也逐渐容易。
3.1.2 经济可行性分析
开发此程序最关键的设备就是一台电脑，无论是学校计算机室配备的电脑，还是自己入学以来购置的笔记本，都是可以符合开发要求的设备，另外在网络上，学校本已完全覆盖了校园网，所以在设备以及网络上无须考虑经济问题。
3.1.3 运行可行性分析
随着电脑软件以及配套硬件的完善升级，当下的计算机环境是一片大好，尤其是计算机已经广泛普及到家家户户，所以计算机设备现在是随处可见，由于本次开发的程序占有的资源耗费较小，在一般的电脑或笔记本上都能轻松运转起来。
通过上面的可行性描述，可以从经济，技术，运行方面解决程序开发是否可行的问题。因此可以认为该程序软件是可以进行开发的。
3.2 系统性能分析
系统性能分析也是比较重要的内容，进行系统性能分析就是为了确保系统的功能要能够在生活中运行使用时，达到规定的指标，因此一个完整的系统软件，是需要进行系统的性能分析这个步骤的。本次进行性能分析主要从易用性指标，可扩展性指标，系统健壮性指标，系统安全性指标这几个方面进行分析。
3.2.1 易用性指标
本次程序软件的开发的目的就是让使用者可以通过使用该软件提高信息数据的管理效率，同时该程序软件也需要针对不同的操作用户设置对应的功能，因此，此程序的操作流程应该尽量与用户日常操作软件的行为习惯相贴合，另外，程序软件的设计与开发也应考虑非计算机专业用户的计算机操作水平，要让大部分使用者都可以轻松操作程序提供的各个功能。
3.2.2 可扩展性指标
当前需要开发的程序软件是根据当下的用户需求进行设计开发的，但是随着时间的推移，社会大环境的改变，开发出的程序也是需要与时俱进的，需要根据用户不断变换的需求进行相应的功能内容的扩展，需要注意的就是，当对成型的程序进行功能模块新增时，仍然需要保证程序原有架构以及功能不能受到影响，新增的功能模块在系统中也能够运行正常，该指标达标也就可以保证此程序是可以在满足信息管理要求下，从容应对市场环境的变化。
3.2.3 健壮性指标
程序软件的开发就是为了投入使用时，可以一直稳定的处理各种数据信息，程序软件一旦不稳定，也会给使用者带来干扰。因此从性能分析的角度，就要要求程序软件在应对使用者的误操作，或者是使用者因为各种原因，填写有误的数据等情况时，程序要一直保持稳定，并能够正常让使用者进行使用。当程序的某个功能模块出现异常时，程序的其它功能模块也要能够确保正常使用。程序的健壮性指标达标可以让使用者产生良好的用户体验。
3.2.4 安全性指标
程序软件的安全问题是首要问题，毕竟程序对应数据库里面存放的数据信息是庞大的，里面也包括了许多重要的个人信息，这就对程序要具备一个完善的安全机制提出了要求。因此程序必须要设置登录功能用以进行用户身份的检查，以及身份和权限的匹配，通过对不同用户身份进行功能约束，绝不容忍用户越权操作程序。另外，也需要时刻防范计算机病毒，还有黑客，通过采取针对性的办法进行安全应对，确保程序时刻处于安全的环境，让使用者放心使用。
3.3 系统流程分析
3.3.1 操作流程分析
程序上交给用户进行使用时，需要提供程序的操作流程图（如图3.1所示），这样便于用户容易理解程序的具体工作步骤，现如今程序的操作流程都有一个大致的标准，即先通过登录页面提交登录数据，通过程序验证正确之后，用户才能在程序功能操作区页面操作对应的功能。
图3.1 程序操作流程图
3.3.2 登录流程分析
在这个部分，需要对程序的登录功能模块的运行流程（如图3.2所示），进行单独说明。程序设置登录模块也是为了安全起见，让用户使用放心，登录模块主要就是让用户提交登录信息，程序进行数据验证，验证通过的用户才能够成功登录程序。
图3.2 程序登录流程图
3.3.3 信息添加流程分析
程序的添加功能就是提供给操作者录入信息的功能，不管是涉及到用户信息添加，还是其它功能模块涉及到的信息添加，程序的信息添加流程（如图3.3所示）都是一致的。程序都是先对操作者录入的数据进行判定，这个判定规则是一段提前编写完成的程序代码，当程序判定数据符合要求时，才会把操作者录入的数据登记在数据表里面，比如添加的用户信息，就会把新添加的用户信息写入用户信息的数据表文件里面。
图3.3 信息添加流程图
3.3.4 信息删除流程分析
当从程序里面删除某种无效数据时，遵循程序的信息删除流程（如图3.4所示），先要选中操作者需要删除的数据，程序为了预防操作者误删信息，也会进行提示，当操作者真正确定要删选中的信息时，该信息就会从数据库中被永久删除。
图3.4 信息删除流程图
4 系统设计
汽车养护管理系统的设计方案比如功能框架的设计，比如数据库的设计的好坏也就决定了该系统在开发层面是否高效，以及在系统维护层面是否容易维护和升级，因为在系统实现阶段是需要考虑用户的所有需求，要是在设计阶段没有经过全方位考虑，那么系统实现的部分也就无从下手，所以系统设计部分也是至关重要的一个环节，只有根据用户需求进行细致全面的考虑，才有希望开发出功能健全稳定的程序软件。
4.1 系统概要设计
本次拟开发的系统为了节约开发成本，也为了后期在维护和升级上的便利性，打算通过浏览器来实现系统功能界面的展示，让程序软件的主要事务集中在后台的服务器端处理，前端部分只用处理少量的事务逻辑。下面使用一张图（如图4.1所示）来说明程序的工作原理。
图4.1 程序工作的原理图
4.2 系统功能结构设计
在分析并得出使用者对程序的功能要求时，就可以进行程序设计了。如图4.2展示的就是管理员功能结构图，管理员主要负责填充图书和其类别信息，并对已填充的数据进行维护，包括修改与删除，管理员也需要审核老师注册信息，发布公告信息，管理自助租房信息等。
汽车养护管理系统
系管理员管理
反零件设备管理
收员工出勤管理
申零件分类管理
用员工信息管理
帐管理员修改
密管理员新增
用员工信息添加
用员工信息删除
用员工信息修改
申零件分类添加
申零件分类修改
申零件分类删除
反零件设备添加
反零件设备删改
反零件设备删除
用员工出勤添加
用员工出勤修改
用员工出勤删除
反客户信息管理
反客户信息修改
反客户信息删除
反客户信息添加
图4.2 系统功能结构图
4.3 数据库设计
程序功能操作不管是添加，修改，还是删除等功能产生的数据都是经由数据库进行数据保存和更新的，所以一个数据库设计的好坏也是程序是否好坏的判定标准，因为程序的成功，有一半的功劳都是靠数据库的优秀设计。数据库一旦设计得良好是可以减轻开发人员的开发负担的。
4.3.1 数据库E-R图设计
这个部分的设计需要使用到E-R图绘制工具，常用的工具就是Visio工具来绘制E-R模型图，这款工具不仅可以快速创建需要的E-R模型图，而且该工具提供的操作界面很简单，可以短时间内修改绘图界面的图形或者是文字的属性。在绘制E-R模型图时，要分清楚各个图形代表的含义，以免绘制出错，E-R模型图由长方形（实体），椭圆形（属性），菱形（关系）这三部分图形符号组成，绘制期间要区分开来，用准确的图形符号代表相应的数据元素。
各个实体之间的联系用下图的E-R图表示。绘制的系统E-R图见图4.8。
零件信息
属于
属于
查询
管理
用户
零件类型
管理员
汽车养护管理系统
管理
管理
管理
查询
n
n
n
n
1
1
n
1
1
1 
图4.8 系统E-R图
4.3.2 数据库表结构设计
数据库系统一旦选定之后，需要根据程序要求在数据库中建立数据库文件，并在已经完成创建的数据库文件里面，为程序运行中产生的数据建立对应的数据表格，数据表结构设计就是对创建的数据表格进行字段设计，字段长度设计，字段类型设计等，当数据表格合理设计完成之后，才能正常存储相关程序运行产生的数据信息。
表4.1 管理员信息表
| 列名 | 说明 | 数据类型 | 允许空 |
|---|---|---|---|
| id | int(20) | 主键 | 否 |
| serial | varchar(200) | 编号 | 是 |
| name | varchar(200) | 姓名 | 是 |
| account | varchar(200) | 账号 | 是 |
| password | varchar(200) | 密码 | 是 |
| age | tinyint(4) | 年龄 | 是 |
| sex_types | tinyint(4) | 性别 | 是 |
| mobile | varchar(200) | 电话 | 是 |
| address | varchar(200) | 住址 | 是 |
| role | varchar(200) | 身份 | 是 |
表4.2 客户信息表
| 列名 | 说明 | 数据类型 | 允许空 |
|---|---|---|---|
| id | int(20) | 主键 | 否 |
| serial | varchar(200) | 客户编号 | 是 |
| name | varchar(200) | 客户姓名 | 是 |
| account | varchar(200) | 账号 | 是 |
| password | varchar(200) | 密码 | 是 |
| age | tinyint(4) | 客户年龄 | 是 |
| sex_types | tinyint(4) | 客户性别 | 是 |
| mobile | varchar(200) | 联系方式 | 是 |
| role | varchar(255) | 身份 | 是 |
| information | varchar(200) | 车辆信息 | 是 |
表4.3 零件设备信息表
| 列名 | 说明 | 数据类型 | 允许空 |
|---|---|---|---|
| id | int(20) | 主键 | 否 |
| serial | varchar(200) | 零件编号 | 是 |
| name | varchar(200) | 零件名称 | 是 |
| lj_types | tinyint(4) | 零件分类 | 是 |
| amount | tinyint(4) | 零件数量 | 是 |
| production | tinyint(4) | 生产单位 | 是 |
| create_time | timestamp | 采购日期 | 是 |
表4.4 维修信息表
| 列名 | 说明 | 数据类型 | 允许空 |
|---|---|---|---|
| id | int(20) | 主键 | 否 |
| serial_types | tinyint(4) | 客户编号 | 是 |
| maintenance | varchar(200) | 维修项目 | 是 |
| ygdate | tinyint(4) | 员工工时 | 是 |
| wx_types | tinyint(4) | 维修等级 | 是 |
| pj_types | tinyint(4) | 配件信息 | 是 |
| money | decimal(6,2) | 维修收费 | 是 |
| create_time | timestamp | 维修日期 | 是 |
表4.5 员工信息表
| 列名 | 说明 | 数据类型 | 允许空 |
|---|---|---|---|
| id | int(20) | 主键 | 否 |
| serial | varchar(200) | 员工编号 | 是 |
| name | varchar(200) | 员工姓名 | 是 |
| age | tinyint(4) | 年龄 | 是 |
| sex_types | tinyint(4) | 性别 | 是 |
| zc_types | tinyint(4) | 技术职称 | 是 |
| create_time | timestamp | 入职日期 | 是 |
| 是 | |||
5 系统实现
系统实现部分就是将系统分析，系统设计部分的内容通过编码进行功能实现，以一个实际应用系统的形式展示系统分析与系统设计的结果。前面提到的系统分析，系统设计最主要还是进行功能，系统操作逻辑的设计，也包括了存储数据的数据库方面的设计等内容，系统实现就是一个最终的实施阶段，将前面的设计成果进行物理转化，最终出具可以运用于实际的软件系统。
5.1管理员信息管理
如图5.1显示的就是管理员信息管理页面，此页面提供给管理员的功能有：房东信息的查询管理，可以删除管理员信息、修改管理员信息、新增管理员信息，
还进行了对管理员名称、管理员编号、管理员账号模糊查询的条件
图5.1 管理员信息管理页面
5.2 员工信息管理
如图5.2显示的就是员工信息管理页面，此页面提供给管理员的功能有：查看全部的员工信息，可以删除员工信息、修改员工信息、新增员工信息，
还进行了对员工信息名称、员工信息编号、员工信息账号模糊查询的条件
图5.2 员工信息管理页面
5.3员工出勤管理
如图5.3显示的就是房屋信息管理页面，此页面提供给管理员的功能有：查看全部的员工出勤信息，可以删除员工出勤、修改员工出勤、新增员工出勤，
还进行了对员工编号条件进行查询
图5.3 员工出勤管理页面
5.1客户信息管理
如图5.4显示的就是客户信息管理页面，此页面提供给管理员的功能有：查看全部的客户信息，可以删除客户信息、修改客户信息、新增客户信息，
还进行了对客户编号、客户名称、客户账号条件进行查询
图5.4 客户信息管理页面
系统
GuanliyuanServiceImpl.java
package com.service.impl;
import org.springframework.stereotype.Service;
import java.util.Map;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
import com.utils.PageUtils;
import com.utils.Query;
import com.dao.GuanliyuanDao;
import com.entity.GuanliyuanEntity;
import com.service.GuanliyuanService;
import com.entity.view.GuanliyuanView;
/**
* 管理员表 服务实现类
* @author
* @since 2021-02-24
*/
@Service("guanliyuanService")
@Transactional
public class GuanliyuanServiceImpl extends ServiceImpl<GuanliyuanDao, GuanliyuanEntity> implements GuanliyuanService {
@Override
public PageUtils queryPage(Map<String,Object> params) {
if(params != null && (params.get("limit") == null || params.get("page") == null)){
params.put("page","1");
params.put("limit","10");
}
Page<GuanliyuanView> page =new Query<GuanliyuanView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,params));
return new PageUtils(page);
}
}
CommonController.java
package com.controller;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.entity.ConfigEntity;
import org.apache.commons.lang3.StringUtils;
import org.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.annotation.IgnoreAuth;
import com.baidu.aip.face.AipFace;
import com.baidu.aip.face.MatchRequest;
import com.baidu.aip.util.Base64Util;
import com.service.CommonService;
import com.service.ConfigService;
import com.utils.BaiduUtil;
import com.utils.FileUtil;
import com.utils.R;
/**
* 通用接口
*/
@RestController
public class CommonController{
@Autowired
private CommonService commonService;
@Autowired
private ConfigService configService;
private static AipFace client = null;
private static String BAIDU_DITU_AK = null;
@RequestMapping("/location")
public R location(String lng,String lat) {
if(BAIDU_DITU_AK==null) {
BAIDU_DITU_AK = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "baidu_ditu_ak")).getValue();
if(BAIDU_DITU_AK==null) {
return R.error("请在配置管理中正确配置baidu_ditu_ak");
}
}
Map<String, String> map = BaiduUtil.getCityByLonLat(BAIDU_DITU_AK, lng, lat);
return R.ok().put("data", map);
}
/**
* 人脸比对
*
* @param face1 人脸1
* @param face2 人脸2
* @return
*/
@RequestMapping("/matchFace")
public R matchFace(String face1, String face2, HttpServletRequest request) {
if(client==null) {
/*String AppID = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "AppID")).getValue();*/
String APIKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "APIKey")).getValue();
String SecretKey = configService.selectOne(new EntityWrapper<ConfigEntity>().eq("name", "SecretKey")).getValue();
String token = BaiduUtil.getAuth(APIKey, SecretKey);
if(token==null) {
return R.error("请在配置管理中正确配置APIKey和SecretKey");
}
client = new AipFace(null, APIKey, SecretKey);
client.setConnectionTimeoutInMillis(2000);
client.setSocketTimeoutInMillis(60000);
}
JSONObject res = null;
try {
File file1 = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+face1);
File file2 = new File(request.getSession().getServletContext().getRealPath("/upload")+"/"+face2);
String img1 = Base64Util.encode(FileUtil.FileToByte(file1));
String img2 = Base64Util.encode(FileUtil.FileToByte(file2));
MatchRequest req1 = new MatchRequest(img1, "BASE64");
MatchRequest req2 = new MatchRequest(img2, "BASE64");
ArrayList<MatchRequest> requests = new ArrayList<MatchRequest>();
requests.add(req1);
requests.add(req2);
res = client.match(requests);
System.out.println(res.get("result"));
} catch (FileNotFoundException e) {
e.printStackTrace();
return R.error("文件不存在");
} catch (IOException e) {
e.printStackTrace();
}
return R.ok().put("data", com.alibaba.fastjson.JSONObject.parse(res.get("result").toString()));
}
/**
* 获取table表中的column列表(联动接口)
* @param table
* @param column
* @return
*/
@RequestMapping("/option/{tableName}/{columnName}")
@IgnoreAuth
public R getOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,String level,String parent) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
if(StringUtils.isNotBlank(level)) {
params.put("level", level);
}
if(StringUtils.isNotBlank(parent)) {
params.put("parent", parent);
}
List<String> data = commonService.getOption(params);
return R.ok().put("data", data);
}
/**
* 根据table中的column获取单条记录
* @param table
* @param column
* @return
*/
@RequestMapping("/follow/{tableName}/{columnName}")
@IgnoreAuth
public R getFollowByOption(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName, @RequestParam String columnValue) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
params.put("columnValue", columnValue);
Map<String, Object> result = commonService.getFollowByOption(params);
return R.ok().put("data", result);
}
/**
* 修改table表的sfsh状态
* @param table
* @param map
* @return
*/
@RequestMapping("/sh/{tableName}")
public R sh(@PathVariable("tableName") String tableName, @RequestBody Map<String, Object> map) {
map.put("table", tableName);
commonService.sh(map);
return R.ok();
}
/**
* 获取需要提醒的记录数
* @param tableName
* @param columnName
* @param type 1:数字 2:日期
* @param map
* @return
*/
@RequestMapping("/remind/{tableName}/{columnName}/{type}")
@IgnoreAuth
public R remindCount(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName,
@PathVariable("type") String type,@RequestParam Map<String, Object> map) {
map.put("table", tableName);
map.put("column", columnName);
map.put("type", type);
if(type.equals("2")) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
Date remindStartDate = null;
Date remindEndDate = null;
if(map.get("remindstart")!=null) {
Integer remindStart = Integer.parseInt(map.get("remindstart").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindStart);
remindStartDate = c.getTime();
map.put("remindstart", sdf.format(remindStartDate));
}
if(map.get("remindend")!=null) {
Integer remindEnd = Integer.parseInt(map.get("remindend").toString());
c.setTime(new Date());
c.add(Calendar.DAY_OF_MONTH,remindEnd);
remindEndDate = c.getTime();
map.put("remindend", sdf.format(remindEndDate));
}
}
int count = commonService.remindCount(map);
return R.ok().put("count", count);
}
/**
* 单列求和
*/
@RequestMapping("/cal/{tableName}/{columnName}")
@IgnoreAuth
public R cal(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
Map<String, Object> result = commonService.selectCal(params);
return R.ok().put("data", result);
}
/**
* 分组统计
*/
@RequestMapping("/group/{tableName}/{columnName}")
@IgnoreAuth
public R group(@PathVariable("tableName") String tableName, @PathVariable("columnName") String columnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("column", columnName);
List<Map<String, Object>> result = commonService.selectGroup(params);
return R.ok().put("data", result);
}
/**
* （按值统计）
*/
@RequestMapping("/value/{tableName}/{xColumnName}/{yColumnName}")
@IgnoreAuth
public R value(@PathVariable("tableName") String tableName, @PathVariable("yColumnName") String yColumnName, @PathVariable("xColumnName") String xColumnName) {
Map<String, Object> params = new HashMap<String, Object>();
params.put("table", tableName);
params.put("xColumn", xColumnName);
params.put("yColumn", yColumnName);
List<Map<String, Object>> result = commonService.selectValue(params);
return R.ok().put("data", result);
}
}
UserServiceImpl.java
package com.service.impl;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.UserDao;
import com.entity.UserEntity;
import com.service.UserService;
import com.utils.PageUtils;
import com.utils.Query;
/**
* 系统用户
* @author yangliyuan
* @date 2019年10月10日 上午9:17:59
*/
@Service("userService")
public class UserServiceImpl extends ServiceImpl<UserDao, UserEntity> implements UserService {
@Override
public PageUtils queryPage(Map<String, Object> params) {
Page<UserEntity> page = this.selectPage(
new Query<UserEntity>(params).getPage(),
new EntityWrapper<UserEntity>()
);
return new PageUtils(page);
}
@Override
public List<UserEntity> selectListView(Wrapper<UserEntity> wrapper) {
return baseMapper.selectListView(wrapper);
}
@Override
public PageUtils queryPage(Map<String, Object> params,
Wrapper<UserEntity> wrapper) {
Page<UserEntity> page =new Query<UserEntity>(params).getPage();
page.setRecords(baseMapper.selectListView(page,wrapper));
PageUtils pageUtil = new PageUtils(page);
return pageUtil;
}
}
jquery.stepy.js
/*!
* jQuery Stepy - A Wizard Plugin
* --------------------------------------------------------------
*
* jQuery Stepy is a plugin that generates a customizable wizard.
*
* Licensed under The MIT License
*
* @version 1.1.0
* @since 2010-07-03
* @author Washington Botelho
* @documentation wbotelhos.com/stepy
*
* --------------------------------------------------------------
*
* <form>
* <fieldset title="Step 1">
* <legend>description one</legend>
* <!-- inputs -->
* </fieldset>
*
* <fieldset title="Step 2">
* <legend>description two</legend>
* <!-- inputs -->
* </fieldset>
*
* <input type="submit" />
* </form>
*
* $('form').stepy();
*
*/
;(function($) {
var methods = {
init: function(settings) {
return this.each(function() {
methods.destroy.call(this);
this.opt = $.extend({}, $.fn.stepy.defaults, settings);
var self = this,
that = $(this),
id = that.attr('id');
if (id === undefined || id === '') {
var id = methods._hash.call(self);
that.attr('id', id);
}
// Remove Validator...
if (self.opt.validate) {
jQuery.validator.setDefaults({ ignore: self.opt.ignore });
that.append('<div class="stepy-errors" />');
}
self.header = methods._header.call(self);
self.steps = that.children('fieldset');
self.steps.each(function(index) {
methods._createHead.call(self, this, index);
methods._createButtons.call(self, this, index);
});
self.heads = self.header.children('li');
self.heads.first().addClass('stepy-active');
if (self.opt.finishButton) {
methods._bindFinish.call(self);
}
// WIP...
if (self.opt.titleClick) {
self.heads.click(function() {
var array = self.heads.filter('.stepy-active').attr('id').split('-'), // TODO: try keep the number in an attribute.
current = parseInt(array[array.length - 1], 10),
clicked = $(this).index();
if (clicked > current) {
if (self.opt.next && !methods._execute.call(that, self.opt.next, clicked)) {
return false;
}
} else if (clicked < current) {
if (self.opt.back && !methods._execute.call(that, self.opt.back, clicked)) {
return false;
}
}
if (clicked != current) {
methods.step.call(self, (clicked) + 1);
}
});
} else {
self.heads.css('cursor', 'default');
}
if (self.opt.enter) {
methods._bindEnter.call(self);
}
self.steps.first().find(':input:visible:enabled').first().select().focus();
that.data({ 'settings': this.opt, 'stepy': true });
});
}, _bindEnter: function() {
var self = this;
self.steps.delegate('input[type="text"], input[type="password"]', 'keypress', function(evt) {
var key = (evt.keyCode ? evt.keyCode : evt.which);
if (key == 13) {
evt.preventDefault();
var buttons = $(this).closest('fieldset').find('.stepy-navigator');
if (buttons.length) {
var next = buttons.children('.button-next');
if (next.length) {
next.click();
} else if (self.finish) {
self.finish.click();
}
}
}
});
}, _bindFinish: function() {
var self = this,
that = $(this),
finish = that.children('input[type="submit"]');
self.finish = (finish.length === 1) ? finish : that.children('.stepy-finish');
if (self.finish.length) {
var isForm = that.is('form'),
onSubmit = undefined;
if (isForm && self.opt.finish) {
onSubmit = that.attr('onsubmit');
that.attr('onsubmit', 'return false;');
}
self.finish.on('click.stepy', function(evt) {
if (self.opt.finish && !methods._execute.call(that, self.opt.finish, self.steps.length - 1)) {
evt.preventDefault();
} else if (isForm) {
if (onSubmit) {
that.attr('onsubmit', onSubmit);
} else {
that.removeAttr('onsubmit');
}
var isSubmit = self.finish.attr('type') === 'submit';
if (!isSubmit && (!self.opt.validate || methods.validate.call(that, self.steps.length - 1))) {
that.submit();
}
}
});
self.steps.last().children('.stepy-navigator').append(self.finish);
} else {
$.error('Submit button or element with class "stepy-finish" missing!');
}
}, _createBackButton: function(nav, index) {
var self = this,
that = $(this),
attributes = { href: '#', 'class': 'button-back', html: self.opt.backLabel };
$('<a />', attributes).on('click.stepy', function(e) {
e.preventDefault();
if (!self.opt.back || methods._execute.call(self, self.opt.back, index - 1)) {
methods.step.call(self, (index - 1) + 1);
}
}).appendTo(nav);
}, _createButtons: function(step, index) {
var nav = methods._navigator.call(this).appendTo(step);
if (index === 0) {
if (this.steps.length > 1) {
methods._createNextButton.call(this, nav, index);
}
} else {
$(step).hide();
methods._createBackButton.call(this, nav, index);
if (index < this.steps.length - 1) {
methods._createNextButton.call(this, nav, index);
}
}
}, _createHead: function(step, index) {
var step = $(step).attr('id', $(this).attr('id') + '-step-' + index).addClass('stepy-step'),
head = methods._head.call(this, index);
head.append(methods._title.call(this, step));
if (this.opt.description) {
head.append(methods._description.call(this, step));
}
this.header.append(head);
}, _createNextButton: function(nav, index) {
var self = this,
that = $(this),
attributes = { href: '#', 'class': 'button-next', html: self.opt.nextLabel };
$('<a/>', attributes).on('click.stepy', function(e) {
e.preventDefault();
if (!self.opt.next || methods._execute.call(that, self.opt.next, index + 1)) {
methods.step.call(self, (index + 1) + 1);
}
}).appendTo(nav);
}, _description: function(step) {
var legend = step.children('legend');
if (!this.opt.legend) {
legend.hide();
}
if (legend.length) {
return $('<span />', { html: legend.html() });
}
methods._error.call(this, '<legend /> element missing!');
}, _error: function(message) {
$(this).html(message);
$.error(message);
}, _execute: function(callback, index) {
var isValid = callback.call(this, index + 1);
return isValid || isValid === undefined;
}, _hash: function() {
this.hash = 'stepy-' + Math.random().toString().substring(2)
return this.hash;
}, _head: function(index) {
return $('<li />', { id: $(this).attr('id') + '-head-' + index });
}, _header: function() {
var header = $('<ul />', { id: $(this).attr('id') + '-header', 'class': 'stepy-header' });
if (this.opt.titleTarget) {
header.appendTo(this.opt.titleTarget);
} else {
header.insertBefore(this);
}
return header;
}, _navigator: function(index) {
return $('<p class="stepy-navigator" />');
}, _title: function(step) {
return $('<div />', { html: step.attr('title') || '--' });
}, destroy: function() {
return $(this).each(function() {
var that = $(this);
if (that.data('stepy')) {
var steps = that.data('stepy', false).children('fieldset').css('display', '');
that.children('.stepy-errors').remove();
this.finish.appendTo(steps.last());
steps.find('p.stepy-navigator').remove();
}
});
}, step: function(index) {
var self = this
that = $(this),
opt = that[0].opt;
index--;
var steps = that.children('fieldset');
if (index > steps.length - 1) {
index = steps.length - 1;
}
var max = index;
// Remove Validator...
if (opt.validate) {
var isValid = true;
for (var i = 0; i < index; i++) {
isValid &= methods.validate.call(this, i);
if (opt.block && !isValid) {
max = i;
break;
}
}
}
// WIP...
var stepsCount = steps.length;
if (opt.transition == 'fade') {
steps.fadeOut(opt.duration, function() {
if (--stepsCount > 0) {
return;
}
steps.eq(max).fadeIn(opt.duration);
});
} else if (opt.transition == 'slide') {
steps.slideUp(opt.duration, function() {
if (--stepsCount > 0) {
return;
}
steps.eq(max).slideDown(opt.duration);
});
} else {
steps.hide(opt.duration).eq(max).show(opt.duration);
}
that[0].heads.removeClass('stepy-active').eq(max).addClass('stepy-active');
if (that.is('form')) {
var $fields = undefined;
if (max == index) {
$fields = steps.eq(max).find(':input:enabled:visible');
} else {
$fields = steps.eq(max).find('.error').select().focus();
}
$fields.first().select().focus();
}
if (opt.select) {
opt.select.call(this, max + 1);
}
return that;
}, validate: function(index) { // WIP...
var that = $(this);
if (!that.is('form')) {
return true;
}
var self = this,
step = that.children('fieldset').eq(index),
isValid = true,
$title = $('#' + that.attr('id') + '-header').children().eq(index),
$validate = that.validate();
$(step.find(':input:enabled').get().reverse()).each(function() {
var fieldIsValid = $validate.element($(this));
if (fieldIsValid === undefined) {
fieldIsValid = true;
}
isValid &= fieldIsValid;
if (isValid) {
if (self.opt.errorImage) {
$title.removeClass('stepy-error');
}
} else {
if (self.opt.errorImage) {
$title.addClass('stepy-error');
}
$validate.focusInvalid();
}
});
return isValid;
}
};
$.fn.stepy = function(method) {
if (methods[method]) {
return methods[method].apply(this, Array.prototype.slice.call(arguments, 1));
} else if (typeof method === 'object' || !method) {
return methods.init.apply(this, arguments);
} else {
$.error('Method ' + method + ' does not exist!');
}
};
$.fn.stepy.defaults = {
back : undefined,
backLabel : '< Back',
block : false, // WIP...
description : true,
duration : undefined,
enter : true,
errorImage : false, // WIP...
finish : undefined,
finishButton : true,
ignore : '', // WIP...
legend : true,
next : undefined,
nextLabel : 'Next >',
select : undefined,
titleClick : false,
titleTarget : undefined,
transition : undefined,
validate : false // WIP...
};
})(jQuery);
声明
本博客适用于广泛的学术和教育用途，包括但不限于个人学习、开发设计，产品设计。仅供学习参考，旨在为读者提供深入理解和学术研究的材料。
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
