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

import com.alibaba.fastjson.JSONObject;
import com.jeeplus.common.config.Global;
import com.jeeplus.common.json.AjaxJson;
import com.jeeplus.common.oss.OSSClientUtil;
import com.jeeplus.common.utils.StringUtils;
import com.jeeplus.core.persistence.Page;
import com.jeeplus.core.service.CrudService;
import com.jeeplus.modules.dpposition.service.DpPositionService;
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.mapper.HpResumeMapper;
import com.jeeplus.modules.sys.entity.HpMember;
import com.jeeplus.modules.sys.entity.HpUser;
import com.jeeplus.modules.sys.service.HpMemberService;
import com.jeeplus.modules.sys.service.HpUserService;
import com.jeeplus.modules.sys.wxUtils.TokenUtil;
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.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.*;

/**
 * 用户简历Service
 *
 * @author zwq
 * @version 2019-04-22
 */
@Service
@Transactional(readOnly = true)
public class HpResumeService extends CrudService<HpResumeMapper, HpResume> {

    @Autowired
    private HpResumeWorkExperienceService hpResumeWorkExperienceService;
    @Autowired
    private HpUserService hpUserService;
    @Autowired
    private DpPositionService dpPositionService;
    @Autowired
    private HpMemberService hpMemberService;
    @Autowired
    private HpApplyPositionService hpApplyPositionService;

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

    public List<HpResume> findList(HpResume hpResume) {
        return super.findList(hpResume);
    }

    public Page<HpResume> findPage(Page<HpResume> page, HpResume hpResume) {
        return super.findPage(page, hpResume);
    }

    @Transactional(readOnly = false)
    public void save(HpResume hpResume) {
        super.save(hpResume);
    }

    @Transactional(readOnly = false)
    public void delete(HpResume hpResume) {
        super.delete(hpResume);
    }

    /**
     * 保存基本资料
     *
     * @param request
     * @param response
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveBaseData(HttpServletRequest request, HttpServletResponse response) {
        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 realName = request.getParameter("realName");
                String gender = request.getParameter("gender");
                String phone = request.getParameter("phone");
                String birthYear = request.getParameter("birthYear");
                String highestQualification = request.getParameter("highestQualification");
                String avatar = request.getParameter("avatar");
                String wechatNumber = request.getParameter("wechatNumber");
                HpResume hpResume = new HpResume();
                HpMember hpMember = hpMemberService.get(memberId);
                List<HpResume> hpResumeList = this.findListByMemberId(memberId);
                if (hpResumeList != null && hpResumeList.size() > 0) {
                    hpResume = hpResumeList.get(0);
                } else {
                    hpResume.setHpMember(hpMember);
                }
                //小程序使用
                if (StringUtils.isNotBlank(avatar)) {
                    hpResume.setHeadImg(avatar);
                } else {
                    //头像上传调用
                    try {
                        if (request instanceof MultipartHttpServletRequest) {
                            AjaxJson j = webupload(request, "files", hpMember, "/hpuser/resume");
                            if (j.isSuccess()) {
                                hpResume.setHeadImg((String) j.getBody().get("url"));
                            } else {
                                System.out.println("wpload========" + j.getMsg());
                            }
                        } else {
                            System.out.println("wpnonono========没有文件上传");
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
                if (StringUtils.isNotBlank(realName)) {
                    hpResume.setRealName(realName);
                }
                if (StringUtils.isNotBlank(gender)) {
                    hpResume.setGender(gender);
                }
                if (StringUtils.isNotBlank(birthYear)) {
                    hpResume.setBirthYear(birthYear);
                }
                if (StringUtils.isNotBlank(phone)) {
                    hpResume.setPhone(phone);
                }
                if (StringUtils.isNotBlank(highestQualification)) {
                    hpResume.setHighestQualification(highestQualification);
                }
                hpResume.setWechatNumber(wechatNumber);
                this.save(hpResume);
                List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                    if (!hpResume.getHeadImg().contains("http")) {
                        hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                    }
                }
                returnMap.put("userResume", hpResume);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 查询用户简历是否存在
     *
     * @param memberId
     * @return
     */
    public List<HpResume> findListByMemberId(String memberId) {
        return mapper.findListByMemberId(memberId);
    }

    /**
     * 保存求职意向
     *
     * @param requestMap
     * @param request
     * @param response
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveExpectationData(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 expectationPosition = requestMap.get("expectationPosition");
                String expectationProvinceId = requestMap.get("expectationProvinceId");
                String expectationCityId = requestMap.get("expectationCityId");
                String expectationCountryId = requestMap.get("expectationCountryId");
                String expectationSalary = requestMap.get("expectationSalary");
                String expectationAddress = requestMap.get("expectationAddress");
                HpResume hpResume = new HpResume();
                List<HpResume> hpResumeList = this.findListByMemberId(memberId);
                if (hpResumeList != null && hpResumeList.size() > 0) {
                    hpResume = hpResumeList.get(0);
                } else {
                    returnMap.put("success", "1015");
                    return returnMap;
                }
                if (StringUtils.isNotBlank(expectationPosition)) {
                    hpResume.setExpectationPosition(expectationPosition);
                }
                if (StringUtils.isNotBlank(expectationProvinceId)) {
                    hpResume.setExpectationProvinceId(expectationProvinceId);
                }
                if (StringUtils.isNotBlank(expectationCityId)) {
                    hpResume.setExpectationCityId(expectationCityId);
                }
                if (StringUtils.isNotBlank(expectationCountryId)) {
                    hpResume.setExpectationCountryId(expectationCountryId);
                }
                if (StringUtils.isNotBlank(expectationSalary)) {
                    hpResume.setExpectationSalary(expectationSalary);
                }
                if (StringUtils.isNotBlank(expectationAddress)) {
                    hpResume.setExpectationAddress(expectationAddress);
                }
                this.save(hpResume);
                List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                    if (!hpResume.getHeadImg().contains("http")) {
                        hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                    }
                }
                returnMap.put("userResume", hpResume);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 工作经验
     *
     * @param requestMap
     * @param request
     * @param response
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveWorkExperience(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 resumeId = requestMap.get("resumeId");
                String workCompany = requestMap.get("workCompany");
                String workPosition = requestMap.get("workPosition");
                String workStartDate = requestMap.get("workStartDate");
                String workEndDate = requestMap.get("workEndDate");
                String workExperienceId = requestMap.get("workExperienceId");
                HpResumeWorkExperience hpResumeWorkExperience = new HpResumeWorkExperience();
                if (StringUtils.isNotBlank(workExperienceId)) {
                    hpResumeWorkExperience = hpResumeWorkExperienceService.get(workExperienceId);
                } else {
                    hpResumeWorkExperience.setResumeId(resumeId);
                }
                if (StringUtils.isNotBlank(workCompany)) {
                    hpResumeWorkExperience.setWorkCompany(workCompany);
                }
                if (StringUtils.isNotBlank(workPosition)) {
                    hpResumeWorkExperience.setWorkPosition(workPosition);
                }
                if (StringUtils.isNotBlank(workStartDate)) {
                    hpResumeWorkExperience.setWorkStartDate(workStartDate);
                }
                if (StringUtils.isNotBlank(workEndDate)) {
                    hpResumeWorkExperience.setWorkEndDate(workEndDate);
                }
                hpResumeWorkExperienceService.save(hpResumeWorkExperience);
                HpResume hpResume = this.get(resumeId);
                List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                    if (!hpResume.getHeadImg().contains("http")) {
                        hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                    }
                }
                returnMap.put("userResume", hpResume);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 保存微信号
     *
     * @param requestMap
     * @param request
     * @param response
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> saveWechatNumber(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 wechatNumber = requestMap.get("wechatNumber");
                HpResume hpResume = new HpResume();
                List<HpResume> hpResumeList = this.findListByMemberId(memberId);
                if (hpResumeList != null && hpResumeList.size() > 0) {
                    hpResume = hpResumeList.get(0);
                } else {
                    returnMap.put("success", "1015");
                    return returnMap;
                }
                hpResume.setWechatNumber(wechatNumber);
                this.save(hpResume);
                List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                    if (!hpResume.getHeadImg().contains("http")) {
                        hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                    }
                }
                returnMap.put("userResume", hpResume);
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 获取用户简历详情
     *
     * @param requestMap
     * @param request
     * @param response
     * @return
     */
    public Map<String, Object> getUserResume(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)) {
                HpResume hpResume = new HpResume();
                List<HpResume> hpResumeList = this.findListByMemberId(memberId);
                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())) {
                        if (!hpResume.getHeadImg().contains("http")) {
                            hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                        }
                    }
                    returnMap.put("userResume", hpResume);
                } else {
                    returnMap.put("success", "1015");
                }
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }


    /**
     * app上传图片
     *
     * @param request
     * @param param
     * @param hpMember
     * @param uploadPath
     * @return
     * @throws IllegalStateException
     * @throws IOException
     */
    public AjaxJson webupload(HttpServletRequest request, String param, HpMember hpMember, 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 + "/" + hpMember.getId() + "/" + year + "/" + month + "/";
                // 判断文件是否为空
                if (!file.isEmpty()) {
                    String filePath = ossUtil.uploadImg2OSS(file, fileDir);
                    System.out.println("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;
    }

    /**
     * 实名认证
     *
     * @param request
     * @param response
     * @return
     */
    @Transactional(readOnly = false)
    public Map<String, Object> realApprove(HttpServletRequest request, HttpServletResponse response) {
        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 realName = request.getParameter("realName");
                String idCardNumber = request.getParameter("idCardNumber");
                String minaType = request.getParameter("minaType");//1：代表小程序，app不传
                String idFrontPic = request.getParameter("idFrontPic");
                String idBackPic = request.getParameter("idBackPic");
                String idPersonPic = request.getParameter("idPersonPic");
                HpMember hpMember = hpMemberService.get(memberId);
                if (hpMember != null) {
                    if (StringUtils.isNotBlank(minaType)) {
                        if (StringUtils.isNotBlank(idFrontPic)) {
                            hpMember.setIdCardFront(idFrontPic);
                        }
                        if (StringUtils.isNotBlank(idBackPic)) {
                            hpMember.setIdCardBack(idBackPic);
                        }
                        if (StringUtils.isNotBlank(idPersonPic)) {
                            hpMember.setIdCardHold(idPersonPic);
                        }
                    } else {
                        //身份证照片上传调用
                        try {
                            if (request instanceof MultipartHttpServletRequest) {
                                AjaxJson j = webupload(request, "idCardFront", hpMember, "/hpuser/idcard/front");
                                if (j.isSuccess()) {
                                    hpMember.setIdCardFront((String) j.getBody().get("url"));
                                } else {
                                    System.out.println("wpload========" + j.getMsg());
                                }
                                AjaxJson k = webupload(request, "idCardBack", hpMember, "/hpuser/idcard/back");
                                if (k.isSuccess()) {
                                    hpMember.setIdCardBack((String) k.getBody().get("url"));
                                } else {
                                    System.out.println("wpload========" + k.getMsg());
                                }
                                AjaxJson m = webupload(request, "idCardHold", hpMember, "/hpuser/idcard/hold");
                                if (m.isSuccess()) {
                                    hpMember.setIdCardHold((String) m.getBody().get("url"));
                                } else {
                                    System.out.println("wpload========" + m.getMsg());
                                }

                            } else {
                                System.out.println("wpnonono========没有文件上传");
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                    if (StringUtils.isNotBlank(realName)) {
                        hpMember.setRealName(realName);
                    }
                    if (StringUtils.isNotBlank(idCardNumber)) {
                        hpMember.setIdCardNumber(idCardNumber);
                    }
                    //认证状态变为等待认证
                    hpMember.setAuthenticationStatus(1);
                    hpMemberService.save(hpMember);
                }
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 认证状态
     *
     * @param requestMap
     * @param request
     * @param response
     * @return
     */
    public Map<String, Object> approveStatus(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)) {
                HpMember hpMember = hpMemberService.get(memberId);
                if (hpMember != null) {
                    Integer status = hpMember.getAuthenticationStatus();
                    returnMap.put("approveStatus", status);
                }
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    public Page<HpResume> findRemuses(Page<HpResume> page, HpResume hpResume) {
        hpResume.setPage(page);
        page.setList(mapper.findList1(hpResume));
        return page;
    }

    public List<HpResume> findRemuseCount(HpResume hpResume) {
        return mapper.findRemuseList(hpResume);
    }


    private Page<HpResume> pageRecommendRemuse(Page<HpResume> page, HpResume hpResume) {
        hpResume.setPage(page);
        page.setList(mapper.findRecommendRemuse(hpResume));
        return page;
    }

    /**
     * 获取推荐简历
     */
    public Map<String, Object> getRecommendResume(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 pageNo = requestMap.get("pageNo");
                String searchKey = requestMap.get("search_key");
                //搜索简历接口路径（c端）
                if (StringUtils.isBlank(searchKey)) {
                    searchKey = "";
                }
                HpResume hpResume = new HpResume();
                if (StringUtils.isNotBlank(searchKey)) {
                    hpResume.setSearchKey(searchKey);
                }
                Page<HpResume> page = this.pageRecommendRemuse(new Page<HpResume>(request, response), hpResume);
                if (Integer.parseInt(pageNo) > page.getLast()) {
                    List<HpResume> list = new ArrayList<>();
                    returnMap.put("searchResume", list);
                } else {
                    List<HpResume> list1 = page.getList();
                    if (list1 != null && !list1.isEmpty()) {
                        returnMap.put("searchResume", list1);
                        returnMap.put("pageNo", page.getPageNo());
                    } else {
                        returnMap.put("searchResume", list1);
                    }
                    //提示前端是否为最后一页
                    if (Integer.parseInt(pageNo) == page.getLast()) {
                        returnMap.put("isLast", true);
                    } else {
                        returnMap.put("isLast", false);
                    }
                }
                return returnMap;

            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;

    }


    private Page<HpResume> pageApplyRemuse(Page<HpResume> page, HpResume hpResume) {
        hpResume.setPage(page);
        page.setList(mapper.findApplyRemuse(hpResume));
        return page;
    }

    /**
     * 投递简历分页列表
     */
    public Map<String, Object> getApplyResume(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 searchKey = requestMap.get("searchKey");
                String pageNo = requestMap.get("pageNo");
                //该公司所有职位
                List<String> list3 = dpPositionService.findListByMemberId(memberId);
                StringBuilder stringBuilder = new StringBuilder();
                String positionIds = "";
                if (list3 != null && !list3.isEmpty()) {
                    for (String str : list3) {
                        stringBuilder.append(str + ",");
                    }
                    positionIds = stringBuilder.toString();
                    positionIds = positionIds.substring(0, positionIds.length() - 1);
                } else {
                    returnMap.put("applyResume", null);
                    return returnMap;
                }
                HpResume hpResume = new HpResume();
                if (StringUtils.isNotBlank(searchKey)) {
                    boolean isNum = searchKey.matches("[0-9]+");
                    if (isNum) {
                        Calendar cale = Calendar.getInstance();
                        int year = cale.get(Calendar.YEAR);
                        searchKey = String.valueOf(year - Integer.parseInt(searchKey) + 1);

                    }
                    hpResume.setSearchKey(searchKey);
                }
                //投递岗位id集
                if (StringUtils.isNotBlank(positionIds)) {
                    hpResume.setPositionIds(positionIds);
                }
                Page<HpResume> page = this.pageApplyRemuse(new Page<HpResume>(request, response), hpResume);
                if (Integer.parseInt(pageNo) > page.getLast()) {
                    List<HpResume> list = new ArrayList<>();
                    returnMap.put("applyResume", list);
                } else {
                    List<HpResume> list1 = page.getList();
                    if (list1 != null && !list1.isEmpty()) {
                        List<HpResume> list2 = new ArrayList<>();
                        for (HpResume hpResume1 : list1) {
                            //计算年龄
                            if (StringUtils.isNotBlank(hpResume1.getBirthYear())) {
                                Calendar cale = Calendar.getInstance();
                                int year = cale.get(Calendar.YEAR);
                                String birthYear = String.valueOf(year - Integer.parseInt(hpResume1.getBirthYear()) + 1);
                                hpResume1.setBirthYear(birthYear);
                            }
                            HpApplyPosition hpApplyPosition = hpApplyPositionService.get(hpResume1.getApplyId());
                            hpResume1.setCreateDate(hpApplyPosition.getApplyTime());
                            if (StringUtils.isNotBlank(hpResume1.getHeadImg())) {
                                if (!hpResume1.getHeadImg().contains("http")) {
                                    hpResume1.setHeadImg(Global.getAliyunUrl() + hpResume1.getHeadImg());
                                }
                            }
                            list2.add(hpResume1);
                        }
                        returnMap.put("applyResume", list2);
                        returnMap.put("pageNo", page.getPageNo());
                    } else {
                        returnMap.put("applyResume", list1);
                    }
                    //提示前端是否为最后一页
                    if (Integer.parseInt(pageNo) == page.getLast()) {
                        returnMap.put("isLast", true);
                    } else {
                        returnMap.put("isLast", false);
                    }
                }
                return returnMap;
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    /**
     * 简历详情
     */
    public Map<String, Object> getResumeDetail(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 resumeId = requestMap.get("resumeId");
                if (StringUtils.isNotBlank(resumeId)) {
                    HpResume hpResume = mapper.get(resumeId);
                    if (hpResume != null) {
                        Calendar cale = Calendar.getInstance();
                        int year = cale.get(Calendar.YEAR);
                        String birthYear = String.valueOf(year - Integer.parseInt(hpResume.getBirthYear()) + 1);
                        hpResume.setBirthYear(birthYear);
                        List<HpResumeWorkExperience> hpResumeWorkExperienceList = hpResumeWorkExperienceService.findListByResumeId(hpResume.getId());
                        hpResume.setHpResumeWorkExperienceList(hpResumeWorkExperienceList);
                        if (StringUtils.isNotBlank(hpResume.getHeadImg())) {
                            if (!hpResume.getHeadImg().contains("http")) {
                                hpResume.setHeadImg(Global.getAliyunUrl() + hpResume.getHeadImg());
                            }
                        }
                    }
                    returnMap.put("hpResume", hpResume);
                }
                return returnMap;
            } else {
                returnMap.put("success", "1004");
            }
        } else {
            returnMap.put("success", "2010");
        }
        return returnMap;
    }

    public HpResume findResumeByMemberId(String memberId) {
        return mapper.findResumeByMemberId(memberId);
    }

    public void saveMenberIdByuserId(String userid, String hpMemberId) {
        mapper.saveMenberIdByuserId(userid, hpMemberId);
    }

    /**
     * 查询用户简历是否存在（userId）
     *
     * @param id
     * @return
     */
    public List<HpResume> findListByUserId(String id) {
        return mapper.findListByUserId(id);
    }
}