fj-dc/.svn/pristine/fa/fa864d2d7cd8621d68997cc76f9bf2845402ea3d.svn-base

package cn.com.goldenwater.core.web;

import cn.com.goldenwater.core.exception.BaseException;
import cn.com.goldenwater.dcproj.constValue.CommonLabel;
import cn.com.goldenwater.dcproj.dto.LoginUser;
import cn.com.goldenwater.dcproj.utils.JWTTokenUtil;
import cn.com.goldenwater.target.CheckException;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Map;


/**
 * 重写BaseController
 */
@ControllerAdvice
public abstract class BaseController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Value("${swagger.persId}")
    public String swaggerPersId;
    @Value("${swagger.orgId}")
    public String swaggerOrgId;
    @Value("${swagger.enable}")
    private boolean swaggerEnable;
    @Autowired
    private RedisTemplate redisTemplate;

    public BaseController() {
    }

    /**
     * 获取用户id
     */
    public String getCurrentPersId() {
        if (!swaggerEnable) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String persId = request.getHeader(CommonLabel.PERSID);
            if (StringUtils.isNotBlank(persId)) {
                return persId;
            }
            String uuid = request.getHeader(CommonLabel.ACCESS_TOKEN);
            String accessToken = (String) redisTemplate.opsForValue().get(uuid);
            if (StringUtils.isNotBlank(accessToken)) {
                LoginUser loginUser = JWTTokenUtil.unsign(accessToken, persId);
                if (loginUser.getPersId().equals(persId)) {
                    return persId;
                }
            }
        } else {
            return swaggerPersId;
        }


        throw new CheckException("当前用户信息不存在或已经失效，请重新登录!");
    }
    /**
     * 获取用户信息
     */
    public LoginUser getCurrentLoginUser() {
        if (!swaggerEnable) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            String persId = request.getHeader(CommonLabel.PERSID);
            if (StringUtils.isBlank(persId)) {
                throw new CheckException("当前用户信息不全，请重新登录!");
            }
            String uuid = request.getHeader(CommonLabel.ACCESS_TOKEN);
            String accessToken = (String) redisTemplate.opsForValue().get(uuid);
            if (StringUtils.isNotBlank(accessToken)) {
                LoginUser loginUser = JWTTokenUtil.unsign(accessToken, persId);
                return loginUser;
            }
        }
        throw new CheckException("当前用户信息不存在或已经失效，请重新登录!");
    }

    /**
     * 获取机构id
     */
    public String getCurrentOrgId() {
        if (!swaggerEnable) {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
            return request.getHeader("orgId");
        } else {
            return swaggerOrgId;
        }
    }

    /**
     * 返回成功信息
     *
     * @return
     */
    public static BaseResponse buildSuccessResponse() {
        BaseResponse response = new BaseResponse();
        response.setSuccess(true);
        return response;
    }

    /**
     * 返回成功信息
     *
     * @param data
     * @return
     */
    public static <T> BaseResponse<T> buildSuccessResponse(T data) {

        BaseResponse<T> response = new BaseResponse<T>();
        response.setSuccess(true);
        if (data == null) {
            Map<String, Object> params = new HashMap<>(1);
            response.setData((T) params);
            return response;
        }
        if (data instanceof String || data instanceof Integer || data instanceof Double || data instanceof Short
                || data instanceof Character || data instanceof Boolean || data instanceof Float || data instanceof Long) {
            Map<String, Object> params = new HashMap<>(1);
            params.put("key", data);
            response.setData((T) params);
        } else {
            response.setData(data);
        }
        return response;
    }

    public static <T> BaseResponse<T> buildSuccessResponse(T data, String accessToken) {
        BaseResponse<T> response = buildSuccessResponse(data);
        response.setAccessToken(accessToken);
        return response;
    }

    /* -------------------- 构建返回结果 - 失败 -------------------- */

    /**
     * 返回失败信息
     *
     * @return
     */
    public static BaseResponse buildFailResponse() {
        BaseResponse response = new BaseResponse();
        response.setSuccess(false);
        return response;
    }

    /**
     * 返回失败信息
     *
     * @return
     */
    public static BaseResponse buildFailResponse(Exception e) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(false);
        response.setMessage(e.getMessage());
        response.setThrowable(e.getClass().getName());
        if (e instanceof BaseException) {
            response.setCode(((BaseException) e).getCode());
        }
        return response;
    }

    /**
     * 返回失败信息
     *
     * @param message
     * @return
     */
    public static BaseResponse buildFailResponse(String message) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(false);
        response.setMessage(message);
        return response;
    }

    /**
     * 返回失败信息
     *
     * @param code
     * @param message
     * @return
     */
    public static BaseResponse buildFailResponse(Integer code, String message) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(false);
        response.setCode(code);
        response.setMessage(message);
        return response;
    }

    /**
     * 返回成功信息--返回提示信息
     *
     * @param code
     * @param message
     * @return
     */
    public static BaseResponse buildSuccessResponse(Integer code, String message) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(true);
        response.setCode(code);
        response.setMessage(message);
        return response;
    }

    public static <T> BaseResponse<T> buildSuccessResponse(T data, String accessToken, int code, String message) {
        BaseResponse<T> response = buildSuccessResponse(data);
        response.setAccessToken(accessToken);
        response.setCode(code);
        response.setMessage(message);
        return response;
    }

    /**
     * 返回成功信息--带对象
     *
     * @param code
     * @param message
     * @return
     */
    public static <T> BaseResponse<T> buildSuccessResponse(Integer code, String message, T data) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(true);
        response.setMessage(message);
        response = buildSuccessResponse(data);
        response.setCode(code);
        return response;
    }

    /**
     * 返回失败信息
     *
     * @param code
     * @param message
     * @param path
     * @param throwable
     * @return
     */
    public static BaseResponse buildFailResponse(Integer code, String message, String path, String throwable) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(false);
        response.setCode(code);
        response.setMessage(message);
        response.setPath(path);
        response.setThrowable(throwable);
        return response;
    }

    public static BaseResponse buildSuccessOrFailResponse(Integer code, String message, Boolean flag) {
        BaseResponse response = new BaseResponse();
        response.setSuccess(flag);
        response.setCode(code);
        response.setMessage(message);
        return response;
    }
}