JAVA版B2B2C商城源码 多商家入驻商城系统 直播带货 新零售商城 o2o商城 电子商务 拼团商城 分销商城 直播商城 短视频商城 springboot商城 spring boot商城

 @源码地址来源： https://minglisoft.cn/honghu/business.html

会员控制类：

/**
 * Copyright © 2012-2017 HongHu All rights reserved.
 */
package com.honghu.cloud.controller;

import java.io.IOException;
import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.google.common.collect.Maps;
import com.honghu.cloud.bean.Album;
import com.honghu.cloud.bean.CustomerService;
import com.honghu.cloud.bean.MemberFans;
import com.honghu.cloud.bean.Menu;
import com.honghu.cloud.bean.PredepositLog;
import com.honghu.cloud.bean.PullUserOrder;
import com.honghu.cloud.bean.Role;
import com.honghu.cloud.bean.User;
import com.honghu.cloud.bean.UserCard;
import com.honghu.cloud.bean.VerifyidCard;
import com.honghu.cloud.code.MemberResponseCode;
import com.honghu.cloud.code.ResponseCode;
import com.honghu.cloud.code.ResponseVO;
import com.honghu.cloud.constant.Globals;
import com.honghu.cloud.dto.AccessoryDto;
import com.honghu.cloud.dto.AreaDto;
import com.honghu.cloud.dto.IntegralLogDto;
import com.honghu.cloud.dto.ModularClassDto;
import com.honghu.cloud.dto.StoreDto;
import com.honghu.cloud.dto.SysConfigDto;
import com.honghu.cloud.dto.TemplateDto;
import com.honghu.cloud.dto.UserDto;
import com.honghu.cloud.dto.VerifyCodeDto;
import com.honghu.cloud.feign.AccessoryFeignClient;
import com.honghu.cloud.feign.AreaFeignClient;
import com.honghu.cloud.feign.CouponInfoFeignClient;
import com.honghu.cloud.feign.IntegralLogFeignClient;
import com.honghu.cloud.feign.IntegralToolsFeignClient;
import com.honghu.cloud.feign.ModularClassFeignClient;
import com.honghu.cloud.feign.MsgToolsFeignClient;
import com.honghu.cloud.feign.OrderFormFeignClient;
import com.honghu.cloud.feign.QrCodeFeignClient;
import com.honghu.cloud.feign.StoreFeignClient;
import com.honghu.cloud.feign.SysConfigFeignClient;
import com.honghu.cloud.feign.TemplateFeignClient;
import com.honghu.cloud.feign.TencentIMFeignClient;
import com.honghu.cloud.feign.VerifyCodeFeignClient;
import com.honghu.cloud.redis.RedisUtil;
import com.honghu.cloud.service.IAlbumService;
import com.honghu.cloud.service.ICustomerService;
import com.honghu.cloud.service.IFavoriteService;
import com.honghu.cloud.service.IFootPointService;
import com.honghu.cloud.service.IMemberFansService;
import com.honghu.cloud.service.IPredepositLogService;
import com.honghu.cloud.service.IPullUserOrderService;
import com.honghu.cloud.service.IRoleService;
import com.honghu.cloud.service.IUserCardService;
import com.honghu.cloud.service.IUserService;
import com.honghu.cloud.service.IVerifyidCardService;
import com.honghu.cloud.tools.SecurityUserHolder;
import com.honghu.cloud.utils.CommUtil;
import com.honghu.cloud.utils.JWT;
import com.honghu.cloud.utils.beans.BeanUtils;
import com.honghu.cloud.utils.tools.Md5Encrypt;

import net.sf.json.JSONObject;


/**
 * 用户Controller
 * @author Administrator
 * @param 
 *
 */
@SuppressWarnings({"rawtypes","unchecked"})
@RestController
@RequestMapping(value = "/user")
/*/*@CrossOrigin(origins = "*", maxAge = 3600, methods = { RequestMethod.GET, RequestMethod.POST, RequestMethod.DELETE,
		RequestMethod.PUT })*/
public class UserController  {
	
	private static final Logger logger = LoggerFactory.getLogger(UserController.class);

	@Autowired
	private IUserService userService;
	@Autowired
	private IFootPointService footPointService;
	@Autowired
	private CouponInfoFeignClient couponInfoFeignClient;
	@Autowired
	private OrderFormFeignClient orderFormFeignClient;
	@Autowired
	private SysConfigFeignClient sysConfigFeignClient;
	@Autowired
	private AccessoryFeignClient accessoryFeignClient;
	@Autowired
	private VerifyCodeFeignClient verifyCodeFeignClient;
	@Autowired
	private MsgToolsFeignClient msgToolsFeignClient;
	@Autowired
	private IPullUserOrderService pullUserOrderService;
	@Autowired
	private QrCodeFeignClient qrCodeFeignClient;
	@Autowired
	private IRoleService roleService;
	@Autowired
	private AreaFeignClient areaFeignClient;
	@Autowired
	private IntegralLogFeignClient integralLogFeignClient;
	@Autowired
	private TemplateFeignClient templateFeignClient;
	@Autowired
	private ModularClassFeignClient modularClassFeignClient;
	@Autowired
	private ICustomerService customerService;
	@Autowired
	private IAlbumService albumService;
	@Autowired
	private IFavoriteService favoriteService;
	@Autowired
	private RedisUtil redisUtil;
	@Autowired
	private IVerifyidCardService verifyidCardService;
	@Autowired
	private StoreFeignClient storeFeignClient;
	@Autowired
	private TencentIMFeignClient tencentIMFeignClient;
	@Autowired
	private IUserCardService userCardService;
	@Autowired
	private IPredepositLogService predepositLogService;
	@Autowired
	private IMemberFansService memberFansService;
	@Autowired
	private IntegralToolsFeignClient integralToolsFeignClient;
	
	
	@RequestMapping(value = "/apiForFeign/selectByIds", method = RequestMethod.POST)
	public List selectByIds(@RequestBody Map params) {
		return userService.selectByIds(params);
	}
	
	@RequestMapping(value = "/apiForFeign/getMsgSubUsers", method = RequestMethod.GET)
	public List getMsgSubUsers(@RequestParam("parent_id") Long parent_id){
		return userService.getMsgSubUsers(parent_id);
	}

	@RequestMapping(value = "/apiForFeign/auditNoteUser", method = RequestMethod.GET)
	public List auditNoteUser(){
		return userService.auditNoteUser();
	}
	@RequestMapping(value = "/apiForFeign/selectCount", method = RequestMethod.GET)
	public int selectCount(@RequestParam("params")Map params){
		return userService.selectCount(params);
	}
	
	@RequestMapping(value = "/apiForFeign/whetherFans", method = RequestMethod.GET)
	public boolean whetherFans(@RequestParam("mid") Long mid, @RequestParam("fansid") Long fansid) {
		MemberFans memberFans = memberFansService.whetherFans(mid, fansid);
		if (memberFans != null)
			return true;
		return false;
	}
	
	/**
	 * 根据用户id查询用户
	 * @param congelationDto
	 * @return
	 */
	@RequestMapping(value = "/apiForFeign/selectByPrimaryKey", method = RequestMethod.GET)
	public User selectByPrimaryKey(@RequestParam("id") Long id) {
		User user = userService.selectByPrimaryKey(id);
		if(user != null && user.getPhoto_id() != null){
			user.setPhoto(accessoryFeignClient.selectByPrimaryKey(user.getPhoto_id()));
		}
		return user;
	}
	@RequestMapping(value = "/apiForFeign/selectUserCardByUserId", method = RequestMethod.GET)
	public UserCard selectUserCardByUserId(@RequestParam("id") Long id) {
		return userCardService.selectByUserId(id);
	}
	

	@RequestMapping(value = "/apiForFeign/queryPageList", method = RequestMethod.GET)
	public List queryPageList(@RequestParam("params")Map params) {
		return userService.queryPageList(params, null, null);
	}
	
	
	@RequestMapping(value = "/apiForFeign/verityUserNamePassword", method = RequestMethod.POST)
	public List verityUserNamePassword(@RequestBody Map params) {
		return userService.verityUserNamePassword(params);
	}
	@RequestMapping(value = "/apiForFeign/selectPullByOrderId", method = RequestMethod.GET)
	public PullUserOrder selectPullByOrderId(@RequestParam("id") Long id) {
		PullUserOrder obj = pullUserOrderService.selectPullByOrderId(id);
		return obj;
	}
	
	
	
	@RequestMapping(value = "/apiForFeign/savePullUserOrder", method = RequestMethod.POST)
	public void savePullUserOrder(@RequestBody PullUserOrder obj) {
		pullUserOrderService.saveEntity(obj);
	}
	/**
	 * 根据订单id查询拉新用户表 ,进行删除
	 * @param id
	 */
	@RequestMapping(value = "/apiForFeign/delPullByOrderId", method = RequestMethod.GET)
	public void delPullByOrderId(@RequestParam("id") Long id) {
		pullUserOrderService.deleteByOrderId(id);
		
	}
	
	
	
	@RequestMapping(value = "/apiForFeign/queryByProperty", method = RequestMethod.POST)
	public User queryByProperty(@RequestParam("params")Map params) {
		return userService.queryByProperty(params);
	}
	
	
	@RequestMapping(value = "/apiForFeign/updateById", method = RequestMethod.POST)
	public void updateById(@RequestBody User obj) {
		userService.updateById(obj);
	}
	
	
	@RequestMapping(value = "/apiForFeign/update", method = RequestMethod.POST)
	public void update(@RequestBody User obj) {
		userService.update(obj);
	}
	
	@RequestMapping(value = "/apiForFeign/saveEntity", method = RequestMethod.POST)
	public User saveEntity(@RequestBody User obj) {
		return userService.saveEntity(obj);
	}
	@RequestMapping(value = "/apiForFeign/saveUserCard", method = RequestMethod.POST)
	public void saveUserCard(@RequestBody UserCard obj) {
		 userCardService.saveEntity(obj);
	}
	
	/**
	 * 根据unionid查询用户
	 * @param unionid
	 * @return
	 */
	@RequestMapping(value = "/apiForFeign/selectByUnionid", method = RequestMethod.POST)
	public User selectByUnionid(@RequestParam("unionid") String unionid){
		return userService.selectByUnionid(unionid);
	}
	
	@RequestMapping(value = "/apiForFeign/selectByWxOpenId", method = RequestMethod.POST)
	public User selectByWxOpenId(@RequestParam("openid") String openid){
		return userService.selectByWxOpenId(openid);
	}
	
	@RequestMapping(value = "/apiForFeign/getUserByStoreId", method = RequestMethod.GET)
	public User getUserByStoreId(@RequestParam("id") Long id) {
		return userService.getUserByStoreId(id);
	}
	
	
	@RequestMapping(value = "/apiForFeign/deleteUserMenu", method = RequestMethod.GET)
	public void deleteUserMenu(@RequestParam("id") Long id) {
		userService.deleteUserMenu(id);
	}
	@RequestMapping(value = "/apiForFeign/updateLiveById", method = RequestMethod.GET)
	public void updateLiveById(@RequestParam("id") Long id) {
		userService.updateLiveById(id);
	}
	@RequestMapping(value = "/apiForFeign/saveUserMenu", method = RequestMethod.POST)
	public void saveUserMenu(@RequestParam("id") Long id,@RequestBody List ms) {
		 userService.saveUserMenu(id,ms);
	}
	
	
	
	/**
	 * 客服列表
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception 
	 */
	@RequestMapping(value="/buyer/customerServiceList", method = RequestMethod.POST)
	public Map customerServiceList(HttpServletRequest request,HttpServletResponse response)  {
		Map params = Maps.newHashMap();
		List list = customerService.queryPages(params);
		HashMap result = new HashMap<>();
		result.put("list", list);
		System.out.println(result);
		return ResponseCode.buildSuccessMap(result);
	}
	
	
	/**
	 * 用户中心完善资料
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value="/buyer/account")
	public Map account(HttpServletRequest request,
			HttpServletResponse response) {
		Map result = new HashMap();
		
		long user_id = SecurityUserHolder.getCurrentUser(request).getId().longValue();
		
		User user = selectByPrimaryKey(user_id);
		if(user == null){
			return ResponseCode.buildEnumMap(ResponseCode.USER_NOT_EXISTS_ERROR, null);
		}
		
		result.put("obj", user);
		result.put("imageFilesize", Integer.valueOf(sysConfigFeignClient.getSysConfig().getImageFilesize()));
		return ResponseCode.buildSuccessMap(result);
	}
	
	
	
	/**
	 * 用户中心完善资料
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping(value="/buyer/liveCode")
	public Map liveCode(HttpServletRequest request,
			HttpServletResponse response) {
		HashMap result = new HashMap<>();
		User user = userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUserId(request));
		result.put("liveCode", user.getLive_code());
		return ResponseCode.buildSuccessMap(result);
	}
	
	/**
	 * 用户中资料保存
	 * @param request
	 * @param response
	 * @param USER_AGE
	 * @param card
	 * @param userName
	 * @param sex
	 * @return
	 * @throws Exception
	 */
	@RequestMapping(value="/buyer/account_save", method = RequestMethod.POST)
	public Map account_saveEntity(HttpServletRequest request,
			HttpServletResponse response,@RequestBody JSONObject json) throws Exception {
		String userName = json.optString("userName");
		String nickName = json.optString("nickName");
		String sex = json.optString("sex");
		String photo_id = json.optString("photo_id");
		String USER_AGE = json.optString("USER_AGE");
		
		
		User user = this.userService.selectByPrimaryKey(SecurityUserHolder
				.getCurrentUser(request).getId());
		
		if ((userName != null) && (!userName.equals(""))) {
			user.setTrueName(userName);
		}
		if ((USER_AGE != null) && (!USER_AGE.equals(""))) {
			user.setBirthday(CommUtil.formatDate(USER_AGE));
		}
		if ((nickName != null) && (!nickName.equals(""))) {
			user.setNickName(nickName);
		}
		if ((sex != null) && (!sex.equals(""))) {
			user.setSex(CommUtil.null2Int(sex));
		}
		if(StringUtils.isNotBlank(photo_id)){
			user.setPhoto_id(CommUtil.null2Long(photo_id));
		}
		this.userService.updateById(user);
		try{
			//腾讯IM账号资料更改
			UserDto userDto = new UserDto();
			BeanUtils.copyProperties(user, userDto);
			tencentIMFeignClient.portraitSet(userDto);
		}catch (Exception e) {
			logger.error("UserController >> account_saveEntity >> IM portraitSet  "+ e.getMessage());
		}
		return ResponseCode.buildSuccessMap(null);
	}
	
	
	/**
	 * 手机客户端商城首页
	 * @param request
	 * @param response
	 * @param store_id
	 * @return
	 */
	@RequestMapping(value="/center", method = RequestMethod.POST)
	public Map center(HttpServletRequest request, HttpServletResponse response) {
		Map result = new HashMap();
		UserDto u = SecurityUserHolder.getCurrentUser(request);
		if ((u != null) && (!u.equals(""))) {
			User user = this.userService.selectByPrimaryKey(SecurityUserHolder
					.getCurrentUser(request).getId());
			if (user!=null&&user.getPhoto_id()!=null) {
				AccessoryDto photo = accessoryFeignClient.selectByPrimaryKey(user.getPhoto_id());
				user.setPhoto(photo);
			}
			int selectCount = footPointService.selectSumCount(user.getId());
			/*Map foot_params = Maps.newHashMap();
			foot_params.put("fp_user_id", user.getId());
			foot_params.put("deleteStatus", 0);
			//List fps = footPointService.queryPageList(foot_params);
			//result.put("objs", fps);*/		
			result.put("footsize", selectCount);
			Map params = Maps.newHashMap();
			params.put("user_id", user.getId());
			params.put("status", Integer.valueOf(0));
			
			result.put("couponInfos",Integer.valueOf(couponInfoFeignClient.selectCount(params)));
		/*	params.clear();
			params.put("status", Integer.valueOf(10));
			params.put("user_id", user.getId().toString());
			result.put("orders_10",Integer.valueOf(orderFormFeignClient.selectCount(params)));*/
			
			// result.put("integralViewTools", this.integralViewTools);
			params.clear();
			params.put("type", Integer.valueOf(0));
			params.put("user_id", user.getId());
			
			int favorite_goods = favoriteService.selectCount(params);
			
			result.put("favorite_goods", favorite_goods);
			params.clear();
			params.put("type", Integer.valueOf(1));
			params.put("user_id", user.getId());
			
			result.put("favorite_store",favoriteService.selectCount(params));
			params.clear();
			params.put("order_status", Integer.valueOf(10));
			params.put("user_id", user.getId().toString());
			//params.put("order_main", Integer.valueOf(1));
			
			//List order_nopays = orderFormFeignClient.queryPageList(params);
			Integer order_nopays = orderFormFeignClient.selectCount(params);
			String order_nopay = "";
			if (order_nopays > 99) {
				order_nopay = "99+";
			} else {
				order_nopay = order_nopays + "";
			}
			
			result.put("order_nopay", order_nopay);
			params.clear();
			params.put("order_status1", Integer.valueOf(14));
			params.put("order_status2", Integer.valueOf(20));
			params.put("user_id", user.getId().toString());
			//params.put("order_main", Integer.valueOf(1));

			//List order_noships = orderFormFeignClient.queryPageList(params);
			
			
			
			Integer order_noships = orderFormFeignClient.selectCount(params);
			String order_noship = "";
			if (order_noships > 99) {
				order_noship = "99+";
			} else {
				order_noship = order_noships + "";
			}
			
			result.put("order_noship", order_noship);
			params.clear();
			params.put("order_status1", Integer.valueOf(30));
			params.put("order_status2", Integer.valueOf(35));
			params.put("user_id", user.getId().toString());
			//params.put("order_main", Integer.valueOf(1));
			
			//List order_notakes = orderFormFeignClient.queryPageList(params);
			Integer order_notakes = orderFormFeignClient.selectCount(params);
			
			String order_notake = "";
			if (order_notakes > 99) {
				order_notake = "99+";
			} else {
				order_notake = order_notakes + "";
			}
			result.put("order_notake", order_notake);
			
			params.clear();
			params.put("order_status", Integer.valueOf(40));
			params.put("user_id", user.getId().toString());
			
			 Integer order_noevaluate = orderFormFeignClient.selectCount(params);
			
			String noevaluate = "0";
			if (order_noevaluate > 99) {
				noevaluate = "99+";
			} else {
				noevaluate = order_noevaluate + "";
			}
			result.put("noevaluate", noevaluate);
			
			params.clear();
		/*	params.put("status", Integer.valueOf(0));
			params.put("user_id", user.getId());
			params.put("parent", -1);
			
			List msgs  = messageFeignClient.queryPageList(params);
			
			result.put("msg_size", msgs.get(0));*/
			result.put("user", user);
			// result.put("integralViewTools", this.integralViewTools);
			
			result.put("level", integralToolsFeignClient.query_user_level(String.valueOf(user.getId())));
			Integer	store_status=0;
			if (user.getStore_id()!=null) {
				StoreDto store = storeFeignClient.selectByPrimaryKey(user.getStore_id());
				if (store!=null) {
					store_status = store.getStore_status();
					ModularClassDto ModularClassDto = modularClassFeignClient.selectByStoreId(store.getId());
					if (ModularClassDto!=null) {
						result.put("timely", ModularClassDto.isTimely());
					}else{
						result.put("timely",false);
					}
					
				}
			}
			result.put("store_status", store_status);
			
			//是否是代理商（业务员：推荐开店能获取店铺收益的那种）
			Integer platAgent = userService.agentCount(user.getId());
			result.put("platAgent", platAgent);

		}
		return ResponseCode.buildSuccessMap(result);
	}
	
	
	/**
	 * 个人二维码
	 * @param request
	 * @param response
	 * @return
	 * @throws Exception 
	 */
	@RequestMapping(value="/buyer/myQrcode", method = RequestMethod.GET)
	public Map myQrcode(HttpServletRequest request,HttpServletResponse response) throws Exception {
		UserDto userDto = SecurityUserHolder.getCurrentUser(request);
		User user = userService.selectByPrimaryKey(userDto.getId());
		if(StringUtils.isEmpty(user.getDirect_selling_qr_path())) {
			if(null != user.getPhoto_id()){
				user.setPhoto(accessoryFeignClient.selectByPrimaryKey(user.getPhoto_id()));
			}
			BeanUtils.copyProperties(user, userDto);
			// 生成用户分销二维码
			String myQrcode = qrCodeFeignClient.myQrcode(userDto);
			user.setDirect_selling_qr_path(myQrcode);
			userService.updateById(user);
		}
		return ResponseCode.buildSuccessMap(user.getDirect_selling_qr_path());
	}
	
	
	/**
	 * 用户中心支付密码修改
	 * @param request
	 * @param response
	 * @return
	 
	@RequestMapping(value="/buyer/account_pay_password", method = RequestMethod.GET)
	public Map account_pay_password(HttpServletRequest request,
			HttpServletResponse response) {
		Map result = new HashMap();
		
		User user = this.userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUser().getId());
		result.put("user", user);
		if ((user.getMobile() != null) && (!user.getMobile().equals(""))) {
			String show_tel = user.getMobile();
			result.put("show_tel", show_tel);
			result.put("first", Integer.valueOf(-1));
		} else {
			result.put("first", "1");
		}
		return ResponseCode.buildSuccessMap(result);
	}*/
	
	
	/**
	 * 修改支付密码提交
	 * @param request
	 * @param response
	 * @param pay_password
	 * @param pay_password_confirm
	 * @param phone_number
	 * @param code
	 * @param t
	 * @return
	 */
	@RequestMapping(value="/buyer/account_pay_password_save", method = RequestMethod.POST)
	public Map account_pay_password_saveEntity(HttpServletRequest request,
			HttpServletResponse response, String pay_password, String pay_password_confirm, String phone_number, String code) {
		Map result = new HashMap();
		
		if(null == code || StringUtils.isEmpty(code)){
			result.put("op_title", "验证码不能为空，支付密码修改失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_pay_password");
			return ResponseCode.buildCodeMap("20004", "不要做违规操作，超过一定次数将冻结预存款", result);
		}
		
		VerifyCodeDto vc = verifyCodeFeignClient.getObjByProperty("mobile", "=",  phone_number);
		if (vc == null) {
			result.put("op_title", "不要做违规操作，超过一定次数将冻结预存款");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_pay_password");
			return ResponseCode.buildCodeMap("20003", "不要做违规操作，超过一定次数将冻结预存款", result);
		} 
			
		if (!code.equalsIgnoreCase(vc.getCode())) {
			result.put("op_title", "验证码错误，支付密码修改失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_pay_password");
			return ResponseCode.buildCodeMap("20002", "验证码错误，支付密码修改失败", result);
		}
			
		if (StringUtils.isEmpty(pay_password) || StringUtils.isEmpty(pay_password_confirm)
				|| !StringUtils.equals(pay_password, pay_password_confirm)){
			result.put("op_title", "两次密码输入不相同");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_pay_password");
			return ResponseCode.buildCodeMap("20001", "两次密码输入不相同", result);
		}
			
		User user = this.userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUser(request).getId());
		user.setMobile(phone_number);
		user.setPay_password(Md5Encrypt.md5(pay_password));
		this.userService.updateById(user);
		result.put("op_title", "支付密码修改成功");
		result.put("url", CommUtil.getURL(request) + "/index");
		return ResponseCode.buildSuccessMap(result);
			
	}
	
	
	
	/**手机短信密码修改 TODO:(小程序没有
	 * @param request
	 * @param response
	 * @param password  密码
	 * @param mobile  手机号
	 * @param mobile_code  验证码
	 * @return
	 *//*
	@RequestMapping({ "/mobile_account_password_save" })
	@ResponseBody
	public String mobile_account_password_save(HttpServletRequest request,
			HttpServletResponse response,String password,String mobile ,String mobile_code,String password_or) {
		if(mobile == null || "".equals(mobile)){
			return "403";
		}
		if(mobile_code == null || "".equals(mobile_code)){
			return "404";
		}
		Jedis jedis = RedisCache.getJedis();
		if(jedis.exists(SerializeUtil.serialize(mobile))){
			byte[] bs = jedis.get(SerializeUtil.serialize(mobile));
			Object deserialize = SerializeUtil.deserialize(bs);
			if(deserialize != null){
				if(!CommUtil.null2String(mobile_code).equals(deserialize.toString())){
					return "402";
				}
			}
		}else{
			return "401";
		}
		if(jedis != null){
			jedis.close();
		}
		if(password != null && password_or != null){
					if(password.equals(password_or)){
			
						if(!CommUtil.null2String(mobile).equals("")){
							List users=this.userService.selectByMobileOrUserName(mobile);
							if(users != null && users.size() > 0){
								User user = users.get(0);
								user.setPassword(Md5Encrypt.md5(password));
								this.userService.updateById(user);
							}else{
								return "400";
							}
						}
					}else{
						return "406";
					}
			}else{
				return "405";
			}
		 return "200";
	}
	*/
	
	
	
	
	
	
/*	*//**
	 * 修改支付密码-手机短信发送
	 * @param request
	 * @param response
	 * @param mobile
	 *//*
	@RequestMapping(value="/buyer/account_mobile_sms", method = RequestMethod.POST)
	public Map account_mobile_sms(HttpServletRequest request,
			HttpServletResponse response, String mobile) {
		SysConfigDto sysConfigDto = sysConfigFeignClient.getSysConfig();
		if (!sysConfigDto.getSmsEnbale()) {
			return ResponseCode.buildCodeMap("20002", "短信服务未开启", null);
		}
		
		String code = CommUtil.randomInt(4);
		String content = "尊敬的" + SecurityUserHolder.getCurrentUser(request).getUserName()
				+ "您好，您在试图修改" + sysConfigDto.getWebsiteName() + "的支付密码，" 
				+ "手机验证码为：" + code + "。[" + sysConfigDto.getTitle() + "]";
		
		boolean ret_op = msgToolsFeignClient.sendSMS(mobile, content);
		if (!ret_op) {
			return ResponseCode.buildCodeMap("20001", "发送短信失败", null);
		}
		
		VerifyCodeDto mvc = verifyCodeFeignClient.getObjByProperty("mobile","=",  mobile);
		if (mvc == null) {
			mvc = new VerifyCodeDto();
		}
		mvc.setAddTime(new Date());
		mvc.setCode(code);
		mvc.setMobile(mobile);
		verifyCodeFeignClient.updateById(mvc);
		
		return ResponseCode.buildSuccessMap(null);
	}
	
	*//**
	 * 修改绑定手机
	 * @param request
	 * @param response
	 * @return
	 
	@RequestMapping(value="/buyer/account_mobile_bind", method = RequestMethod.POST)
	public Map account_mobile_password(HttpServletRequest request,
			HttpServletResponse response) {
		Map result = new HashMap();
		
		User user = this.userService.selectByPrimaryKey(SecurityUserHolder
				.getCurrentUser().getId());
		if ((user.getMobile() != null) && (!user.getMobile().equals(""))) {
			String show_tel = user.getMobile().substring(0, 3) + "*****"
					+ user.getMobile().substring(8, 11);
			result.put("show_tel", show_tel);
			result.put("first", "-1");
		} else {
			result.put("first", "1");
		}
		return ResponseCode.buildSuccessMap(result);
	}*//*
	
	*//**
	 * 手机号码绑定提交
	 * @param request
	 * @param response
	 * @param code
	 * @param new_mobile
	 * @param t
	 * @return
	 * @throws Exception
	 *//*
	@RequestMapping(value="/buyer/account_mobile_bind_save", method = RequestMethod.POST)
	public Map account_mobile_bind_saveEntity(HttpServletRequest request,
			HttpServletResponse response, String code, String new_mobile,
			String t) throws Exception {
		
		Map result = new HashMap();
		if (StringUtils.isEmpty(code)) {
			result.put("op_title", "验证码不能为空，支付密码修改失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_mobile_bind");
			return ResponseCode.buildCodeMap("20004", "验证码不能为空，支付密码修改失败", result);
		}
		
		VerifyCodeDto mvc = verifyCodeFeignClient.getObjByProperty("mobile","=",  new_mobile);
		if (mvc == null) {
			result.put("op_title", "请填写正确的验证码和手机号码，手机绑定失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_mobile_bind");
			return ResponseCode.buildCodeMap("20003", "请填写正确的验证码和手机号码，手机绑定失败", result);
		}
		
		if (!StringUtils.equals(mvc.getCode(), code)) {
			result.put("op_title", "验证码错误，手机绑定失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_mobile_bind");
			return ResponseCode.buildCodeMap("20002", "验证码错误，手机绑定失败", result);
		}
		
		User user = this.userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUser(request).getId());
		if (new_mobile.equals(user.getMobile())) {
			result.put("op_title", "新旧输入电话号码不能相同，手机绑定失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_mobile_bind");
			return ResponseCode.buildCodeMap("20001", "新旧输入电话号码不能相同，手机绑定失败", result);
		}
		
		user.setMobile(new_mobile);
		this.userService.updateById(user);
		verifyCodeFeignClient.deleteById(mvc.getId());
		result.put("op_title", "手机绑定成功");
		String content = "尊敬的" + SecurityUserHolder.getCurrentUser(request).getUserName() 
						+ "您好，您于" + CommUtil.formatLongDate(new Date())+ "绑定手机号成功。["
						+ sysConfigFeignClient.getSysConfig().getTitle() + "]";
		
		msgToolsFeignClient.sendSMS(user.getMobile(), content);
		result.put("op_title", "手机绑定成功");
		result.put("url", CommUtil.getURL(request) + "/buyer/account_safe");
		
		return ResponseCode.buildSuccessMap(result);
	}
	
	*//**
	 * 手机绑定短信发送
	 * @param request
	 * @param response
	 * @param new_mobile
	 * @param t
	 *//*
	@RequestMapping(value="/buyer/account_mobile_bind_sms", method = RequestMethod.POST)
	public Map account_mobile_bind_sms(HttpServletRequest request,
			HttpServletResponse response, String new_mobile) {
		SysConfigDto configDto = sysConfigFeignClient.getSysConfig();
		if (!configDto.getSmsEnbale()) {
			return ResponseCode.buildCodeMap("20002", "短信服务未开启", null);
		}
			
		String code = CommUtil.randomInt(4);
		String content = "";
		content = "尊敬的" + SecurityUserHolder.getCurrentUser(request).getUserName()
				+ "您好，您在试图修改" + configDto.getWebsiteName() + "的绑定手机号码，" 
				+ "手机验证码为：" + code + "。[" + configDto.getTitle() + "]";
		
		boolean ret_op = msgToolsFeignClient.sendSMS(new_mobile, content);
		if (!ret_op) {
			return ResponseCode.buildCodeMap("20001", "发送短信失败", null);
		}
		
		VerifyCodeDto mvc = verifyCodeFeignClient.getObjByProperty("mobile","=",  new_mobile);
		if (mvc == null) {
			mvc = new VerifyCodeDto();
		}
		mvc.setAddTime(new Date());
		mvc.setCode(code);
		mvc.setMobile(new_mobile);
		verifyCodeFeignClient.updateById(mvc);
		
		return ResponseCode.buildSuccessMap(null);
	}*/
	
	/**
	 * 已有账号绑定保存
	 * @param request
	 * @param response
	 * @param userName
	 * @param password
	 * @param mobile_verify_code
	 * @param mobile
	 */
	@RequestMapping(value="/buyer/datum2", method = RequestMethod.POST)
	public Map datum2(HttpServletRequest request,
			HttpServletResponse response, String userName, String password,
			String mobile_verify_code, String mobile){
		Map result = new HashMap();
		VerifyCodeDto mvc = verifyCodeFeignClient.getObjByProperty("mobile","=",  mobile);
		if (mvc == null) {
			result.put("op_title", "请填写正确的验证码和手机号码，手机绑定失败");
			result.put("url", CommUtil.getURL(request) + "/buyer/account_mobile_bind");
			return ResponseCode.buildCodeMap("20003", "请填写正确的验证码和手机号码，手机绑定失败", result);
		}
		
		String passwd = Md5Encrypt.md5(password).toLowerCase();
		Map map = Maps.newHashMap();
		map.put("userName", userName);
		map.put("passwd", passwd);
		List users = this.userService.queryPageList(map);
		
		if ((mvc != null) && (mvc.getCode().equalsIgnoreCase(mobile_verify_code))
				&& (users.size() > 0)) {
			User bind_user = (User) users.get(0);
			if (CommUtil.null2String(bind_user.getOpenId()).equals("")) {
				User current_user = this.userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUser(request).getId());
				if (current_user != null) {
					bind_user.setOpenId(current_user.getOpenId());
					bind_user.setUserMark(null);
					this.userService.updateById(bind_user);
					Map json = Maps.newHashMap();
					json.put("login", Boolean.valueOf(true));
					json.put("userName", userName);
					json.put("passwd", passwd);
					json.put("userId", current_user.getId());
					return ResponseCode.buildSuccessMap(json);
				}
			}
			return ResponseCode.buildCodeMap("20001", "参数错误", null);
		} else {
			return ResponseCode.buildCodeMap("20002", "验证码错误", null);
		}
	}
	
	/**
	 * 已有账号绑定保存错误提示
	 * @param request
	 * @param response
	 * @return
	@RequestMapping(value="/buyer/datum_error", method = RequestMethod.GET)
	public Map datum_error(HttpServletRequest request,
			HttpServletResponse response) {
		Map result = new HashMap();
		result.put("op_title", "用户名或验证码输入错误！");
		result.put("url", CommUtil.getURL(request) + "/buyer/center");
		return ResponseCode.buildSuccessMap(result);
	}*/
	@RequestMapping(value = "/test", method = RequestMethod.POST)
	public ResponseVO login1( HttpServletRequest request){
		return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_PASSWORD_NOT_EMPTY, null);
		   
	}
	/**
	 * 用户登录(WAP)
	 * @param request
	 * @return
	 */
	@RequestMapping(value = "/login", method = RequestMethod.POST)
	public ResponseVO login(@RequestBody JSONObject json, HttpServletRequest request){
		//获取数据
		String username = json.optString("username");
		String password = json.optString("password");
		//验证用户是否为空;
	    if(StringUtils.isEmpty(username)){
	    	return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_NAME_NOT_EMPTY, null);
	    }
	    //验证密码是否为空;
	    if(StringUtils.isEmpty(password)){
	    	return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_PASSWORD_NOT_EMPTY, null);
	    }
	    
	    HashMap params = new HashMap();
	    params.put("userName", username);
	    List User_list = userService.queryPageList(params);
	    if(User_list == null||User_list.size()<1){
	    	return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_DOES_NOT_EXIST, null);
	    }
	    User info = User_list.get(0);
	    
	    //判断用户是否禁用
    	if( -1== info.getStatus()){
    		return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_NAME_IS_DISABLE, null);
    	}
    	
	    //用户密码是否匹配
    	if(!StringUtils.equals(Md5Encrypt.md5(password), info.getPassword())){
    		return MemberResponseCode.buildEnumResponseVO(MemberResponseCode.RESPONSE_CODE_USER_PASSWORD_NOT_VALIDATE, null);
    	}
		String token = JWT.sign(info.getId() + ";" + System.currentTimeMillis()+";"+"app", 0);
		// 将token存到redis中，有效期24小时 
		redisUtil.set(Globals.ANDROID_LOGIN_MARK + info.getId(), token, Globals.USER_INFO_EXPIRE_TIME);
		
		// 覆盖redis用户信息
		UserDto userDto = new UserDto();
		BeanUtils.copyProperties(info, userDto);
		redisUtil.set(Globals.USER_INFO_MARK + info.getId(), userDto, Globals.USER_INFO_EXPIRE_TIME);

    	//加密用户名、密码 
	   /* String token = JWT.sign(info.getId(), 0);
	    //将用户名密码生成的token信息放入redis缓存
	    redisUtil.set(Globals.WAP_LOGIN_MARK + info.getId(), token);*/
    	Map result = new HashMap();
    	//根据uid查询member信息
    	User user = userService.selectByPrimaryKey(info.getId());
    	/*if (user.getPhoto_id()!=null) {
			AccessoryDto accessoryDto = accessoryFeignClient.selectByPrimaryKey(user.getPhoto_id());
			if (accessoryDto!=null) user.setPhoto(accessoryDto);
    	}*/
    	result.put("userInfo", user);
	    result.put("token", token);
		return ResponseCode.buildEnumResponseVO(ResponseCode.SUCCESS, result);
	}
	
	
	private static final String REGEX1 = "(.*管理员.*)";
	private static final String REGEX2 = "(.*admin.*)";
	/**
	 * 注册完成
	 * @param request
	 * @param response
	 * @param userName
	 * @param password
	 * @param email
	 * @param code
	 * @param user_type
	 * @return
	 * @throws HttpException
	 * @throws IOException
	 * @throws InterruptedException
	 */
	@RequestMapping(value="/register_finish", method = RequestMethod.POST)
	public Map register_finish(@RequestBody JSONObject json,HttpServletRequest request, HttpServletResponse response
			) throws HttpException, IOException, InterruptedException {
		// 获取数据
		String userName = json.optString("username");
		String password = json.optString("password");
		String user_type = json.optString("user_type");
		String directSellingParent_id = json.optString("directSellingParent_id");
		String email = json.optString("email");

		// 验证用户是否为空;
		if (StringUtils.isEmpty(userName)) {
			return ResponseCode.buildFailMap("10004", "参数错误");
		}
		// 验证密码是否为空;
		if (StringUtils.isEmpty(password)) {
			return ResponseCode.buildFailMap("10004", "参数错误");
		}
				
		SysConfigDto sysConfig = sysConfigFeignClient.getSysConfig();
		//查询是否有用户名
		HashMap map = new HashMap();
		map.put("userName", userName);
		List User_list = userService.queryPageList(map);
		if (User_list.size() > 0) {
			return ResponseCode.buildFailMap("10003", "该用户名已注册");
		}
		try {
			boolean reg = true;
			if ((userName.matches(REGEX1)) || (userName.toLowerCase().matches(REGEX2))) {
				reg = false;
			}
			if (reg) {
				User user = new User();
				user.setUserName(userName);
				user.setUserRole("BUYER");
				user.setAddTime(new Date());
				user.setEmail(email);
				user.setAvailableBalance(BigDecimal.valueOf(0L));
				user.setFreezeBlance(BigDecimal.valueOf(0L));
				if (directSellingParent_id != null) {
					User directSellingParent = this.userService
							.selectByPrimaryKey(CommUtil.null2Long(directSellingParent_id));
					user.setDirectSellingParent(directSellingParent);
				}
				if ((user_type != null) && (!user_type.equals(""))) {
					user.setUser_type(CommUtil.null2Int(user_type));
					user.setContact_user(request.getParameter("contact_user"));
					user.setDepartment(request.getParameter("department"));
					user.setTelephone(request.getParameter("telephone"));
					user.setMobile(request.getParameter("mobile"));
					user.setCompany_name(request.getParameter("company_name"));
					AreaDto area = this.areaFeignClient.selectByPrimaryKey(CommUtil
							.null2Long(request.getParameter("area_id")));
					user.setCompany_address(area.getParent().getParent()
							.getAreaName()
							+ area.getParent().getAreaName()
							+ area.getAreaName()
							+ " "
							+ request.getParameter("company_address"));
					if (request.getParameter("company_purpose") != null) {
						if (!request.getParameter("company_purpose").equals("")) {
							user.setCompany_purpose(request.getParameter(
									"company_purpose").substring(
									0,
									request.getParameter("company_purpose")
											.length() - 1));
						}
					}
					user.setCompany_url(request.getParameter("company_url"));
					user.setCompany_person_num(request
							.getParameter("company_person_num"));
					user.setCompany_trade(request.getParameter("company_trade"));
					user.setCompany_nature(request
							.getParameter("company_nature"));
				}
				user.setPassword(Md5Encrypt.md5(password).toLowerCase());
				Map params = Maps.newHashMap();
				params.put("type", "BUYER");
				
				List roles = this.roleService.queryPageList(params);
				
				this.userService.saveUserRole(user.getId(), roles);
				
				if (sysConfig.getIntegral()) {
					user.setIntegral(sysConfig
							.getMemberRegister());
					try {
						this.userService.saveEntity(user);
					} catch (Exception e) {
						e.printStackTrace();
					}
					IntegralLogDto log = new IntegralLogDto();
					log.setAddTime(new Date());
					log.setContent("用户注册增加"
							+ sysConfig
									.getMemberRegister() + "分");
					log.setIntegral(sysConfig
							.getMemberRegister());
					log.setIntegral_user_id(user.getId());
					log.setType("reg");
					integralLogFeignClient.saveEntity(log);
				} else {
					this.userService.saveEntity(user);
				}
				Album album = new Album();
				album.setAddTime(new Date());
				album.setAlbum_default(true);
				album.setAlbum_name("默认相册");
				album.setAlbum_sequence(55536);
				album.setUser_id(user.getId());
				this.albumService.saveEntity(album);
				
				return ResponseCode.buildSuccessMap(null);
			}
			return ResponseCode.buildFailMap("10001", "请求失败");
		} catch (Exception e) {
		}
		return ResponseCode.buildSuccessMap(null);
	}
	
	/**发送短信   (用户登录界面)
	 * @param mobile
	 * @return
	 */
	@RequestMapping(value ="/mobile_send", method = RequestMethod.POST)
	public Map mobile_send(@RequestBody JSONObject json) {
		// 获取数据
		String mobile = json.optString("mobile");
		String type = json.optString("type");

		if (mobile == null || "".equals(mobile)) {
			return ResponseCode.buildReturnMap(ResponseCode.RESPONSE_CODE_USER_MOBILE_OR_TELEPHONE_NOT_EMPTY,
					"联系方式不能为空");
		}

	/*	// 系统配置是否开启短信功能  (后面有做验证)
		SysConfigDto sysConfig = sysConfigFeignClient.getSysConfig();
		if (sysConfig.getSmsEnbale() == false) {
			return ResponseCode.buildReturnMap(ResponseCode.RESPONSE_CODE_SMS_CLOSE,"系统尚未开启短信服务");
			
		}*/
		
		// 短信模板(固定模板,一个是注册,一个登陆) 登录验证码
		String mark = "sms_tobuyer_user_login_notify"; // 后台短信模板登录标识
		if (CommUtil.null2String(type).equals("find")) {
			mark = "sms_tobuyer_find_password_notify"; // 重置密码
		} else if (CommUtil.null2String(type).equals("bind")) {
			mark = "sms_tobuyer_user_login_notify"; // 通用验证码
		} else {
			List users = this.userService.selectByMobileOrUserName(mobile);// (手机号唯一),通过手机号(账号),查询用户
			if (users != null && users.size() > 0) {
				mark = "sms_tobuyer_user_login_notify"; // 登录验证码
			} else {
				mark = "sms_tobuyer_tips_notify";
			}
		}
		// 根据短信模板标识(固定)查询模板信息
		HashMap hashMap = new HashMap();
		hashMap.put("mark", mark); // 模板标识
		hashMap.put("open", 1); // 开启
		List templatedto_list = templateFeignClient.queryPageList(hashMap);

		
		if (templatedto_list.size()==0) {
			return ResponseCode.buildReturnMap(ResponseCode.RESPONSE_CODE_SMS_CLOSE,"系统尚未开启短信服务");
		}
		
		
		ThreadLocalRandom current = ThreadLocalRandom.current();
		int muber = current.nextInt(100000, 1000000);
		if (!redisUtil.existsHashKey("mobile", mobile)) {    //查询是否存在
			redisUtil.setHashvValueTimeout("mobile", mobile, muber, 5, TimeUnit.MINUTES);       //不存在,则创建,超时时间为5分钟
			//TODO(待修改,动态)  目前是阿里的内容
			String content = "{\"code\":\"" + muber + "\"}";
			msgToolsFeignClient.sendSMS(mobile,templatedto_list.get(0).getSms_mark(),content);     //发送短信请求
		} else {
			Object hashValue = redisUtil.getHashValue("mobile", mobile);
			String content = "{\"code\":\"" + hashValue.toString() + "\"}";
			msgToolsFeignClient.sendSMS(mobile, templatedto_list.get(0).getSms_mark(), content);
		}
		//RedisCache.removeObject(mobile);
		return ResponseCode.buildSuccessMap("短信已发送");
	}
	
	
	/**短信验证
	 * @param mobile
	 * @param code
	 * @return
	 */
	/*@RequestMapping({"/code_validate"})
	public String  code_validate(@RequestBody JSONObject json){
		String mobile = json.optString("mobile");
		String code = json.optString("code");
		
		if(mobile == null || "".equals(mobile)){
			return "404";
		}
		if(code == null || "".equals(code)){
			return "404";
		}
		Jedis jedis = RedisCache.getJedis();
		if(jedis.exists(SerializeUtil.serialize(mobile))){
			byte[] bs = jedis.get(SerializeUtil.serialize(mobile));
			Object deserialize = SerializeUtil.deserialize(bs);
			if(deserialize != null){
				if(CommUtil.null2String(code).equals(deserialize.toString())){
					return "200";
				}else{
					return "400";
				}
			}
		}
		if(jedis != null){
			jedis.close();
		}
		return "401";
	}*/
	
	/**短信验证
	 * @param mobile
	 * @param code
	 * @return
	 *//*
	@RequestMapping({"/code_validate"})
	public  Boolean code_validate(String mobile,String code){
		if(mobile == null || "".equals(mobile)){
			return false;
		}
		if(code == null || "".equals(code)){
			return false;
		}
		Jedis jedis = RedisCache.getJedis();
		if(jedis.exists(SerializeUtil.serialize(mobile))){
			byte[] bs = jedis.get(SerializeUtil.serialize(mobile));
			Object deserialize = SerializeUtil.deserialize(bs);
			if(deserialize != null){
				if(CommUtil.null2String(code).equals(deserialize.toString())){
					RedisCache.removeObject(mobile);
					return true;
				}
			}
		}
		if(jedis != null){
			jedis.close();
		}
		return false;
	}*/
	
	
	
	/**
	 * 用户申请主播,
	 * 已是主播则进行更换上级
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping({ "/buyer/add_livecode" })
	public Map add_livecode(HttpServletRequest request, HttpServletResponse response,
			@RequestBody JSONObject json) {
		HashMap result = new HashMap<>();
		User user = userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUserId(request));
		// 如果是审核通过的主播,则进行更换
		result.put("Is_live", user.getIs_live());// 是否是主播
		result.put("Live_code_up", user.getLive_code_up());
		result.put("goods_id", 502); // 增值服务商品id

		return ResponseCode.buildSuccessMap(result);

	}
	
	
	//进身份证验证页面
	@RequestMapping({ "/inLiveCode" })
	public Map inLiveCode(HttpServletRequest request, HttpServletResponse response) {
		
		UserDto userDto = SecurityUserHolder.getCurrentUser(request);
		if(userDto == null){
			return ResponseCode.buildEnumMap(ResponseCode.TOKEN_EXPIRE, null);
		}
		
		User currentUser = userService.selectByPrimaryKey(userDto.getId());
		HashMap result = new HashMap<>();
		result.put("is_live", currentUser.getIs_live());
		if(currentUser.getIs_live() == 1){
			VerifyidCard vc = verifyidCardService.selectByUserId(currentUser.getId());
			if(vc != null){
				result.put("vc", vc);
			}
		}
		return ResponseCode.buildSuccessMap(result);
	}
	
	/**
	 * 校验邀请码(添加了身份证验证功能)
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping({ "/checkLiveCode" })
	public Map checkLiveCode(HttpServletRequest request, HttpServletResponse response,
			@RequestBody JSONObject json) {
		String liveCode = json.optString("liveCode");
		String name = json.optString("name");
		String code = json.optString("code");
		String phone = json.optString("phone");
		Long img_id1 = json.optLong("img_id1");
		Long img_id2 = json.optLong("img_id2");
		Long img_id3 = json.optLong("img_id3");
		
		if(StringUtils.isBlank(name) || StringUtils.isBlank(code) || StringUtils.isBlank(phone) 
				|| img_id1 == null ||  img_id2 == null || img_id3 == null){
			return ResponseCode.buildEnumMap(ResponseCode.REQ_CANNOT_EMPTY, null);
		}
		
		if(StringUtils.isBlank(liveCode)){
			liveCode = "100000";
		}
		
		UserDto userDto = SecurityUserHolder.getCurrentUser(request);
		if(userDto == null){
			return ResponseCode.buildEnumMap(ResponseCode.TOKEN_EXPIRE, null);
		}
		
		HashMap result = new HashMap<>();
		User currentUser = userService.selectByPrimaryKey(userDto.getId());
		User user = userService.selectByLiveCode(CommUtil.null2Long(liveCode));//100086
		boolean isflag=false;
		if (user!=null) {  //不能是自己的邀请码并且这个邀请码存在
			currentUser.setLive_code_up(CommUtil.null2Long(liveCode));
			userService.updateById(currentUser);
			isflag=true;
		}
		result.put("check", isflag);
		result.put("goods_id", 502); // 增值服务商品id
		VerifyidCard vc = verifyidCardService.selectByUserId(currentUser.getId());
		boolean bol = false;
		if(vc == null){
			//保存用户身份证信息
			vc = new VerifyidCard();
			vc.setAddTime(new Date());
			vc.setDeleteStatus(0);
			bol = true;
		}
		vc.setName(name);
		vc.setCode(code);
		vc.setPhone(phone);
		vc.setImg_id1(img_id1);
		vc.setImg_id2(img_id2);
		vc.setImg_id3(img_id3);
		vc.setUid(currentUser.getId());
		
		if(bol){
			verifyidCardService.saveEntity(vc);
		}else{
			verifyidCardService.updateById(vc);
		}
		return ResponseCode.buildSuccessMap(result);
	}
	
	
	/**
	 * 判断店铺是否开通主播（用户名+密码）
	 * @param paraMap
	 * @return 不为空表示已经开通
	 */
	@RequestMapping(value = "/apiForFeign/checkingAccount", method = RequestMethod.POST)
	public Long checkingAccount(@RequestBody Map paraMap){
		String userName = paraMap.get("userName");
		String password = paraMap.get("password");
		User user = userService.selectByUserName(userName);
		if(user == null){
			return null;
		}
		if(!StringUtils.equals(password, user.getPassword())){
			return null;
		}
		if(user.getIs_live() != 2){
			return null;
		}
		return user.getId();
	}

	/**
	 * 判断店铺是否开通主播（用户名）
	 * @param paraMap
	 * @return 不为空表示已经开通
	 */
	@RequestMapping(value = "/apiForFeign/checkingUserName", method = RequestMethod.POST)
	public Long checkingUserName(@RequestBody Map paraMap){
		String userName = paraMap.get("userName");
		User user = userService.selectByUserName(userName);
		if(user == null){
			return null;
		}
		if(user.getIs_live() != 2){
			return null;
		}
		return user.getId();
	}
	
	/**
	 * 根据用户名查询用户
	 * @param username
	 * @return
	 */
	@RequestMapping(value = "/apiForFeign/selectByUserName", method = RequestMethod.POST)
	public User selectByUserName(@RequestParam("userName")String userName){
		return userService.selectByUserName(userName);
	}
	
	//将邀请注册奖金提现到余额
	@RequestMapping(value ="/invProChangeBalance", method = RequestMethod.POST)
	public Map invProChangeBalance(HttpServletRequest request, HttpServletResponse response, @RequestBody JSONObject json) {
		String money = json.optString("money");
		if(StringUtils.isBlank(money)){
			return ResponseCode.buildEnumMap(ResponseCode.REQ_CANNOT_EMPTY, null);
		}
		UserDto user = SecurityUserHolder.getCurrentUser(request);
		if(user == null || user.getId() == null){
			return ResponseCode.buildEnumMap(ResponseCode.TOKEN_EXPIRE, null);
		}
		User inviter = userService.selectByPrimaryKey(user.getId());
		//判断是否超过额度
		if(new BigDecimal(money).compareTo(inviter.getInvitation_profit()) == 1){
			return ResponseCode.buildCodeMap("21001", "超过可转额度", null);
		}
		//判断金额是不是20的倍数
		Integer changeMoney = Integer.parseInt(money);
		if(changeMoney >= 0 && changeMoney%20 == 0){
			inviter.setInvitation_profit(inviter.getInvitation_profit().subtract(new BigDecimal(money)));
			BigDecimal before = inviter.getAvailableBalance();
			inviter.setAvailableBalance(inviter.getAvailableBalance().add(new BigDecimal(money)));
			userService.updateById(inviter);
			
			try{
				//添加记录
				PredepositLog log = new PredepositLog();
				log.setPd_log_user_id(inviter.getId());
				log.setPd_log_amount(new BigDecimal(money));
				log.setAmount_before(before);
				log.setAmount_after(inviter.getAvailableBalance());
				log.setAddTime(new Date());
				log.setDeleteStatus(0);
				log.setPd_log_info("邀请注册收益转余额");
				log.setPd_op_type("分销结算收益");
				log.setPd_type("可用预存款");
				predepositLogService.saveEntity(log);
			}catch (Exception e) {
				logger.error("UserController >> invProChangeBalance >> Exception:"+ e.getMessage());
			}
			
		}
		return ResponseCode.buildSuccessMap(true);
	}
	
	
	
	

	/**
	 * 下单显示  (随机100个用户 )
	 * @param request
	 * @param response
	 * @return
	 */
	@RequestMapping({ "/userIndex" })
	public Map userIndex(HttpServletRequest request, HttpServletResponse response) {

		//UserDto userDto = SecurityUserHolder.getCurrentUser(request);

		Map params = Maps.newHashMap();
		/*if (userDto!=null) {
			params.put("id_no", userDto.getId());
		}*/
		params.put("deleteStatus", 0);
		params.put("weixin_unionID_is_no", "weixin_unionID_is_no");
		// 总用户数量
		int selectCount = userService.selectCount(params);
		int c = 0;
		int nextInt =0;
		if (selectCount<100) {
			c=1;
		}else{
			c = (int) selectCount / 100;
			Random random = new Random();
			nextInt = random.nextInt(c);
		}
		HashMap result = new HashMap<>();
		// 用户列表
		//List list = new ArrayList();
		List list = (List) redisUtil.get("userIndexList");
		/*result.put("userIndexList", list);
		return ResponseCode.buildSuccessMap(result);*/
		
		if (null == list || list.size() < 1) {
			params.clear();
			params.put("start", nextInt);
			params.put("weixin_unionID_is_no", "weixin_unionID_is_no");
			list = userService.listIndex(params);
			//设置成一天过期
			long oneday=24*60*60;
			redisUtil.set("userIndexList", list,oneday);
			result.put("userIndexList", list);

		} else {
			result.put("userIndexList", list);
		}

		return ResponseCode.buildSuccessMap(result);
	}
	
	/**
	 * 查看用户是否有公众号openid (没有则去鱼易库里查,在没有就提示给前端)
	 * @param request
	 * @param response
	 * @return
	 *//*
	@RequestMapping({ "/buyer/selectWxOpenId" })
	public Map selectWxOpenId(HttpServletRequest request, HttpServletResponse response,
			@RequestBody JSONObject json) {
		HashMap result = new HashMap<>();
		User user = userService.selectByPrimaryKey(SecurityUserHolder.getCurrentUserId(request));
		if(user==null){
			// 用户不存在
			return ResponseCode.buildFailMap("用户不存在", null);
		}
		boolean isfalg=false;
		String openid=user.getWx_open_id();
		//为空则去鱼易数据库查
		
		if(StringUtils.isEmpty(openid)){
			
			JSONObject paramJson = new JSONObject();
			paramJson.put("username", user.getMobile());
			
			String data =  "";
	        try {
	        	// 加密data
				data = AESUtil.getInstance().Encrypt(paramJson.toString(), AESUtil.akk_secret);
			} catch (Exception e) {
				log.error("加密请求参数出错，错误信息"+Exceptions.getStackTraceAsString(e));
			}
	        
	        Map params = new HashMap();
	    	params.put("data", data);
	    	String url = "https://www.fishmq.cn/apply/synchroOpenid";
	        
	    	String result1 = HttpClientUtils.doPostReturn(url, params, "application/json; charset=UTF-8"); //UTF-8
	    	//{"msg":"您的账号未绑定渔易水产科技公众号","code":500}
	    	Map map = (Map)JSON.parse(result1);
	    	Integer code = (Integer)map.get("code");
	    	if(code == 200){
	    		openid=(String) map.get("msg");
	    		isfalg=true;
	    		//将openid 保存进用户表
	    		user.setWx_open_id(openid);
	    		userService.updateById(user);
	    	}
		}
		//如果openid还为空则返回false,需要用户关注公众号
		result.put("isfalg", isfalg);

		return ResponseCode.buildSuccessMap(result);

	}*/
	
	@RequestMapping(value = "/logoff", method = RequestMethod.POST)
	public Map logoff(HttpServletRequest request,@RequestBody JSONObject json){
		UserDto currentUser = SecurityUserHolder.getCurrentUser(request);
		User user = this.userService.selectByPrimaryKey(currentUser.getId());
		
		// 注销用户
		user.setUserName("logoff_" + user.getUserName());
		user.setMobile("logoff_" + user.getMobile());
		user.setStatus(-2);
		user.setWeixin_unionID("logoff_"+user.getWeixin_unionID());
		user.setOpenId("logoff_"+user.getOpenId());
		user.setWx_open_id("logoff_"+user.getWx_open_id());
		user.setDeleteStatus(1);

		// 修改登录信息
		user.setLastLoginDate(new Date());
		user.setLastLoginIp(CommUtil.getIpAddr(request));

		userService.updateById(user);

		// 将token删除
		redisUtil.remove(Globals.ANDROID_LOGIN_MARK + user.getId());

		// 返回结果集
		return ResponseCode.buildSuccessMap(new HashMap<>());
	}
	
}

 @源码地址来源： https://minglisoft.cn/honghu/business.html