@TOC
springboot289基于JAVA的房地产销售管理系统的设计与实现
研究背景与现状
时代的进步使人们的生活实现了部分自动化，由最初的全手动办公已转向手动+自动相结合的方式。比如各种办公系统、智能电子电器的出现，都为人们生活的享受提供帮助。采用新型的自动化方式可以减少手动的办公时间，增加正确率从而增加人们的幸福指数。时代进步中计算机技术的发展尤为突出，渗透进生活的方方面面，各种App、 网站、管理系统、小程序迅速占领市场。
对于房产的购买问题，大多数客户采用在售楼部、找中介进行。实地去售楼部需要大量时间，找中介需要付额外的中介费用。现实房地产销售缺少一种更为优质、简单的方法途径。
1.2课题实现目的和研究意义
时代的发展也为人们提出了更高的要求，只有不断的学习和发展才可以前进。目前我们正在科技和网络发展的关键点，网络已实现普及。然而还是有大量的企业、机构采用传统的办公方式进行处理事务，当然传统的方式对于小规模的企业、机构来说更为适合，但想要发展就需要以发展的目光来看待问题。如果可以采用更科学、省力的方式进行办公将会带来变革。
房地产销售方式关系着需要房产的客户使用。相关单位对房产的准确性要严格把关，更要考虑到预约看房、购买的方便。以往都是由客户提供房产面积、位置等来寻找房屋，客户占主导地位，工作人员负责查询信息然后推荐。信息传递有时候会不准确，造成推荐的麻烦。如果采用共享的平台，把客户、销售经理都结合到一起，起到信息共享就可以解决这类问题。房产的所有信息都可以由销售经理直接管理，客户的预约过程也可由相关人员负责把控，把客户的预约、购买实现流程化、清晰化，减少恶意操作，提供更为透明的工作流程，实现基于JAVA的房地产销售管理系统的真正价值。
1.3课题研究内容
本系统从房地产销售的工作出发，包括管理员和客户、销售经理三种权限。管理员的功能为房产管理、预约看房管理、购置房产管理、客户打分管理、公告信息管理、客户管理、销售经理管理等，实现系统里用户的全面管控，客户可以在线选择需要的房产进行在线预约，预约完成后可以进行购买和给工作人员打分等。销售经理负责房产管理、预约看房管理以及购置房产管理、客户打分管理等。三种权限的用户功能相辅相成，不可缺少，共同帮助房产的销售管理。
1.4论文结构安排
本篇论文的结构分为摘要、目录、正文部分、总结、致谢和参考文献。正文部分为核心。正文部分分为：
第1章绪论，从课题的开发背景、现状、目的意义等进行本课题的介绍；
第2章系统分析，从系统的开发技术、环境、可行性、操作流程等进行系统的详细分析；
第3章系统设计，从系统的功能图、数据库设计、ER图、数据库表进行系统的设计；
第4章系统实现，主要介绍系统的实现界面和实现内容；
第5章系统测试，讲解主要功能的测试过程以及测试结果。
第2章 系统分析
2.1系统开发中使用相关技术介绍
2.1.1JAVA介绍
JAVA语言是从Asp进行衍生出来的一种新型编程语言，他保留了Asp语言中很多核心技术，继承了他的面向对象的优点，而且舍弃了很多缺点，比如在JAVA语言中去掉了指针，这样可以减少很多错误，还去掉了运算符，这样提高了运行处理效率。还增加了很多优点，添加了垃圾回收功能，提高了代码的使用率，总体来说，JAVA语言是一个分布式的、高性能的、多线程的开发语言。JAVA从开发之初就是打算作为一个开放性的语言技术，这就要求需要有很高的兼容性，首先就需要同样的代码程序可以在不同的计算机上运行，还要支持不同的网络，同时还要注重安全性，方便用户使用。JAVA语言最突出的特点就是面向对象，可以把一个对象当成很多代码状态的物体，然后进行自定义类型进行关联操作，这样进行集合起来的代码就叫对象，面向对象的方法可以使设计根据的简单，方便管理，还可以减少失败。Asp最大的一个缺点就是没有垃圾回收机制，通常在编程的过程中，初始化对象时候系统会自动分配一个内存地址，如果不需要这个对象的时候，系统不能进行自动删除和回收，这样造成了很大的内存浪费，导致系统卡顿，会让系统非常的不稳定，严重的话甚至会系统崩溃，而JAVA语言就是在这个基础上设置了垃圾回收机制，当一个使用过的对象没有引用的时候，系统可以自动删除，回收内存，这样就可以很好的避免了内存泄漏，保障了程序的安全，同时提高了运行效率。
2.1.2Mysql数据库介绍
Mysql数据库是目前比较流行的一种开源数据库，可以支持多种编译器进行在线测试，从而保证了代码的可移植性，而且支持多种操作系统有很好的跨平台性，为编程语言提供所需要的API,可以多线程同时运行，这样有效的减少了内存占用率，提高了使用效率。运行的过程中还能自动优化sql查询算法，这样使数据查询速度达到了显著的提高，而且Mysql数据库还可以作为一个独立的程序在客户端中单独使用，也可以嵌入到其他程序中搭配一起使用。Mysql数据库效率非常的高，可以处理上千万条数据，可以同时支持多种不同的数据引擎，而且是开源的软件，不需要支付任何费用，而且可以进行定制，使用GPL协议进行代码修改，开发属于自己的Mysql系统。综上所述，Mysql数据库是一个非常受欢迎的一个数据库，体积小，速度快，最重要的还是免费，非常适合中小型项目的开发使用。
2.1.3B/s架构介绍
B/s架构是随着网络快速发展而开发出来的一种网络框架，跟传统的c/s框架最大的区别就是，直接把代码部署到网络服务器中，这样方便了系统的后期开发和维护，然后用户可以直接通过浏览器进行代码的访问，不需要额外安装任何的软件客户端，简化了用户的使用。B/s结构是指Browser／Server结构，意思就是只需要安装一个服务器就行了， 客户端方面主要就是采用浏览器进行访问，主要是对传统的c/s架构的一种改进，采用www浏览器技术和其他Script语言技术，把系统实现需要的代码全部部署到了服务器上面，是一种新型的架构技术，可以直接借助浏览器进行数据访问和数据交互。最大的优点就是，不需要安装客户端，不受环境影响，可以实时实地的进行访问，其次就是维护非常的方便。当然了有优点也有不可避免的缺点，首先是在访问速度方面，比较受网络的影响，不像cs架构一样，处理速度非常的快，直接在本机就可以完成数据交互，而B/s需要借助网络才能进行服务器访问，必须保证有顺畅的网络，才能有好的使用体验，其次就是安全性，因为所有数据存储在网络服务器中，比较容易受到攻击，从而造成数据泄漏，这是目前B/s架构存在的最大的弊端。所以说B/s架构适合一些电子商务类的网站，适合比较有用户共享交互的，开放性的网站的设计与开发。所以我开发本系统采用B/s架构是非常适合的，可以达到多人同时登录系统，可以实现信息交互，而且方便随时随地的进行数据访问，而且本人对B/s架构开发比较熟悉，所以本系统就采用B/s架构来进行开发设计。
2.1.4 Tomcat服务器介绍
Tomcat服务器属于Web服务器的一部分。Tomcat服务器作为JAVA语言项目的运行条件非常受欢迎。因为Tomcat服务器非常小，可以内置到运行软件里使用，不需要单独安装，这样可以减少多种环境的安装，从而简化项目的调试。Tomcat服务器由SUN公司创立，可以处理Html页面，在运行中处理Vue和Servlet页面。
2.1.5Vue技术介绍
Vue技术是新一代的用来创建动态页面的技术。Vue技术通过服务器来响应要求，再根据要求生成Html、Xml来进行转换成Web页面。Vue技术也属于一种脚本语言，常用来搭配JAVA语言使用，可以和静态的页面一起使用，把静态的页面改成动态的页面。Vue技术在使用时可以转换成Servlet代码，然后再编译成二进制的机器码，当然也可以直接编译成二进制的机器码。Vue技术的特点为简单好用，可以快速的把静态页面变成动态的页面，它使用JAVA来把常用的代码来复制，可以减少编程人员的重复工作，同时Vue技术还拥有很多标签，可以支持更多的外在标签和内在的标签，还可以自定义标签，使编程人员在使用时更加的灵活，加快项目开发的速度。Vue技术的功能非常简单，只负责页面数据，负责页面的传输，所以更加的单纯，不容易出错。
2.2系统可行性分析
系统的可行性关系着系统开发的成功和市场，没有经过详细可行性分析的系统开发过程会非常艰难。系统的可行性分析也是在系统开发前的必要研究过程。通过研究已有的大量论文和文献发现，系统可行性从系统的经济方面、操作方面和技术方面进行分析。
2.2.1经济可行性分析
系统开发所需要的经济主要在系统的成本问题、运行问题和维护问题上。本系统在开发中不需要经济的支撑，所需要的开发软件和设备都是在已有条件上。本系统在运行里所需要的环境也都为免费就可以下载的。本系统在后期的维护上也只需要技术支持就可以完成。所以本系统在经济可行性上可以通过。
2.2.2操作可行性分析
本系统在开发中充分调查了所使用用户的操作习惯和风格，所有的操作流程也都为简单的流程，在操作中也设置了提醒。用户在使用本系统时只要按照提示就可以完成，非常简单。所以本系统在操作可行性上可以通过。
2.2.3技术可行性分析
本系统所需要的技术支持为JAVA语言，Mysql数据库，Vue技术和B/s框架等。所使用的技术都为开源成熟的技术，也是目前流行的技术之一。使用这些技术开发的系统可以保证系统的前詹性和稳定性、安全性。所以本系统在技术可性性上可以通过。
2.3系统需求分析
目前计算机、网络技术已进入到各行各业。房产做为生活的重要组成部分更应身体力行，房地产销售里的所有工作都是围绕房产而展开，每套房的房产档案信息都非常多，如果采用传统的管理方式非常容易造成混乱，而且对于房产的信息查询非常不便。对于房产的管理工作需要额外的严谨，如果还是采用传统的房产管理方式对房地产销售、购买都做不到百分百的监管，工作步骤、内容也实现不了透明。所以非常需要新的管理方式出现。
2.4系统性能分析
系统在设计时也需要注意系统的性能，一般系统的性能方面包括系统的稳定性、安全性、界面设计方面、操作方面、协调等方面。
- 本系统在界面设计方面尊重所有的使用权限，多方面参考不同使用权限的使用习惯以及风格，综合不同的情况整理出符合大众要求的系统界面。做到自己的最大能力；
- 在系统的稳定性、安全性方面采用必要的登录验证，不同权限采用不同的账号和密码。为了使系统更为稳定采用成熟的开发环境和技术，在代码编写时尽可能的减少冗余，保证系统的运行效率；
- 在系统的操作流程方面，尽可能的采用简单的流程来实现用户要求的反馈，当用户提出需求时，可以用最少的步骤进行提问操作；
- 本系统采用数据库和功能界面分开设计，这样可以保证当系统的功能运行出错时不会影响系统里的数据，也就保证了数据的安全。
2.5系统功能分析
系统的功能分析决定了系统的功能设计，完整详细的系统功能分析可以使系统的开发事半功倍。本系统的功能围绕客户、销售经理、管理员三种权限设计。根据不同权限的不同需求设计出更符合用户要求的功能。本系统中销售经理主要负责发布分享新的房产，审核用户的预约信息和进行房产购置处理等，客户可以对需要的房产进行预约、购置等。管理员负责网站里所有信息的审核管理。本基于JAVA的房地产销售管理系统管理员的用例图如下图2-1所示：
图2-1管理员用例图
客户可以管理个人资料、查询房产、在线预约和购置、打分等，客户的个人资料是由用户注册时产生，客户的预约内容由客户在预约看房时产生，客户打分内容由客户发布分数操作时产生。客户用例图如下图2-2所示：
图2-2客户用例图
销售经理可以审核预约看房、管理房产信息、论坛管理、购置房产管理以及客户打分管理、公告信息管理等。销售经理用例图如下图2-3所示：
图2-3销售经理用例图
2.6系统操作流程分析
信息从如何产生到反馈结果的过程可以称为信息的流程。分析好系统的操作流程才可以使系统正确运行不会出现Bug。本系统的流程为管理员先进行登录，登录后管理注册用户的账号、密码等信息，更新房产，管理用户的预约和购置等，客户可以查询房产、预约看房、购置房产等。销售经理可以审核用户的预约看房，管理客户的购置房产等。系统里展示的房产数据都是由管理员、销售经理负责。本基于JAVA的房地产销售管理系统的操作流程如下图2-5所示：
图2-5基于JAVA的房地产销售管理系统操作流程图
第3章 系统设计
3.1系统功能结构设计
系统的功能结构是采用树形图来绘制功能设计。根据分析所得，本系统的功能设计为管理员、客户、销售经理三部分。管理员为房产管理、预约看房管理、论坛管理、购置房产管理、客户打分管理、公告信息管理、客户管理、销售经理管理等，客户的功能为查询房产，在线预约、购置房产、管理个人信息、打分信息等。客户可以注册进行登录。销售经理为审核客户的预约、管理购置房产信息、客户打分信息等。本基于JAVA的房地产销售管理系统的功能结构设计图如下图3-1所示：
图3-1基于JAVA的房地产销售管理系统功能结构图
3.2数据库设计
数据库为数据的仓库，决定了数据的保存和修改、删除、调用等。数据库的稳定决定了系统里数据的安全。为了保证数据的查询效率，在建立数据库时需要按照一定的规则。数据不单指文本类型的，也包括音乐、图片甚至是声音都可以称为数据。为了使数据库更加安全，在建立数据库时就需要使用正规的数据库管理系统和在设置权限时需要设置严格的角色分权，更要阻止一切外部端口的探测形为。
本系统采用Mysql数据库，在建立数据库时采用Root用户名。数据库的建立过程为先进行数据的ER图设计然后进行数据库表的实现。
3.2.1数据ER图设计
数据ER图中记录了关系、实体、属性。实体与实体的关系决定了数据在调用时的正确与否，实体的属性决定了该实体的内容。数据ER图的设计同样重要，也是数据库建立的基础。
通过系统中的功能数据分析，本系统的实体主要有房产、管理员、客户、预约等。
- 管理员的ER图中的属性有账号、密码、权限。管理员ER图如下图3-2所示：
图3-2管理员ER图
- 客户的ER图里的属性有性别、姓名、编号等，客户的ER图如下图3-3所示：
图3-3客户ER图
- 房产的ER图里的属性有房产编号、面积、户型图、价格等，房产的ER图如下图3-4所示：
图3-4房产ER图
(4)预约的ER图里的属性有预约人、编号、预约时间、房产等，预约ER图如下图3-5所示：
图3-5预约ER图
3.2.2数据库表设计
数据库表是把ER图进行详细化、实体化。不同的表名下保存着相对应的表信息数据。在数据库表里记录着数据的主键、外键、数据类型、长度等。本基于JAVA的房地产销售管理系统所创建的数据库表有管理员信息表、房产信息表、预约信息表、购置房产信息表等。本基于JAVA的房地产销售管理系统的数据库表如下表3-1—3-13所示：
表3-1 config
|| | :- | 表3-2 dictionary
表3-3 fangchan
|| | :- | 表3-4 fangchan_collection
|| | :- | 表3-5 fangchan_yuyue
|| | :- | 表3-6 forum
|| | :- | 表3-7 gouzhifangcan
|| | :- | 表3-8 kehudafen
表3-9 news
表3-10 token
|| | :- | 表3-11 users
|| | :- | 表3-12 yonghu
|| | :- |
表3-13 yuangong
|| | :- |
第4章 系统详细实现
4.1用户登录功能的详细实现
用户登录界面起到验证身份的作用，本界面采用风景图片背景进行设计。在用户登录界面里设置了程序的名称和用户、密码、客户注册的文本框。在文本框下是登录按钮。用户在信息输入完成后可以使用登录按钮进行相对应的操作，还加入了登录安全的简单文字提醒。用户登录功能的实现界面如下图4-1所示：
图4-1用户登录实现界面
4.2管理员权限的功能实现
4.2.1客户信息管理功能的详细实现
管理员负责客户信息的录入和管理，客户的地址、联系方式等都可以由管理员在此功能里看到。管理员查询客户信息的功能实现如下图4-2所示：
图4-2管理员查询客户信息的实现界面
4.2.2房产管理功能的详细实现
管理员可以对房产的信息进行管理、审核。本功能可以实现房产的定时更新和审核管理。管理员查询房产信息的实现界面如下图4-3所示：
图4-3管理员查询房产信息的实现界面
4.2.3预约看房功能的详细实现
本功能包括查询已有的所有预约看房信息和删除预约看房信息。预约看房查询功能的实现详情如下图4-4所示：
图4-4预约看房查询功能的实现界面
4.2.4论坛管理功能的详细实现
管理员可以查询论坛和审核管理客户发布的帖子。论坛管理功能的实现界面如下图4-5所示：
图4-5论坛管理功能的实现界面
4.2.5购置房产管理功能的详细实现
管理员可以管理客户的购置房产信息，也可以查询和删除购置房产内容。购置房产管理功能的实现界面如下图4-6所示：
图4-6购置房产管理功能的实现界面
4.2.6个人中心管理功能的详细实现
管理员可以对个人的资料进行修改和管理，管理员还可以在本功能里修改密码。管理员查询个人资料的实现界面如下图4-7所示：
图4-7个人中心管理功能的实现界面
4.2.7客户打分管理功能的实现界面
管理员可以查询客户的打分详情，并进行查询等操作。客户打分管理功能的实现界面如下图4-8所示：
图4-8客户打分管理功能的实现界面
4.2.8基础数据管理功能的实现界面
管理员可以管理房产户型和公告类型。实现界面如下图4-9所示：
图4-9基础数据管理功能的实现界面
4.2.9轮播图管理功能的实现界面
可以设置轮播图。实现界面如下图4-10所示：
图4-10轮播图管理功能的实现界面
4.3客户权限的功能详细实现
4.3.1个人中心管理功能的详细界面实现
当客户登录进系统后可以修改自己的资料，可以使自己信息的保持正确性。客户修改个人资料的实现界面如下图4-11所示：
图4-11修改个人资料功能的运行界面
4.3.2房产查询功能的详细实现
用户可以根据房产名称搜索相对应的房产，用户查询房产的界面实现如下图4-12所示：
图4-12房产查询功能的运行界面
4.3.3预约看房功能的详细实现
在本功能里客户可以查看自己预约的所有房产信息。预约看房功能的实现界面如下图4-13所示：
图4-13预约看房功能的运行界面
4.3.4论坛管理功能的详细实现
客户可以发布帖子和查看帖子的回复信息。论坛管理功能的实现界面如下图4-14所示：
图4-14论坛管理功能的实现界面
4.3.5购置房产管理功能的详细实现
客户可以在线购置房产，也可以查询自己的详细购置内容。购置房产管理功能的实现界面如下图4-15所示：
图4-15购置房产管理功能的实现界面
4.3.6客户打分功能的详细实现
完成销售后，客户可以进行打分。客户打分的实现界面如下图4-16所示：
图4-16客户打分功能的运行界面
4.4销售经理权限功能的实现
销售经理的功能和管理员的类似，功能包括房产信息管理、预约看房管理、论坛管理、公告管理、购置房产管理、客户打分管理。销售经理权限的功能实现界面如下图4-17所示：
图4.17销售经理权限功能的实现界面
第5章 系统测试
系统测试的方
FangchanYuyueController.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("/fangchanYuyue")
public class FangchanYuyueController {
private static final Logger logger = LoggerFactory.getLogger(FangchanYuyueController.class);
@Autowired
private FangchanYuyueService fangchanYuyueService;
@Autowired
private TokenService tokenService;
@Autowired
private DictionaryService dictionaryService;
//级联表service
@Autowired
private FangchanService fangchanService;
@Autowired
private YonghuService yonghuService;
@Autowired
private YuangongService yuangongService;
/**
* 后端列表
*/
@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"));
else if("销售经理".equals(role))
params.put("yuangongId",request.getSession().getAttribute("userId"));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
}
PageUtils page = fangchanYuyueService.queryPage(params);
//字典表数据转换
List<FangchanYuyueView> list =(List<FangchanYuyueView>)page.getList();
for(FangchanYuyueView 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);
FangchanYuyueEntity fangchanYuyue = fangchanYuyueService.selectById(id);
if(fangchanYuyue !=null){
//entity转view
FangchanYuyueView view = new FangchanYuyueView();
BeanUtils.copyProperties( fangchanYuyue , view );//把实体数据重构到view中
//级联表
FangchanEntity fangchan = fangchanService.selectById(fangchanYuyue.getFangchanId());
if(fangchan != null){
BeanUtils.copyProperties( fangchan , view ,new String[]{ "id", "createTime", "insertTime", "updateTime"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setFangchanId(fangchan.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangchanYuyue.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 FangchanYuyueEntity fangchanYuyue, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,fangchanYuyue:{}",this.getClass().getName(),fangchanYuyue.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
else if("客户".equals(role))
fangchanYuyue.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
Wrapper<FangchanYuyueEntity> queryWrapper = new EntityWrapper<FangchanYuyueEntity>()
.eq("fangchan_id", fangchanYuyue.getFangchanId())
.eq("yonghu_id", fangchanYuyue.getYonghuId())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
FangchanYuyueEntity fangchanYuyueEntity = fangchanYuyueService.selectOne(queryWrapper);
if(fangchanYuyueEntity==null){
fangchanYuyue.setInsertTime(new Date());
fangchanYuyue.setCreateTime(new Date());
fangchanYuyueService.insert(fangchanYuyue);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
/**
* 后端修改
*/
@RequestMapping("/update")
public R update(@RequestBody FangchanYuyueEntity fangchanYuyue, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,fangchanYuyue:{}",this.getClass().getName(),fangchanYuyue.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
// else if("客户".equals(role))
// fangchanYuyue.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
//根据字段查询是否有相同数据
Wrapper<FangchanYuyueEntity> queryWrapper = new EntityWrapper<FangchanYuyueEntity>()
.notIn("id",fangchanYuyue.getId())
.andNew()
.eq("fangchan_id", fangchanYuyue.getFangchanId())
.eq("yonghu_id", fangchanYuyue.getYonghuId())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
FangchanYuyueEntity fangchanYuyueEntity = fangchanYuyueService.selectOne(queryWrapper);
if(fangchanYuyueEntity==null){
fangchanYuyueService.updateById(fangchanYuyue);//根据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());
fangchanYuyueService.deleteBatchIds(Arrays.asList(ids));
return R.ok();
}
/**
* 批量上传
*/
@RequestMapping("/batchInsert")
public R save( String fileName){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
try {
List<FangchanYuyueEntity> fangchanYuyueList = 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){
//循环
FangchanYuyueEntity fangchanYuyueEntity = new FangchanYuyueEntity();
// fangchanYuyueEntity.setFangchanId(Integer.valueOf(data.get(0))); //房产 要改的
// fangchanYuyueEntity.setYonghuId(Integer.valueOf(data.get(0))); //客户 要改的
// fangchanYuyueEntity.setFangchanYuyueTime(new Date(data.get(0))); //预约时间 要改的
// fangchanYuyueEntity.setInsertTime(date);//时间
// fangchanYuyueEntity.setCreateTime(date);//时间
fangchanYuyueList.add(fangchanYuyueEntity);
//把要查询是否重复的字段放入map中
}
//查询是否重复
fangchanYuyueService.insertBatch(fangchanYuyueList);
return R.ok();
}
}
}
}catch (Exception e){
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));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
}
PageUtils page = fangchanYuyueService.queryPage(params);
//字典表数据转换
List<FangchanYuyueView> list =(List<FangchanYuyueView>)page.getList();
for(FangchanYuyueView 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);
FangchanYuyueEntity fangchanYuyue = fangchanYuyueService.selectById(id);
if(fangchanYuyue !=null){
//entity转view
FangchanYuyueView view = new FangchanYuyueView();
BeanUtils.copyProperties( fangchanYuyue , view );//把实体数据重构到view中
//级联表
FangchanEntity fangchan = fangchanService.selectById(fangchanYuyue.getFangchanId());
if(fangchan != null){
BeanUtils.copyProperties( fangchan , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setFangchanId(fangchan.getId());
}
//级联表
YonghuEntity yonghu = yonghuService.selectById(fangchanYuyue.getYonghuId());
if(yonghu != null){
BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
view.setYonghuId(yonghu.getId());
}
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody FangchanYuyueEntity fangchanYuyue, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,fangchanYuyue:{}",this.getClass().getName(),fangchanYuyue.toString());
Wrapper<FangchanYuyueEntity> queryWrapper = new EntityWrapper<FangchanYuyueEntity>()
.eq("fangchan_id", fangchanYuyue.getFangchanId())
.eq("yonghu_id", fangchanYuyue.getYonghuId())
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
FangchanYuyueEntity fangchanYuyueEntity = fangchanYuyueService.selectOne(queryWrapper);
if(fangchanYuyueEntity==null){
fangchanYuyue.setInsertTime(new Date());
fangchanYuyue.setCreateTime(new Date());
fangchanYuyueService.insert(fangchanYuyue);
return R.ok();
}else {
return R.error(511,"表中有相同数据");
}
}
}
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);
@Autowired
private DictionaryService dictionaryService;
@Autowired
private TokenService tokenService;
//级联表service
@Autowired
private YonghuService yonghuService;
@Autowired
private YuangongService yuangongService;
/**
* 后端列表
*/
@RequestMapping("/page")
@IgnoreAuth
public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
}
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){
logger.debug("update方法:,,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>()
.notIn("id",dictionary.getId())
.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){
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();
}else {
return R.error(511,"表中有相同数据");
}
}
/**
* 删除
*/
@RequestMapping("/delete")
public R delete(@RequestBody Integer[] ids){
logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
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 != null ){
return R.ok().put("maxCodeIndex",dictionaryEntityList.get(0).getCodeIndex()+1);
}else{
return R.ok().put("maxCodeIndex",1);
}
}
/**
* 批量上传
*/
@RequestMapping("/batchInsert")
public R save( String fileName){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
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){
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
}
YuangongController.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("/yuangong")
public class YuangongController {
private static final Logger logger = LoggerFactory.getLogger(YuangongController.class);
@Autowired
private YuangongService yuangongService;
@Autowired
private TokenService tokenService;
@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("yonghuId",request.getSession().getAttribute("userId"));
else if("销售经理".equals(role))
params.put("yuangongId",request.getSession().getAttribute("userId"));
params.put("yuangongDeleteStart",1);params.put("yuangongDeleteEnd",1);
if(params.get("orderBy")==null || params.get("orderBy")==""){
params.put("orderBy","id");
}
PageUtils page = yuangongService.queryPage(params);
//字典表数据转换
List<YuangongView> list =(List<YuangongView>)page.getList();
for(YuangongView 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);
YuangongEntity yuangong = yuangongService.selectById(id);
if(yuangong !=null){
//entity转view
YuangongView view = new YuangongView();
BeanUtils.copyProperties( yuangong , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 后端保存
*/
@RequestMapping("/save")
public R save(@RequestBody YuangongEntity yuangong, HttpServletRequest request){
logger.debug("save方法:,,Controller:{},,yuangong:{}",this.getClass().getName(),yuangong.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
if(false)
return R.error(511,"永远不会进入");
Wrapper<YuangongEntity> queryWrapper = new EntityWrapper<YuangongEntity>()
.eq("username", yuangong.getUsername())
.or()
.eq("yuangong_phone", yuangong.getYuangongPhone())
.andNew()
.eq("yuangong_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YuangongEntity yuangongEntity = yuangongService.selectOne(queryWrapper);
if(yuangongEntity==null){
yuangong.setYuangongDelete(1);
yuangong.setCreateTime(new Date());
yuangong.setPassword("123456");
yuangongService.insert(yuangong);
return R.ok();
}else {
return R.error(511,"账户或者联系方式已经被使用");
}
}
/**
* 后端修改
*/
@RequestMapping("/update")
public R update(@RequestBody YuangongEntity yuangong, HttpServletRequest request){
logger.debug("update方法:,,Controller:{},,yuangong:{}",this.getClass().getName(),yuangong.toString());
String role = String.valueOf(request.getSession().getAttribute("role"));
// if(false)
// return R.error(511,"永远不会进入");
//根据字段查询是否有相同数据
Wrapper<YuangongEntity> queryWrapper = new EntityWrapper<YuangongEntity>()
.notIn("id",yuangong.getId())
.andNew()
.eq("username", yuangong.getUsername())
.or()
.eq("yuangong_phone", yuangong.getYuangongPhone())
.andNew()
.eq("yuangong_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YuangongEntity yuangongEntity = yuangongService.selectOne(queryWrapper);
if("".equals(yuangong.getYuangongPhoto()) || "null".equals(yuangong.getYuangongPhoto())){
yuangong.setYuangongPhoto(null);
}
if(yuangongEntity==null){
yuangongService.updateById(yuangong);//根据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());
ArrayList<YuangongEntity> list = new ArrayList<>();
for(Integer id:ids){
YuangongEntity yuangongEntity = new YuangongEntity();
yuangongEntity.setId(id);
yuangongEntity.setYuangongDelete(2);
list.add(yuangongEntity);
}
if(list != null && list.size() >0){
yuangongService.updateBatchById(list);
}
return R.ok();
}
/**
* 批量上传
*/
@RequestMapping("/batchInsert")
public R save( String fileName){
logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
try {
List<YuangongEntity> yuangongList = 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){
//循环
YuangongEntity yuangongEntity = new YuangongEntity();
// yuangongEntity.setUsername(data.get(0)); //账户 要改的
// //yuangongEntity.setPassword("123456");//密码
// yuangongEntity.setYuangongName(data.get(0)); //销售经理姓名 要改的
// yuangongEntity.setYuangongPhoto("");//照片
// yuangongEntity.setSexTypes(Integer.valueOf(data.get(0))); //性别 要改的
// yuangongEntity.setYuangongPhone(data.get(0)); //联系方式 要改的
// yuangongEntity.setYuangongEmail(data.get(0)); //邮箱 要改的
// yuangongEntity.setYuangongDelete(1);//逻辑删除字段
// yuangongEntity.setCreateTime(date);//时间
yuangongList.add(yuangongEntity);
//把要查询是否重复的字段放入map中
//账户
if(seachFields.containsKey("username")){
List<String> username = seachFields.get("username");
username.add(data.get(0));//要改的
}else{
List<String> username = new ArrayList<>();
username.add(data.get(0));//要改的
seachFields.put("username",username);
}
//联系方式
if(seachFields.containsKey("yuangongPhone")){
List<String> yuangongPhone = seachFields.get("yuangongPhone");
yuangongPhone.add(data.get(0));//要改的
}else{
List<String> yuangongPhone = new ArrayList<>();
yuangongPhone.add(data.get(0));//要改的
seachFields.put("yuangongPhone",yuangongPhone);
}
}
//查询是否重复
//账户
List<YuangongEntity> yuangongEntities_username = yuangongService.selectList(new EntityWrapper<YuangongEntity>().in("username", seachFields.get("username")).eq("yuangong_delete", 1));
if(yuangongEntities_username.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(YuangongEntity s:yuangongEntities_username){
repeatFields.add(s.getUsername());
}
return R.error(511,"数据库的该表中的 [账户] 字段已经存在 存在数据为:"+repeatFields.toString());
}
//联系方式
List<YuangongEntity> yuangongEntities_yuangongPhone = yuangongService.selectList(new EntityWrapper<YuangongEntity>().in("yuangong_phone", seachFields.get("yuangongPhone")).eq("yuangong_delete", 1));
if(yuangongEntities_yuangongPhone.size() >0 ){
ArrayList<String> repeatFields = new ArrayList<>();
for(YuangongEntity s:yuangongEntities_yuangongPhone){
repeatFields.add(s.getYuangongPhone());
}
return R.error(511,"数据库的该表中的 [联系方式] 字段已经存在 存在数据为:"+repeatFields.toString());
}
yuangongService.insertBatch(yuangongList);
return R.ok();
}
}
}
}catch (Exception e){
return R.error(511,"批量插入数据异常，请联系管理员");
}
}
/**
* 登录
*/
@IgnoreAuth
@RequestMapping(value = "/login")
public R login(String username, String password, String captcha, HttpServletRequest request) {
YuangongEntity yuangong = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("username", username));
if(yuangong==null || !yuangong.getPassword().equals(password))
return R.error("账号或密码不正确");
else if(yuangong.getYuangongDelete() != 1)
return R.error("账户已被删除");
// // 获取监听器中的字典表
// ServletContext servletContext = ContextLoader.getCurrentWebApplicationContext().getServletContext();
// Map<String, Map<Integer, String>> dictionaryMap= (Map<String, Map<Integer, String>>) servletContext.getAttribute("dictionaryMap");
// Map<Integer, String> role_types = dictionaryMap.get("role_types");
// role_types.get(.getRoleTypes());
String token = tokenService.generateToken(yuangong.getId(),username, "yuangong", "销售经理");
R r = R.ok();
r.put("token", token);
r.put("role","销售经理");
r.put("username",yuangong.getYuangongName());
r.put("tableName","yuangong");
r.put("userId",yuangong.getId());
return r;
}
/**
* 注册
*/
@IgnoreAuth
@PostMapping(value = "/register")
public R register(@RequestBody YuangongEntity yuangong){
// ValidatorUtils.validateEntity(user);
Wrapper<YuangongEntity> queryWrapper = new EntityWrapper<YuangongEntity>()
.eq("username", yuangong.getUsername())
.or()
.eq("yuangong_phone", yuangong.getYuangongPhone())
.andNew()
.eq("yuangong_delete", 1)
;
YuangongEntity yuangongEntity = yuangongService.selectOne(queryWrapper);
if(yuangongEntity != null)
return R.error("账户或者联系方式已经被使用");
yuangong.setYuangongDelete(1);
yuangong.setCreateTime(new Date());
yuangongService.insert(yuangong);
return R.ok();
}
/**
* 重置密码
*/
@GetMapping(value = "/resetPassword")
public R resetPassword(Integer id){
YuangongEntity yuangong = new YuangongEntity();
yuangong.setPassword("123456");
yuangong.setId(id);
yuangongService.updateById(yuangong);
return R.ok();
}
/**
* 忘记密码
*/
@IgnoreAuth
@RequestMapping(value = "/resetPass")
public R resetPass(String username, HttpServletRequest request) {
YuangongEntity yuangong = yuangongService.selectOne(new EntityWrapper<YuangongEntity>().eq("username", username));
if(yuangong!=null){
yuangong.setPassword("123456");
boolean b = yuangongService.updateById(yuangong);
if(!b){
return R.error();
}
}else{
return R.error("账号不存在");
}
return R.ok();
}
/**
* 获取用户的session用户信息
*/
@RequestMapping("/session")
public R getCurrYuangong(HttpServletRequest request){
Integer id = (Integer)request.getSession().getAttribute("userId");
YuangongEntity yuangong = yuangongService.selectById(id);
if(yuangong !=null){
//entity转view
YuangongView view = new YuangongView();
BeanUtils.copyProperties( yuangong , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 退出
*/
@GetMapping(value = "logout")
public R logout(HttpServletRequest request) {
request.getSession().invalidate();
return R.ok("退出成功");
}
/**
* 前端列表
*/
@IgnoreAuth
@RequestMapping("/list")
public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
// 没有指定排序字段就默认id倒序
if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
params.put("orderBy","id");
}
PageUtils page = yuangongService.queryPage(params);
//字典表数据转换
List<YuangongView> list =(List<YuangongView>)page.getList();
for(YuangongView 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);
YuangongEntity yuangong = yuangongService.selectById(id);
if(yuangong !=null){
//entity转view
YuangongView view = new YuangongView();
BeanUtils.copyProperties( yuangong , view );//把实体数据重构到view中
//修改对应字典表字段
dictionaryService.dictionaryConvert(view, request);
return R.ok().put("data", view);
}else {
return R.error(511,"查不到数据");
}
}
/**
* 前端保存
*/
@RequestMapping("/add")
public R add(@RequestBody YuangongEntity yuangong, HttpServletRequest request){
logger.debug("add方法:,,Controller:{},,yuangong:{}",this.getClass().getName(),yuangong.toString());
Wrapper<YuangongEntity> queryWrapper = new EntityWrapper<YuangongEntity>()
.eq("username", yuangong.getUsername())
.or()
.eq("yuangong_phone", yuangong.getYuangongPhone())
.andNew()
.eq("yuangong_delete", 1)
;
logger.info("sql语句:"+queryWrapper.getSqlSegment());
YuangongEntity yuangongEntity = yuangongService.selectOne(queryWrapper);
if(yuangongEntity==null){
yuangong.setYuangongDelete(1);
yuangong.setCreateTime(new Date());
yuangong.setPassword("123456");
yuangongService.insert(yuangong);
return R.ok();
}else {
return R.error(511,"账户或者联系方式已经被使用");
}
}
}
扫一扫
520
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
