731 lines
28 KiB
Java
731 lines
28 KiB
Java
package com.peanut.modules.book.controller;
|
|
|
|
import java.math.BigDecimal;
|
|
import java.util.*;
|
|
import java.util.concurrent.TimeUnit;
|
|
import java.util.stream.Collectors;
|
|
import cn.hutool.core.util.ObjectUtil;
|
|
import cn.hutool.http.HttpUtil;
|
|
import com.alibaba.druid.util.StringUtils;
|
|
import com.alibaba.fastjson.JSON;
|
|
import com.alibaba.fastjson.JSONObject;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
|
import com.peanut.common.utils.MD5Utils;
|
|
import com.peanut.common.utils.MailUtil;
|
|
import com.peanut.modules.book.service.*;
|
|
import com.peanut.modules.book.to.PageIdDto;
|
|
import com.peanut.modules.common.entity.*;
|
|
import com.peanut.modules.common.service.UserContributionService;
|
|
import com.peanut.modules.common.service.UserInviteRegisterService;
|
|
import com.peanut.modules.common.service.UserVipService;
|
|
import com.peanut.modules.sys.service.SysUserTokenService;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.redis.core.StringRedisTemplate;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.web.bind.annotation.PathVariable;
|
|
import org.springframework.web.bind.annotation.RequestBody;
|
|
import org.springframework.web.bind.annotation.RequestMapping;
|
|
import org.springframework.web.bind.annotation.RequestParam;
|
|
import org.springframework.web.bind.annotation.RestController;
|
|
import com.peanut.common.utils.PageUtils;
|
|
import com.peanut.common.utils.R;
|
|
|
|
|
|
/**
|
|
*
|
|
*
|
|
* @author yl
|
|
* @email yl328572838@163.com
|
|
* @date 2022-08-10 14:20:12
|
|
*/
|
|
@Slf4j
|
|
@RestController
|
|
@RequestMapping("book/user")
|
|
public class MyUserController {
|
|
@Autowired
|
|
private MyUserService userService;
|
|
@Autowired
|
|
private StringRedisTemplate redisTemplate;
|
|
@Autowired
|
|
private SysUserTokenService sysUserTokenService;
|
|
@Autowired
|
|
private TransactionDetailsService transactionDetailsService;
|
|
@Autowired
|
|
private UserInviteRegisterService inviteRegisterService;
|
|
@Autowired
|
|
private UserVipService userVipService;
|
|
@Autowired
|
|
private UserContributionService userContributionService;
|
|
|
|
/**
|
|
* 列表
|
|
*/
|
|
@RequestMapping("/list")
|
|
// @RequiresPermissions("book:user:list")
|
|
public R list(@RequestParam Map<String, Object> params){
|
|
PageUtils page = userService.queryPage(params);
|
|
|
|
return R.ok().put("page", page);
|
|
}
|
|
|
|
/**
|
|
* 获取用户列表
|
|
* @param p
|
|
* @return
|
|
*/
|
|
@RequestMapping("/getUserList")
|
|
public R getUserList(@RequestBody PageIdDto p){
|
|
MPJLambdaWrapper<MyUserEntity> wrapper = new MPJLambdaWrapper<>();
|
|
wrapper.and(p.getKey()!="",k->k.like(MyUserEntity::getName,p.getKey()).or().like(MyUserEntity::getTel,p.getKey()).or().like(MyUserEntity::getEmail,p.getKey()));
|
|
if (!StringUtils.isEmpty(p.getVipType())){
|
|
if ("1".equals(p.getVipType())){
|
|
List<Map<String,Object>> list = userVipService.listMaps(new MPJLambdaWrapper<UserVip>().eq(UserVip::getState,0)
|
|
.in(UserVip::getType,4,5,6,9).groupBy(UserVip::getUserId)
|
|
.select("count(1) num,user_id userId ").having("num = 4"));
|
|
List<Integer> ids = list.stream().map(map -> (int)map.get("userId")).collect(Collectors.toList());
|
|
wrapper.in(MyUserEntity::getId,ids);
|
|
}else if ("2".equals(p.getVipType())){
|
|
List<Map<String,Object>> list = userVipService.listMaps(new MPJLambdaWrapper<UserVip>().eq(UserVip::getState,0)
|
|
.in(UserVip::getType,7,8).groupBy(UserVip::getUserId)
|
|
.select("count(1) num,user_id userId ").having("num = 2"));
|
|
List<Integer> ids = list.stream().map(map -> (int)map.get("userId")).collect(Collectors.toList());
|
|
wrapper.in(MyUserEntity::getId,ids);
|
|
}else {
|
|
wrapper.selectAll(MyUserEntity.class);
|
|
wrapper.leftJoin(UserVip.class,UserVip::getUserId,MyUserEntity::getId);
|
|
wrapper.eq(UserVip::getType,p.getVipType());
|
|
wrapper.eq(UserVip::getState,0);
|
|
}
|
|
}
|
|
wrapper.orderByDesc(MyUserEntity::getCreateTime);
|
|
Page<MyUserEntity> myUserEntityPage = userService.getBaseMapper().selectPage(new Page<MyUserEntity>(p.getPage(), p.getLimit()), wrapper);
|
|
for (MyUserEntity myUserEntity : myUserEntityPage.getRecords()) {
|
|
myUserEntity.setUserVips(userVipService.list(new LambdaQueryWrapper<UserVip>()
|
|
.eq(UserVip::getUserId,myUserEntity.getId()).eq(UserVip::getState,0)));
|
|
Map map = userContributionService.getMap(new MPJLambdaWrapper<UserContribution>()
|
|
.selectSum(UserContribution::getScore).eq(UserContribution::getUserId,myUserEntity.getId()));
|
|
myUserEntity.setContributionScore(0+"");
|
|
if (map!=null&&map.containsKey("score")){
|
|
myUserEntity.setContributionScore(map.get("score").toString());
|
|
}
|
|
}
|
|
return R.ok().put("user",myUserEntityPage);
|
|
}
|
|
|
|
/**
|
|
* 管理员添加用户
|
|
* @return
|
|
*/
|
|
@RequestMapping("/addUserForAdmin")
|
|
public R addUserForAdmin(){
|
|
return null;
|
|
}
|
|
|
|
|
|
/**
|
|
* 信息
|
|
*/
|
|
@RequestMapping("/info/{id}")
|
|
// @RequiresPermissions("book:user:info")
|
|
public R info(@PathVariable("id") String id){
|
|
MyUserEntity user = userService.getById(id);
|
|
// List<CouponHistoryEntity> list = couponHistoryService.getBaseMapper().selectList(new QueryWrapper<CouponHistoryEntity>().eq("member_id", id)
|
|
// .eq("use_status", 0));
|
|
// user.setConponsCount(list.size());
|
|
|
|
return R.ok().put("user", user);
|
|
}
|
|
|
|
/**
|
|
* 保存
|
|
*/
|
|
@RequestMapping("/save")
|
|
public R save(@RequestBody MyUserEntity user){
|
|
String password = user.getPassword();
|
|
String saltMD5 = MD5Utils.getSaltMD5(password);
|
|
user.setPassword(saltMD5);
|
|
userService.save(user);
|
|
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 修改用户信息
|
|
*/
|
|
@RequestMapping("/update")
|
|
public R update(@RequestBody MyUserEntity user){
|
|
boolean b = userService.checkUserTelOrEmail(user);
|
|
if(!b){
|
|
return R.error("电话或邮箱已存在");
|
|
}
|
|
userService.updateById(user);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 修改用户密码
|
|
* @param user
|
|
* @return
|
|
*/
|
|
@RequestMapping("/updateUserPassword")
|
|
public R updateUserPassword(@RequestBody MyUserEntity user){
|
|
String password = user.getPassword();
|
|
if(password.equals(null)){
|
|
return R.error("密码不能为空");
|
|
}
|
|
String saltMD5 = MD5Utils.getSaltMD5(password);
|
|
user.setPassword(saltMD5);
|
|
userService.updateById(user);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 审核用户是否有某书的权限
|
|
* @return
|
|
*/
|
|
@RequestMapping("/checkUserBook")
|
|
public R checkUserBook(@RequestBody Map<String,Object> param){
|
|
Integer userId = Integer.valueOf(param.get("userId").toString());
|
|
Integer bookId = Integer.valueOf(param.get("bookId").toString());
|
|
boolean b = userService.checkUserBook(userId, bookId);
|
|
if (b){
|
|
return R.ok();
|
|
}else {
|
|
return R.error("鉴权失败");
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* 删除
|
|
*/
|
|
@RequestMapping("/delete")
|
|
// @RequiresPermissions("book:user:delete")
|
|
public R delete(@RequestBody Integer[] ids){
|
|
userService.removeByIds(Arrays.asList(ids));
|
|
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 常规注册 发短信验证码
|
|
*/
|
|
@RequestMapping("/sms/sendcode")
|
|
public R registerSms(@RequestParam("phone") String phone,@RequestParam(required = false) String areaCode) throws Exception {
|
|
int areacode=0;
|
|
if(areaCode==null||areaCode.equals("")){
|
|
areacode=0;
|
|
}else{
|
|
areacode = Integer.valueOf(areaCode);
|
|
}
|
|
//验证一分钟内是否已经发过
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + phone);
|
|
if (!StringUtils.isEmpty(redisCode)) {
|
|
long l = Long.parseLong(redisCode.split("_")[1]);
|
|
if (System.currentTimeMillis() - l < 60000) {
|
|
//60s 内不能再发
|
|
return R.error(500,"短信验证码频率过高，请稍后再试！");
|
|
}
|
|
}
|
|
//生成随机六位数
|
|
Random random = new Random();
|
|
String i = random.nextInt(999999) + "";
|
|
StringBuffer sb = new StringBuffer();
|
|
for (int j = 0; j < 6 - i.length(); j++) {
|
|
sb.append("0");
|
|
}
|
|
i = sb.toString() + i;
|
|
String code = i + "_"+System.currentTimeMillis();
|
|
//redis 缓存验证码
|
|
redisTemplate.opsForValue().set("RegistCode"+phone,code,5, TimeUnit.MINUTES);
|
|
//发送
|
|
return userService.sendCodeForRegister(phone,code,areacode);
|
|
}
|
|
|
|
/**
|
|
* 常规注册 发送邮箱验证码
|
|
*/
|
|
@RequestMapping("/getMailCaptcha")
|
|
public R getMailCaptcha(String email) throws Exception {
|
|
//验证一分钟内是否已经发过
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + email);
|
|
if (!StringUtils.isEmpty(redisCode)) {
|
|
long l = Long.parseLong(redisCode.split("_")[1]);
|
|
if (System.currentTimeMillis() - l < 60000) {
|
|
//60s 内不能再发
|
|
return R.error(500,"验证码频率过高，请稍后再试！");
|
|
}
|
|
}
|
|
//生成随机六位数
|
|
Random random = new Random();
|
|
String code = random.nextInt(999999) + "";
|
|
StringBuffer sb = new StringBuffer();
|
|
for (int j = 0; j < 6 - code.length(); j++) {
|
|
sb.append("0");
|
|
}
|
|
code = sb.toString() + code;
|
|
String timeCode = code + "_"+System.currentTimeMillis();
|
|
//redis 缓存验证码
|
|
redisTemplate.opsForValue().set("RegistCode"+email,timeCode,5, TimeUnit.MINUTES);
|
|
//发送
|
|
return MailUtil.sendMail("疯子读书邮箱验证码",code,email);
|
|
}
|
|
|
|
/**
|
|
* 绑定用户电话号
|
|
* @return
|
|
*/
|
|
@RequestMapping("/updateUserTel")
|
|
public R updateUserTel(@RequestBody Map<String,Object> map){
|
|
String phone = map.get("phone").toString();
|
|
String code = map.get("code").toString();
|
|
Integer id = Integer.valueOf(map.get("id").toString());
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode"+phone);
|
|
if(StringUtils.isEmpty(redisCode)){
|
|
return R.error("验证码已过期，请重试");
|
|
}
|
|
String lcode = redisCode.split("_")[0];
|
|
if (!lcode.equals(code)) {
|
|
return R.error("短信验证码不符！");
|
|
}
|
|
MyUserEntity userInfo = userService.getById(id);
|
|
userInfo.setTel(phone);
|
|
userService.updateById(userInfo);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 绑定用户邮件
|
|
* @return
|
|
*/
|
|
@RequestMapping("/updateUserEmail")
|
|
public R updateUserEmail(@RequestBody Map<String,Object> map){
|
|
String email = map.get("email").toString();
|
|
String code = map.get("code").toString();
|
|
Integer id = Integer.valueOf(map.get("id").toString());
|
|
//查询是否存在当前邮箱
|
|
LambdaQueryWrapper<MyUserEntity> wrapper = new LambdaQueryWrapper();
|
|
wrapper.eq(MyUserEntity::getEmail,email);
|
|
MyUserEntity userEntity = userService.getOne(wrapper);
|
|
if (userEntity == null) {
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode"+email);
|
|
if(StringUtils.isEmpty(redisCode)){
|
|
return R.error("验证码已过期，请重试");
|
|
}
|
|
String lcode = redisCode.split("_")[0];
|
|
if (!lcode.equals(code)) {
|
|
return R.error("短信验证码不符！");
|
|
}
|
|
MyUserEntity userInfo = userService.getById(id);
|
|
userInfo.setEmail(email);
|
|
userService.updateById(userInfo);
|
|
return R.ok();
|
|
}else {
|
|
return R.error("邮箱已被绑定！");
|
|
}
|
|
}
|
|
|
|
@RequestMapping("/register")
|
|
public R register(@RequestParam("tel") String tel,
|
|
@RequestParam("code") String code,
|
|
@RequestParam("password") String password){
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + tel);
|
|
|
|
|
|
if (StringUtils.isEmpty(redisCode)){
|
|
return R.error(500,"短信验证码已过期，请重试");
|
|
}
|
|
|
|
String lcode = redisCode.split("_")[0];
|
|
|
|
if (!lcode.equals(code)) {
|
|
return R.error(500,"短信验证码不符！");
|
|
}
|
|
|
|
MyUserEntity user = userService.getBaseMapper().selectOne(new QueryWrapper<MyUserEntity>().eq("tel", tel));
|
|
if(!ObjectUtil.isEmpty(user)){
|
|
return R.error(500,"该手机号已经注册！");
|
|
}
|
|
String saltMD5 = MD5Utils.getSaltMD5(password);
|
|
MyUserEntity myUserEntity = new MyUserEntity();
|
|
myUserEntity.setTel(tel);
|
|
myUserEntity.setPassword(saltMD5);
|
|
userService.save(myUserEntity);
|
|
R r = sysUserTokenService.createToken(myUserEntity.getId());
|
|
return R.ok("注册成功").put("userInfo",myUserEntity).put("token",r);
|
|
|
|
}
|
|
/**
|
|
* 常规注册 / 验证码 登录
|
|
*/
|
|
@RequestMapping("/registerOrLogin")
|
|
@Transactional
|
|
public R registerOrLogin(String tel, String code,String inviteCode) {
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + tel);
|
|
if (StringUtils.isEmpty(redisCode)){
|
|
return R.error(500,"验证码已过期，请重试");
|
|
}
|
|
String lcode = redisCode.split("_")[0];
|
|
if (!lcode.equals(code)) {
|
|
return R.error(500,"验证码不符！");
|
|
}
|
|
//校验邀请码
|
|
MyUserEntity inviteUser = null;
|
|
if (!StringUtils.isEmpty(inviteCode)) {
|
|
inviteUser = userService.getOne(new LambdaQueryWrapper<MyUserEntity>()
|
|
.eq(MyUserEntity::getInviteCode, inviteCode));
|
|
if (inviteUser == null) {
|
|
return R.error("邀请码有误");
|
|
}
|
|
}
|
|
//查询是否存在当前用户手机号
|
|
LambdaQueryWrapper<MyUserEntity> wrapper = new LambdaQueryWrapper();
|
|
if (tel.contains("@")){
|
|
wrapper.eq(MyUserEntity::getEmail,tel);
|
|
}else {
|
|
wrapper.eq(MyUserEntity::getTel,tel);
|
|
}
|
|
wrapper.orderByDesc(MyUserEntity::getLastLoginTime);
|
|
//防止多账号报错
|
|
List<MyUserEntity> userList = userService.getBaseMapper().selectList(wrapper);
|
|
if (userList == null || userList.size() == 0) {
|
|
// 用户不存在则创建用户 注册成功
|
|
MyUserEntity myUserEntity = new MyUserEntity();
|
|
if (tel.contains("@")){
|
|
myUserEntity.setEmail(tel);
|
|
}else {
|
|
myUserEntity.setTel(tel);
|
|
}
|
|
myUserEntity.setInviteCode(inviteRegisterService.generateInviteCode());
|
|
userService.save(myUserEntity);
|
|
//添加邀请记录
|
|
if (!StringUtils.isEmpty(inviteCode)){
|
|
myUserEntity.setInviteCode(inviteCode);
|
|
userService.updateById(myUserEntity);
|
|
UserInviteRegister inviteRegister = new UserInviteRegister();
|
|
inviteRegister.setUserId(inviteUser.getId());
|
|
inviteRegister.setInvitedUserId(myUserEntity.getId());
|
|
inviteRegisterService.save(inviteRegister);
|
|
inviteRegisterService.checkInviteRegisterCount(inviteUser.getId());
|
|
}
|
|
R r = sysUserTokenService.createToken(myUserEntity.getId());
|
|
return R.ok("注册成功").put("userInfo",myUserEntity).put("token",r);
|
|
}else {
|
|
R r = sysUserTokenService.createToken(userList.get(0).getId());
|
|
return R.ok("登录成功！").put("userInfo",userList.get(0)).put("token",r);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 常规 密码登录
|
|
*/
|
|
@RequestMapping("/login")
|
|
public R login(@RequestParam("phone") String phone,
|
|
@RequestParam("password") String password) {
|
|
|
|
LambdaQueryWrapper<MyUserEntity> wrapper = new LambdaQueryWrapper();
|
|
if (phone.contains("@")) {
|
|
wrapper.eq(MyUserEntity::getEmail,phone);
|
|
}else {
|
|
wrapper.eq(MyUserEntity::getTel,phone);
|
|
}
|
|
//防止多账号报错
|
|
List<MyUserEntity> userList = userService.getBaseMapper().selectList(wrapper);
|
|
if (userList == null || userList.size() == 0) {
|
|
return R.error(500,"用户不存在！");
|
|
}else {
|
|
int flag = 0;
|
|
for (MyUserEntity user : userList) {
|
|
if (user.getPassword() == null|| user.getPassword().equals("")) {
|
|
flag++;
|
|
continue;
|
|
}
|
|
if (MD5Utils.getSaltverifyMD5(password,user.getPassword())){
|
|
R r = sysUserTokenService.createToken(user.getId());
|
|
return R.ok("登陆成功！").put("userInfo",user).put("token",r);
|
|
}
|
|
}
|
|
if (flag>0){
|
|
return R.error(500,"当前未设置密码，请使用验证码登录！");
|
|
}
|
|
return R.error(500,"密码不正确，请重试！");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 常规 设置密码
|
|
*/
|
|
@RequestMapping("/setPassword")
|
|
public R setPassword(@RequestParam("phone") String phone,
|
|
@RequestParam("password") String password,
|
|
@RequestParam("code") String code) {
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + phone);
|
|
if (StringUtils.isEmpty(redisCode)){
|
|
return R.error(500,"验证码已过期，请重试");
|
|
}
|
|
String lcode = redisCode.split("_")[0];
|
|
if (!lcode.equals(code)) {
|
|
return R.error(500,"验证码不符！");
|
|
}
|
|
//查询是否存在当前用户手机号
|
|
LambdaQueryWrapper<MyUserEntity> wrapper = new LambdaQueryWrapper<>();
|
|
if (phone.contains("@")){
|
|
wrapper.eq(MyUserEntity::getEmail, phone);
|
|
}else {
|
|
wrapper.eq(MyUserEntity::getTel, phone);
|
|
}
|
|
MyUserEntity userEntity = userService.getBaseMapper().selectOne(wrapper);
|
|
if (userEntity == null) {
|
|
return R.error(500,"当前用户不存在！");
|
|
}
|
|
String saltMD5 = MD5Utils.getSaltMD5(password);
|
|
userEntity.setPassword(saltMD5);
|
|
userService.updateById(userEntity);
|
|
return R.ok("成功");
|
|
}
|
|
|
|
|
|
/**
|
|
* 获取 一路健康用户信息
|
|
*/
|
|
@RequestMapping("/getEverhealthInfo")
|
|
public R getEverhealthInfo(@RequestParam("phone") String phone,
|
|
@RequestParam("password") String password,
|
|
@RequestParam(value = "hsuserId", required = false) Integer hsuserId) {
|
|
|
|
String s = HttpUtil.get("http://101.201.146.165:8088/App-EH/app/phone.do?login&loginName="+ phone +"&loginPwd="+ password +"");
|
|
//将结果转成json 取值
|
|
JSONObject jsonObject = JSON.parseObject(s);
|
|
|
|
if (jsonObject.getString("msg").equals("登录名或密码错误！")) {
|
|
|
|
return R.error(404,jsonObject.getString("msg"));
|
|
}
|
|
|
|
|
|
String yljkOid = jsonObject.getJSONObject("obj").getString("customerOid");
|
|
String cellPhone = jsonObject.getJSONObject("obj").getString("cellPhone");
|
|
String customerIcons = jsonObject.getJSONObject("obj").getString("customerIcons");
|
|
String nameCN = jsonObject.getJSONObject("obj").getString("nameCN");
|
|
// String password = jsonObject.getJSONObject("obj").getString("pass");
|
|
|
|
|
|
|
|
//查询 当前 花生账号 和 当前绑定的 一路健康账号是否有绑定 关系
|
|
|
|
MyUserEntity user = userService.getBaseMapper().selectOne(new QueryWrapper<MyUserEntity>().eq("yljk_oid", yljkOid));
|
|
|
|
if (user != null ) {
|
|
|
|
// 判断 hsuserId 是否为空 查询 传入的 花生id 和 查询的花生 id 是否一致
|
|
if (hsuserId != null && user.getId() == hsuserId){
|
|
|
|
MyUserEntity myUserEntity = userService.getBaseMapper().selectById(hsuserId);
|
|
//绑定
|
|
myUserEntity.setYljkOid(yljkOid);
|
|
userService.updateById(myUserEntity);
|
|
|
|
return R.ok("绑定成功！");
|
|
|
|
}
|
|
|
|
//如果系统存在该用户 并且绑定关系 成立 登录成功 ，返回用户信息
|
|
R r = sysUserTokenService.createToken(user.getId());
|
|
|
|
return R.ok("登陆成功").put("userInfo",user).put("token",r);
|
|
}
|
|
|
|
|
|
|
|
//不存在 返回 手机号 oid 姓名 头像
|
|
|
|
HashMap<Object, Object> map = new HashMap<>();
|
|
map.put("cellPhone",cellPhone);
|
|
map.put("customerIcons",customerIcons);
|
|
map.put("yljkOid",yljkOid);
|
|
map.put("nameCN",nameCN);
|
|
|
|
return R.ok("绑定信息").put("everhealthInfo",map);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* 一路健康账号注册花生
|
|
*/
|
|
@RequestMapping("/registerHs")
|
|
public R registerHs(@RequestParam("phone") String phone,
|
|
@RequestParam("code") String code,
|
|
@RequestParam("yljkOid") String yljkOid,
|
|
@RequestParam("userName") String userName,
|
|
@RequestParam("customerIcons") String customerIcons) {
|
|
|
|
String redisCode = redisTemplate.opsForValue().get("RegistCode" + phone);
|
|
|
|
|
|
if (StringUtils.isEmpty(redisCode)){
|
|
return R.error(500,"短信验证码已过期，请重试");
|
|
}
|
|
|
|
String lcode = redisCode.split("_")[0];
|
|
|
|
if (!lcode.equals(code)) {
|
|
return R.error(500,"短信验证码不符！");
|
|
}
|
|
|
|
|
|
//查询是否存在当前用户手机号
|
|
MyUserEntity userEntity = userService.getBaseMapper().selectOne(new QueryWrapper<MyUserEntity>().eq("tel", phone));
|
|
if (userEntity == null) {
|
|
MyUserEntity myUserEntity = new MyUserEntity();
|
|
myUserEntity.setTel(phone);
|
|
myUserEntity.setYljkOid(yljkOid);
|
|
myUserEntity.setName(userName);
|
|
myUserEntity.setAvatar(customerIcons);
|
|
userService.save(myUserEntity);
|
|
R r = sysUserTokenService.createToken(myUserEntity.getId());
|
|
return R.ok().put("userInfo",myUserEntity).put("token",r);
|
|
}
|
|
//判断当前手机号用户是否绑定过一路健康账号
|
|
if (userEntity.getYljkOid() != null){
|
|
return R.error(500,"当前手机号已绑定一路健康账号！");
|
|
}
|
|
//直接绑定 返回登录信息
|
|
userEntity.setTel(phone);
|
|
userEntity.setYljkOid(yljkOid);
|
|
userEntity.setName(userName);
|
|
userEntity.setAvatar(customerIcons);
|
|
userService.updateById(userEntity);
|
|
R r = sysUserTokenService.createToken(userEntity.getId());
|
|
// todo 为什么验证成功以后不能实现页面跳转登录 R返回更新生成的token和电话
|
|
return R.ok().put("userInfo",userEntity).put("token",r);
|
|
|
|
}
|
|
|
|
@RequestMapping("/test")
|
|
public R test() {
|
|
// userService.openMember("15022449475",1);
|
|
// userService.rechargeHSPoint("15022449475",100);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 花生币充扣
|
|
*/
|
|
@Transactional
|
|
@RequestMapping("/pointChange")
|
|
public R pointChange(@RequestParam Map<String, String> params){
|
|
String pointType = params.get("pointType");
|
|
BigDecimal pointAmount = new BigDecimal(params.get("pointAmount"));
|
|
if (pointAmount.compareTo(BigDecimal.ZERO)<=0){
|
|
return R.error("变动金额不能为0或负数");
|
|
}
|
|
String id = params.get("id");
|
|
MyUserEntity byId = userService.getById(id);
|
|
BigDecimal i = BigDecimal.ZERO;
|
|
if (pointType.equals("0")) {
|
|
i = byId.getPeanutCoin().add(pointAmount);
|
|
byId.setPeanutCoin(i);
|
|
}else {
|
|
i = byId.getPeanutCoin().subtract(pointAmount);
|
|
if (i.compareTo(BigDecimal.ZERO)>=0) {
|
|
byId.setPeanutCoin(i);
|
|
}else {
|
|
return R.error("余额不足！扣除失败！");
|
|
}
|
|
|
|
}
|
|
TransactionDetailsEntity transactionDetailsEntity = new TransactionDetailsEntity();
|
|
transactionDetailsEntity.setUserId(Integer.valueOf(id));
|
|
transactionDetailsEntity.setOrderType("后台充扣操作");
|
|
transactionDetailsEntity.setTel(byId.getTel());
|
|
transactionDetailsEntity.setUserName(byId.getNickname());
|
|
transactionDetailsEntity.setNote(params.get("note"));
|
|
if (pointType.equals("0")) {
|
|
transactionDetailsEntity.setChangeAmount(pointAmount);
|
|
transactionDetailsEntity.setRemark("充值");
|
|
transactionDetailsEntity.setPayMethod(params.get("payMethod"));
|
|
transactionDetailsEntity.setPayNo(params.get("payNo"));
|
|
}else {
|
|
transactionDetailsEntity.setChangeAmount(pointAmount.negate());
|
|
transactionDetailsEntity.setRemark("扣费");
|
|
}
|
|
transactionDetailsEntity.setUserBalance(i);
|
|
transactionDetailsService.save(transactionDetailsEntity);
|
|
userService.updateById(byId);
|
|
return R.ok();
|
|
}
|
|
|
|
|
|
/**
|
|
* 使用虚拟币开通vip
|
|
* @return
|
|
*/
|
|
// @RequestMapping("/openVipByVirtualCoin")
|
|
// public R openVipByVirtualCoin(@RequestParam Map<String,Object> params){
|
|
//
|
|
// Integer configId = Integer.valueOf(params.get("configId").toString());
|
|
// String orderSn = params.get("orderSn").toString();
|
|
// Integer userId = Integer.valueOf(params.get("userId").toString());
|
|
// // 根据userId查找用户信息
|
|
// MyUserEntity user = this.userService.getById(userId);
|
|
// BookBuyConfigEntity bookBuyConfigEntity = bookBuyConfigService.getById(configId);
|
|
// String month = bookBuyConfigEntity.getMonth();
|
|
// BigDecimal amount = new BigDecimal(bookBuyConfigEntity.getRealMoney());
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// if(user.getPeanutCoin().compareTo(amount) >= 0){
|
|
// user.setPeanutCoin(user.getPeanutCoin().subtract(amount));
|
|
//
|
|
// this.userService.updateById(user);
|
|
// // 添加消费信息
|
|
// TransactionDetailsEntity transactionDetailsEntity = new TransactionDetailsEntity();
|
|
// transactionDetailsEntity.setRemark("购买"+bookBuyConfigEntity.getType()+"，金额"+bookBuyConfigEntity.getMoney());
|
|
// transactionDetailsEntity.setUserId(user.getId());
|
|
// transactionDetailsEntity.setUserName(user.getNickname());
|
|
// transactionDetailsEntity.setChangeAmount(amount.negate());
|
|
// transactionDetailsEntity.setUserBalance(user.getPeanutCoin());
|
|
// transactionDetailsEntity.setTel(user.getTel());
|
|
// transactionDetailsEntity.setOrderType("购买会员！");
|
|
// transactionDetailsService.save(transactionDetailsEntity);
|
|
// userService.openMember(userId,Integer.valueOf(month));
|
|
// // 插入 开通记录
|
|
// buyOrderService.updateOrderStatus(userId,orderSn,"2");
|
|
// }else{
|
|
// return R.error(500,"余额不足，请检查后操作！");
|
|
// }
|
|
//
|
|
// return R.ok();
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// /**
|
|
// * @Description: app微信登陆
|
|
// * @Author: z.hw
|
|
// */
|
|
// @RequestMapping("/appUserAuthorLogin")
|
|
//// @ApiOperation(value = "getUserInfoByAppCode", notes = "不分页", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
|
|
//// @ApiResponses(value = {
|
|
//// @ApiResponse(code = 404, message = "Not Found"),
|
|
//// @ApiResponse(code = 400, message = "No Name Provided"),
|
|
//// })
|
|
// public R getUserInfoByApp(@Validated @RequestBody UserAppAuthorEntity userAppAuthorEntity) {
|
|
//
|
|
// return userService.getUserInfoByApp(userAppAuthorEntity);
|
|
// }
|
|
//
|
|
|
|
}
|