jzg/authentication/src/main/java/com/jzg/controller/AuthController.java

package com.jzg.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.jzg.commons.request.RequestSingleParam;
import com.jzg.commons.util.MinioUtils;
import com.jzg.commons.util.PasswordUtils;
import com.jzg.config.JzgTokenService;
import com.jzg.config.JzgUserDetailsService;
import com.jzg.config.JzgUsernamePasswordAuthenticationToken;
import com.jzg.commons.constants.RedisKeyConstants;
import com.jzg.commons.core.base.BaseController;
import com.jzg.commons.core.page.HttpResult;
import com.jzg.entity.RedisToken;
import com.jzg.entity.SysUploadFiles;
import com.jzg.entity.SysUser;
import com.jzg.entity.vo.LoginFormVo;
import com.jzg.entity.vo.ModifyPassWordFormVo;
import com.jzg.commons.exception.SystemException;
import com.jzg.handler.JzgAuthenticationSuccessHandler;
import com.jzg.mapper.SysUploadFilesMapper;
import com.jzg.service.SysUserService;
import com.jzg.commons.util.ImageUtil;
import com.wf.captcha.SpecCaptcha;
import com.wf.captcha.base.Captcha;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.ServletException;
import jakarta.servlet.ServletOutputStream;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.http.fileupload.IOUtils;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.TimeUnit;


/**
 * 授权接口
 */
@Tag(name="授权接口")
@RestController
@RequestMapping("/auth")
public class AuthController extends BaseController {

    @Value("${minio.bucket-name}")
    private String bucketName;

    @Autowired
    AuthenticationManager authenticationManager;

    @Autowired
    SysUserService sysUserService;

    @Autowired
    JzgUserDetailsService jzgUserDetailsService;

    @Autowired
    private JzgTokenService tokenStore;

    @Autowired
    RedissonClient redissonClient;

    @Autowired
    SysUploadFilesMapper sysUploadFilesMapper;

    /**
     * 登录接口
     * @param loginFormVo
     * @throws ServletException
     * @throws IOException
     */
    @Operation(
            summary = "登录接口",
            description = "登录接口",
    responses = {
            @ApiResponse(responseCode = "200",description = "登录成功"),
            @ApiResponse(responseCode = "403",description = "登录失败")
    })
    @PostMapping("/login")
    public void login(@RequestBody LoginFormVo loginFormVo) throws ServletException, IOException {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        HttpServletResponse response = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getResponse();
        JzgUsernamePasswordAuthenticationToken authentication = new JzgUsernamePasswordAuthenticationToken(loginFormVo);
        Authentication authenticate = authenticationManager.authenticate(authentication);
        SecurityContextHolder.getContext().setAuthentication(authenticate);
        JzgAuthenticationSuccessHandler successHandler = new JzgAuthenticationSuccessHandler(tokenStore);
        successHandler.onAuthenticationSuccess(request, response, authenticate);
    }


    @GetMapping("captchaById")
    @Operation(summary = "获取验证码通过用户ID",
                description = "获取验证码通过用户ID")
    public void captchaByIdNew(HttpServletResponse response, String captchaId) throws Exception {
        response.setHeader("Cache-Control", "no-store, no-cache");
        response.setContentType("image/jpeg");
        String text;
        String imageId = null;
        if(Objects.isNull(redissonClient.getBucket(RedisKeyConstants.VERIFICATION_CODE + captchaId))) {
            imageId = redissonClient.getBucket(RedisKeyConstants.VERIFICATION_CODE + captchaId).get().toString();
        }

        Captcha captcha = new SpecCaptcha();

        // 重复验证码问题
        if (StringUtils.isNotEmpty(imageId)) {
            text = imageId;
        } else {
            // 生成文字验证码
            text = captcha.text();
        }
        // 生成图片验证码
        BufferedImage image = ImageUtil.base64ToBufferedImage(captcha.toBase64());
        if (StringUtils.isEmpty(captchaId)) {
            throw new SystemException("captchaId  必传");
        }

        // 保存到验证码到 redis
        redissonClient.getBucket(RedisKeyConstants.VERIFICATION_CODE + captchaId).set(text, 120, TimeUnit.SECONDS);
        ServletOutputStream out = response.getOutputStream();
        ImageIO.write(image, "jpg", out);
        IOUtils.closeQuietly(out);
    }

    @PostMapping("modifyPass")
    @Operation(summary = "修改密码")
    public HttpResult modifyPass(@RequestBody ModifyPassWordFormVo modifyPassWordFormVo){
        String userName = getUserName();
        SysUser sysUser = sysUserService.getOne(new LambdaQueryWrapper<SysUser>()
                .eq(SysUser::getUsername, userName)
                .or()
                .eq(SysUser::getMobile, userName));
        //如果旧密码一致更改密码
        if(!PasswordUtils.encode(modifyPassWordFormVo.getOldPassWord(),sysUser.getSalt()).equals(sysUser.getPassword()))
        {
            throw new SystemException("旧密码错误");
        }
        sysUser.setPassword(PasswordUtils.encode(modifyPassWordFormVo.getNewPassWord(),sysUser.getSalt()));
        return sysUserService.updateById(sysUser) ? HttpResult.ok("密码修改成功") : HttpResult.error("密码修改失败");
    }

    @PostMapping("register")
    @Operation(summary = "用户注册")
    public HttpResult register(@RequestBody SysUser sysUser){
        boolean register = sysUserService.register(sysUser);
        return HttpResult.ok("");
    }

    @PostMapping("logout")
    @Operation(summary = "退出登录")
    public HttpResult logout(){
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();
        String authorizationHeader = request.getHeader("Authorization");
        boolean delete = redissonClient.getBucket(authorizationHeader).delete();
        return delete ? HttpResult.ok("退出登录成功") : HttpResult.error("退出登录失败");
    }

    @PostMapping("changeHeadSculpture")
    @Operation(summary = "修改头像")
    public HttpResult changeHeadSculpture(@RequestSingleParam(value = "id") String id){
        String userName = getUserName();
        SysUser sysUser = sysUserService.getOne(new LambdaQueryWrapper<SysUser>()
                .eq(SysUser::getMobile, userName));
        sysUser.setHeadSculpture(id);
        SysUploadFiles sysUploadFiles = sysUploadFilesMapper.selectById(id);
        String jzgTouXiang = MinioUtils.getPresignedObjectUrl(bucketName, sysUploadFiles.getFileName());
        return sysUserService.updateById(sysUser)? HttpResult.ok(jzgTouXiang) : HttpResult.error("头像修改失败");
    }

    @PostMapping("getUsers")
    @Operation(summary = "用户列表")
    public HttpResult getUsers(){
        Page page = new Page();
        page.setSize(10);
        page.setPages(1);
        return HttpResult.ok(sysUserService.page(page));
    }

    @Operation(summary = "获取用户权限标识")
    @GetMapping("/getUserPer")
    public HttpResult getUserPer(){
        List<String> userPerms = getUserPerms();
        return HttpResult.ok(userPerms);
    }

    @Operation(summary = "获取个人信息")
    @GetMapping("/getUserInfo")
    public HttpResult<RedisToken> getUserInfo(){
        String userTokenString = getUserTokenString();
        return HttpResult.ok(JSONObject.parseObject(userTokenString,RedisToken.class));
    }
}