package com.whyc.service;
|
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.whyc.constant.UserConstant;
|
import com.whyc.constant.YamlProperties;
|
import com.whyc.dto.Response;
|
import com.whyc.mapper.*;
|
import com.whyc.pojo.*;
|
import com.whyc.util.ActionUtil;
|
import com.whyc.util.RSAUtil;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.context.ApplicationContext;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.bind.annotation.RequestParam;
|
|
import javax.annotation.Resource;
|
import javax.servlet.ServletContext;
|
import javax.servlet.http.HttpSession;
|
import java.io.UnsupportedEncodingException;
|
import java.net.URLDecoder;
|
import java.security.InvalidParameterException;
|
import java.util.*;
|
|
@Service
|
@Slf4j
|
public class UserService {
|
|
@Resource
|
private UserMapper userMapper;
|
@Resource
|
private UserPermitGroupDataMapper permitMapper;
|
@Resource
|
private BaoJiGroupUserMapper baoJiGroupUserMapper;
|
@Resource
|
private UserBridgeService userBridgeService;
|
|
@Autowired
|
private ApplicationContext applicationContext;
|
|
@Resource
|
private PermitGroupUserService permitGroupUserService;
|
|
@Resource
|
private PageParamMapper pageParamMapper;
|
|
|
|
public Response add(UserInf user) {
|
try {
|
UserInf userFound = userBridgeService.findPasswordByUserName(user.getUName());
|
if (userFound.getUId() != 0) {
|
return new Response<>().set(1, false, "用户已存在");
|
}
|
if (userMapper.addJudge(user.getUName(),user.getUMobilephone())>0){
|
return new Response<>().set(1, false, "用户已存在");
|
}
|
//user.setCreateTime(new Date());
|
String[] dataArr = RSAUtil.decryptFrontP(user.getUpassword(), RSAUtil.fontSeparator);
|
String password = dataArr[0];
|
String passwordMD5 = dataArr[1];
|
if(!ActionUtil.EncryptionMD5(password).equals(passwordMD5)){
|
throw new InvalidParameterException("参数校验失败");
|
}
|
user.setUpassword(RSAUtil.encrypt(password,RSAUtil.getPublicKey()));
|
int flag = userMapper.insert(user);
|
if (flag > 0) {
|
Integer uId= userMapper.getUserInfoByPhoneNumber(user.getUMobilephone()).getUId().intValue();
|
UserPermitGroupData permitGroupData = new UserPermitGroupData();
|
permitGroupData.setPermitGroupId(user.getPermitGroupId());
|
permitGroupData.setUId(uId);
|
permitMapper.insert(permitGroupData);
|
return new Response<>().set(1, true);
|
} else {
|
return new Response<>().set(1, false, "添加失败");
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
return new Response<>().set(0);
|
}
|
}
|
public Response addByRSA(UserInf user) {
|
//首先校验当前用户所在的权限组,是否存在用户编辑权限 usr_edit_permit
|
if (!checkUserPermit()) return new Response<>().set(1, false, "当前用户没有用户编辑权限");
|
try {
|
UserInf userFound = userBridgeService.findPasswordByUserName(user.getUName());
|
if (userFound.getUId() != 0) {
|
return new Response<>().set(1, false, "用户名已存在");
|
}
|
UserInf userOfMobilephone = userBridgeService.findUserByMobilephone(user.getUMobilephone());
|
if (userOfMobilephone.getUId()!=0) {
|
return new Response<>().set(1, false, "手机号已存在");
|
}
|
//String password = URLDecoder.decode(user.getUpassword(), "utf-8");
|
String password = user.getUpassword();
|
String[] dataArr = RSAUtil.decryptFront(password, RSAUtil.fontSeparator);
|
String pwd = RSAUtil.encrypt(dataArr[0],RSAUtil.getPublicKey());
|
user.setUpassword(pwd);
|
user.setUSnId(pwd);
|
user.setPasswordUpdateTime(new Date());
|
user.setCreateTime(new Date());
|
user.setLastLoginTime(new Date());
|
int flag = userMapper.insert(user);
|
if (flag > 0) {
|
//添加成功,分配到默认初始化权限组
|
Integer uId= userMapper.getUserInfoByPhoneNumber(user.getUMobilephone()).getUId().intValue();
|
UserPermitGroupData permitGroupData = new UserPermitGroupData();
|
permitGroupData.setPermitGroupId(user.getPermitGroupId());
|
permitGroupData.setUId(uId);
|
permitMapper.insert(permitGroupData);
|
return new Response<>().set(1, true);
|
} else {
|
return new Response<>().set(1, false, "添加失败");
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
return new Response<>().set(0);
|
}
|
}
|
|
private boolean checkUserPermit() {
|
//首先校验当前用户所在的权限组,是否存在用户编辑权限 usr_edit_permit
|
Long uId = ActionUtil.getUser().getUId();
|
List<String> itemList = permitGroupUserService.getItemList(uId);
|
if (!itemList.contains("usr_edit_permit")){
|
return false;
|
}
|
return true;
|
}
|
|
private boolean checkUserPermitWithQuery() {
|
//首先校验当前用户所在的权限组,是否存在用户查询权限 usr_query_permit
|
Long uId = ActionUtil.getUser().getUId();
|
List<String> itemList = permitGroupUserService.getItemList(uId);
|
if (!itemList.contains("usr_query_permit")){
|
return false;
|
}
|
return true;
|
}
|
|
public Response registerUser(UserInf user){
|
try {
|
UserInf userFound = userBridgeService.findPasswordByUserName(user.getUName());
|
if (userFound.getUId() != 0) {
|
return new Response<>().set(1, false, "用户名已存在");
|
}
|
UserInf userOfMobilephone = userBridgeService.findUserByMobilephone(user.getUMobilephone());
|
if (userOfMobilephone.getUId()!=0) {
|
return new Response<>().set(1, false, "手机号已存在");
|
}
|
//String password = URLDecoder.decode(user.getUpassword(), "utf-8");
|
String password = user.getUpassword();
|
|
String[] dataArr = RSAUtil.decryptFront(password, RSAUtil.fontSeparator);
|
String pwd = RSAUtil.encrypt(dataArr[0],RSAUtil.getPublicKey());
|
user.setUpassword(pwd);
|
user.setUSnId(pwd);
|
int flag = userMapper.insert(user);
|
if (flag > 0) {
|
//添加成功,分配到默认初始化权限组
|
Integer uId= userMapper.getUserInfoByPhoneNumber(user.getUMobilephone()).getUId().intValue();
|
UserPermitGroupData permitGroupData = new UserPermitGroupData();
|
permitGroupData.setPermitGroupId(100020);
|
permitGroupData.setUId(uId);
|
permitMapper.insert(permitGroupData);
|
//添加成功,分配到默认的包机组
|
BaoJiGroupUser baoJiGroupUser = new BaoJiGroupUser();
|
baoJiGroupUser.setBaoJiGroupId(100091);
|
baoJiGroupUser.setuId(uId);
|
baoJiGroupUserMapper.insert(baoJiGroupUser);
|
return new Response<>().set(1, true,"注册成功");
|
} else {
|
return new Response<>().set(1, false, "注册失败");
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
return new Response<>().set(0);
|
}
|
}
|
|
public UserInf getById(int id) {
|
return userMapper.selectById(id);
|
}
|
|
public List<UserInf> getAll() {
|
List<UserInf> users = userMapper.selectList((Wrapper<UserInf>) ActionUtil.objeNull);
|
return users;
|
}
|
|
public Response getAllWithPage(int pageNum,int pageSize) {
|
//验证是否存在usr_query_permit权限
|
if (!checkUserPermitWithQuery()) {
|
return new Response<Boolean>().set(1, false, "当前用户没有查询权限");
|
}
|
PageHelper.startPage(pageNum,pageSize);
|
List<UserInf> list = userMapper.getUserInfAndPermitInf();
|
for (UserInf uinf:list) {
|
uinf.setUSnId("*******");
|
uinf.setUpassword("*******");
|
}
|
PageInfo<UserInf> pageInfo = new PageInfo<>(list);
|
return new Response().set(1,pageInfo,"查询成功");
|
}
|
|
public Response update(UserInf user) {
|
//首先校验当前用户所在的权限组,是否存在用户编辑权限 usr_edit_permit
|
if (!checkUserPermit()) return new Response<>().set(1, false, "当前用户没有用户编辑权限");
|
//非系统管理员用户,禁止修改访问ip和访问时间
|
if(user.getUId()!=1 && user.getUName().equals("sys_admin")){
|
user.setVisitIp((String) ActionUtil.objeNull);
|
user.setVisitTime((String) ActionUtil.objeNull);
|
}
|
UserInf userFound = userBridgeService.findPasswordByUserName(user.getUName());
|
UserInf userOfMobilephone = userBridgeService.findUserByMobilephone(user.getUMobilephone());
|
if (userFound.getUId() != 0 && !userFound.getUId().equals(user.getUId())) {
|
return new Response().set(1,false,"用户名重复");
|
}
|
if( userOfMobilephone.getUId()!=0 && !userFound.getUId().equals(user.getUId())){
|
return new Response().set(1,false,"手机号重复");
|
}
|
user.setUpassword(null);
|
user.setUSnId(null);
|
if(userMapper.updateById(user)>0){
|
return new Response().set(1,true,"修改成功");
|
}else{
|
return new Response().set(1,false,"修改失败");
|
}
|
|
}
|
|
@Transactional
|
public boolean delete(int id) {
|
//首先校验当前用户所在的权限组,是否存在用户编辑权限 usr_edit_permit
|
if (!checkUserPermit()) return false;
|
UpdateWrapper wrapper = new UpdateWrapper();
|
wrapper.eq("uId", id);
|
//删除对应的包机组记录
|
baoJiGroupUserMapper.delete(wrapper);
|
//删除对应的权限组记录
|
permitMapper.delete(wrapper);
|
//删除用户
|
return userMapper.deleteById(id) > 0;
|
}
|
|
// 将所有登陆的用户的信息存到application中
|
public void setApplication(UserInf user) {
|
ServletContext application = ActionUtil.getApplication();
|
//查看全局中存储的users的Map的key-value集合
|
Map<String, UserClient> map = (Map) application.getAttribute("users");
|
if (map == ActionUtil.objeNull) {
|
map = new HashMap<String, UserClient>();
|
} else {
|
//如果集合中有值,则获取当前用户对应的用户信息,key为用户名username,Value为用户名,存储的时间
|
UserClient client = map.get(user.getUName());
|
if (client != ActionUtil.objeNull) { //已存在
|
map.remove(user.getUName());
|
}
|
}
|
Long login_time = new Date().getTime();
|
ActionUtil.getSession().setAttribute("login_time", login_time);
|
map.put(user.getUName(), new UserClient(ActionUtil.getRequest().getRemoteAddr(),user,login_time));
|
application.setAttribute("users", map);
|
}
|
|
public UserInf getUserByUKeyId(String uKeyId){
|
QueryWrapper queryWrapper = new QueryWrapper();
|
queryWrapper.eq("uKey_ID",uKeyId);
|
queryWrapper.last("limit 1");
|
UserInf userInf = userMapper.selectOne(queryWrapper);
|
return userInf;
|
}
|
|
public UserInf getUserByUserName(String userName){
|
QueryWrapper queryWrapper = new QueryWrapper();
|
queryWrapper.eq("Uname",userName);
|
queryWrapper.last("limit 1");
|
UserInf userInf = userMapper.selectOne(queryWrapper);
|
return userInf;
|
}
|
|
public boolean bindUkey(UserInf userInf){
|
UpdateWrapper updateWrapper = new UpdateWrapper();
|
updateWrapper.set("uKey_ID",userInf.getUkeyId());
|
updateWrapper.eq("uName",userInf.getUName());
|
int affectRows = userMapper.update((UserInf) ActionUtil.objeNull,updateWrapper);
|
return affectRows>0;
|
}
|
|
|
public Response updatePassword(UserInf userInf,String password){
|
String[] dataArr = RSAUtil.decryptFrontP(password, RSAUtil.fontSeparator);
|
password = dataArr[0];
|
String passwordMD5 = dataArr[1];
|
if(!ActionUtil.EncryptionMD5(password).equals(passwordMD5)){
|
throw new InvalidParameterException("参数校验失败");
|
}
|
String pwd = RSAUtil.encrypt(password,RSAUtil.getPublicKey());
|
userInf.setUpassword(pwd);
|
userInf.setUSnId(pwd);
|
if (userMapper.updateById(userInf)>0){
|
return new Response().set(1,"修改成功");
|
}else {
|
return new Response().set(0,"修改失败");
|
}
|
}
|
|
public Response updatePasswordByRSA(UserInf user,String newPwd){
|
String[] dataArr = RSAUtil.decryptFrontP(newPwd, RSAUtil.fontSeparator);
|
newPwd = dataArr[0];
|
String passwordMD5 = dataArr[1];
|
if(!ActionUtil.EncryptionMD5(newPwd).equals(passwordMD5)){
|
throw new InvalidParameterException("参数校验失败");
|
}
|
if(!ActionUtil.filterPwd(newPwd)){
|
return new Response().set(0,false,"新密码验证不通过(最少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符)");
|
}
|
String pwd = RSAUtil.encrypt(newPwd,RSAUtil.getPublicKey());
|
user.setUpassword(pwd);
|
user.setUSnId(pwd);
|
user.setPasswordUpdateTime(new Date());
|
if (userMapper.updateById(user)>0){
|
return new Response().set(1,true,"新密码修改成功");
|
}else {
|
return new Response().set(0,false,"新密码修改失败");
|
}
|
}
|
//密码失效修改密码
|
public Response updatePasswordByValidity(String uname, String oldPwd, String newPwd) throws UnsupportedEncodingException {
|
//验证旧密码是否正确
|
QueryWrapper<UserInf> queryWrapper = Wrappers.query();
|
queryWrapper.select("uid","upassword").eq("uName",uname).last(" limit 1");
|
UserInf user=userMapper.selectOne(queryWrapper);
|
if(user==null){
|
return new Response().set(0,false,"用户不存在");
|
}
|
String passwordDB =user.getUpassword();
|
oldPwd = RSAUtil.decryptFront(oldPwd, RSAUtil.fontSeparator)[0];
|
if(!RSAUtil.decrypt(passwordDB,RSAUtil.getPrivateKey()).equals(oldPwd)){
|
return new Response().set(0,false,"旧密码输入错误");
|
}
|
String[] dataArr = RSAUtil.decryptFrontP(newPwd, RSAUtil.fontSeparator);
|
newPwd = dataArr[0];
|
String passwordMD5 = dataArr[1];
|
if(!ActionUtil.filterPwd(newPwd)){
|
return new Response().set(0,false,"新密码验证不通过(最少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符)");
|
}
|
if(!ActionUtil.EncryptionMD5(newPwd).equals(passwordMD5)){
|
throw new InvalidParameterException("参数校验失败");
|
}
|
String pwd = RSAUtil.encrypt(newPwd,RSAUtil.getPublicKey());
|
user.setUpassword(pwd);
|
user.setUSnId(pwd);
|
user.setPasswordUpdateTime(new Date());
|
if (userMapper.updateById(user)>0){
|
return new Response().set(1,true,"新密码修改成功");
|
}else {
|
return new Response().set(0,false,"新密码修改失败");
|
}
|
}
|
|
|
public Response updatePassword2(UserInf userInf, String passwordOld, String passwordNew) {
|
//检查旧密码
|
QueryWrapper<UserInf> queryWrapper = Wrappers.query();
|
queryWrapper.select("upassword").eq("uName",userInf.getUName()).last(" limit 1");
|
String passwordDB = userMapper.selectOne(queryWrapper).getUpassword();
|
if(!RSAUtil.decrypt(passwordDB,RSAUtil.getPrivateKey()).equals(passwordOld)){
|
return new Response().set(1,false,"旧密码输入错误");
|
}
|
//更新新密码
|
UpdateWrapper<UserInf> updateWrapper = Wrappers.update();
|
updateWrapper.set("upassword",RSAUtil.encrypt(passwordNew,RSAUtil.getPublicKey())).set("password_update_time",new Date()).eq("uName",userInf.getUName());
|
userMapper.update((UserInf) ActionUtil.objeNull,updateWrapper);
|
return new Response().set(1,true,"密码修改成功");
|
}
|
|
/**锁定账号*/
|
public void lock(Long uId) {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("status", UserConstant.ACCOUNT_STATUS_LOCK_FAIL.getValue()).set("lock_time",new Date()).eq("uId",uId);
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
/**更新登录时间*/
|
public void updateLoginTime(Long uId) {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("last_login_time", new Date()).eq("uId",uId);
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
|
public void updateExpiredAccount() {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("status",UserConstant.ACCOUNT_STATUS_CANCEL.getValue()).eq("type",UserConstant.ACCOUNT_TYPE_TEMP.getValue()).gt("expiration_time",new Date());
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
public void unLock() {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("status", UserConstant.ACCOUNT_STATUS_ACTIVE.getValue()).set("lock_time",null)
|
.eq("status",UserConstant.ACCOUNT_STATUS_LOCK_FAIL.getValue())
|
.last(" and date_add(lock_time,interval 20 MINUTE)<now() and uId is not null");
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
public void updateAccountStatus(int status) {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("status", status)
|
.eq("status",UserConstant.ACCOUNT_STATUS_ACTIVE.getValue())
|
.last(" and date_add(last_login_time,interval 3 MONTH)<now() and uId >100");
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
public void unLock(int uId, int unLockType) {
|
UpdateWrapper<UserInf> wrapper = Wrappers.update();
|
wrapper.set("status",1).eq("uId",uId);
|
if(unLockType==1){
|
wrapper.set("lock_time",ActionUtil.objeNull);
|
}else{
|
wrapper.set("last_login_time",new Date());
|
}
|
userMapper.update((UserInf) ActionUtil.objeNull,wrapper);
|
}
|
|
public List<UserInf> searchCS_All2() {
|
return userMapper.searchCS_All2();
|
}
|
|
public List<UserInf> getUserInfoByStationId(String stationId){
|
List<UserInf> list = userMapper.getUserInfoByStationId(stationId);
|
return list;
|
}
|
|
public Response loginByUId(int uId) {
|
Response<Object> response = new Response<>();
|
response.setCode(1);
|
response.setData(false);
|
//查询对应的用户
|
QueryWrapper<UserInf> query = Wrappers.query();
|
query.select("uId","uName","uSnId","upassword","unote","UKey_ID","uRole","password_update_time","status","visit_time","visit_ip")
|
.eq("uId",uId).last(" limit 1");
|
UserInf userInf = userMapper.selectOne(query);
|
if(userInf == ActionUtil.objeNull){
|
response.setMsg("对应的用户不存在");
|
}else{
|
//判断用户状态
|
if(userInf.getStatus()!=1){
|
switch (userInf.getStatus()){
|
case 0: response.setMsg("当前账号的状态异常,无法登录. 异常信息为: "+UserConstant.ACCOUNT_STATUS_CANCEL.getLabel());break;
|
case 2: response.setMsg("当前账号的状态异常,无法登录. 异常信息为: "+UserConstant.ACCOUNT_STATUS_HIBERNATE.getLabel());break;
|
case 3: response.setMsg("当前账号的状态异常,无法登录. 异常信息为: "+UserConstant.ACCOUNT_STATUS_LOCK.getLabel());break;
|
case 4: response.setMsg("当前账号的状态异常,无法登录. 异常信息为: "+UserConstant.ACCOUNT_STATUS_LOCK_FAIL.getLabel());break;
|
default:response.setMsg("当前账号的状态异常,无法登录. 异常信息为: 无");
|
}
|
return response;
|
}
|
//判断是否为国网系统,校验密码是否3个月修改过一次
|
if(1 == YamlProperties.systemType){
|
|
//登录之前,首先校验允许时间和登录ip
|
boolean ipPass = true;
|
|
String firstTime = userInf.getVisitTime().split("~")[0];
|
String lastTime = userInf.getVisitTime().split("~")[1];
|
|
List<String> ipRules = new LinkedList<>();
|
String ipRuleStr = userInf.getVisitIp();
|
ipRules = Arrays.asList(ipRuleStr.split(","));
|
|
Calendar instance = Calendar.getInstance();
|
String hourOfDay = String.format("%1$02d",instance.get(Calendar.HOUR_OF_DAY));
|
int minute = instance.get(Calendar.MINUTE);
|
int second = instance.get(Calendar.SECOND);
|
String nowTime = hourOfDay+":"+minute+":"+second;
|
//登录时间校验
|
if(nowTime.compareTo(firstTime)>=0 && nowTime.compareTo(lastTime)<=0){
|
//登录ip校验
|
String clientIp = ActionUtil.getRequest().getRemoteAddr();
|
if(!ipRules.contains("*")){
|
for(String ipRule:ipRules){
|
ipPass = true;
|
//ip规则格式为 * 或者 xxx.xxx.x.x
|
String[] ipArr = clientIp.split("\\.");
|
String[] ipRuleArr = ipRule.split("\\.");
|
for (int i = 0; i < ipRuleArr.length; i++) {
|
if(!ipRuleArr[i].equals("*") && !ipRuleArr[i].equals(ipArr[i])){
|
ipPass = false;
|
break;
|
}
|
}
|
if(ipPass){
|
break;
|
}
|
}
|
}
|
if(!ipPass){
|
return response.set(1,false,"您的IP禁止访问,请知晓");
|
}
|
}else{
|
return response.set(1,false,"登录时间不在允许的时间范围内");
|
}
|
}
|
//校验通过,登录成功
|
{
|
response.setData(true);
|
//查询用户对应的权限组id并返回给前端
|
QueryWrapper<UserPermitGroupData> query2 = Wrappers.query();
|
query2.select("permit_group_id").eq("uId",uId).last(" limit 1");
|
UserPermitGroupData userPermitGroupData = permitMapper.selectOne(query2);
|
response.setData2(userPermitGroupData.getPermitGroupId());
|
//将登陆成功的用户存入session
|
HttpSession session = ActionUtil.getSession();
|
session.setAttribute("user",userInf);
|
session.setAttribute("ip",ActionUtil.getRequest().getRemoteAddr());
|
|
List<UserPermitGroup> permitGroupList = permitMapper.getPermitGroupListByUId(uId);
|
if(permitGroupList!=ActionUtil.objeNull && permitGroupList.size()>0){
|
session.setAttribute("permits", ActionUtil.tojson(permitGroupList));
|
}else{
|
response.setMsg("还未分配权限");
|
return response;
|
}
|
//将新登录的用户存入application
|
setApplication(userInf);
|
//特定的用户信息返回
|
UserInf userDto = new UserInf();
|
userDto.setUId(userInf.getUId());
|
userDto.setURole(userInf.getURole());
|
userDto.setUName(userInf.getUName());
|
response.setData3(userDto);
|
}
|
}
|
return response;
|
}
|
|
public void updatePasswordsTo3072(List<UserInf> userListWithNewPwd) {
|
userMapper.updatePasswordsTo3072(userListWithNewPwd);
|
}
|
//验证密码的时效性
|
public int checkPasswordValidity(UserInf uinf) {
|
int flag=1;
|
//获取系统设置的密码时效(57,15)
|
QueryWrapper wrapper=new QueryWrapper();
|
wrapper.eq("categoryId",15);
|
wrapper.eq("id",57);
|
wrapper.last("limit 1");
|
PageParam pageParam=pageParamMapper.selectOne(wrapper);
|
if(pageParam!=null){
|
int dayDifference=ActionUtil.daysBetween(uinf.getPasswordUpdateTime(),new Date());
|
if((pageParam.getStatus()>0)&&(dayDifference>pageParam.getStatus())){
|
flag= -1;
|
}
|
}
|
return flag;
|
}
|
}
|
