基于Spring Boot的大学校园生存信息平台的设计与实现pf

万万哇 · 2024-8-21 16:34:07

@TOC
springboot523基于Spring Boot的大学校园生存信息平台的设计与实现pf

绪论

1.1 研究背景

当前社会各行业范畴竞争压力非常大，随着当前时代的信息化，科学化发展，让社会各行业范畴都争相使用新的信息技术，对行业内的各种相关数据进行科学化，规范化管理。如许的大环境让那些止步不前，不接受信息改革带来的信息技术的企业随时面临被淘汰，被取代的风险。所以当今，各个行业范畴，不管是传统的教育行业，餐饮行业，还是旅游行业，医疗行业等范畴都将使用新的信息技术进行信息革命，改变传统的纸质化，需要人手工处理工作事务的办公环境。软件信息技术能够覆盖社会各行业范畴是时代的发展要求，各种数据以及文件真正实现电子化是信息社会发展的不可逆转的必然趋势。本大学校园生存信息平台也是紧跟科学技术的发展，运用当今一流的软件技术实现软件系统的开辟，让员工信息完全通过管理系统实现科学化，规范化，程序化管理。从而资助信息管理者节流事务处理的时间，低沉数据处理的错误率，对于基础数据的管理水平可以起到促进作用，也从一定程度上对随意的业务管理工作进行了避免，同时，大学校园生存信息平台的数据库里面存储的各种动态信息，也为上层管理人员作出重大决策提供了大量的事实依据。总之，大学校园生存信息平台是一款可以真正提升管理者的办公效率的软件系统。
1.2 目标和意义

信息数据的处理完全依赖人工进行操作，会泯灭大量的人工成本，特殊是面临大量的数据信息时，传统人工操作不但不能对数据的出错率进行保证，还轻易出现各种信息资源的低利用率与低安全性问题。更有甚者，延长大量的宝贵时间，尤其是对信息的更新，归纳与统计更是耗财耗力的过程。所以电子化信息管理的出现就能缓解以及改变传统人工方式面临的处境，一方面可以确保信息数据在短时间被高效处理，还能节流人力成本，另一方面可以确保信息数据的安全性，可靠性，并可以实现信息数据的快速检索与修改操作，这些优点是之前的旧操作模式无法相比的。因此大学校园生存信息平台为数据信息的管理模式的升级与改革提供了紧张的窗口。
1.3 论文结构安排

为了资助用户更好的了解和明白程序的开辟流程与相关内容，本文将通过六个章节进行内容阐述。
第一章：形貌了程序的开辟背景，程序运用于实际生存的目标与意义，以及程序文档的结构安排信息；
第二章：形貌了程序的开辟环境，包罗程序开辟涉及到的技术，程序开辟使用的数据存储工具等信息；
第三章：形貌了程序动手进行开辟时，会面临的可行性问题，并对程序功能以及性能要求进行形貌；
第四章：形貌了程序大功能模块下的功能细分信息，以及存储程序数据的数据库表文件结构的设计信息等；
第五章：形貌了程序的功能实现界面的内容，也对程序操作人员操作的部分功能进行了形貌；
第六章：形貌了程序功能的测试内容，并先容了系统测试的概念与方法。
2 相关技术

2.1 SpringBoot框架先容

本课题程序开辟使用到的框架技术，英文名称缩写是SpringBoot，在JavaWeb开辟中使用的流行框架有SSH、SSM、SpringBoot、SpringMVC等，作为一个课题程序采用SSH框架也可以，SSM框架也可以，SpringMVC也可以。SSH框架是属于重量级别的框架，配置繁琐，不敷灵活，修改程序需要修改很多多少个文件，而且运行起来也占用内存较高，CPU使用率相对也高，SpringBoot是基础Spring开辟的一套整合架构，更灵活更好用，SpringBoot框架取中心值，既没有SSH臃肿，也没有SpringMVC简化，属于中心级别的，在配置过程和使用过程中更能编写和明白。SpringBoot框架取代Hibernate框架是因为它更灵活，不需要完全在框架里操作，它在数据操作上可以写出更灵活的代码，它的性能也比Hibernate框架更稳定。总的来说，使用SpringBoot框架是通过综合考虑而使用的，网上有很多的使用教程和心得体会，而且SpringBoot又是这么的流行，用SpringBoot框架开辟是顺其天然的。
2.2 VUE先容

Vue (读音 /vjuː/，雷同于 view) 是一套用于构建用户界面的渐进式框架。与其它大型框架不同的是，Vue 被设计为可以自底向上逐层应用。Vue 的核心库只关凝视图层，不但易于上手，还便于与第三方库或既有项目整合。另一方面，当与今世化的工具链以及各种支持类库结合使用时，Vue 也完全能够为复杂的单页应用提供驱动。
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模型图由长方形（实体），椭圆形（属性），菱形（关系）这三部分图形符号组成，绘制期间要区分开来，用准确的图形符号代表相应的数据元素。
（1）下图是活动实体和其具备的属性。

活动实体属性图
（2）下图是用户实体和其具备的属性。

用户实体属性图
（3）下图是测验记录表实体和其具备的属性。

测验记录表实体属性图
（4）下图是答题详情表实体和其具备的属性。

答题详情表实体属性图
（5）下图是试卷选题实体和其具备的属性。

试卷选题实体属性图
（6）下图是错题表实体和其具备的属性。

错题表实体属性图
（7）下图是活动收藏实体和其具备的属性。

活动收藏实体属性图
（8）下图是论坛实体和其具备的属性。

论坛实体属性图
（9）下图是试卷实体和其具备的属性。

试卷实体属性图
（10）下图是活动留言实体和其具备的属性。

活动留言实体属性图
（11）下图是试题表实体和其具备的属性。

试题表实体属性图
（12）下图是校园资讯实体和其具备的属性。

校园资讯实体属性图
（13）下图是活动报名实体和其具备的属性。

活动报名实体属性图
各个实体之间的联系用下图的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字典表
序号列名数据类型阐明允许空1IdIntid否2dic_codeString字段是3dic_nameString字段名是4code_indexInteger编码是5index_nameString编码名字是6super_idInteger父字段id是7beizhuString备注是8create_timeDate创建时间是表4.2试卷表
序号列名数据类型阐明允许空1IdIntid否2exampaper_nameString试卷名称是3exampaper_dateInteger测验时长(分钟)是4exampaper_myscoreInteger试卷总分数是5kemu_typesInteger科目是6exampaper_typesInteger试卷状态是7zujuan_typesInteger组卷方式是8exampaper_deleteInteger逻辑删除（1代表未删除 2代表已删除）是9create_timeDate创建时间是表4.3试卷选题表
序号列名数据类型阐明允许空1IdIntid否2exampaper_idInteger试卷是3examquestion_idInteger试题是4exampapertopic_numberInteger试题分数是5create_timeDate创建时间是表4.4试题表表
序号列名数据类型阐明允许空1IdIntid否2examquestion_nameString试题名称是3kemu_typesInteger科目是4examquestion_optionsString选项，json字符串是5examquestion_answerString正确答案是6examquestion_analysisString答案剖析是7examquestion_typesInteger试题类型是8examquestion_sequenceInteger试题排序，值越大排越前面是9create_timeDate创建时间是表4.5测验记录表表
序号列名数据类型阐明允许空1IdIntid否2examrecord_uuid_numberString测验编号是3yonghu_idInteger测验用户是4exampaper_idInteger所属试卷id（外键）是5total_scoreInteger所得总分是6insert_timeDate测验时间是7create_timeDate创建时间是表4.6答题详情表表
序号列名数据类型阐明允许空1IdIntid否2examredetails_uuid_numberString试卷编号是3yonghu_idInteger用户id是4examquestion_idInteger试题id（外键）是5examredetails_myanswerString考生答案是6examredetails_myscoreInteger试题得分是7create_timeDate创建时间是表4.7错题表表
序号列名数据类型阐明允许空1IdIntid否2yonghu_idInteger用户id是3exampaper_idInteger试卷（外键）是4examquestion_idInteger试题id（外键）是5examredetails_myanswerString考生作答是6insert_timeDate记录时间是7create_timeDate创建时间是表4.8论坛表
序号列名数据类型阐明允许空1IdIntid否2forum_nameString帖子标题是3yonghu_idInteger用户是4users_idInteger管理员是5forum_contentString发布内容是6super_idsInteger父id是7forum_typesInteger帖子类型是8forum_state_typesInteger帖子状态是9insert_timeDate发帖时间是10update_timeDate修改时间是11create_timeDate创建时间是表4.9活动表
序号列名数据类型阐明允许空1IdIntid否2huodong_nameString活动名称是3huodong_uuid_numberString活动编号是4huodong_photoString活动照片是5huodong_addressString活动地点是6huodong_typesInteger活动类型是7huodong_kucun_numberInteger活动库存是8zan_numberInteger赞是9cai_numberInteger踩是10huodong_kaishi_timeDate活动开始时间是11huodong_clicknumInteger活动热度是12huodong_contentString活动内容是13shangxia_typesInteger是否上架是14huodong_deleteInteger逻辑删除是15insert_timeDate录入时间是16create_timeDate创建时间是表4.10活动收藏表
序号列名数据类型阐明允许空1IdIntid否2huodong_idInteger活动是3yonghu_idInteger用户是4huodong_collection_typesInteger类型是5insert_timeDate收藏时间是6create_timeDate创建时间是表4.11活动留言表
序号列名数据类型阐明允许空1IdIntid否2huodong_idInteger活动是3yonghu_idInteger用户是4huodong_liuyan_textString留言内容是5insert_timeDate留言时间是6reply_textString回复内容是7update_timeDate回复时间是8create_timeDate创建时间是表4.12活动报名表
序号列名数据类型阐明允许空1IdIntid否2huodong_yuyue_uuid_numberString报名编号是3huodong_idInteger活动是4yonghu_idInteger用户是5huodong_yuyue_textString报名来由是6huodong_yuyue_yesno_typesInteger报名状态是7huodong_yuyue_yesno_textString审核回复是8huodong_yuyue_shenhe_timeDate审核时间是9insert_timeDate活动报名时间是10create_timeDate创建时间是表4.13校园资讯表
序号列名数据类型阐明允许空1IdIntid否2news_nameString资讯名称是3news_photoString资讯图片是4news_typesInteger资讯类型是5insert_timeDate资讯发布时间是6news_contentString资讯详情是7create_timeDate创建时间是表4.14用户表
序号列名数据类型阐明允许空1IdIntid否2yonghu_nameString用户姓名是3yonghu_phoneString用户手机号是4yonghu_id_numberString用户身份证号是5yonghu_photoString用户头像是6yonghu_emailString用户邮箱是7create_timeDate创建时间是表4.15管理员表
序号列名数据类型阐明允许空1IdIntid否2usernameString门生名是3passwordString密码是4roleString脚色是5addtimeDate新增时间是 5 系统实现

系统实现部分就是将系统分析，系统设计部分的内容通过编码进行功能实现，以一个实际应用系统的形式展示系统分析与系统设计的效果。前面提到的系统分析，系统设计最主要还是进行功能，系统操作逻辑的设计，也包罗了存储数据的数据库方面的设计等内容，系统实现就是一个最终的实施阶段，将前面的设计成果进行物理转化，最终出具可以运用于实际的软件系统。
5.1 管理员功能先容

5.1.1 校园活动管理

如图5.1表现的就是校园活动管理页面，此页面提供给管理员的功能有：检察校园活动列表,新增校园活动,修改校园活动,删除校园活动。

图5.1 校园活动管理页面
5.1.2 校园资讯管理

如图5.2表现的就是校园资讯管理页面，此页面提供给管理员的功能有：新增校园资讯,修改校园资讯,删除校园资讯。

图5.2 校园资讯管理页面
5.1.3 校园资讯类型管理

如图5.3表现的就是校园资讯类型管理页面，此页面提供给管理员的功能有：新增校园资讯类型,修改校园资讯类型,删除校园资讯类型。

图5.3 校园资讯类型管理页面
系统

DictionaryController.java

package com.controller;
import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;
import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;
/**
* 字典
* 后端接口
* @author
* @email
*/
@RestController
@Controller
@RequestMapping("/dictionary")
public class DictionaryController {
private static final Logger logger = LoggerFactory.getLogger(DictionaryController.class);
private static final String TABLE_NAME = "dictionary";
@Autowired
private DictionaryService dictionaryService;
@Autowired
private TokenService tokenService;
@Autowired
private ExampaperService exampaperService;//问卷调查
@Autowired
private ExampapertopicService exampapertopicService;//问卷调查选题
@Autowired
private ExamquestionService examquestionService;//试题表
@Autowired
private ExamrecordService examrecordService;//问卷调查记录表
@Autowired
private ExamredetailsService examredetailsService;//答题详情表
@Autowired
private ExamrewrongquestionService examrewrongquestionService;//错题表
@Autowired
private ForumService forumService;//论坛
@Autowired
private HuodongService huodongService;//活动
@Autowired
private HuodongCollectionService huodongCollectionService;//活动收藏
@Autowired
private HuodongLiuyanService huodongLiuyanService;//活动留言
@Autowired
private HuodongYuyueService huodongYuyueService;//活动报名
@Autowired
private NewsService newsService;//校园资讯
@Autowired
private YonghuService yonghuService;//用户
@Autowired
private UsersService usersService;//管理员
/**
* 后端列表
*/
@RequestMapping("/page")
@IgnoreAuth
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params);
PageUtils page = dictionaryService.queryPage(params);
//字典表数据转换
List<DictionaryView> list =(List<DictionaryView>)page.getList();
for(DictionaryView 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);
DictionaryEntity dictionary = dictionaryService.selectById(id);
if(dictionary !=null){
//entity转view
DictionaryView view = new DictionaryView();
BeanUtils.copyProperties( dictionary , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 后端保存
*/
@RequestMapping("/save")
public R save(@RequestBody DictionaryEntity dictionary, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.eq("index_name", dictionary.getIndexName())
;
if(dictionary.getDicCode().contains("_erji_types")){
queryWrapper.eq("super_id",dictionary.getSuperId());
}
logger.info("sql语句:"+queryWrapper.getSqlSegment());
DictionaryEntity dictionaryEntity = dictionaryService.selectOne(queryWrapper);
if(dictionaryEntity==null){
dictionary.setCreateTime(new Date());
dictionaryService.insert(dictionary);
//字典表新增数据,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
ServletContext servletContext = request.getServletContext();
Map<String, Map<Integer,String>> map = new HashMap<>();
for(DictionaryEntity d :dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode());
if(m ==null || m.isEmpty()){
m = new HashMap<>();
}
m.put(d.getCodeIndex(),d.getIndexName());
map.put(d.getDicCode(),m);
}
servletContext.setAttribute("dictionaryMap",map);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
/**
* 后端修改
*/
@RequestMapping("/update")
public R update(@RequestBody DictionaryEntity dictionary, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
DictionaryEntity oldDictionaryEntity = dictionaryService.selectById(dictionary.getId());//查询原先数据
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
dictionaryService.updateById(dictionary);//根据id更新
//如果字典表修改数据的话,把数据再重新查出,放入监听器中
List<DictionaryEntity> dictionaryEntities = dictionaryService.selectList(new EntityWrapper<DictionaryEntity>());
ServletContext servletContext = request.getServletContext();
Map<String, Map<Integer,String>> map = new HashMap<>();
for(DictionaryEntity d :dictionaryEntities){
Map<Integer, String> m = map.get(d.getDicCode());
if(m ==null || m.isEmpty()){
m = new HashMap<>();
}
m.put(d.getCodeIndex(),d.getIndexName());
map.put(d.getDicCode(),m);
}
servletContext.setAttribute("dictionaryMap",map);
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<DictionaryEntity> oldDictionaryList =dictionaryService.selectBatchIds(Arrays.asList(ids));//要删除的数据
dictionaryService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
* 最大值
*/
@RequestMapping("/maxCodeIndex")
public R maxCodeIndex(@RequestBody DictionaryEntity dictionary){
logger.debug("maxCodeIndex:,,Controller:{},,dictionary:{}",this.getClass().getName(),dictionary.toString());
List<String> descs = new ArrayList<>();
descs.add("code_index");
Wrapper<DictionaryEntity> queryWrapper = new EntityWrapper<DictionaryEntity>()
.eq("dic_code", dictionary.getDicCode())
.orderDesc(descs);
logger.info("sql语句:"+queryWrapper.getSqlSegment());
List<DictionaryEntity> dictionaryEntityList = dictionaryService.selectList(queryWrapper);
if(dictionaryEntityList.size()>0 ){
return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1);
}else{
return R.ok().put("maxCodeIndex",1);
}
}
/**
* 批量上传
*/
@RequestMapping("/batchInsert")
public R save( String fileName, HttpServletRequest request){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<DictionaryEntity> dictionaryList = 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("static/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){
//循环
DictionaryEntity dictionaryEntity = new DictionaryEntity();
// dictionaryEntity.setDicCode(data.get(0)); //字段要改的
// dictionaryEntity.setDicName(data.get(0)); //字段名要改的
// dictionaryEntity.setCodeIndex(Integer.valueOf(data.get(0))); //编码要改的
// dictionaryEntity.setIndexName(data.get(0)); //编码名字要改的
// dictionaryEntity.setSuperId(Integer.valueOf(data.get(0))); //父字段id 要改的
// dictionaryEntity.setBeizhu(data.get(0)); //备注要改的
// dictionaryEntity.setCreateTime(date);//时间
dictionaryList.add(dictionaryEntity);
//把要查询是否重复的字段放入map中
}
//查询是否重复
dictionaryService.insertBatch(dictionaryList);
return R.ok();
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
}

复制代码

ExamrecordController.java

package com.controller;
import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;
import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;
/**
* 问卷调查记录表
* 后端接口
* @author
* @email
*/
@RestController
@Controller
@RequestMapping("/examrecord")
public class ExamrecordController {
private static final Logger logger = LoggerFactory.getLogger(ExamrecordController.class);
private static final String TABLE_NAME = "examrecord";
@Autowired
private ExamrecordService examrecordService;
@Autowired
private TokenService tokenService;
@Autowired
private DictionaryService dictionaryService;//字典
@Autowired
private ExampaperService exampaperService;//问卷调查
@Autowired
private ExampapertopicService exampapertopicService;//问卷调查选题
@Autowired
private ExamquestionService examquestionService;//试题表
@Autowired
private ExamredetailsService examredetailsService;//答题详情表
@Autowired
private ExamrewrongquestionService examrewrongquestionService;//错题表
@Autowired
private ForumService forumService;//论坛
@Autowired
private HuodongService huodongService;//活动
@Autowired
private HuodongCollectionService huodongCollectionService;//活动收藏
@Autowired
private HuodongLiuyanService huodongLiuyanService;//活动留言
@Autowired
private HuodongYuyueService huodongYuyueService;//活动报名
@Autowired
private NewsService newsService;//校园资讯
@Autowired
private YonghuService yonghuService;//用户
@Autowired
private UsersService usersService;//管理员
/**
* 后端列表
*/
@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("yonghuId",request.getSession().getAttribute("userId"));
CommonUtil.checkMap(params);
PageUtils page = examrecordService.queryPage(params);
//字典表数据转换
List<ExamrecordView> list =(List<ExamrecordView>)page.getList();
for(ExamrecordView 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);
ExamrecordEntity examrecord = examrecordService.selectById(id);
if(examrecord !=null){
//entity转view
ExamrecordView view = new ExamrecordView();
BeanUtils.copyProperties( examrecord , view );//把实体数据重构到view中
//级联表用户
//级联表
YonghuEntity yonghu = yonghuService.selectById(examrecord.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "yonghuId"});//把级联的数据添加到view中,并排除id和创建时间字段,当前表的级联注册表
view.setYonghuId(yonghu.getId());
}
//级联表问卷调查
//级联表
ExampaperEntity exampaper = exampaperService.selectById(examrecord.getExampaperId());
if(exampaper != null){
BeanUtils.copyProperties( exampaper , view ,new String[]{ "id", "createTime", "insertTime", "updateTime", "yonghuId"});//把级联的数据添加到view中,并排除id和创建时间字段,当前表的级联注册表
view.setExampaperId(exampaper.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 后端保存
*/
@RequestMapping("/save")
public R save(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,examrecord:{}",this.getClass().getName(),examrecord.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
else if("用户".equals(role))
examrecord.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
Wrapper<ExamrecordEntity> queryWrapper = new EntityWrapper<ExamrecordEntity>()
.eq("yonghu_id", examrecord.getYonghuId())
.eq("exampaper_id", examrecord.getExampaperId())
.eq("total_score", examrecord.getTotalScore())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
ExamrecordEntity examrecordEntity = examrecordService.selectOne(queryWrapper);
if(examrecordEntity==null){
examrecord.setInsertTime(new Date());
examrecord.setCreateTime(new Date());
examrecordService.insert(examrecord);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
/**
* 后端修改
*/
@RequestMapping("/update")
public R update(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
logger.debug("update方法:,,Controller:{},,examrecord:{}",this.getClass().getName(),examrecord.toString());
ExamrecordEntity oldExamrecordEntity = examrecordService.selectById(examrecord.getId());//查询原先数据
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
// else if("用户".equals(role))
// examrecord.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
examrecordService.updateById(examrecord);//根据id更新
return R.ok();
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
List<ExamrecordEntity> oldExamrecordList =examrecordService.selectBatchIds(Arrays.asList(ids));//要删除的数据
examrecordService.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);
Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
try {
List<ExamrecordEntity> examrecordList = 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("static/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){
//循环
ExamrecordEntity examrecordEntity = new ExamrecordEntity();
// examrecordEntity.setExamrecordUuidNumber(data.get(0)); //考试编号要改的
// examrecordEntity.setYonghuId(Integer.valueOf(data.get(0))); //考试用户要改的
// examrecordEntity.setExampaperId(Integer.valueOf(data.get(0))); //所属问卷调查id（外键）要改的
// examrecordEntity.setTotalScore(Integer.valueOf(data.get(0))); //所得总分要改的
// examrecordEntity.setInsertTime(date);//时间
// examrecordEntity.setCreateTime(date);//时间
examrecordList.add(examrecordEntity);
//把要查询是否重复的字段放入map中
//考试编号
if(seachFields.containsKey("examrecordUuidNumber")){
List<String> examrecordUuidNumber = seachFields.get("examrecordUuidNumber");
examrecordUuidNumber.add(data.get(0));//要改的
}else{
List<String> examrecordUuidNumber = new ArrayList<>();
examrecordUuidNumber.add(data.get(0));//要改的
seachFields.put("examrecordUuidNumber",examrecordUuidNumber);
}
}
//查询是否重复
//考试编号
List<ExamrecordEntity> examrecordEntities_examrecordUuidNumber = examrecordService.selectList(new EntityWrapper<ExamrecordEntity>().in("examrecord_uuid_number", seachFields.get("examrecordUuidNumber")));
if(examrecordEntities_examrecordUuidNumber.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(ExamrecordEntity s:examrecordEntities_examrecordUuidNumber){
repeatFields.add(s.getExamrecordUuidNumber());
}
return R.error(511,"数据库的该表中的 [考试编号] 字段已经存在存在数据为:"+repeatFields.toString());
}
examrecordService.insertBatch(examrecordList);
return R.ok();
}
}
}
}catch (Exception e){
e.printStackTrace();
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
CommonUtil.checkMap(params);
PageUtils page = examrecordService.queryPage(params);
//字典表数据转换
List<ExamrecordView> list =(List<ExamrecordView>)page.getList();
for(ExamrecordView c:list)
dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
return R.ok().put("data", page);
}
/**
* 前端详情
*/
@RequestMapping("/detail/{id}")
public R detail(@PathVariable("id") Long id, HttpServletRequest request){
logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
ExamrecordEntity examrecord = examrecordService.selectById(id);
if(examrecord !=null){
//entity转view
ExamrecordView view = new ExamrecordView();
BeanUtils.copyProperties( examrecord , view );//把实体数据重构到view中
//级联表
YonghuEntity yonghu = yonghuService.selectById(examrecord.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//级联表
ExampaperEntity exampaper = exampaperService.selectById(examrecord.getExampaperId());
if(exampaper != null){
BeanUtils.copyProperties( exampaper , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setExampaperId(exampaper.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody ExamrecordEntity examrecord, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,examrecord:{}",this.getClass().getName(),examrecord.toString());
Wrapper<ExamrecordEntity> queryWrapper = new EntityWrapper<ExamrecordEntity>()
.eq("examrecord_uuid_number", examrecord.getExamrecordUuidNumber())
.eq("yonghu_id", examrecord.getYonghuId())
.eq("exampaper_id", examrecord.getExampaperId())
.eq("total_score", examrecord.getTotalScore())
// .notIn("examrecord_types", new Integer[]{102})
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
ExamrecordEntity examrecordEntity = examrecordService.selectOne(queryWrapper);
if(examrecordEntity==null){
examrecord.setInsertTime(new Date());
examrecord.setCreateTime(new Date());
examrecordService.insert(examrecord);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
}

复制代码

HuodongYuyueServiceImpl.java

package com.service.impl;
import com.utils.StringUtil;
import com.service.DictionaryService;
import com.utils.ClazzDiff;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.lang.reflect.Field;
import java.util.*;
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 org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
import com.dao.HuodongYuyueDao;
import com.entity.HuodongYuyueEntity;
import com.service.HuodongYuyueService;
import com.entity.view.HuodongYuyueView;
/**
* 活动报名服务实现类
*/
@Service("huodongYuyueService")
@Transactional
public class HuodongYuyueServiceImpl extends ServiceImpl<HuodongYuyueDao, HuodongYuyueEntity> implements HuodongYuyueService {
@Override
public PageUtils queryPage(Map<String,Object> params) {
Page<HuodongYuyueView> page =new Query<HuodongYuyueView>(params).getPage();
page.setRecords(baseMapper.selectListView(page,params));
return new PageUtils(page);
}
}

复制代码

list.vue

<template>
<div class="main-content">
<div v-if="showFlag">
<el-form :inline="true" :model="searchForm" class="form-content">
<el-row :gutter="20" class="slt" :style="{justifyContent:contents.searchBoxPosition=='1'?'flex-start':contents.searchBoxPosition=='2'?'center':'flex-end'}">
<el-form-item label="科目">
<el-input prefix-icon="el-icon-search" v-model="searchForm.indexNameSearch" placeholder="科目" clearable></el-input>
</el-form-item>
<el-form-item>
<el-button icon="el-icon-search" type="success" @click="search()">查询</el-button>
</el-form-item>
</el-row>
<el-row class="ad" :style="{justifyContent:contents.btnAdAllBoxPosition=='1'?'flex-start':contents.btnAdAllBoxPosition=='2'?'center':'flex-end'}">
<el-form-item>
<el-button
v-if="isAuth('dictionaryKemu','新增')"
type="success"
icon="el-icon-plus"
@click="addOrUpdateHandler()"
>新增</el-button>
<el-button
v-if="isAuth('dictionaryKemu','删除')"
:disabled="dataListSelections.length <= 0"
type="danger"
icon="el-icon-delete"
@click="deleteHandler()"
>删除</el-button>
</el-form-item>
</el-row>
</el-form>
<div class="table-content">
<el-table class="tables" :size="contents.tableSize" :show-header="contents.tableShowHeader"
:header-row-style="headerRowStyle" :header-cell-style="headerCellStyle"
:border="contents.tableBorder"
:fit="contents.tableFit"
:stripe="contents.tableStripe"
:row-style="rowStyle"
:cell-style="cellStyle"
:style="{width: '100%',fontSize:contents.tableContentFontSize,color:contents.tableContentFontColor}"
v-if="isAuth('dictionaryKemu','查看')"
:data="dataList"
v-loading="dataListLoading"
@selection-change="selectionChangeHandler">
<el-table-column v-if="contents.tableSelection"
type="selection"
header-align="center"
align="center"
width="50">
</el-table-column>
<el-table-column label="索引" v-if="contents.tableIndex" type="index" width="50" />
<el-table-column :sortable="contents.tableSortable" :align="contents.tableAlign"
prop="codeIndex"
header-align="center"
label="科目编码">
<template slot-scope="scope">
{{scope.row.codeIndex}}
</template>
</el-table-column>
<el-table-column :sortable="contents.tableSortable" :align="contents.tableAlign"
prop="indexName"
header-align="center"
label="科目名称">
<template slot-scope="scope">
{{scope.row.indexName}}
</template>
</el-table-column>
<!--<el-table-column :sortable="contents.tableSortable" :align="contents.tableAlign"
prop="beizhu"
header-align="center"
label="备注">
<template slot-scope="scope">
{{scope.row.beizhu}}
</template>
</el-table-column>-->
<el-table-column width="300" :align="contents.tableAlign"
header-align="center"
label="操作">
<template slot-scope="scope">
<el-button v-if="isAuth('dictionaryKemu','查看')" type="success" icon="el-icon-tickets" size="mini" @click="addOrUpdateHandler(scope.row.id,'info')">详情</el-button>
<el-button v-if="isAuth('dictionaryKemu','修改')" type="primary" icon="el-icon-edit" size="mini" @click="addOrUpdateHandler(scope.row.id)">修改</el-button>
<el-button v-if="isAuth('dictionaryKemu','删除')" type="danger" icon="el-icon-delete" size="mini" @click="deleteHandler(scope.row.id)">删除</el-button>
</template>
</el-table-column>
</el-table>
<el-pagination
clsss="pages"
:layout="layouts"
@size-change="sizeChangeHandle"
@current-change="currentChangeHandle"
:current-page="pageIndex"
:page-sizes="[10, 20, 50, 100]"
:page-size="Number(contents.pageEachNum)"
:total="totalPage"
:small="contents.pageStyle"
class="pagination-content"
:background="contents.pageBtnBG"
:style="{textAlign:contents.pagePosition==1?'left':contents.pagePosition==2?'center':'right'}"
></el-pagination>
</div>
</div>
<add-or-update v-if="addOrUpdateFlag" :parent="this" ref="addOrUpdate"></add-or-update>
</div>
</template>
<script>
import AddOrUpdate from "./add-or-update";
import styleJs from "../../../utils/style.js";
export default {
data() {
return {
searchForm: {
key: ""
},
form:{},
dataList: [],
pageIndex: 1,
pageSize: 10,
totalPage: 0,
dataListLoading: false,
dataListSelections: [],
showFlag: true,
sfshVisiable: false,
shForm: {},
chartVisiable: false,
addOrUpdateFlag:false,
contents:null,
layouts: '',
};
},
created() {
this.contents = styleJs.listStyle();
this.init();
this.getDataList();
this.contentStyleChange()
},
mounted() {
},
filters: {
htmlfilter: function (val) {
return val.replace(/<[^>]*>/g).replace(/undefined/g,'');
}
},
components: {
AddOrUpdate,
},
methods: {
contentStyleChange() {
this.contentSearchStyleChange()
this.contentBtnAdAllStyleChange()
this.contentSearchBtnStyleChange()
this.contentTableBtnStyleChange()
this.contentPageStyleChange()
},
contentSearchStyleChange() {
this.$nextTick(()=>{
document.querySelectorAll('.form-content .slt .el-input__inner').forEach(el=>{
let textAlign = 'left'
if(this.contents.inputFontPosition == 2) textAlign = 'center'
if(this.contents.inputFontPosition == 3) textAlign = 'right'
el.style.textAlign = textAlign
el.style.height = this.contents.inputHeight
el.style.lineHeight = this.contents.inputHeight
el.style.color = this.contents.inputFontColor
el.style.fontSize = this.contents.inputFontSize
el.style.borderWidth = this.contents.inputBorderWidth
el.style.borderStyle = this.contents.inputBorderStyle
el.style.borderColor = this.contents.inputBorderColor
el.style.borderRadius = this.contents.inputBorderRadius
el.style.backgroundColor = this.contents.inputBgColor
})
if(this.contents.inputTitle) {
document.querySelectorAll('.form-content .slt .el-form-item__label').forEach(el=>{
el.style.color = this.contents.inputTitleColor
el.style.fontSize = this.contents.inputTitleSize
el.style.lineHeight = this.contents.inputHeight
})
}
setTimeout(()=>{
document.querySelectorAll('.form-content .slt .el-input__prefix').forEach(el=>{
el.style.color = this.contents.inputIconColor
el.style.lineHeight = this.contents.inputHeight
})
document.querySelectorAll('.form-content .slt .el-input__suffix').forEach(el=>{
el.style.color = this.contents.inputIconColor
el.style.lineHeight = this.contents.inputHeight
})
document.querySelectorAll('.form-content .slt .el-input__icon').forEach(el=>{
el.style.lineHeight = this.contents.inputHeight
})
},10)
})
},
// 搜索按钮
contentSearchBtnStyleChange() {
this.$nextTick(()=>{
document.querySelectorAll('.form-content .slt .el-button--success').forEach(el=>{
el.style.height = this.contents.searchBtnHeight
el.style.color = this.contents.searchBtnFontColor
el.style.fontSize = this.contents.searchBtnFontSize
el.style.borderWidth = this.contents.searchBtnBorderWidth
el.style.borderStyle = this.contents.searchBtnBorderStyle
el.style.borderColor = this.contents.searchBtnBorderColor
el.style.borderRadius = this.contents.searchBtnBorderRadius
el.style.backgroundColor = this.contents.searchBtnBgColor
})
})
},
// 新增、批量删除
contentBtnAdAllStyleChange() {
this.$nextTick(()=>{
document.querySelectorAll('.form-content .ad .el-button--success').forEach(el=>{
el.style.height = this.contents.btnAdAllHeight
el.style.color = this.contents.btnAdAllAddFontColor
el.style.fontSize = this.contents.btnAdAllFontSize
el.style.borderWidth = this.contents.btnAdAllBorderWidth
el.style.borderStyle = this.contents.btnAdAllBorderStyle
el.style.borderColor = this.contents.btnAdAllBorderColor
el.style.borderRadius = this.contents.btnAdAllBorderRadius
el.style.backgroundColor = this.contents.btnAdAllAddBgColor
})
document.querySelectorAll('.form-content .ad .el-button--danger').forEach(el=>{
el.style.height = this.contents.btnAdAllHeight
el.style.color = this.contents.btnAdAllDelFontColor
el.style.fontSize = this.contents.btnAdAllFontSize
el.style.borderWidth = this.contents.btnAdAllBorderWidth
el.style.borderStyle = this.contents.btnAdAllBorderStyle
el.style.borderColor = this.contents.btnAdAllBorderColor
el.style.borderRadius = this.contents.btnAdAllBorderRadius
el.style.backgroundColor = this.contents.btnAdAllDelBgColor
})
document.querySelectorAll('.form-content .ad .el-button--warning').forEach(el=>{
el.style.height = this.contents.btnAdAllHeight
el.style.color = this.contents.btnAdAllWarnFontColor
el.style.fontSize = this.contents.btnAdAllFontSize
el.style.borderWidth = this.contents.btnAdAllBorderWidth
el.style.borderStyle = this.contents.btnAdAllBorderStyle
el.style.borderColor = this.contents.btnAdAllBorderColor
el.style.borderRadius = this.contents.btnAdAllBorderRadius
el.style.backgroundColor = this.contents.btnAdAllWarnBgColor
})
})
},
// 表格
rowStyle({ row, rowIndex}) {
if (rowIndex % 2 == 1) {
if(this.contents.tableStripe) {
return {color:this.contents.tableStripeFontColor}
}
} else {
return ''
}
},
cellStyle({ row, rowIndex}){
if (rowIndex % 2 == 1) {
if(this.contents.tableStripe) {
return {backgroundColor:this.contents.tableStripeBgColor}
}
} else {
return ''
}
},
headerRowStyle({ row, rowIndex}){
return {color: this.contents.tableHeaderFontColor}
},
headerCellStyle({ row, rowIndex}){
return {backgroundColor: this.contents.tableHeaderBgColor}
},
// 表格按钮
contentTableBtnStyleChange(){
},
// 分页
contentPageStyleChange(){
let arr = []
if(this.contents.pageTotal) arr.push('total')
if(this.contents.pageSizes) arr.push('sizes')
if(this.contents.pagePrevNext){
arr.push('prev')
if(this.contents.pagePager) arr.push('pager')
arr.push('next')
}
if(this.contents.pageJumper) arr.push('jumper')
this.layouts = arr.join()
this.contents.pageEachNum = 10
},
init () {
},
search() {
this.pageIndex = 1;
this.getDataList();
},
// 获取数据列表
getDataList() {
this.dataListLoading = true;
let params = {
page: this.pageIndex,
limit: this.pageSize,
sort: 'id',
}
if(this.searchForm.indexNameSearch!='' && this.searchForm.indexNameSearch!=undefined){
params['indexName'] = this.searchForm.indexNameSearch
}
//本表的
params['dicCode'] = "kemu_types"//编码名字
params['dicName'] = "科目",//汉字名字
this.$http({
url: "dictionary/page",
method: "get",
params: params
}).then(({ data }) => {
if (data && data.code === 0) {
this.dataList = data.data.list;
this.totalPage = data.data.total;
} else {
this.dataList = [];
this.totalPage = 0;
}
this.dataListLoading = false;
});
},
// 每页数
sizeChangeHandle(val) {
this.pageSize = val;
this.pageIndex = 1;
this.getDataList();
},
// 当前页
currentChangeHandle(val) {
this.pageIndex = val;
this.getDataList();
},
// 多选
selectionChangeHandler(val) {
this.dataListSelections = val;
},
// 添加/修改
addOrUpdateHandler(id,type) {
this.showFlag = false;
this.addOrUpdateFlag = true;
this.crossAddOrUpdateFlag = false;
if(type!='info'){
type = 'else';
}
this.$nextTick(() => {
this.$refs.addOrUpdate.init(id,type);
});
},
// 删除
deleteHandler(id) {
var ids = id
? [Number(id)]
: this.dataListSelections.map(item => {
return Number(item.id);
});
this.$confirm(`确定进行[${id ? "删除" : "批量删除"}]操作?`, "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning"
}).then(() => {
this.$http({
url: "dictionary/delete",
method: "post",
data: ids
}).then(({ data }) => {
if (data && data.code === 0) {
this.$message({
message: "操作成功",
type: "success",
duration: 1500,
onClose: () => {
this.search();
}
});
} else {
this.$message.error(data.msg);
}
});
});
},
}
};
</script>
<style lang="scss" scoped>
.slt {
margin: 0 !important;
display: flex;
}
.ad {
margin: 0 !important;
display: flex;
}
.pages {
& /deep/ el-pagination__sizes{
& /deep/ el-input__inner {
height: 22px;
line-height: 22px;
}
}
}
.el-button+.el-button {
margin:0;
}
.tables {
& /deep/ .el-button--success {
height: 40px;
color: #333;
font-size: 14px;
border-width: 1px;
border-style: solid;
border-color: #DCDFE6;
border-radius: 4px;
background-color: var(--publicMainColor);
}
& /deep/ .el-button--primary {
height: 40px;
color: #333;
font-size: 14px;
border-width: 1px;
border-style: solid;
border-color: #DCDFE6;
border-radius: 4px;
background-color: rgba(102, 204, 255, 1);
}
& /deep/ .el-button--danger {
height: 40px;
color: #333;
font-size: 14px;
border-width: 1px;
border-style: solid;
border-color: #DCDFE6;
border-radius: 4px;
background-color: rgba(204, 255, 102, 1);
}
& /deep/ .el-button {
margin: 4px;
}
}</style>

复制代码

声明

本博客适用于广泛的学术和教育用途，包罗但不限于个人学习、开辟设计，产物设计。仅供学习参考，旨在为读者提供深入明白和学术研究的材料。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

基于Spring Boot的大学校园生存信息平台的设计与实现pf

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云