Java/src/main/java/com/jeeplus/modules/sys/service/HpUserService.java

/**
 * Copyright &copy; 2015-2020 <a href="http://www.jeeplus.org/">JeePlus</a> All rights reserved.
 */
package com.jeeplus.modules.sys.service;

import com.google.common.collect.Lists;
import com.jeeplus.common.config.Global;
import com.jeeplus.common.json.AjaxJson;
import com.jeeplus.common.oss.OSSClientUtil;
import com.jeeplus.common.sms.SMS253Utils;
import com.jeeplus.common.sms.SMSConst;
import com.jeeplus.common.utils.CacheUtils;
import com.jeeplus.common.utils.StringUtils;
import com.jeeplus.common.utils.api.OtherException;
import com.jeeplus.core.persistence.Page;
import com.jeeplus.core.service.CrudService;
import com.jeeplus.modules.dpenterprise.entity.DpEnterpriseAuthentication;
import com.jeeplus.modules.dpenterprise.service.DpEnterpriseAuthenticationService;
import com.jeeplus.modules.dpposition.service.DpPositionService;
import com.jeeplus.modules.hpmessage.entity.HpMessage;
import com.jeeplus.modules.hpmessage.service.HpMessageService;
import com.jeeplus.modules.hpuser.entity.HpApplyPosition;
import com.jeeplus.modules.hpuser.entity.HpResume;
import com.jeeplus.modules.hpuser.entity.HpResumeWorkExperience;
import com.jeeplus.modules.hpuser.entity.HpUserContact;
import com.jeeplus.modules.hpuser.mapper.HpApplyPositionMapper;
import com.jeeplus.modules.hpuser.service.HpApplyPositionService;
import com.jeeplus.modules.hpuser.service.HpResumeService;
import com.jeeplus.modules.hpuser.service.HpResumeWorkExperienceService;
import com.jeeplus.modules.hpuser.service.HpUserContactService;
import com.jeeplus.modules.sys.entity.HpMember;
import com.jeeplus.modules.sys.entity.HpUser;
import com.jeeplus.modules.sys.entity.WxInformation;
import com.jeeplus.modules.sys.mapper.HpUserMapper;
import com.jeeplus.modules.sys.wxUtils.*;
import com.jeeplus.modules.tools.utils.TwoDimensionCode;
import com.jeeplus.modules.utils.AppLoginsEnum;
import net.sf.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;

import javax.imageio.ImageIO;
import javax.imageio.stream.ImageOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;

/**
 * 开心用户Service
 *
 * @author zwq
 * @version 2019-03-20
 */
@Service
@Transactional(readOnly = true)
public class HpUserService extends CrudService<HpUserMapper, HpUser> {

    @Autowired
    private HpResumeWorkExperienceService hpResumeWorkExperienceService;
    @Autowired
    private HpResumeService hpResumeService;
    @Autowired
    private HpUserContactService hpUserContactService;
    @Autowired
    private HpMessageService hpMessageService;
    @Autowired
    private WxInformationService wxInformationService;
    @Autowired
    private DpEnterpriseAuthenticationService dpEnterpriseAuthenticationService;
    @Autowired
    private HpMemberService hpMemberService;
    @Autowired
    private HpApplyPositionMapper hpApplyPositionMapper;

    private static final String APP_USER = "appUser";
    private static final String APP_USERMSG = "appUserMsg";
    private static final String MINA_USERMSG = "minaUserMsg";

    public HpUser get(String id) {
        return super.get(id);
    }

    public List<HpUser> findList(HpUser hpUser) {
        return super.findList(hpUser);
    }

    public Page<HpUser> findPage(Page<HpUser> page, HpUser hpUser) {
        return super.findPage(page, hpUser);
    }

    @Transactional(readOnly = false)
    public void save(HpUser hpUser) {
        super.save(hpUser);
    }

    @Transactional(readOnly = false)
    public void saveChat(HpUser hpUser) {
        super.save(hpUser);
        HpUserContact hpUserContact = new HpUserContact();
        hpUserContact.setHpUser(hpUser);
        hpUserContact.setContactContent(hpUser.getContactContent());
        hpUserContact.setContactStatus(hpUser.getContactStatus());
        hpUserContact.setContactTime(hpUser.getContactTime());
        hpUserContact.setContactUser(hpUser.getContactPerson());
        hpUserContactService.save(hpUserContact);
    }

    @Transactional(readOnly = false)
    public void delete(HpUser hpUser) {
        super.delete(hpUser);
    }

    public List<HpUser> findByUnionId(String unionId) {
        return mapper.findByUnionId(unionId);
    }

    private List<HpUser> findByWxOpenId(String openId) {
        return mapper.findByWxOpenId(openId);
    }

    private List<HpUser> findByMinaOpenId(String openId) {
        return mapper.findByMinaOpenId(openId);
    }

    private List<HpUser> findByPhone(HpUser hpUser) {
        return mapper.findByPhone(hpUser);
    }


    /**
     * 注册发送手机验证码
     */
    public Map<String, Object> sendMobileCode(HashMap<String, String> hashMap) throws OtherException {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String mobile = hashMap.get("phone");
        if (StringUtils.isNotEmpty(mobile)) {
            try {
                Random random = new Random();
                String code = "";
                for (int i = 0; i < 6; i++) {
                    code += random.nextInt(10);
                }
                HashMap<String, String> hashMaps = new HashMap<String, String>();
                hashMaps.put("phone", mobile);// 手机号码
                hashMaps.put("msg", "亲爱的用户，您的验证码是" + code + "，如非本人操作请忽略！");
                returnMap = SMS253Utils.sendSms(hashMaps);
                if (SMSConst.OKCode.equals(returnMap.get("success"))) {
                    returnMap.put("code", code);
                    //将获取到的验证码存到redis中
                    CacheUtils.put(APP_USER, mobile, code);
                }
            } catch (Exception e) {
                throw new OtherException("10000", "系统内部错误！");
            }
        }
        return returnMap;
    }

    /**
     * 手机号登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> getLoginApp(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String mobile = requestMap.get("phone");
        String clientId = requestMap.get("client_id");
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        hpUser.setPhone(mobile);
        //查询是否存在本条数据
        List<HpUser> hpUserList = this.findByPhone(hpUser);
        //如果存在则更新
        if (hpUserList != null && hpUserList.size() > 0) {
            hpUser1 = hpUserList.get(0);
            hpUser1.setLoginTime(new Date());
            hpUser1.setClientId(clientId);
            //如果登录方式不包含app，则添加
            if (!hpUser1.getLoginType().contains(AppLoginsEnum.APP.getType())) {
                String loginType = hpUser1.getLoginType() + "," + AppLoginsEnum.APP.getType();
                hpUser1.setLoginType(loginType);
            }
            if (StringUtils.isBlank(hpUser1.getUserToken())) {
                //用户token作为请求的标准
                long t1 = System.currentTimeMillis();
                String timestamp = String.valueOf(t1);
                String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
                hpUser1.setUserToken(user_token);
            }
            this.save(hpUser1);
            returnMap.put("hpUser", hpUser1);
        } else {
            hpUser.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_APP.getRegistType());
            hpUser.setLoginType(AppLoginsEnum.APP.getType());
            hpUser.setLoginTime(new Date());
            hpUser.setAuthenticationStatus(0);
            hpUser.setContactStatus(0);
            hpUser.setUserType("0");
            hpUser.setClientId(clientId);
            hpUser.setUseFlag(false);
            this.save(hpUser);
            hpUser1 = this.get(hpUser.getId());
            //用户token作为请求的标准
            long t1 = System.currentTimeMillis();
            String timestamp = String.valueOf(t1);
            String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
            hpUser1.setUserToken(user_token);
            String qrcode = makeUserQrCode(hpUser1);
            hpUser1.setQrCode(qrcode);
            this.save(hpUser1);
            returnMap.put("hpUser", hpUser1);
        }
        //返回用户简历信息
        List<HpResume> hpResumeList = hpResumeService.findListByUserId(hpUser1.getId());
        if (hpResumeList != null && hpResumeList.size() > 0) {
            HpResume hpResume = hpResumeList.get(0);
            List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
            hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
            if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
            }
            returnMap.put("userResume", hpResume);
        }
        DpEnterpriseAuthentication dpEnterpriseAuthentication = dpEnterpriseAuthenticationService.findCompanyByuserId(hpUser1.getId());
        returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
        //清除redis缓存的验证码
        CacheUtils.remove(APP_USER, mobile);
        return returnMap;
    }

    /**
     * app微信授权登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> wxLogin(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        HpUser hpUser = new HpUser();
        String code = requestMap.get("code");
        String clientId = requestMap.get("client_id");
        //只有一个code的时候，获取用户凭证
        JSONObject result = TokenUtil.getAccessToken(code);
        String openId = result.getString("openid");
        String accessToken = result.getString("access_token");
        String unionId = result.getString("unionid");
        String refreshToken = result.getString("refresh_token");
        int access_token_endtime = (int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE;
        logger.info("time======" + access_token_endtime);
        if (StringUtils.isNotBlank(openId)) {
            //查询数据库中是否存在此条数据,同一个用户在同一平台下unionId相同
            List<HpUser> list = Lists.newArrayList();
            if (StringUtils.isNotBlank(unionId)) {
                list = this.findByUnionId(unionId);
            }
            //查询数据库是否存在相同的wxopenid
            List<HpUser> list1 = this.findByWxOpenId(openId);
            //已存在用户
            if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                if (list != null && list.size() > 0) {
                    hpUser = list.get(0);
                    if (StringUtils.isBlank(hpUser.getWxOpenid())) {
                        hpUser.setWxOpenid(openId);
                    }
                } else {
                    hpUser = list1.get(0);
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                //用户存在手机号
                if (StringUtils.isNotBlank(hpUser.getPhone())) {
                    //如果登录方式不包含微信授权，则添加
                    if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                        String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                        hpUser.setLoginType(loginType);
                    }
                    if (StringUtils.isBlank(hpUser.getUserToken())) {
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                        hpUser.setUserToken(user_token);
                    }
                    if (StringUtils.isBlank(hpUser.getUserType())) {
                        hpUser.setUserType("0");
                    }
                    //通过openid和用户access_token获取用户信息
                    JSONObject wxuser = TokenUtil.getWxuser(accessToken, openId);
                    // 获取对象中的数据
                    String nickname = wxuser.getString("nickname");
                    String sex = wxuser.getString("sex");
                    String avatar = wxuser.getString("headimgurl");
                    String province = wxuser.getString("province");
                    String city = wxuser.getString("city");
                    String country = wxuser.getString("country");
                    hpUser.setLoginTime(new Date());
                    hpUser.setNickName(nickname);
                    hpUser.setGender(sex);
                    hpUser.setHeadImgUrl(avatar);
                    hpUser.setProvince(province);
                    hpUser.setCity(city);
                    hpUser.setCoutry(country);
                    hpUser.setClientId(clientId);
                    hpUser.setAccessToken(accessToken);
                    hpUser.setRefreshToken(refreshToken);
                    hpUser.setAccessTokenEndtime(access_token_endtime);
                    this.save(hpUser);
                    returnMap.put("hpUser", hpUser);
                    //返回用户简历信息
                    List<HpResume> hpResumeList = hpResumeService.findListByUserId(hpUser.getId());
                    if (hpResumeList != null && hpResumeList.size() > 0) {
                        HpResume hpResume = hpResumeList.get(0);
                        List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                        hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                        if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                            hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                        }
                        returnMap.put("userResume", hpResume);
                    }
                    DpEnterpriseAuthentication dpEnterpriseAuthentication = dpEnterpriseAuthenticationService.findCompanyByuserId(hpUser.getId());
                    returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
                } else {
                    CacheUtils.put(APP_USERMSG, unionId + openId, result);
                    returnMap.put("success", "1014");
                    returnMap.put("openId", openId);
                    returnMap.put("unionId", unionId);
                }
            } else {
                //新增是没有手机号的，不去判断
                //将授权信息暂存redis
                CacheUtils.put(APP_USERMSG, unionId + openId, result);
                returnMap.put("success", "1014");
                returnMap.put("openId", openId);
                returnMap.put("unionId", unionId);
            }
        } else {
            returnMap.put("success", "1010");
        }
        return returnMap;
    }

    /**
     * app微信授权登录后绑定手机号
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> wxPhone(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        String phone = requestMap.get("phone");
        String clientId = requestMap.get("client_id");
        String openId = requestMap.get("openId");
        String unionId = requestMap.get("unionId");

        if (StringUtils.isNotBlank(openId)) {
            //查询数据库中是否存在此条数据,同一个用户在同一平台下unionId相同
            List<HpUser> list = this.findByUnionId(unionId);
            //查询数据库是否存在相同的wxopenid
            List<HpUser> list1 = this.findByWxOpenId(openId);
            //已存在用户
            if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                if (list != null && list.size() > 0) {
                    hpUser = list.get(0);
                    if (StringUtils.isBlank(hpUser.getWxOpenid())) {
                        hpUser.setWxOpenid(openId);
                    }
                } else {
                    hpUser = list1.get(0);
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                if (StringUtils.isNotBlank(phone)) {
                    hpUser.setPhone(phone);
                    //判断手机号是否存在
                    List<HpUser> hpUserList = this.findByPhone(hpUser);
                    if (hpUserList != null && hpUserList.size() > 0) {
                        returnMap.put("success", "1007");
                        return returnMap;
                    }
                }
                //如果登录方式不包含微信授权，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                    String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                    hpUser.setLoginType(loginType);
                }
                if (StringUtils.isBlank(hpUser.getUserToken())) {
                    //用户token作为请求的标准
                    long t1 = System.currentTimeMillis();
                    String timestamp = String.valueOf(t1);
                    String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                    hpUser.setUserToken(user_token);
                }
                if (StringUtils.isBlank(hpUser.getUserType())) {
                    hpUser.setUserType("0");
                }
            } else {
                //绑不绑定手机号
                //绑定的情况
                if (StringUtils.isNotBlank(phone)) {
                    //判断手机号是否已存在
                    hpUser.setPhone(phone);
                    //查询是否存在本条数据
                    List<HpUser> hpUserList = this.findByPhone(hpUser);
                    if (hpUserList != null && hpUserList.size() > 0) {
                        //手机号已存在
                        hpUser = hpUserList.get(0);
                        //判断这条数据是否存在opneid或者unionid
                        if (StringUtils.isNotBlank(hpUser.getUnionid()) && StringUtils.isNotBlank(hpUser.getWxOpenid())) {
                            if (!openId.equals(hpUser.getWxOpenid()) && !unionId.equals(hpUser.getUnionid())) {
                                //如果opneid和unionid不相同，则手机号已被其他账号绑定
                                returnMap.put("success", "1007");
                                return returnMap;
                            }
                        }
                        //如果登录方式不包含微信授权，则添加
                        if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                            String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                            hpUser.setLoginType(loginType);
                        }
                        if (StringUtils.isBlank(hpUser.getUserToken())) {
                            //用户token作为请求的标准
                            long t1 = System.currentTimeMillis();
                            String timestamp = String.valueOf(t1);
                            String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                            hpUser.setUserToken(user_token);
                        }
                        if (StringUtils.isBlank(hpUser.getUserType())) {
                            hpUser.setUserType("0");
                        }
                        hpUser.setUnionid(unionId);
                        hpUser.setWxOpenid(openId);
                    } else {
                        //新用户
                        hpUser1.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_WX_AUTH.getRegistType());
                        hpUser1.setLoginType(AppLoginsEnum.WX_AUTH.getType());
                        hpUser1.setWxOpenid(openId);
                        hpUser1.setUnionid(unionId);
                        hpUser1.setAuthenticationStatus(0);
                        hpUser1.setContactStatus(0);
                        hpUser1.setUserType("0");
                        hpUser1.setUseFlag(false);
                        this.save(hpUser1);
                        hpUser = this.get(hpUser1.getId());
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                        hpUser.setUserToken(user_token);
                        String qrcode = makeUserQrCode(hpUser);
                        hpUser.setQrCode(qrcode);
                    }
                } else {
                    //新用户
                    hpUser1.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_WX_AUTH.getRegistType());
                    hpUser1.setLoginType(AppLoginsEnum.WX_AUTH.getType());
                    hpUser1.setWxOpenid(openId);
                    hpUser1.setUnionid(unionId);
                    hpUser1.setAuthenticationStatus(0);
                    hpUser1.setContactStatus(0);
                    hpUser1.setUserType("0");
                    hpUser1.setUseFlag(false);
                    this.save(hpUser1);
                    hpUser = this.get(hpUser1.getId());
                    //用户token作为请求的标准
                    long t1 = System.currentTimeMillis();
                    String timestamp = String.valueOf(t1);
                    String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                    hpUser.setUserToken(user_token);
                    String qrcode = makeUserQrCode(hpUser);
                    hpUser.setQrCode(qrcode);
                }
            }
            JSONObject result = (JSONObject) CacheUtils.get(APP_USERMSG, unionId + openId);
            String accessToken = result.getString("access_token");
            String refreshToken = result.getString("refresh_token");
            int access_token_endtime = (int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE;
            //通过openid和用户access_token获取用户信息
            JSONObject wxuser = TokenUtil.getWxuser(accessToken, openId);
            // 获取对象中的数据
            String nickname = wxuser.getString("nickname");
            String sex = wxuser.getString("sex");
            String avatar = wxuser.getString("headimgurl");
            String province = wxuser.getString("province");
            String city = wxuser.getString("city");
            String country = wxuser.getString("country");
            if (StringUtils.isNotBlank(phone)) {
                hpUser.setPhone(phone);
            }
            hpUser.setLoginTime(new Date());
            hpUser.setNickName(nickname);
            hpUser.setGender(sex);
            hpUser.setHeadImgUrl(avatar);
            hpUser.setProvince(province);
            hpUser.setCity(city);
            hpUser.setCoutry(country);
            hpUser.setClientId(clientId);
            hpUser.setAccessToken(accessToken);
            hpUser.setRefreshToken(refreshToken);
            hpUser.setAccessTokenEndtime(access_token_endtime);
            this.save(hpUser);
            returnMap.put("hpUser", hpUser);
            //清除微信授权时缓存的用户授权信息
            CacheUtils.remove(APP_USERMSG, unionId + openId);
            //清除redis缓存的验证码
            CacheUtils.remove(APP_USER, phone);
            //返回用户简历信息
            List<HpResume> hpResumeList = hpResumeService.findListByUserId(hpUser.getId());
            if (hpResumeList != null && hpResumeList.size() > 0) {
                HpResume hpResume = hpResumeList.get(0);
                List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                    hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                }
                returnMap.put("userResume", hpResume);
            }
            DpEnterpriseAuthentication dpEnterpriseAuthentication = dpEnterpriseAuthenticationService.findCompanyByuserId(hpUser.getId());
            returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
        } else {
            returnMap.put("success", "1010");
        }
        return returnMap;
    }

    /**
     * 日常获取app微信授权用户信息
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> getUserInfo(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = requestMap.get("user_id");
        String userToken = requestMap.get("user_token");
        String loginType = requestMap.get("login_type");   //手机登录标志（默认:1）
        JSONObject json_object = new JSONObject();
        String errcode = "";
        //验证用户合法性
        if (TokenUtil.validateToken(userId, userToken)) {
            //日常获取用户access_token
            HpUser hpUser1 = this.get(userId);
            //手机用户
            if (StringUtils.isNotBlank(loginType)) {
                if ("1".equals(loginType)) {
                    returnMap.put("hpUser", hpUser1);
                    return returnMap;
                }
            }
            if (StringUtils.isBlank(hpUser1.getUnionid()) && StringUtils.isBlank(hpUser1.getWxOpenid())) {
                //手机用户
                returnMap.put("hpUser", hpUser1);
                return returnMap;
            }
            HpUser hpUser = this.get(userId);
            json_object = TokenUtil.getDayAccessToken(userId);
            //不为空，则为微信授权
            if (json_object != null) {
                //判断是否存在errcode键
                if (json_object.containsKey("errcode")) {
                    errcode = json_object.getString("errcode");
                }
                //当刷新access_token如果存在errcode且不等于0，则认为refreshToken已过期
                if (StringUtils.isNotBlank(errcode) && !"0".equals(errcode)) {
                    returnMap.put("success", "1013");
                    return returnMap;
                } else {
                    //获取用户最新信息
                    String accessToken = json_object.getString("access_token");
                    JSONObject wxuser = TokenUtil.getWxuser(accessToken, userId);
                    //更新用户access_token信息
                    String nickname = wxuser.getString("nickname");
                    String sex = wxuser.getString("sex");
                    String avatar = wxuser.getString("headimgurl");
                    String province = wxuser.getString("province");
                    String city = wxuser.getString("city");
                    String country = wxuser.getString("country");
                    hpUser.setNickName(nickname);
                    hpUser.setGender(sex);
                    hpUser.setHeadImgUrl(avatar);
                    hpUser.setProvince(province);
                    hpUser.setCity(city);
                    hpUser.setCoutry(country);
                    hpUser.setAccessToken(json_object.getString("access_token"));
                    //如果包含refresh_token，说明是刷新了access_token
                    if (json_object.containsKey("refresh_token")) {
                        hpUser.setRefreshToken(json_object.getString("refresh_token"));
                        hpUser.setAccessTokenEndtime((int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE);
                    }
                    this.save(hpUser);
                }
            }
            returnMap.put("hpUser", hpUser);
        } else {
            returnMap.put("success", "1004");
        }
        return returnMap;
    }


    /********************小程序授权************************/

    /**
     * 小程序授权登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> minaLogin(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String code = requestMap.get("code");
        //通过小程序code获取用户openId
        JSONObject result = TokenUtil.minaGetSession(code);
        //返回成功时，不返回errcode
        if (result != null && !result.containsKey("errcode") && result.containsKey("openid")) {
            String openId = result.getString("openid");
            String sessionKey = result.getString("session_key");
            returnMap.put("openId", openId);
            returnMap.put("sessionKey", sessionKey);
        } else {
            returnMap.put("success", "1005");
            returnMap.put("errmsg", result.getString("errmsg"));
        }
        return returnMap;
    }

    /**
     * 保存小程序用户信息
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveMinaInfo(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String encryptedData = requestMap.get("encryptedData");
        String iv = requestMap.get("iv");
        String openId = requestMap.get("openid");
        String sessionKey = requestMap.get("session_key");
        if (StringUtils.isBlank(encryptedData) || StringUtils.isBlank(iv)) {
            returnMap.put("success", 1005);
            return returnMap;
        }
        //微信加密信息：解密，获取用户信息
        JSONObject json = this.decodeWxData(encryptedData, iv, sessionKey);
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        if (json != null && !json.containsKey("errcode")) {
            String unionId = json.getString("unionId");
            logger.info("openid===============================" + openId);
            logger.info("unioniD===============================" + unionId);
            if (StringUtils.isNotBlank(openId)) {
                //获取小程序accsee_token
//                String token = getMinaAccessToken();
                //查询数据库中是否存在此条数据，同一个用户在同一平台下unionId相同
                List<HpUser> list = new ArrayList<>();
                if (StringUtils.isNotBlank(unionId)) {
                    list = this.findByUnionId(unionId);
                }
                //查询数据库是否存在相同的minaopenid
                List<HpUser> list1 = this.findByMinaOpenId(openId);
                //如果存在
                if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                    if (list != null && list.size() > 0) {
                        hpUser1 = list.get(0);
                        if (StringUtils.isBlank(hpUser1.getMinaOpenid())) {
                            hpUser1.setMinaOpenid(openId);
                        }
                    } else {
                        hpUser1 = list1.get(0);
                        if (StringUtils.isBlank(hpUser1.getUnionid())) {
                            hpUser1.setUnionid(unionId);
                        }
                    }
                    //如果登录方式不包含小程序授权，则添加
                    if (!hpUser1.getLoginType().contains(AppLoginsEnum.MINA.getType())) {
                        String loginType = hpUser1.getLoginType() + "," + AppLoginsEnum.MINA.getType();
                        hpUser1.setLoginType(loginType);
                    }
                    if (StringUtils.isBlank(hpUser1.getUserToken())) {
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
                        hpUser1.setUserToken(user_token);
                    }
                    if (StringUtils.isBlank(hpUser1.getUserType())) {
                        hpUser1.setUserType("0");
                    }
                    //sessionkey需要刷新
                    hpUser1.setMinaSessionKey(sessionKey);
                } else {
                    hpUser.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_MINA.getRegistType());
                    hpUser.setLoginType(AppLoginsEnum.MINA.getType());
                    hpUser.setAuthenticationStatus(0);
                    hpUser.setContactStatus(0);
                    hpUser.setUserType("0");
                    hpUser.setUseFlag(false);
                    hpUser.setMinaOpenid(openId);
                    hpUser.setMinaSessionKey(sessionKey);
                    hpUser.setUnionid(unionId);
                    this.save(hpUser);
                    hpUser1 = this.get(hpUser.getId());
                    //用户token作为请求的标准
                    long t1 = System.currentTimeMillis();
                    String timestamp = String.valueOf(t1);
                    String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                    hpUser1.setUserToken(user_token);
                    String qrcode = makeUserQrCode(hpUser1);
                    hpUser1.setQrCode(qrcode);
                }
                String nickName = json.getString("nickName");
                String gender = json.getString("gender");
                String avatarUrl = json.getString("avatarUrl");
                String country = json.getString("country");
                String province = json.getString("province");
                String city = json.getString("city");
                hpUser1.setNickName(nickName);
                hpUser1.setGender(gender);
                hpUser1.setHeadImgUrl(avatarUrl);
                hpUser1.setCoutry(country);
                hpUser1.setProvince(province);
                hpUser1.setCity(city);
                hpUser1.setLoginTime(new Date());
                List<HpResume> hpResumeList = hpResumeService.findListByUserId(hpUser1.getId());
                if (hpResumeList != null && hpResumeList.size() > 0) {
                    hpUser1.setBirthYear(hpResumeList.get(0).getBirthYear());
                }
                this.save(hpUser1);
                returnMap.put("hpUser", hpUser1);
            } else {
                returnMap.put("success", "1010");
            }
        }
        return returnMap;
    }

    /**
     * 检查小程序用户手机号存不存在
     *
     * @param requestMap
     * @return
     */
    public Map<String, Object> checkPhone(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = requestMap.get("user_id");
        String userToken = requestMap.get("user_token");
        //验证用户合法性
        if (TokenUtil.validateToken(userId, userToken)) {
            HpUser hpUser = this.get(userId);
            //用户没有手机号
            if (StringUtils.isBlank(hpUser.getPhone())) {
                returnMap.put("success", "1020");
            }
        } else {
            returnMap.put("success", "1004");
        }
        return returnMap;
    }

    /**
     * 保存小程序用户手机号
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveMinaPhone(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String encryptedData = requestMap.get("encryptedData");
        String iv = requestMap.get("iv");
        String userId = requestMap.get("user_id");
        String userToken = requestMap.get("user_token");
        //验证用户合法性
        if (TokenUtil.validateToken(userId, userToken)) {
            if (StringUtils.isBlank(encryptedData) || StringUtils.isBlank(iv)) {
                returnMap.put("success", 1005);
                return returnMap;
            }
            //微信加密信息：解密
            JSONObject json = this.decodeWxDataFormUserId(encryptedData, iv, userId);
            HpUser hpUser = this.get(userId);
            if (json != null && !json.containsKey("errcode")) {
                String phoneNumber = json.getString("phoneNumber");
                hpUser.setPhone(phoneNumber);
                //查询是否存在本条数据
                List<HpUser> hpUserList = this.findByPhone(hpUser);
                if (hpUserList != null && hpUserList.size() > 0) {
                    //手机号已存在
                    HpUser hpUser1 = hpUserList.get(0);
                    //判断这条数据是否存在opneid或者unionid
                    if (!hpUser.getMinaOpenid().equals(hpUser1.getMinaOpenid()) && !hpUser.getUnionid().equals(hpUser1.getUnionid())) {
                        //如果opneid和unionid不相同，则手机号已被其他账号绑定
                        returnMap.put("success", "1007");
                        return returnMap;
                    }
                }
                this.save(hpUser);
            }
            returnMap.put("hpUser", hpUser);
        } else {
            returnMap.put("success", "1004");
        }
        return returnMap;
    }

    /**
     * 小程序上传图片
     *
     * @param request
     * @return
     */
    public Map<String, Object> saveImgUp(HttpServletRequest request) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = request.getParameter("user_id");
        String userToken = request.getParameter("user_token");
        //验证用户合法性
        if (TokenUtil.validateToken(userId, userToken)) {
            String type = request.getParameter("up_type");
            HpUser hpUser = this.get(userId);
            String path = "/hpuser/index";
            if (StringUtils.isNotBlank(type)) {
                switch (type) {
                    case "0":
                        //基本资料
                        path = "/hpuser/resume";
                        break;
                    case "1":
                        //身份证正面
                        path = "/hpuser/idcard/front";
                        break;
                    case "2":
                        //身份证反面
                        path = "/hpuser/idcard/back";
                        break;
                    case "3":
                        //手持身份证
                        path = "/hpuser/idcard/hold";
                        break;
                }
            }
            //头像上传调用
            try {
                if (request instanceof MultipartHttpServletRequest) {
                    AjaxJson j = webupload(request, "file", hpUser, path);
                    if (j.isSuccess()) {
                        returnMap.put("imgUrl", j.getBody().get("url"));
                    } else {
                        logger.info("wpload========" + j.getMsg());
                    }
                } else {
                    logger.info("wpnonono========没有文件上传");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        } else {
            returnMap.put("success", "1004");
        }
        return returnMap;
    }

    /**
     * 微信加密信息：解密
     *
     * @param encryptedData
     * @param iv
     * @param sessionKey
     * @return
     */
    private JSONObject decodeWxData(String encryptedData, String iv, String sessionKey) {
        JSONObject jsonObject = null;
        if (StringUtils.isNotBlank(sessionKey)) {
            jsonObject = Util.decodeWxData(encryptedData, iv, sessionKey);
        }
        return jsonObject;
    }

    /**
     * 微信加密信息：解密
     *
     * @param encryptedData
     * @param iv
     * @param userId
     * @return
     */
    private JSONObject decodeWxDataFormUserId(String encryptedData, String iv, String userId) {
        String sessionKey = this.getSessionKey(userId);
        JSONObject jsonObject = null;
        if (StringUtils.isNotBlank(sessionKey)) {
            jsonObject = Util.decodeWxData(encryptedData, iv, sessionKey);
        }
        return jsonObject;
    }

    /**
     * 获取小程序用户sessionkey
     *
     * @param userId
     * @return
     */
    private String getSessionKey(String userId) {
        return mapper.getSessionKey(userId);
    }

    /**
     * 认证用户
     *
     * @param hpUser
     */
    @Transactional(readOnly = false)
    public void approve(HpUser hpUser) {
        mapper.approve(hpUser);
        //推送消息
        HpMessage hpMessage = new HpMessage();
        hpMessage.setHpUser(hpUser);
        String message = "";
        if (hpUser.getAuthenticationStatus() == 3) {
            message = "已通过";
        } else if (hpUser.getAuthenticationStatus() == 2) {
            message = "未通过";
        }
        hpMessage.setContent("您的身份审核" + message);
        hpMessage.setIsRead(false);
        hpMessage.setType(1);
        hpMessage.setMessageTime(new Date());
        hpMessageService.save(hpMessage);
    }

    @Transactional(readOnly = false)
    public void deleteByLogic(HpUser hpUser) {
        mapper.deleteByLogic(hpUser);
    }


    /**
     * 生成用户二维码
     *
     * @param hpUser
     * @return
     */
    private String makeUserQrCode(HpUser hpUser) {
        //生成用户二维码，使用登录名
        String realPath = Global.USERFILES_BASE_URL + "/qrcode/appuser/" + hpUser.getId() + "/";
        String name = hpUser.getId() + ".png"; //encoderImgId此处二维码的图片名
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("id", hpUser.getId());
        String content = jsonObject.toString();
        //执行生成二维码
        BufferedImage bufImg = TwoDimensionCode.qRCodeCommon(content, "png", 2);
        bufImg.flush();
        ByteArrayOutputStream bs = new ByteArrayOutputStream();
        ImageOutputStream imOut;
        InputStream is = null;
        try {
            imOut = ImageIO.createImageOutputStream(bs);
            ImageIO.write(bufImg, "png", imOut);
            is = new ByteArrayInputStream(bs.toByteArray());
        } catch (IOException e) {
            e.printStackTrace();
        }
        //保存到oss
        OSSClientUtil ossUtil = new OSSClientUtil();
        ossUtil.uploadFile2OSS(is, realPath, name);
        return "/" + realPath + name;
    }

    /**
     * 获取小程序全局Access_Token验证凭证
     *
     * @return
     */
    @Transactional(readOnly = false)
    public String getMinaAccessToken() {
        String url = Constants.ACCESS_TOKEN_URL.replace("APPID", WxAppParamsEnum.PARAMS_APPLETS_JOB.getAppId())
                .replace("APPSECRET", WxAppParamsEnum.PARAMS_APPLETS_JOB.getAppSecret());
        JSONObject json_object = null;
        WxInformation wxInformation = new WxInformation();
        List<WxInformation> wxInformationList = wxInformationService.findList(wxInformation);
        //如果已经存在小程序授权信息
        if (wxInformationList != null && wxInformationList.size() > 0) {
            WxInformation wxInformation1 = wxInformationList.get(0);
            int access_token_endtime = wxInformation1.getAccessTokenTime();
            //如果授权access_token过期,则重新获取
            if ((int) (System.currentTimeMillis() / 1000) >= access_token_endtime) {
                json_object = WxCommonUtil.httpsRequest(url, "GET", null);
                //并更新微信授权信息
                String token = json_object.getString("access_token");
                wxInformation1.setAccessToken(token);
                //access_token的到期时间（当前时间+2小时）
                wxInformation1.setAccessTokenTime((int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE);
                wxInformationService.save(wxInformation1);
            }
            return wxInformation1.getAccessToken();
        }
        //新增
        json_object = WxCommonUtil.httpsRequest(url, "GET", null);
        if (json_object != null) {
            String token = json_object.getString("access_token");
            //保存微信授权信息
            wxInformation.setAccessToken(token);
            //access_token的到期时间（当前时间+2小时）
            wxInformation.setAccessTokenTime((int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE);
            wxInformationService.save(wxInformation);
            return token;
        }
        return null;
    }

    /**
     * 小程序上传图片
     *
     * @param request
     * @param param
     * @param hpUser
     * @param uploadPath
     * @return
     * @throws IllegalStateException
     * @throws IOException
     */
    public AjaxJson webupload(HttpServletRequest request, String param, HpUser hpUser, String uploadPath) throws IllegalStateException, IOException {
        AjaxJson j = new AjaxJson();
        //创建一个通用的多部分解析器.
        CommonsMultipartResolver commonsMultipartResolver = new CommonsMultipartResolver(request.getSession().getServletContext());
        //设置编码
        commonsMultipartResolver.setDefaultEncoding("utf-8");
        //判断 request 是否有文件上传,即多部分请求（multipart/form-data类型判定）
        if (commonsMultipartResolver.isMultipart(request)) {
            try {
                MultipartHttpServletRequest mulReq = (MultipartHttpServletRequest) request;
                MultipartFile file = mulReq.getFile(param);
                if (file == null) {
                    j.setMsg("上传照片为空。");
                    j.setSuccess(false);
                    return j;
                }
                OSSClientUtil ossUtil = new OSSClientUtil();
                //获取当前年月
                Calendar cal = Calendar.getInstance();
                int year = cal.get(Calendar.YEAR);
                int month = cal.get(Calendar.MONTH) + 1;
                String fileDir = Global.USERFILES_BASE_URL + uploadPath + "/" + hpUser.getId() + "/" + year + "/" + month + "/";
                // 判断文件是否为空
                if (!file.isEmpty()) {
                    String filePath = ossUtil.uploadImg2OSS(file, fileDir);
                    logger.info("lu" + filePath);
                    j.put("url", filePath);
                    j.setMsg("上传成功");
                    j.setSuccess(true);
                }
            } catch (Exception e) {
                j.setMsg("上传失败" + e.getMessage());
                j.setSuccess(false);
                logger.error(e.getMessage());
            }
        } else {
            j.setMsg("上传照片不能为空。");
            j.setSuccess(false);
        }
        return j;
    }

    public Page<HpUser> findUserPage(Page<HpUser> hpUserPage, HpUser hpUser) {
        dataRuleFilter(hpUser);
        hpUser.setPage(hpUserPage);
        hpUserPage.setList(mapper.findUserList(hpUser));
        return hpUserPage;
    }


    /**=========================新版登录接口===============================================*/

    /**
     * 手机号登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> getLoginApp_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String mobile = requestMap.get("phone");
        String clientId = requestMap.get("client_id");
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        String userIds = ""; //废弃的userid集
        hpUser.setPhone(mobile);
        //查询是否存在本条数据
        List<HpUser> hpUserList = this.findByPhone_new(hpUser);
        //如果存在则更新
        if (hpUserList != null && hpUserList.size() > 0) {
            //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
            List list = new ArrayList();
            if (hpUserList.size() > 1) {
                for (int i = 0; i < hpUserList.size(); i++) {
                    Map map = getUserLists(hpUserList.get(i));
                    HpResume hpResume = (HpResume) map.get("hpResume");
                    //以简历是否存在作为判断该账号下是否存在数据的标准
                    if (hpResume == null) {
                        //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                        if (i == 0) {
                            HpUser hpUserOth = hpUserList.get(1);
                            HpUser hpUserOld = hpUserList.get(0);
                            hpUser1 = changeHpUserData(hpUserOth, hpUserOld);
                            userIds = hpUserOld.getId();
                        } else {
                            HpUser hpUserOth = hpUserList.get(0);
                            HpUser hpUserOld = hpUserList.get(1);
                            hpUser1 = changeHpUserData(hpUserOth, hpUserOld);
                            userIds = hpUserOld.getId();
                        }
                        break;
                    } else {
                        list.add(map);
                    }
                }

            } else {
                hpUser1 = hpUserList.get(0);
            }
            //如果数据list大小相同，则存在重复
            if (list.size() == hpUserList.size()) {
                returnMap.put("userList", list);
                returnMap.put("success", "2009");
                return returnMap;
            }
            hpUser1.setLoginTime(new Date());
            hpUser1.setClientId(clientId);
            //如果登录方式不包含app，则添加
            if (!hpUser1.getLoginType().contains(AppLoginsEnum.APP.getType())) {
                String loginType = hpUser1.getLoginType() + "," + AppLoginsEnum.APP.getType();
                hpUser1.setLoginType(loginType);
            }
            if (StringUtils.isBlank(hpUser1.getUserToken())) {
                //用户token作为请求的标准
                long t1 = System.currentTimeMillis();
                String timestamp = String.valueOf(t1);
                String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
                hpUser1.setUserToken(user_token);
            }
            this.save(hpUser1);
        } else {
            hpUser.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_APP.getRegistType());
            hpUser.setLoginType(AppLoginsEnum.APP.getType());
            hpUser.setLoginTime(new Date());
            hpUser.setAuthenticationStatus(0);
            hpUser.setContactStatus(0);
            hpUser.setUserType("0");
            hpUser.setClientId(clientId);
            hpUser.setUseFlag(false);
            this.save(hpUser);
            hpUser1 = this.get(hpUser.getId());
            //用户token作为请求的标准
            long t1 = System.currentTimeMillis();
            String timestamp = String.valueOf(t1);
            String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
            hpUser1.setUserToken(user_token);
            String qrcode = makeUserQrCode(hpUser1);
            hpUser1.setQrCode(qrcode);
            this.save(hpUser1);
        }
        returnMap.put("hpUser", hpUser1);
        //判断member表是否存在该手机号用户
        HpMember hpMember = checkMember(hpUser1, mobile, userIds);
        returnMap.put("hpMember", hpMember);
        //返回用户简历信息
        HpResume hpResume = this.getResume(hpMember);
        returnMap.put("userResume", hpResume);
        //返回用户的企业信息
        DpEnterpriseAuthentication dpEnterpriseAuthentication = this.getDpEnterpriseAuthentication(hpMember);
        returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
        //清除redis缓存的验证码
        CacheUtils.remove(APP_USER, mobile);
        return returnMap;
    }

    /**
     * 登录获取用户的企业信息
     *
     * @param hpMember
     * @return
     */
    private DpEnterpriseAuthentication getDpEnterpriseAuthentication(HpMember hpMember) {
        DpEnterpriseAuthentication dpEnterpriseAuthentication = dpEnterpriseAuthenticationService.findCompanyByMemberId(hpMember.getId());
        return dpEnterpriseAuthentication;
    }

    /**
     * 登录获取用户简历信息
     *
     * @param hpMember
     * @return
     */
    private HpResume getResume(HpMember hpMember) {
        HpResume hpResume = new HpResume();
        List<HpResume> hpResumeList = hpResumeService.findListByMemberId(hpMember.getId());
        if (hpResumeList != null && hpResumeList.size() > 0) {
            hpResume = hpResumeList.get(0);
            List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
            hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
            if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
            }
        }
        return hpResume;
    }


    /**
     * 通过手机号查询用户信息（逻辑删除的不算在内）
     *
     * @param hpUser
     * @return
     */
    private List<HpUser> findByPhone_new(HpUser hpUser) {
        return mapper.findByPhone_new(hpUser);
    }

    /**
     * 用户重复时
     * 变更用户数据到另一个用户上
     *
     * @param hpUserOth
     * @param hpUserOld
     * @return
     */
    private HpUser changeHpUserData(HpUser hpUserOth, HpUser hpUserOld) {
        if (StringUtils.isNotBlank(hpUserOth.getUnionid()) &&
                (StringUtils.isNotBlank(hpUserOth.getWxOpenid())
                        || StringUtils.isNotBlank(hpUserOth.getMinaOpenid()))) {

        } else {
            if (StringUtils.isNotBlank(hpUserOld.getUnionid())) {
                hpUserOld.setId(hpUserOth.getId());
                return hpUserOld;
            }
        }
        return hpUserOth;
    }

    /**
     * 获取用户多条信息集合
     *
     * @param hpUser2
     * @return
     */
    public Map getUserLists(HpUser hpUser2) {
        Map map = new HashMap();
        //返回用户简历信息
        List<HpResume> hpResumeList = hpResumeService.findListByUserId(hpUser2.getId());
        HpResume hpResume = new HpResume();
        if (hpResumeList != null && hpResumeList.size() > 0) {
            hpResume = hpResumeList.get(0);
            List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
            hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
            if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
            }
        }
        HpApplyPosition hpApplyPosition = new HpApplyPosition();
        hpApplyPosition.setHpUser(hpUser2);
        List<HpApplyPosition> applyPositionList = hpApplyPositionMapper.findUserOldList(hpApplyPosition);
        map.put("hpUser", hpUser2);
        map.put("hpResume", hpResume);
        map.put("applySize", applyPositionList.size());
        return map;
    }

    /**
     * 判断member表是否存在该手机号用户
     */
    @Transactional(readOnly = false)
    public HpMember checkMember(HpUser hpUser1, String mobile, String userIds) {
        HpMember hpMember = new HpMember();
        hpMember.setPhone(mobile);
        List<HpMember> hpMemberList = hpMemberService.findListByPhone(hpMember);
        if (hpMemberList != null && hpMemberList.size() > 0) {
            hpMember = hpMemberList.get(0);
        } else {
            //新增member用户
            hpMember.setHpUser(hpUser1);
            hpMember.setAuthenticationStatus(hpUser1.getAuthenticationStatus());
            hpMember.setIdCardBack(hpUser1.getIdCardBack());
            hpMember.setIdCardFront(hpUser1.getIdCardFront());
            hpMember.setIdCardHold(hpUser1.getIdCardHold());
            hpMember.setIdCardNumber(hpUser1.getIdCardNumber());
            hpMember.setRealName(hpUser1.getRealName());
            hpMember.setMemberType(0);
            hpMember.setContactStatus(0);
            if (StringUtils.isNotBlank(hpUser1.getBirthYear())) {
                hpMember.setBirthYear(Integer.parseInt(hpUser1.getBirthYear()));
            }
            if (StringUtils.isNotBlank(hpUser1.getGender())) {
                hpMember.setGender(Integer.parseInt(hpUser1.getGender()));
            }
            hpMemberService.save(hpMember);

            //将业务表跟member表信息关联
            hpMemberService.mergeInfo(hpUser1.getId(), userIds, hpMember.getId());
        }
        return hpMember;
    }

    /**
     * 选择用户信息
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> selectInfo(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = requestMap.get("user_id");//选择的用户id
        String phone = requestMap.get("phone");
        String userIds = requestMap.get("userIds");//废弃的用户id集
        String loginType = requestMap.get("login_type");   //0:小程序；1：微信授权；2：手机号
        HpUser hpUser = this.get(userId);
        //没有微信unionid等信息则从废弃的数据里获取
        if (StringUtils.isBlank(hpUser.getUnionid())) {
            String[] userIdArray = userIds.split(",");
            for (int i = 0; i < userIdArray.length; i++) {
                HpUser hpUser1 = this.get(userIdArray[i]);
                if (StringUtils.isNotBlank(hpUser1.getUnionid())) {
                    hpUser.setUnionid(hpUser1.getUnionid());
                }
                if (StringUtils.isNotBlank(hpUser1.getWxOpenid())) {
                    hpUser.setWxOpenid(hpUser1.getWxOpenid());
                }
                if (StringUtils.isNotBlank(hpUser1.getMinaOpenid())) {
                    hpUser.setMinaOpenid(hpUser1.getMinaOpenid());
                }
            }
        }
        //如果没有accesstoken等信息
        if (StringUtils.isBlank(hpUser.getAccessToken())) {
            String[] userIdArray = userIds.split(",");
            for (int i = 0; i < userIdArray.length; i++) {
                HpUser hpUser1 = this.get(userIdArray[i]);
                if (StringUtils.isNotBlank(hpUser1.getAccessToken())) {
                    hpUser.setAccessToken(hpUser1.getAccessToken());
                }
                if (hpUser1.getAccessTokenEndtime() != null) {
                    hpUser.setAccessTokenEndtime(hpUser1.getAccessTokenEndtime());
                }
                if (StringUtils.isNotBlank(hpUser1.getRefreshToken())) {
                    hpUser.setRefreshToken(hpUser1.getRefreshToken());
                }
            }
        }
        //如果没有小程序SessionKey信息
        if (StringUtils.isBlank(hpUser.getMinaSessionKey())) {
            String[] userIdArray = userIds.split(",");
            for (int i = 0; i < userIdArray.length; i++) {
                HpUser hpUser1 = this.get(userIdArray[i]);
                if (StringUtils.isNotBlank(hpUser1.getMinaSessionKey())) {
                    hpUser.setMinaSessionKey(hpUser1.getMinaSessionKey());
                }
            }
        }
        //更新用户信息
        switch (loginType) {
            case "0":
                //如果登录方式不包含小程序授权，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.MINA.getType())) {
                    String loginType1 = hpUser.getLoginType() + "," + AppLoginsEnum.MINA.getType();
                    hpUser.setLoginType(loginType1);
                }
                break;
            case "1":
                //如果登录方式不包含微信授权，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                    String loginType1 = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                    hpUser.setLoginType(loginType1);
                }
                break;
            case "2":
                //如果登录方式不包含app，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.APP.getType())) {
                    String loginType1 = hpUser.getLoginType() + "," + AppLoginsEnum.APP.getType();
                    hpUser.setLoginType(loginType1);
                }
                break;
        }
        if (StringUtils.isBlank(hpUser.getUserToken())) {
            //用户token作为请求的标准
            long t1 = System.currentTimeMillis();
            String timestamp = String.valueOf(t1);
            String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
            hpUser.setUserToken(user_token);
        }
        if (StringUtils.isBlank(hpUser.getUserType())) {
            hpUser.setUserType("0");
        }
        this.save(hpUser);
        //合并用户信息
        HpMember hpMember = checkMember(hpUser, phone, userIds);
        returnMap.put("hpUser", hpUser);
        returnMap.put("hpMember", hpMember);
        //返回用户简历信息
        HpResume hpResume = this.getResume(hpMember);
        returnMap.put("userResume", hpResume);
        //返回用户的企业信息
        DpEnterpriseAuthentication dpEnterpriseAuthentication = this.getDpEnterpriseAuthentication(hpMember);
        returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
        return returnMap;
    }

    /**
     * app微信授权登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> wxLogin_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        HpUser hpUser = new HpUser();
        String code = requestMap.get("code");
        String clientId = requestMap.get("client_id");
        //只有一个code的时候，获取用户凭证
        JSONObject result = TokenUtil.getAccessToken(code);
        String openId = result.getString("openid");
        String accessToken = result.getString("access_token");
        String unionId = result.getString("unionid");
        String refreshToken = result.getString("refresh_token");
        int access_token_endtime = (int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE;
        logger.info("time======" + access_token_endtime);
        String userIds = ""; //废弃的userid集
        if (StringUtils.isNotBlank(openId)) {
            //查询数据库中是否存在此条数据,同一个用户在同一平台下unionId相同
            List<HpUser> list = Lists.newArrayList();
            if (StringUtils.isNotBlank(unionId)) {
                list = this.findByUnionId_new(unionId);
            }
            //查询数据库是否存在相同的wxopenid
            List<HpUser> list1 = this.findByWxOpenId_new(openId);
            //已存在用户
            if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                if (list != null && list.size() > 0) {
                    hpUser = list.get(0);
                    if (StringUtils.isBlank(hpUser.getWxOpenid())) {
                        hpUser.setWxOpenid(openId);
                    }
                } else {
                    hpUser = list1.get(0);
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                //用户存在手机号
                if (StringUtils.isNotBlank(hpUser.getPhone())) {
                    //查询是否存在本条数据
                    List<HpUser> hpUserList = this.findByPhone_new(hpUser);
                    //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                    List list2 = new ArrayList();
                    if (hpUserList.size() > 1) {
                        for (int i = 0; i < hpUserList.size(); i++) {
                            Map map = getUserLists(hpUserList.get(i));
                            HpResume hpResume = (HpResume) map.get("hpResume");
                            //以简历是否存在作为判断该账号下是否存在数据的标准
                            if (hpResume == null) {
                                //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                if (i == 0) {
                                    HpUser hpUserOth = hpUserList.get(1);
                                    HpUser hpUserOld = hpUserList.get(0);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                } else {
                                    HpUser hpUserOth = hpUserList.get(0);
                                    HpUser hpUserOld = hpUserList.get(1);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                }
                                break;
                            } else {
                                list2.add(map);
                            }
                        }
                    }
                    //如果登录方式不包含微信授权，则添加
                    if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                        String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                        hpUser.setLoginType(loginType);
                    }
                    if (StringUtils.isBlank(hpUser.getUserToken())) {
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                        hpUser.setUserToken(user_token);
                    }
                    if (StringUtils.isBlank(hpUser.getUserType())) {
                        hpUser.setUserType("0");
                    }
                    //通过openid和用户access_token获取用户信息
                    JSONObject wxuser = TokenUtil.getWxuser(accessToken, openId);
                    // 获取对象中的数据
                    String nickname = wxuser.getString("nickname");
                    String sex = wxuser.getString("sex");
                    String avatar = wxuser.getString("headimgurl");
                    String province = wxuser.getString("province");
                    String city = wxuser.getString("city");
                    String country = wxuser.getString("country");
                    hpUser.setLoginTime(new Date());
                    hpUser.setNickName(nickname);
                    hpUser.setGender(sex);
                    hpUser.setHeadImgUrl(avatar);
                    hpUser.setProvince(province);
                    hpUser.setCity(city);
                    hpUser.setCoutry(country);
                    hpUser.setClientId(clientId);
                    hpUser.setAccessToken(accessToken);
                    hpUser.setRefreshToken(refreshToken);
                    hpUser.setAccessTokenEndtime(access_token_endtime);
                    this.save(hpUser);
                    if (list2.size() == hpUserList.size()) {
                        returnMap.put("userList", list2);
                        returnMap.put("success", "2009");
                        return returnMap;
                    }
                    returnMap.put("hpUser", hpUser);
                    //判断member表是否存在该手机号用户
                    HpMember hpMember = checkMember(hpUser, hpUser.getPhone(), userIds);
                    returnMap.put("hpMember", hpMember);
                    //返回用户简历信息
                    HpResume hpResume = this.getResume(hpMember);
                    returnMap.put("userResume", hpResume);
                    //返回用户的企业信息
                    DpEnterpriseAuthentication dpEnterpriseAuthentication = this.getDpEnterpriseAuthentication(hpMember);
                    returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
                } else {
                    CacheUtils.put(APP_USERMSG, unionId + openId, result);
                    returnMap.put("success", "1014");
                    returnMap.put("openId", openId);
                    returnMap.put("unionId", unionId);
                }
            } else {
                //新增是没有手机号的，不去判断
                //将授权信息暂存redis
                CacheUtils.put(APP_USERMSG, unionId + openId, result);
                returnMap.put("success", "1014");
                returnMap.put("openId", openId);
                returnMap.put("unionId", unionId);
            }
        } else {
            returnMap.put("success", "1010");
        }
        return returnMap;
    }

    private List<HpUser> findByWxOpenId_new(String openId) {
        return mapper.findByWxOpenId_new(openId);
    }

    private List<HpUser> findByUnionId_new(String unionId) {
        return mapper.findByUnionId_new(unionId);
    }

    /**
     * app微信授权登录后绑定手机号
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> wxPhone_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        String phone = requestMap.get("phone");
        String clientId = requestMap.get("client_id");
        String openId = requestMap.get("openId");
        String unionId = requestMap.get("unionId");
        String userIds = "";
        if (StringUtils.isNotBlank(openId)) {
            //查询数据库中是否存在此条数据,同一个用户在同一平台下unionId相同
            List<HpUser> list = this.findByUnionId_new(unionId);
            //查询数据库是否存在相同的wxopenid
            List<HpUser> list1 = this.findByWxOpenId_new(openId);
            List list2 = new ArrayList();
            List<HpUser> hpUserList = new ArrayList<>();
            //已存在用户
            if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                if (list != null && list.size() > 0) {
                    hpUser = list.get(0);
                    if (StringUtils.isBlank(hpUser.getWxOpenid())) {
                        hpUser.setWxOpenid(openId);
                    }
                } else {
                    hpUser = list1.get(0);
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                hpUser.setPhone(phone);
                //判断手机号是否存在
                hpUserList = this.findByPhone_new(hpUser);
                hpUserList.add(hpUser);//将当前准备绑定手机号的用户添加到该集合去做合并处理
                if (hpUserList != null && hpUserList.size() > 0) {
                    //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                    if (hpUserList.size() > 1) {
                        for (int i = 0; i < hpUserList.size(); i++) {
                            Map map = getUserLists(hpUserList.get(i));
                            HpResume hpResume = (HpResume) map.get("hpResume");
                            if (hpResume == null) {
                                //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                if (i == 0) {
                                    HpUser hpUserOth = hpUserList.get(1);
                                    HpUser hpUserOld = hpUserList.get(0);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                } else {
                                    HpUser hpUserOth = hpUserList.get(0);
                                    HpUser hpUserOld = hpUserList.get(1);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                }
                                break;
                            } else {
                                list2.add(map);
                            }
                        }
                    } else {
                        hpUser = hpUserList.get(0);
                    }
                    if (StringUtils.isBlank(hpUser.getWxOpenid())) {
                        hpUser.setWxOpenid(openId);
                    }
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }

                //如果登录方式不包含微信授权，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                    String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                    hpUser.setLoginType(loginType);
                }
                if (StringUtils.isBlank(hpUser.getUserToken())) {
                    //用户token作为请求的标准
                    long t1 = System.currentTimeMillis();
                    String timestamp = String.valueOf(t1);
                    String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                    hpUser.setUserToken(user_token);
                }
                if (StringUtils.isBlank(hpUser.getUserType())) {
                    hpUser.setUserType("0");
                }
            } else {
                //绑不绑定手机号
                //绑定的情况
                if (StringUtils.isNotBlank(phone)) {
                    //判断手机号是否已存在
                    hpUser.setPhone(phone);
                    //查询是否存在本条数据
                    hpUserList = this.findByPhone_new(hpUser);
                    if (hpUserList != null && hpUserList.size() > 0) {
                        //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                        if (hpUserList.size() > 1) {
                            for (int i = 0; i < hpUserList.size(); i++) {
                                Map map = getUserLists(hpUserList.get(i));
                                HpResume hpResume = (HpResume) map.get("hpResume");
                                if (hpResume == null) {
                                    //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                    if (i == 0) {
                                        HpUser hpUserOth = hpUserList.get(1);
                                        HpUser hpUserOld = hpUserList.get(0);
                                        hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    } else {
                                        HpUser hpUserOth = hpUserList.get(0);
                                        HpUser hpUserOld = hpUserList.get(1);
                                        hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    }
                                    break;
                                } else {
                                    list2.add(map);
                                }
                            }
                        } else {
                            //手机号已存在
                            hpUser = hpUserList.get(0);
                        }
                        //如果登录方式不包含微信授权，则添加
                        if (!hpUser.getLoginType().contains(AppLoginsEnum.WX_AUTH.getType())) {
                            String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.WX_AUTH.getType();
                            hpUser.setLoginType(loginType);
                        }
                        if (StringUtils.isBlank(hpUser.getUserToken())) {
                            //用户token作为请求的标准
                            long t1 = System.currentTimeMillis();
                            String timestamp = String.valueOf(t1);
                            String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                            hpUser.setUserToken(user_token);
                        }
                        if (StringUtils.isBlank(hpUser.getUserType())) {
                            hpUser.setUserType("0");
                        }
                        hpUser.setUnionid(unionId);
                        hpUser.setWxOpenid(openId);
                    } else {
                        //新用户
                        hpUser1.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_WX_AUTH.getRegistType());
                        hpUser1.setLoginType(AppLoginsEnum.WX_AUTH.getType());
                        hpUser1.setWxOpenid(openId);
                        hpUser1.setUnionid(unionId);
                        hpUser1.setAuthenticationStatus(0);
                        hpUser1.setContactStatus(0);
                        hpUser1.setUserType("0");
                        hpUser1.setUseFlag(false);
                        this.save(hpUser1);
                        hpUser = this.get(hpUser1.getId());
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                        hpUser.setUserToken(user_token);
                        String qrcode = makeUserQrCode(hpUser);
                        hpUser.setQrCode(qrcode);
                    }
                }
            }
            JSONObject result = (JSONObject) CacheUtils.get(APP_USERMSG, unionId + openId);
            String accessToken = result.getString("access_token");
            String refreshToken = result.getString("refresh_token");
            int access_token_endtime = (int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE;
            //通过openid和用户access_token获取用户信息
            JSONObject wxuser = TokenUtil.getWxuser(accessToken, openId);
            // 获取对象中的数据
            String nickname = wxuser.getString("nickname");
            String sex = wxuser.getString("sex");
            String avatar = wxuser.getString("headimgurl");
            String province = wxuser.getString("province");
            String city = wxuser.getString("city");
            String country = wxuser.getString("country");
            if (StringUtils.isNotBlank(phone)) {
                hpUser.setPhone(phone);
            }
            hpUser.setLoginTime(new Date());
            hpUser.setNickName(nickname);
            hpUser.setGender(sex);
            hpUser.setHeadImgUrl(avatar);
            hpUser.setProvince(province);
            hpUser.setCity(city);
            hpUser.setCoutry(country);
            hpUser.setClientId(clientId);
            hpUser.setAccessToken(accessToken);
            hpUser.setRefreshToken(refreshToken);
            hpUser.setAccessTokenEndtime(access_token_endtime);
            this.save(hpUser);
            if (list2.size() == hpUserList.size()) {
                returnMap.put("userList", list2);
                returnMap.put("success", "2009");
                return returnMap;
            }
            returnMap.put("hpUser", hpUser);
            //判断member表是否存在该手机号用户
            HpMember hpMember = checkMember(hpUser, phone, userIds);
            returnMap.put("hpMember", hpMember);
            //清除微信授权时缓存的用户授权信息
            CacheUtils.remove(APP_USERMSG, unionId + openId);
            //清除redis缓存的验证码
            CacheUtils.remove(APP_USER, phone);
            //返回用户简历信息
            HpResume hpResume = this.getResume(hpMember);
            returnMap.put("userResume", hpResume);
            //返回用户的企业信息
            DpEnterpriseAuthentication dpEnterpriseAuthentication = this.getDpEnterpriseAuthentication(hpMember);
            returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
        } else {
            returnMap.put("success", "1010");
        }
        return returnMap;
    }


    /**
     * 用户合并时，逻辑删除
     */
    public void deleteByUserId(String userid) {
        mapper.deleteByUserId(userid);
    }

    /**
     * 日常获取app微信授权用户信息
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> getUserInfo_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = requestMap.get("user_id");
        String userToken = requestMap.get("user_token");
        String loginType = requestMap.get("login_type");   //手机登录标志（默认:1）
        String memberId = requestMap.get("member_id");
        JSONObject json_object = new JSONObject();
        String errcode = "";
        //验证用户是否处于登录态
        if (TokenUtil.validateLogin(memberId, userId)) {
            //验证用户合法性
            if (TokenUtil.validateToken(userId, userToken)) {
                HpUser hpUser = this.get(userId);
                HpMember hpMember = hpMemberService.getAPI(memberId);
                //手机用户
                if (StringUtils.isNotBlank(loginType)) {
                    if ("1".equals(loginType)) {
                        returnMap.put("hpUser", hpUser);
                        returnMap.put("hpMember", hpMember);
                        return returnMap;
                    }
                }
                if (StringUtils.isBlank(hpUser.getUnionid()) && StringUtils.isBlank(hpUser.getWxOpenid())) {
                    //手机用户
                    returnMap.put("hpUser", hpUser);
                    returnMap.put("hpMember", hpMember);
                    return returnMap;
                }
                //日常获取用户access_token
                json_object = TokenUtil.getDayAccessToken(userId);
                //不为空，则为微信授权
                if (json_object != null) {
                    //判断是否存在errcode键
                    if (json_object.containsKey("errcode")) {
                        errcode = json_object.getString("errcode");
                    }
                    //当刷新access_token如果存在errcode且不等于0，则认为refreshToken已过期
                    if (StringUtils.isNotBlank(errcode) && !"0".equals(errcode)) {
                        returnMap.put("success", "1013");
                        return returnMap;
                    } else {
                        //获取用户最新信息
                        String accessToken = json_object.getString("access_token");
                        JSONObject wxuser = TokenUtil.getWxuser(accessToken, userId);
                        //更新用户access_token信息
                        String nickname = wxuser.getString("nickname");
                        String sex = wxuser.getString("sex");
                        String avatar = wxuser.getString("headimgurl");
                        String province = wxuser.getString("province");
                        String city = wxuser.getString("city");
                        String country = wxuser.getString("country");
                        hpUser.setNickName(nickname);
                        hpUser.setGender(sex);
                        hpUser.setHeadImgUrl(avatar);
                        hpUser.setProvince(province);
                        hpUser.setCity(city);
                        hpUser.setCoutry(country);
                        hpUser.setAccessToken(json_object.getString("access_token"));
                        //如果包含refresh_token，说明是刷新了access_token
                        if (json_object.containsKey("refresh_token")) {
                            hpUser.setRefreshToken(json_object.getString("refresh_token"));
                            hpUser.setAccessTokenEndtime((int) (System.currentTimeMillis() / 1000) + Constants.WX_ACCESS_TOKEN_AGE);
                        }
                        this.save(hpUser);
                    }
                }
                returnMap.put("hpUser", hpUser);
                returnMap.put("hpMember", hpMember);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 自发布切换身份
     */
    public Map<String, Object> changeIdentity(Map<String, String> requestMap, HttpServletRequest request, HttpServletResponse response) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = requestMap.get("user_id");
        String userToken = requestMap.get("user_token");
        String memberId = requestMap.get("member_id");
        //验证登录态
        if (TokenUtil.validateLogin(memberId, userId)) {
            //验证用户合法性
            if (TokenUtil.validateToken(userId, userToken)) {
                String userType = requestMap.get("user_type");  //1:招聘者 0:找工作
                HpMember hpMember = hpMemberService.get(memberId);
                if ("1".equals(userType)) {
                    DpEnterpriseAuthentication dpEnterpriseAuthentication = dpEnterpriseAuthenticationService.findCompanyByMemberId(memberId);
                    returnMap.put("dpEnterpriseAuthentication", dpEnterpriseAuthentication);
                } else if ("0".equals(userType)) {
                    HpResume hpResume = hpResumeService.findResumeByMemberId(memberId);
                    returnMap.put("hpResume", hpResume);
                }
                returnMap.put("hpMember", hpMember);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /********************小程序授权************************/

    /**
     * 小程序授权登录
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> minaLogin_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String code = requestMap.get("code");
        //通过小程序code获取用户openId
        JSONObject result = TokenUtil.minaGetSession(code);
        //返回成功时，不返回errcode
        if (result != null && !result.containsKey("errcode") && result.containsKey("openid")) {
            String openId = result.getString("openid");
            String sessionKey = result.getString("session_key");
            returnMap.put("openId", openId);
            returnMap.put("sessionKey", sessionKey);
        } else {
            returnMap.put("success", "1005");
            returnMap.put("errmsg", result.getString("errmsg"));
        }
        return returnMap;
    }

    /**
     * 保存小程序用户信息
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveMinaInfo_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String encryptedData = requestMap.get("encryptedData");
        String iv = requestMap.get("iv");
        String openId = requestMap.get("openid");
        String sessionKey = requestMap.get("session_key");
        String userIds = "";
        if (StringUtils.isBlank(encryptedData) || StringUtils.isBlank(iv)) {
            returnMap.put("success", 1005);
            return returnMap;
        }
        //微信加密信息：解密，获取用户信息
        JSONObject json = this.decodeWxData(encryptedData, iv, sessionKey);
        HpUser hpUser1 = new HpUser();
        if (json != null && !json.containsKey("errcode")) {
            String unionId = json.getString("unionId");
            logger.info("openid===============================" + openId);
            logger.info("unioniD===============================" + unionId);
            if (StringUtils.isNotBlank(openId)) {
                //查询数据库中是否存在此条数据，同一个用户在同一平台下unionId相同
                List<HpUser> list = new ArrayList<>();
                if (StringUtils.isNotBlank(unionId)) {
                    list = this.findByUnionId_new(unionId);
                }
                //查询数据库是否存在相同的minaopenid
                List<HpUser> list1 = this.findByMinaOpenId_new(openId);
                //如果存在
                if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                    if (list != null && list.size() > 0) {
                        hpUser1 = list.get(0);
                        if (StringUtils.isBlank(hpUser1.getMinaOpenid())) {
                            hpUser1.setMinaOpenid(openId);
                        }
                    } else {
                        hpUser1 = list1.get(0);
                        if (StringUtils.isBlank(hpUser1.getUnionid())) {
                            hpUser1.setUnionid(unionId);
                        }
                    }
                    //用户存在手机号
                    if (StringUtils.isNotBlank(hpUser1.getPhone())) {
                        //查询是否存在本条数据
                        List<HpUser> hpUserList = this.findByPhone_new(hpUser1);
                        //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                        List list2 = new ArrayList();
                        if (hpUserList.size() > 1) {
                            for (int i = 0; i < hpUserList.size(); i++) {
                                Map map = getUserLists(hpUserList.get(i));
                                HpResume hpResume = (HpResume) map.get("hpResume");
                                //以简历是否存在作为判断该账号下是否存在数据的标准
                                if (hpResume == null) {
                                    //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                    if (i == 0) {
                                        HpUser hpUserOth = hpUserList.get(1);
                                        HpUser hpUserOld = hpUserList.get(0);
                                        hpUser1 = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    } else {
                                        HpUser hpUserOth = hpUserList.get(0);
                                        HpUser hpUserOld = hpUserList.get(1);
                                        hpUser1 = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    }
                                    break;
                                } else {
                                    list2.add(map);
                                }
                            }
                        }
                        //如果登录方式不包含小程序授权，则添加
                        if (!hpUser1.getLoginType().contains(AppLoginsEnum.MINA.getType())) {
                            String loginType = hpUser1.getLoginType() + "," + AppLoginsEnum.MINA.getType();
                            hpUser1.setLoginType(loginType);
                        }
                        if (StringUtils.isBlank(hpUser1.getUserToken())) {
                            //用户token作为请求的标准
                            long t1 = System.currentTimeMillis();
                            String timestamp = String.valueOf(t1);
                            String user_token = Md5Encrypt.md5(hpUser1.getId() + timestamp);
                            hpUser1.setUserToken(user_token);
                        }
                        if (StringUtils.isBlank(hpUser1.getUserType())) {
                            hpUser1.setUserType("0");
                        }
                        //sessionkey需要刷新
                        hpUser1.setMinaSessionKey(sessionKey);
                        String nickName = json.getString("nickName");
                        String gender = json.getString("gender");
                        String avatarUrl = json.getString("avatarUrl");
                        String country = json.getString("country");
                        String province = json.getString("province");
                        String city = json.getString("city");
                        hpUser1.setNickName(nickName);
                        hpUser1.setGender(gender);
                        hpUser1.setHeadImgUrl(avatarUrl);
                        hpUser1.setCoutry(country);
                        hpUser1.setProvince(province);
                        hpUser1.setCity(city);
                        hpUser1.setLoginTime(new Date());
                        this.save(hpUser1);
                        if (list2.size() == hpUserList.size()) {
                            returnMap.put("userList", list2);
                            returnMap.put("success", "2009");
                            return returnMap;
                        }
                        returnMap.put("hpUser", hpUser1);
                        //判断member表是否存在该手机号用户
                        HpMember hpMember = checkMember(hpUser1, hpUser1.getPhone(), userIds);
                        returnMap.put("hpMember", hpMember);
                    } else {
                        CacheUtils.put(MINA_USERMSG, unionId + openId, json);
                        returnMap.put("success", "1014");
                        returnMap.put("openId", openId);
                        returnMap.put("unionId", unionId);
                        returnMap.put("sessionKey", sessionKey);
                    }
                } else {
                    CacheUtils.put(MINA_USERMSG, unionId + openId, json);
                    returnMap.put("success", "1014");
                    returnMap.put("openId", openId);
                    returnMap.put("unionId", unionId);
                    returnMap.put("sessionKey", sessionKey);
                }
            } else {
                returnMap.put("success", "1010");
            }
        }
        return returnMap;
    }

    private List<HpUser> findByMinaOpenId_new(String openId) {
        return mapper.findByMinaOpenId_new(openId);
    }

    /**
     * 保存小程序用户手机号
     *
     * @param requestMap
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveMinaPhone_new(Map<String, String> requestMap) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        HpUser hpUser = new HpUser();
        HpUser hpUser1 = new HpUser();
        String phone = requestMap.get("phone");
        String openId = requestMap.get("openId");
        String unionId = requestMap.get("unionId");
        String sessionKey = requestMap.get("sessionKey");
        String userIds = "";
        if (StringUtils.isNotBlank(openId)) {
            //查询数据库中是否存在此条数据,同一个用户在同一平台下unionId相同
            List<HpUser> list = this.findByUnionId_new(unionId);
            //查询数据库是否存在相同的minaopenid
            List<HpUser> list1 = this.findByMinaOpenId_new(openId);
            List list2 = new ArrayList();
            List<HpUser> hpUserList = new ArrayList<>();
            //已存在用户
            if ((list != null && list.size() > 0) || (list1 != null && list1.size() > 0)) {
                if (list != null && list.size() > 0) {
                    hpUser = list.get(0);
                    if (StringUtils.isBlank(hpUser.getMinaOpenid())) {
                        hpUser.setMinaOpenid(openId);
                    }
                } else {
                    hpUser = list1.get(0);
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                hpUser.setPhone(phone);
                //判断手机号是否存在
                hpUserList = this.findByPhone_new(hpUser);
                hpUserList.add(hpUser);//将当前准备绑定手机号的用户添加到该集合去做合并处理
                if (hpUserList != null && hpUserList.size() > 0) {
                    //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                    if (hpUserList.size() > 1) {
                        for (int i = 0; i < hpUserList.size(); i++) {
                            Map map = getUserLists(hpUserList.get(i));
                            HpResume hpResume = (HpResume) map.get("hpResume");
                            if (hpResume == null) {
                                //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                if (i == 0) {
                                    HpUser hpUserOth = hpUserList.get(1);
                                    HpUser hpUserOld = hpUserList.get(0);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                } else {
                                    HpUser hpUserOth = hpUserList.get(0);
                                    HpUser hpUserOld = hpUserList.get(1);
                                    hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                    userIds = hpUserOld.getId();
                                }
                                break;
                            } else {
                                list2.add(map);
                            }
                        }
                    } else {
                        hpUser = hpUserList.get(0);
                    }
                    if (StringUtils.isBlank(hpUser.getMinaOpenid())) {
                        hpUser.setMinaOpenid(openId);
                    }
                    if (StringUtils.isBlank(hpUser.getUnionid())) {
                        hpUser.setUnionid(unionId);
                    }
                }
                //如果登录方式不包含小程序授权，则添加
                if (!hpUser.getLoginType().contains(AppLoginsEnum.MINA.getType())) {
                    String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.MINA.getType();
                    hpUser.setLoginType(loginType);
                }
                if (StringUtils.isBlank(hpUser.getUserToken())) {
                    //用户token作为请求的标准
                    long t1 = System.currentTimeMillis();
                    String timestamp = String.valueOf(t1);
                    String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                    hpUser.setUserToken(user_token);
                }
                if (StringUtils.isBlank(hpUser.getUserType())) {
                    hpUser.setUserType("0");
                }
            } else {
                //绑不绑定手机号
                //绑定的情况
                if (StringUtils.isNotBlank(phone)) {
                    //判断手机号是否已存在
                    hpUser.setPhone(phone);
                    //查询是否存在本条数据
                    hpUserList = this.findByPhone_new(hpUser);
                    if (hpUserList != null && hpUserList.size() > 0) {
                        //如果该用户有多条记录，则提示选择一条用户，其余则遗弃不再使用
                        if (hpUserList.size() > 1) {
                            for (int i = 0; i < hpUserList.size(); i++) {
                                Map map = getUserLists(hpUserList.get(i));
                                HpResume hpResume = (HpResume) map.get("hpResume");
                                if (hpResume == null) {
                                    //没有简历，该条用户记录自动被视为放弃，数据绑定到另外的用户上
                                    if (i == 0) {
                                        HpUser hpUserOth = hpUserList.get(1);
                                        HpUser hpUserOld = hpUserList.get(0);
                                        hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    } else {
                                        HpUser hpUserOth = hpUserList.get(0);
                                        HpUser hpUserOld = hpUserList.get(1);
                                        hpUser = changeHpUserData(hpUserOth, hpUserOld);
                                        userIds = hpUserOld.getId();
                                    }
                                    break;
                                } else {
                                    list2.add(map);
                                }
                            }
                        } else {
                            //手机号已存在
                            hpUser = hpUserList.get(0);
                        }
                        //如果登录方式不包含小程序授权，则添加
                        if (!hpUser.getLoginType().contains(AppLoginsEnum.MINA.getType())) {
                            String loginType = hpUser.getLoginType() + "," + AppLoginsEnum.MINA.getType();
                            hpUser.setLoginType(loginType);
                        }
                        if (StringUtils.isBlank(hpUser.getUserToken())) {
                            //用户token作为请求的标准
                            long t1 = System.currentTimeMillis();
                            String timestamp = String.valueOf(t1);
                            String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                            hpUser.setUserToken(user_token);
                        }
                        if (StringUtils.isBlank(hpUser.getUserType())) {
                            hpUser.setUserType("0");
                        }
                        hpUser.setUnionid(unionId);
                        hpUser.setMinaOpenid(openId);
                    } else {
                        //新用户
                        hpUser1.setRegisterType(AppLoginsEnum.AppRegisterEnum.R_MINA.getRegistType());
                        hpUser1.setLoginType(AppLoginsEnum.MINA.getType());
                        hpUser1.setMinaOpenid(openId);
                        hpUser1.setUnionid(unionId);
                        hpUser1.setAuthenticationStatus(0);
                        hpUser1.setContactStatus(0);
                        hpUser1.setUserType("0");
                        hpUser1.setUseFlag(false);
                        this.save(hpUser1);
                        hpUser = this.get(hpUser1.getId());
                        //用户token作为请求的标准
                        long t1 = System.currentTimeMillis();
                        String timestamp = String.valueOf(t1);
                        String user_token = Md5Encrypt.md5(hpUser.getId() + timestamp);
                        hpUser.setUserToken(user_token);
                        String qrcode = makeUserQrCode(hpUser);
                        hpUser.setQrCode(qrcode);
                    }
                }
            }
            //获取redis缓存的用户信息
            JSONObject json = (JSONObject) CacheUtils.get(MINA_USERMSG, unionId + openId);
            String nickName = json.getString("nickName");
            String gender = json.getString("gender");
            String avatarUrl = json.getString("avatarUrl");
            String country = json.getString("country");
            String province = json.getString("province");
            String city = json.getString("city");
            if (StringUtils.isNotBlank(phone)) {
                hpUser.setPhone(phone);
            }
            hpUser.setLoginTime(new Date());
            hpUser.setNickName(nickName);
            hpUser.setGender(gender);
            hpUser.setHeadImgUrl(avatarUrl);
            hpUser.setProvince(province);
            hpUser.setCity(city);
            hpUser.setCoutry(country);
            hpUser.setMinaSessionKey(sessionKey);
            this.save(hpUser);
            if (list2.size() == hpUserList.size()) {
                returnMap.put("userList", list2);
                returnMap.put("success", "2009");
                return returnMap;
            }
            returnMap.put("hpUser", hpUser);
            //判断member表是否存在该手机号用户
            HpMember hpMember = checkMember(hpUser, phone, userIds);
            returnMap.put("hpMember", hpMember);
            //清除小程序授权时缓存的用户授权信息
            CacheUtils.remove(MINA_USERMSG, unionId + openId);
            //清除redis缓存的验证码
            CacheUtils.remove(APP_USER, phone);
        } else {
            returnMap.put("success", "1010");
        }
        return returnMap;
    }

    /**
     * 小程序上传图片
     *
     * @param request
     * @return
     */
    public Map<String, Object> saveImgUp_new(HttpServletRequest request) {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        String userId = request.getParameter("user_id");
        String userToken = request.getParameter("user_token");
        String memberId = request.getParameter("member_id");
        //验证用户是否处于登录态
        if (TokenUtil.validateLogin(memberId, userId)) {
            //验证用户合法性
            if (TokenUtil.validateToken(userId, userToken)) {
                String type = request.getParameter("up_type");
                HpUser hpUser = this.get(userId);
                String path = "/hpuser/index";
                if (StringUtils.isNotBlank(type)) {
                    switch (type) {
                        case "0":
                            //基本资料
                            path = "/hpuser/resume";
                            break;
                        case "1":
                            //身份证正面
                            path = "/hpuser/idcard/front";
                            break;
                        case "2":
                            //身份证反面
                            path = "/hpuser/idcard/back";
                            break;
                        case "3":
                            //手持身份证
                            path = "/hpuser/idcard/hold";
                            break;
                    }
                }
                //头像上传调用
                try {
                    if (request instanceof MultipartHttpServletRequest) {
                        AjaxJson j = webupload(request, "file", hpUser, path);
                        if (j.isSuccess()) {
                            returnMap.put("imgUrl", j.getBody().get("url"));
                        } else {
                            logger.info("wpload========" + j.getMsg());
                        }
                    } else {
                        logger.info("wpnonono========没有文件上传");
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }
}