snd-escloud/src/main/java/platform/modules/home/web/HomeRefactorController.java

package platform.modules.home.web;

import com.alibaba.fastjson.JSONObject;
import com.aliyuncs.exceptions.ClientException;
import com.github.pagehelper.PageInfo;
import com.google.common.base.Preconditions;
import com.xiaoleilu.hutool.crypto.SecureUtil;
import com.xiaoleilu.hutool.util.StrUtil;
import io.jsonwebtoken.Claims;
import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authc.pam.UnsupportedTokenException;
import org.apache.shiro.subject.Subject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;
import platform.common.Constant;
import platform.common.annotation.OperationLog;
import platform.common.base.controller.BaseController;
import platform.common.base.model.CheckResult;
import platform.common.base.model.DictionaryItem;
import platform.common.base.service.DictionaryItemService;
import platform.common.util.*;
import platform.config.access.limit.AccessLimit;
import platform.config.redis.RedisService;
import platform.modules.api.dto.SyncUserDto;
import platform.modules.api.response.epoint.EpointTokenDto;
import platform.modules.api.service.SkyImageApiService;
import platform.modules.api.service.SyncThridFacade;
import platform.modules.build.entity.Company;
import platform.modules.build.entity.CompanyContact;
import platform.modules.build.entity.CompanyMaterial;
import platform.modules.build.service.BuildInfoService;
import platform.modules.build.service.CompanyContactService;
import platform.modules.build.service.CompanyMaterialService;
import platform.modules.build.service.CompanyService;
import platform.modules.company.service.CompanyInfoManageService;
import platform.modules.company.service.StockLandService;
import platform.modules.government.dto.ActivitySearchCondition;
import platform.modules.government.dto.FeedbackQuery;
import platform.modules.government.dto.QueryCondition;
import platform.modules.government.entity.*;
import platform.modules.government.service.*;
import platform.modules.home.dto.HomeRefactorDto;
import platform.modules.home.dto.LoginDto;
import platform.modules.home.dto.ThirdLoginDto;
import platform.modules.home.request.FindRequest;
import platform.modules.home.request.GlobalSearchBean;
import platform.modules.home.response.FindResponseProject;
import platform.modules.home.service.HomeRefactorService;
import platform.modules.sys.entity.*;
import platform.modules.sys.service.*;
import platform.modules.sys.shiro.UsernamePasswordToken;
import platform.modules.sys.web.ResponseMessage;
import java.util.Base64;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.CompletableFuture;

import static platform.common.Constant.HEAD_SESSION_STATUS_KEY;
import static platform.common.Constant.HEAD_SESSION_STATUS_VALUE;

/**
 * @author kevin
 * @since 2019/5/21 3:39 PM
 */
@RestController
@RequestMapping("refactor/home")
public class HomeRefactorController extends BaseController {

    @Autowired
    private HomeRefactorService homeRefactorService;

    @Autowired
    private ActivityService activityService;

    @Autowired
    private ProjectDeclarationService projectDeclarationService;

    @Autowired
    private ActivityFeedbackService activityFeedbackService;

    @Autowired
    private ActivityReviewService activityReviewService;

    @Autowired
    private StreetService streetService;

    @Autowired
    private DictionaryItemService dictionaryItemService;

    private static String profiles;

    @Value("${spring.profiles}")
    public void setProfiles(String param) {
        this.profiles = param;
    }

    @Autowired
    private VerificationCodeUtil verificationCodeUtil;

    @Autowired
    UserService userService;

    @Autowired
    private WaitToDoService waitToDoService;

    @Autowired
    private CompanyService companyService;

    @Autowired
    private AttachmentService attachmentService;

    @Autowired
    private SkyImageApiService skyImageApiService;

    @Autowired
    private SyncThridFacade syncThridFacade;

    @Autowired
    CompanyInfoManageService companyInfoManageService;

    @Autowired
    CompanyContactService companyContactService;

    @Autowired
    StockLandService stockLandService;

    @Autowired
    ApprovalService approvalService;

    @Autowired
    private CompanyMaterialService companyMaterialService;

    @Autowired
    private NavigationService navigationService;

    @Autowired
    private FriendLinkService friendLinkService;

    @Autowired
    private LogoService logoService;

    @Autowired
    private ContentService contentService;

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private RedisService redisService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private MenuService menuService;

    @Value("${carrier_hash_key}")
    private String carrier_hash_key;

    /**
     * 门户首页
     *
     * @return
     */
    @GetMapping("")
    public Object index() {
        HomeRefactorDto refactor = homeRefactorService.findHomeIndex();
        refactor.setFile_url(setFileUrl());
        return ResponseMessage.success("success", refactor);
    }

    /**
     * content列表
     *
     * @param request
     * @return
     */
    @PostMapping("/contentList")
    @AccessLimit
    public Object contentList(@RequestBody FindRequest request) {
        PageInfo<Content> info = homeRefactorService.findContentList(request);
        return ResponseMessage.success("success", info);
    }


    /**
     * content详情
     *
     * @param id
     * @return
     */
    @GetMapping("/contentDetail/{id}")
    public Object contentDetail(@PathVariable Integer id) {
        Content content = homeRefactorService.contentDeatil(id);
        content.getFileDown().setDownload_uri(setFileUrl());
        return ResponseMessage.success("success", content);
    }

    /**
     * 专题活动列表
     *
     * @param request
     * @return
     */
    @PostMapping(value = "/activityList")
    public ResponseMessage findActivity(@RequestBody FindRequest request) {
        request.setFile_url(setFileUrl());
        PageInfo<ActivityDetail> pageInfo = activityService.findContentList(request);
        return ResponseMessage.success("查询成功", pageInfo);
    }

    /**
     * 活动回顾列表
     *
     * @param request
     * @return
     */
    @PostMapping(value = "/reviewList")
    public ResponseMessage findReviewList(@RequestBody QueryCondition request) {
        request.setFile_url(setFileUrl());
        PageInfo<ActivityReview> pageInfo = activityReviewService.findActivityReviewList(request);
        return ResponseMessage.success("查询成功", pageInfo);
    }

    /**
     * 专题活动详情
     *
     * @param id
     * @return
     */
    @GetMapping("/activityDetail/{id}")
    public Object activityDetail(@PathVariable("id") Integer id, Integer user_id) {
        if (user_id == null) {
            User user = ShiroUtils.getUserEntity();
            user_id = user.getId();
        }
        ActivityDetail activityDetail = homeRefactorService.findByActivityId(id, user_id);
        activityDetail.setFile_url(setFileUrl());
        return ResponseMessage.success("查询成功", activityDetail);
    }

    /**
     * 门户评论列表
     *
     * @param id
     * @return
     */
    @GetMapping("/feedbacks/{id}")
    public Object frontFeedbackList(@PathVariable Integer id, FeedbackQuery query) {
        //活动反馈与评论
        query.setActivity_id(id);
        PageInfo<ActivityFeedback> pageInfo = activityFeedbackService.findFeedbackList(query);
        return ResponseMessage.success("success", pageInfo);
    }

    /**
     * 项目申报列表
     *
     * @param request
     * @return
     */
    @PostMapping(value = "/projectList")
    public ResponseMessage findProject(@RequestBody FindRequest request) {
        PageInfo<ProjectDeclaration> pageInfo = projectDeclarationService.findProjectList(request);
        return ResponseMessage.success("查询成功", pageInfo);
    }

    /**
     * 项目申报详情
     *
     * @param id
     * @return
     */
    @GetMapping("/projectDetail/{id}/{isFilling}")
    public Object projectDetail(@PathVariable Integer id, @PathVariable Integer isFilling) {
        return ResponseMessage.success("查询成功", homeRefactorService.findProjectDetail(id, isFilling));
    }

    @PostMapping(value = "/getDayEventList")
    public Object getDayEventList(@RequestBody ActivityDetail activityDetail) {
        log.info("获取一天内的所有活动");
        String startTime = activityDetail.getActivity_starttime();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date parse = sdf.parse(startTime);
            startTime = sdf.format(parse);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        List<ActivityDetail> dates = activityService.getEventList(startTime);
        return ResponseMessage.success("success", dates);
    }

    @GetMapping(value = "/activityList/time")
    @ResponseBody
    public ResponseMessage list(String startTime, String endTime) {

        ActivitySearchCondition param = new ActivitySearchCondition();
        param.setStartTime(startTime);
        param.setEndTime(endTime);

        List<ActivityDetail> list = activityService.findAvtivityListByTime(param);

        return ResponseMessage.success("success", list);
    }

    /**
     * 新首页查询  通知公告（其实是content内容管理） 和 活动
     */
    @PostMapping("/search/global")
    public Object searchGlobal(
        @RequestBody GlobalSearchBean globalSearchBean
    ) {
        return ResponseMessage.success("success", homeRefactorService.searchGlobal(globalSearchBean.getPageNum(), globalSearchBean.getPageSize(), globalSearchBean.getKeyword()));
    }

    @GetMapping("/search/latest")
    public Object searchLatest(@RequestParam(value = "size", defaultValue = "10", required = false) Integer size) {
        return ResponseMessage.success("success", homeRefactorService.searchLatest(size));
    }

    @GetMapping(value = "/param/register")
    @ResponseBody
    public ResponseMessage registerParam(HttpServletRequest request, HttpServletResponse response, ModelMap modelMap) {
        log.info("注册页面参数！");
        //Ajax登录超时校验,如果超时，进行前台响应提示
        if (WebUtil.isAjaxRequest(request)) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            response.setHeader(HEAD_SESSION_STATUS_KEY, HEAD_SESSION_STATUS_VALUE);
            response.setContentType("text/html;charset=utf-8");
        }
        List<Street> streetList = streetService.findList();
        Iterator<Street> it = streetList.iterator();
        while (it.hasNext()) {
            Street street = it.next();
            if (!street.getIs_start()) {
                it.remove();
            }
        }
        modelMap.addAttribute("streetList", streetList);

        //查询企业性质
        List<DictionaryItem> companyTypeList = dictionaryItemService.findListByTypeName(Constant.DictionaryType.COMPANY_TYPE);
        modelMap.put("companyTypeList", companyTypeList);
        //modelMap.put("companyTypeList", buildTypeService.findList(Constant.DictType.COMPANY));
        //查询币种单位数据
        List<DictionaryItem> itemList = dictionaryItemService.findListByTypeName(Constant.DictionaryType.CURRENCY_UNIT);
        modelMap.put("itemList", itemList);

        //查询行业类型
        List<DictionaryItem> industryTypeList = dictionaryItemService.findListByTypeName(Constant.DictionaryType.INDUSTRY_TYPE);
        modelMap.put("industryTypeList", industryTypeList);

        return ResponseMessage.success("success", modelMap);
    }

    /**
     * 个人注册
     * 20200514 新门户使用
     *
     * 这里密码需要格式更多一些
     *
     * @param userInfo
     * @return
     */
    @PostMapping("/personalRegister")
    @ResponseBody
    public ResponseMessage personalRegister(@RequestBody User userInfo) {
        if (IsTooFrequently()) {
            ResponseMessage.error("操作过于频繁，请稍后再试!");
        }
        try {
//            if (!Constant.Environment.PROD_TEST.equals(profiles) && !Constant.Environment.TEST.equals(profiles)) {
            if (!verificationCodeUtil.validateVerificationCode(userInfo.getPhone(), userInfo.getValidateNum())) {
                return ResponseMessage.error("验证码错误！");
            }
//            }

            String pwd = userInfo.getPassword().trim();
            Preconditions.checkNotNull(pwd);
            if (!PwdCheckUtil.checkPasswordLength(pwd, "8", null)
                    || !PwdCheckUtil.checkContainCase(pwd)
                    || !PwdCheckUtil.checkContainDigit(pwd)
                    || !PwdCheckUtil.checkContainSpecialChar(pwd)
            ) {
                return ResponseMessage.error("密码必须包含数字、字母、特殊符号且大于8位");
            }

            User user = new User();
            user.setUser_name(userInfo.getUser_name());
            user.setNick_name(userInfo.getNick_name().trim());
            user.setPassword(SecureUtil.md5().digestHex(userInfo.getPassword().trim()));
            user.setPhone(userInfo.getPhone());
            user.setUser_type(Constant.UserType.PERSONAL);
            user.setIs_register(1);
            user.setFist_login(1);
            user.setIs_start(true);
            user.setIs_admin(false);
            user.setCreate_name(userInfo.getUser_name());
            user.setCreate_time(DateUtil.getTimeString(new Date()));

            userService.insertAndGetId(user);
        } catch (Exception e) {
            e.printStackTrace();
            return ResponseMessage.error("注册失败" + e.getMessage());
        }
        return ResponseMessage.success("注册成功");
    }

    /**
     * 企业注册
     * 20200514 新门户使用
     *
     * @param information
     * @return
     * @throws Exception
     */
    @PostMapping("/register")
    @ResponseBody
    public ResponseMessage register(@RequestBody Company information) {

        if (IsTooFrequently()) {
            ResponseMessage.error("操作过于频繁，请稍后再试!");
        }
        try {
            Approval approval = new Approval();
//            if (!Constant.Environment.PROD_TEST.equals(profiles) && !Constant.Environment.TEST.equals(profiles)) {
            if (!verificationCodeUtil.validateVerificationCode(information.getPhone(), information.getValidateNum())) {
                return ResponseMessage.error("验证码错误！");
            }
//            }
            information.setConfirm_password(null);
            Street street = new Street();
            if (null != information.getStreet_id()) {
                street = streetService.findById(information.getStreet_id());
            }
            /*
            if (StringUtils.isNotBlank(stockLandService.getCompanyRegister(information.getStreet_id()))) {
                approval.setNextchecker(stockLandService.getCompanyRegister(information.getStreet_id()));
            }
            //20180418-yl- 街道没有审批人也可以注册，分菜单给某角色，某个角色的人就可以审批
            else {
                return ResponseMessage.error("注册失败，本公司所属街道企业注册审核组没有配置人员，请联系街道管理员配置!");
            }*/

            approval.setOper_type(Constant.OperType.SUBMIT);
            approval.setType(Constant.DictionaryType.COMPANY_REGISTER);
            information.setIs_start(false);
            information.setIs_register(0);
            //查看是否已经存在企业
//            Company company = companyService.findByParkIdAndCompanyName(information.getCompany_name(), information.getBuild_id());
            Company company = companyService.findByCompanyName(information.getCompany_name());
            if (company != null) {
                information.setId(company.getId());
                information.setIs_register(0);
                companyService.updateSelective(information);
            } else {
                information.setStreet_name(street.getName());
                companyService.insertAndGetId(information);
            }
            approval.setApply_id(information.getId());
            approval.setDeal_time(DateUtil.getTimeString(new Date()));
            approval.setDel_flag(false);
            approval.setBefore_approvalstatus("0");
            approval.setCreate_name(information.getUser_name());
            //approvalService.insertAndGetId(approval);
            /*List<CompanyContact> companyContactList = information.getCompanyContacts();
            if (companyContactList != null && companyContactList.size() > 0) {
                for (CompanyContact companyContacts : companyContactList) {
                    companyContacts.setCompany_id(information.getId());
                    companyContactService.saveSelective(companyContacts);
                }
            }*/
            CompanyContact contact = new CompanyContact();
            contact.setCompany_id(information.getId());
            contact.setContact(information.getUser_name());
            contact.setPhone(information.getPhone());
            contact.setDel_flag(false);
            companyContactService.saveSelective(contact);
            List<CompanyContact> companyContactList = information.getContactList();
            if (companyContactList != null && companyContactList.size() > 0) {
                for (CompanyContact companyContacts : companyContactList) {
                    if (companyContacts != null) {
                        companyContacts.setCompany_id(information.getId());
                        companyContactService.saveSelective(companyContacts);
                    }
                }
            }
            List<FileDown> files = information.getFileDownList();
            if (files != null && files.size() > 0) {
                for (FileDown file : files) {
                    if (file != null) {
                        //attachmentDao.deleteByBusiness(Constant.Attachment.COMPANY_MATERIAL, information.getId());
                        attachmentService.updateAttachment(Constant.Attachment.COMPANY_MATERIAL, information.getId(), file.getFile_id());

                        CompanyMaterial companyMaterial = new CompanyMaterial();
                        companyMaterial.setAttachment_id(file.getFile_id());
                        companyMaterial.setCompany_id(information.getId());
                        companyMaterial.setFile_name(file.getFile_name());
                        companyMaterialService.insertAndGetId(companyMaterial);
                    }
                }
            }
            User user = new User();
            user.setUser_name(information.getUser_name());
            user.setNick_name(information.getNick_name().trim());
            user.setPassword(SecureUtil.md5().digestHex(information.getPassword().trim()));
            user.setPhone(information.getPhone());
            user.setUser_type(Constant.UserType.COMPANY);
            user.setIs_register(0);
            user.setFist_login(1);
            user.setIs_start(false);
            user.setIs_admin(true);
            user.setCompany_id(information.getId());
            user.setCompany_name(information.getCompany_name());
            if (null != information.getBuild_id()) {
                user.setBuild_id(information.getBuild_id());
                user.setBuild_name(information.getBuild_name());
            }
            user.setStreet_id(information.getStreet_id());
            user.setStreet_name(information.getStreet_name());
            user.setCreate_name(information.getUser_name());
            userService.insertAndGetId(user);
            approval.setCreate_by(user.getId());
            approvalService.insertAndGetId(approval);
            information.setCreate_by(user.getId());
            information.setCreate_name(user.getUser_name());
            companyService.updateSelective(information);

            Street finalStreet = street;
            CompletableFuture.runAsync(() -> {
                SyncUserDto dto = new SyncUserDto();
                dto.setAction(Constant.METHOD_STATUS.INSERT);
                dto.setOldUserName("");
                dto.setUserName(user.getUser_name());
                dto.setUserLoginName(user.getNick_name());
                dto.setPassword(information.getPassword().trim());
                dto.setCompanyName(information.getCompany_name());
                if (null != information.getStreet_id()) {
                    dto.setStreetName(finalStreet.getName());
                }
                dto.setToken(skyImageApiService.accessToken());
                syncThridFacade.syncUser(dto, null);
            }, ThreadPoolUtil.getInstance());

            //发送短信
            Map<String, String> params = new HashMap<>();
            params.put("user", user.getNick_name());
            params.put("street", information.getStreet_name());
            String templatCode = Constant.SMS_TemplateCode.REGISTER_REMIND;
            String templateParam = JSONObject.toJSONString(params);
            AlibabaSMSUtil.sendSMS(information.getPhone(), templatCode, Constant.SINGNAMW, templateParam);

            //新增街道待办
            addWaitToDo(information);

        } catch (Exception e) {
            e.printStackTrace();
            return ResponseMessage.error("注册失败" + e.getMessage());
        }
        return ResponseMessage.success("您的申请正在属地审核中，审核通过后，您将收到消息提醒。");
    }

    /**
     * 企业重置密码
     *
     * @param information
     * @return
     * @throws Exception
     */
    @PutMapping("/reset")
    @ResponseBody
    public ResponseMessage reset(@RequestBody Company information) {
        try {
            if (!verificationCodeUtil.validateVerificationCode(information.getPhone(), information.getValidateNum())) {
                return ResponseMessage.error("验证码错误！");
            }
            User user = userService.getUserByNickname(information.getNick_name());
            user.setPassword(SecureUtil.md5().digestHex(information.getPassword()));
            userService.updateSelective(user);

            CompletableFuture.runAsync(() -> {
                // 同步密码到天启
                SyncUserDto dto = new SyncUserDto();
                dto.setAction(Constant.METHOD_STATUS.UPDATE);
                dto.setOldUserName(user.getNick_name());
                dto.setUserName(user.getUser_name());
                dto.setUserLoginName(user.getNick_name());
                dto.setPassword(information.getPassword());
                dto.setToken(skyImageApiService.accessToken());
                skyImageApiService.syncUserInfo(dto);
            }, ThreadPoolUtil.getInstance());

        } catch (Exception e) {
            e.printStackTrace();
            return ResponseMessage.error("修改失败" + e.getMessage());
        }
        return ResponseMessage.success("密码修改成功！系统将跳转到登陆页进行登录");
    }

    @Value("${jszypt.url.login}")
    private String JszyptLoginUrl;

    @OperationLog(value = "获取积分平台登录信息")
    @GetMapping(value = "/jszyptLoginInfo")
    @ResponseBody
    public ResponseMessage getJszyptLoginInfo() {

        User user = ShiroUtils.getUserEntity();
        Map map = new HashMap();
        //地址
        map.put("url", JszyptLoginUrl);
        //账号
        map.put("userName ", user.getNick_name());
        //联系电话
        map.put("phone", user.getPhone());
        //用户类型(1代表个人用户，2代表企业用户，3代表政府用户)
        Integer userType = user.getUser_type();
        if(Objects.equals(Constant.UserType.PERSONAL,userType)){
            map.put("userType", 1);
        }else if(Objects.equals(Constant.UserType.COMPANY,userType)){
            map.put("userType", 2);
        }else if(Objects.equals(Constant.UserType.GOVERNMENT,userType)){
            map.put("userType", 3);
        }
        if(Objects.equals(Constant.UserType.COMPANY,userType)){
            Company company = companyService.findById(user.getCompany_id());
            if(company!=null){
                //统一社会信用代码
                map.put("paperNo", company.getUscc());
                //公司名称
                map.put("companyName", company.getCompany_name());
            }
        }
        return ResponseMessage.success("获取积分平台登录信息", map);
    }

    /**
     * 用户登陆
     * 先根据用户名查询出一条用户记录再对比密码是否正确可以防止sql注入
     * 20200514 新门户使用
     *
     * @param login
     * @return
     */
    @OperationLog(value = "用户登录")
    @PostMapping(value = "/login")
    @ResponseBody
    public ResponseMessage login(@RequestBody LoginDto login) {

        String username = login.getUsername();
        String password = login.getPassword();
        Boolean isMobile = login.getIsMobile();
        try {
            //changeNewSession(request);
            Base64.Decoder decoder = Base64.getDecoder();
            username = new String(decoder.decode(username), "UTF-8");
            password = new String(decoder.decode(password), "UTF-8");

            //获取当前的Subject
            Subject currentUser = ShiroUtils.getSubject();
            UsernamePasswordToken token = new UsernamePasswordToken(username, password, isMobile, false);
            //在调用了login方法后,SecurityManager会收到AuthenticationToken,并将其发送给已配置的Realm执行必须的认证检查
            //每个Realm都能在必要时对提交的AuthenticationTokens作出反应
            //所以这一步在调用login(token)方法时,它会走到MyRealm.doGetAuthenticationInfo()方法中,具体验证方式详见此方法
            log.info("对用户进行登录验证..验证开始! username = {}", username);
//            if (checkUserLock(username)) {
//                return ResponseMessage.error(Constant.USER_HAS_LOCK);
//            }
            currentUser.login(token);
            //验证是否登录成功
            if (currentUser.isAuthenticated()) {
                log.info("对用户进行登录验证..验证通过! username = {}", username);
                ModelMap modelMap = new ModelMap();
                this.commonObject(modelMap, false);
                User user = userService.getUser(ShiroUtils.getUserId());
                if ((user.getPhone() == null || "".equals(user.getPhone()))) {
                    return ResponseMessage.success(Constant.USER_PHONE_EMPTY, user);
                }
                //获取token
                modelMap.put("token", userService.createToken());
                return ResponseMessage.success(Constant.USER_LOGIN_IN, modelMap);
            }
        } catch (UnknownAccountException e) {  //账号不存在
            log.info("! username = {}", username);
//            recordLoginFail(username);
            return ResponseMessage.error(Constant.USER_NOT_FIND);

        } catch (IncorrectCredentialsException e) {
            log.info("对用户进行登录验证..验证未通过,错误的凭证! username = {}", username);
            return ResponseMessage.error(Constant.USER_INVALID);

        } catch (LockedAccountException e) {
            log.info("对用户进行登录验证..验证未通过,账户已锁定! username = {}", username);
            return ResponseMessage.error(Constant.USER_HAS_REGISTERING);
        } catch (ExcessiveAttemptsException eae) {
            log.info("对用户进行登录验证..验证未通过,错误次数过多! username = {}", username);
            return ResponseMessage.error(Constant.USER_ERROR_MANY);
        } catch (AuthenticationException e) {
            return ResponseMessage.error(Constant.SYSTEM_ERRORS);
        } catch (Exception e) {
            log.error("对用户进行登录验证失败! username = {} e = {}", username, e);
        }
        return ResponseMessage.error(Constant.SYSTEM_ERRORS);
    }

    @OperationLog(value = "第三方用户使用Code登录")
    @PostMapping(value = "/loginByCode")
    @ResponseBody
    public ResponseMessage loginByCode(@RequestBody ThirdLoginDto login) {

        String code = login.getCode();

        try {
            //根据code拿到token
            EpointTokenDto epointTokenDto = homeRefactorService.getTokenByCode(code);
            String accessToken = epointTokenDto.getAccess_token();
            if (StrUtil.isBlank(accessToken)) {
                return ResponseMessage.error(Constant.USER_CODE_INVALIAD);
            }
            //根据token与库里对比拿用户
            User user = homeRefactorService.getCurrentLoginUser(accessToken);
            if (user != null) {
                String username = user.getNick_name();
                //获取当前的Subject
                Subject currentUser = ShiroUtils.getSubject();
                UsernamePasswordToken token = new UsernamePasswordToken(username, null, false, true);
                //在调用了login方法后,SecurityManager会收到AuthenticationToken,并将其发送给已配置的Realm执行必须的认证检查
                //每个Realm都能在必要时对提交的AuthenticationTokens作出反应
                //所以这一步在调用login(token)方法时,它会走到MyRealm.doGetAuthenticationInfo()方法中,具体验证方式详见此方法
                log.info("对用户进行登录验证..验证开始! username = {}", username);
                currentUser.login(token);
                //验证是否登录成功
                if (currentUser.isAuthenticated()) {
                    log.info("对用户进行登录验证..验证通过! username = {}", username);
                    ModelMap modelMap = new ModelMap();
                    this.commonObject(modelMap, false);
                    //User user = userService.getUser(ShiroUtils.getUserId());
                    if ((user.getPhone() == null || "".equals(user.getPhone()))) {
                        return ResponseMessage.success(Constant.USER_PHONE_EMPTY, user);
                    }
                    //获取token
                    modelMap.put("token", userService.createToken());
                    return ResponseMessage.success(Constant.USER_LOGIN_IN, modelMap);
                }
            } else {
                return ResponseMessage.error(Constant.USER_NOT_FIND);
            }
        } catch (UnknownAccountException e) {  //账号不存在
            //log.info("! username = {}", username);
            return ResponseMessage.error(Constant.USER_NOT_FIND);

        } catch (IncorrectCredentialsException e) {
            //log.info("对用户进行登录验证..验证未通过,错误的凭证! username = {}", username);
            return ResponseMessage.error(Constant.USER_INVALID);

        } catch (LockedAccountException e) {
            //log.info("对用户进行登录验证..验证未通过,账户已锁定! username = {}", username);
            return ResponseMessage.error(Constant.USER_HAS_REGISTERING);
        } catch (ExcessiveAttemptsException eae) {
            //log.info("对用户进行登录验证..验证未通过,错误次数过多! username = {}", username);
            return ResponseMessage.error(Constant.USER_ERROR_MANY);
        } catch (AuthenticationException e) {
            return ResponseMessage.error(Constant.SYSTEM_ERRORS);
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
        return ResponseMessage.error(Constant.SYSTEM_ERRORS);
    }

    /**
     * 用户登出
     * 20200514 新门户使用
     */
    @OperationLog(value = "用户登出")
    @GetMapping(value = "/logout")
    @ResponseBody
    public ResponseMessage logout() {

        ShiroUtils.logout();
        CompletableFuture.runAsync(() -> {
            //todo 远程调用登出逻辑
        }, ThreadPoolUtil.getInstance());
        return ResponseMessage.success("登出成功！");
    }

    /**
     * 账号名是否存在
     */
    @ResponseBody
    @GetMapping(value = "/existNickName")
    public ResponseMessage getNickName(@RequestParam("nick_name") String nickName) {
        boolean flag = false;
        log.debug("检验账号名是否存在! id= {}, nickName= {}", nickName);
        User record = userService.findByNickName(nickName);

        if (null != record) {
            flag = true;
        }
        log.info("检验账号名是否存在! flag = {}", flag);
        return ResponseMessage.success("success", flag);
    }

    /**
     * 企业名是否存在
     */
    @ResponseBody
    @GetMapping(value = "/existCompanyName")
    public ResponseMessage getCompanyName(@RequestParam("company_name") String companyName) {
        boolean flag = false;
        log.debug("检验企业名是否存在! id= {}, companyName= {}", companyName);
        User user = new User();
        user.setDel_flag(false);
        user.setCompany_name(companyName);
        List<User> list = userService.findListByWhere(user);

        if (CommonUtils.isNotNull(list)) {
            flag = true;
        }
        log.info("检验企业名是否存在! flag = {}", flag);
        return ResponseMessage.success("success", flag);
    }

    //企业注册审核待办
    private void addWaitToDo(Company information) {
        if (null != information.getStreet_id()) {
            List<User> users = userService.findUsersByStreetId(information.getStreet_id());
            List<User> pusers = userService.findUsersByPermission("REGISTER_APPROVE");
            for (User user : users) {
                for (User puser : pusers) {
                    if (Objects.equals(user.getId(), puser.getId())) {
                        waitToDoService.newTODO("企业注册审核", "/register/approval?id=" + information.getId(), Constant.WaitToDo_OperType.AUDIT, information.getId(),
                                Constant.DictionaryType.COMPANY_REGISTER, "", user.getId().toString(), Constant.WaitToDo_IsSerial.IS_SERIAL, false);

                        //发送短信提醒
                        Map<String, String> params = new HashMap<>();
                        params.put("companyName", information.getCompany_name());
                        String templatCode = Constant.SMS_TemplateCode.S_REGISTER_REMIND;
                        String templateParam = JSONObject.toJSONString(params);
                        try {
                            AlibabaSMSUtil.sendSMS(puser.getPhone(), templatCode, Constant.SINGNAMW, templateParam);
                        } catch (ClientException | InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }

    @PutMapping("/complete")
    @OperationLog("完善手机号")
    @ResponseBody
    public ResponseMessage complete(@RequestBody User userInfo) throws Exception {
        try {
            if (!verificationCodeUtil.validateVerificationCode(userInfo.getPhone(), userInfo.getValidateNum())) {
                return ResponseMessage.error("验证码错误！");
            }

            User user = new User();
            user.setId(userInfo.getId());
            /*user.setUser_name(userInfo.getUser_name());
            user.setNick_name(userInfo.getNick_name());*/
            user.setPhone(userInfo.getPhone());
            userService.updateSelective(user);

        } catch (Exception e) {
            e.printStackTrace();
            return ResponseMessage.error("注册失败" + e.getMessage());
        }
        return ResponseMessage.success("完善信息成功！请重新登录！");
    }

    public void commonObject(ModelMap modelMap, Boolean isNav) throws Exception {
        Logo logo = logoService.findLogo();
        modelMap.put("fileUrl", setFileUrl());
        modelMap.put("logo", logo);
        modelMap.put("isLogin", ShiroUtils.isLogin());
        modelMap.put("userType", ShiroUtils.getUserType());
        modelMap.put("userName", ShiroUtils.getNickName());
        modelMap.put("userId", ShiroUtils.getUserId());
        User user = ShiroUtils.getUserEntity();
        if (user != null) {
            modelMap.put("firstLogin", user.getFist_login());
            if (org.apache.commons.lang3.StringUtils.isBlank(user.getUser_name()) || org.apache.commons.lang3.StringUtils.isBlank(user.getNick_name()) || StringUtils.isBlank(user.getPhone())) {
                modelMap.put("isComplete", false);
            } else {
                modelMap.put("isComplete", true);
            }
        }
        //获取有亲链接
        List<FriendLink> friendLinks = friendLinkService.findList();
        modelMap.put("friendLinks", friendLinks);
        if (isNav) {
            //	获取导航
            List<Navigation> navigations = navigationService.findList();
            modelMap.put("navigations", navigations);
        }
    }

    /**
     * 随机获取n个有图片的通知
     */
    @OperationLog(value = "随机获取n个有图片的通知")
    @GetMapping(value = "/content/random/{num}")
    @ResponseBody
    public ResponseMessage random(@PathVariable("num") Integer num) {

        ModelMap modelMap = new ModelMap();
        List<Map> list = contentService.randomPic(num);
        String fileUrl = setFileUrl();
        fileUrl = fileUrl.replace("/uploads", "");
        modelMap.put("fileUrl", fileUrl);
        modelMap.put("contentList", list);
        return ResponseMessage.success("success", modelMap);
    }

    /**
     * 获取存量用地后台跳转链接
     */
    @OperationLog(value = "获取存量用地后台跳转链接")
    @GetMapping(value = "/stockland/url")
    @ResponseBody
    public ResponseMessage stocklandUrl(HttpServletRequest request) {

        String authorization = request.getHeader("Authorization");
        if (StringUtils.isEmpty(authorization)) {
            throw new NullPointerException("token不能为空");
        }
        if (!authorization.startsWith("Bearer")) {
            throw new UnsupportedTokenException("token不合法");
        }
        String verifyToken = authorization.substring(7, authorization.length());
        //验证JWT的签名，返回CheckResult对象
        CheckResult checkResult = JWTUtil.validateJWT(verifyToken);
        if (checkResult.getSuccess()) {
            Claims claims = checkResult.getClaims();
            String token_key = claims.getIssuer();
            String usertId = claims.getId();
            HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
            String token = (String) hashOperations.get(carrier_hash_key, token_key);
            if (token != null && !token.equals(authorization)) {
                return ResponseMessage.error("无效的token");
            }
            //获取用户权限
            //获取主身份信息
            User user = userService.findById(Integer.parseInt(usertId));
            if (user != null) {

                List<Menu> menus;
                if (user.getIs_admin()) {
                    Menu menu = new Menu();
                    menu.setUser_type(user.getUser_type());
                    menus = menuService.findListByWhere(menu);
                } else {
                    menus = menuService.findListMenuByUserId(user.getId(), user.getUser_type());
                }

                //单独定一个集合对象
                Map<String, String> map = new HashMap<>();
                if (menus != null) {
                    for (Menu permission : menus) {

                        if (Objects.equals(permission.getPermission(), "C_STOCKLAND_MANAGE")) {
                            map.put("moudle", "C_SERVICE_MANAGE");
                            map.put("menu", permission.getPermission());
                        } else if (Objects.equals(permission.getPermission(), "S_AREA_APPROVE")) {
                            map.put("moudle", "S_SERVICE_MANAGE");
                            map.put("menu", permission.getPermission());
                        } else if (Objects.equals(permission.getPermission(), "G_APPROVAL_PENDING")) {
                            map.put("moudle", "G_SERVICE_MANAGE");
                            map.put("menu", permission.getPermission());
                        }

                    }
                }
                return ResponseMessage.success("success", map);
            } else {
                return ResponseMessage.error(",用户不存在");
            }
        } else {
            return ResponseMessage.error(checkResult.getErrCode() + ",token校验失败");
        }
    }
}