diagbotcloud/user-service/src/main/java/com/diagbot/web/UserController.java

package com.diagbot.web;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.diagbot.annotation.SysLogger;
import com.diagbot.dto.GetConsoleUserInfoDTO;
import com.diagbot.dto.JwtDTO;
import com.diagbot.dto.LoginDTO;
import com.diagbot.dto.RespDTO;
import com.diagbot.dto.UserLoginDTO;
import com.diagbot.dto.UserOrgDTO;
import com.diagbot.entity.Permission;
import com.diagbot.entity.Token;
import com.diagbot.entity.User;
import com.diagbot.facade.PermissionFacade;
import com.diagbot.facade.TokenFacade;
import com.diagbot.facade.UserFacade;
import com.diagbot.vo.AppkeySecretVO;
import com.diagbot.vo.BaseIdVO;
import com.diagbot.vo.JwtVO;
import com.diagbot.vo.ModifyPasswordVO;
import com.diagbot.vo.PersonVO;
import com.diagbot.vo.ResetPasswordVO;
import com.diagbot.vo.UserInfoByIdPageVO;
import com.diagbot.vo.UserLoginVO;
import com.diagbot.vo.UserSaveVO;
import com.diagbot.vo.UsernameVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.common.OAuth2AccessToken;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import javax.validation.Valid;
import java.util.List;
import java.util.Map;

/**
 * @Description: 用户操作API
 * @author: gaodm
 * @time: 2018/8/2 13:56
 */
@RestController
@Api(value = "用户账号注册等API", tags = { "用户账号注册等API" })
@RequestMapping("/user")
@SuppressWarnings("unchecked")
public class UserController {

    @Autowired
    private UserFacade userFacade;
    @Autowired
    private TokenFacade tokenFacade;
    @Autowired
    private PermissionFacade permissionFacade;


    @ApiOperation(value = "注册[by:zhoutg]",
            notes = "username：用户名，必填<br>" +
                    "password：密码，必填<br> " +
                    "organization：组织机构，必填<br>" +
                    "email：邮箱，必填<br>" +
                    "linkman：联系人，必填<br>" +
                    "imgId：图片id，必填<br>" +
                    "code：图片验证码，必填<br>")
    @PostMapping("/registry")
    @SysLogger("registry")
    @Transactional
    public RespDTO<Boolean> createUser(@RequestBody @Valid UserSaveVO userSaveVO) {
        Boolean res = userFacade.createUser(userSaveVO);
        return RespDTO.onSuc(res);
    }



    @ApiOperation(value = "验证token有效性[by:zhoutg]",
            notes = "token：token信息，必填<br>")
    @PostMapping("/verifyToken")
    @SysLogger("verifyToken")
    @ApiIgnore
    public RespDTO<Boolean> verifyToken(@RequestBody Token token) {
        Boolean data = tokenFacade.verifyToken(token.getToken(), 1);
        return RespDTO.onSuc(data);
    }



    @ApiOperation(value = "校验用户(手机号)已注册[by:zhoutg]",
            notes = "username：用户名(手机号)，必填<br>")
    @PostMapping("/verifyExistUsername")
    @SysLogger("verifyExistUsername")
    public RespDTO<Boolean> verifyExistUser(@RequestBody UsernameVO usernameVO) {
        Boolean res = userFacade.verifyExistUser(usernameVO);
        return RespDTO.onSuc(res);
    }


    @ApiOperation(value = "校验用户(手机号)未注册[by:zhoutg]",
            notes = "username：用户名(手机号)，必填<br>")
    @PostMapping("/verifyNoUsername")
    @SysLogger("verifyNoUsername")
    public RespDTO<Boolean> verifyUser(@RequestBody UsernameVO usernameVO) {
        Boolean res = userFacade.verifyNoUser(usernameVO);
        return RespDTO.onSuc(res);
    }

    @ApiOperation(value = "登录获取jwt[by:zhoutg]",
            notes = "username：用户名,必填<br>" +
                    "password：密码, 必填, 默认密码：dc483e80a7a0bd9ef71d8cf973673924<br> ")
    @PostMapping("/getJwt")
    @SysLogger("getJwt")
    public RespDTO<JwtDTO> getJwt(@RequestBody UserLoginVO userLoginVO) {
        JwtDTO data = userFacade.getJwt(userLoginVO.getUsername(), userLoginVO.getPassword());
        return RespDTO.onSuc(data);
    }

    @ApiOperation(value = "刷新jwt[by:zhoutg]",
            notes = "refreshToken：刷新令牌,必填<br>")
    @PostMapping("/refreshJwt")
    @SysLogger("refreshJwt")
    public RespDTO<JwtDTO> refreshJwt(@RequestBody JwtVO jwtVO) {
        JwtDTO data = userFacade.refreshJwt(jwtVO.getToken());
        return RespDTO.onSuc(data);
    }

    @ApiOperation(value = "验证Token[by:zhoutg]",
            notes = "checkToken：令牌,必填<br>")
    @PostMapping("/checkToken")
    @SysLogger("checkToken")
    public RespDTO<OAuth2AccessToken> checkToken(@RequestBody JwtVO jwtVO) {
        OAuth2AccessToken data = userFacade.checkToken(jwtVO.getToken());
        return RespDTO.onSuc(data);
    }


    @ApiOperation(value = "获取用户、机构、菜单信息[by:zhoutg]",
            notes = "")
    @PostMapping("/getUserOrgMenu")
    @SysLogger("getUserOrgMenu")
    public RespDTO<LoginDTO> getUserOrgMenu() {

        LoginDTO data = userFacade.getUserOrgMenu();
        return RespDTO.onSuc(data);
    }


    @ApiOperation(value = "获取朗通后台个人信息[by:zhoutg]",
            notes = "")
    @PostMapping("/getPersonInfo")
    @SysLogger("getPersonInfo")
    public RespDTO<UserLoginDTO> getPersonInfo() {

        UserLoginDTO data = userFacade.getPersonInfo();
        return RespDTO.onSuc(data);
    }


    @ApiOperation(value = "修改朗通后台个人信息[by:zhoutg]", notes = "")
    @PostMapping("/updatePersonInfo")
    @SysLogger("updatePersonInfo")
    public RespDTO<String> updatePersonInfo(@RequestBody PersonVO personVO) {
        userFacade.updatePersonInfo(personVO);
        return RespDTO.onSuc(null);
    }

    @ApiOperation(value = "重置密码[by:zhoutg]",
            notes = "username：用户名,必填<br>" +
                    "password：密码, 必填<br> " +
                    "diffPassword：标志，Y：修改的密码不能和上次相同,其他值：不作限制")
    @PostMapping("/resetPassword")
    @SysLogger("resetPassword")
    @Transactional
    public RespDTO<Boolean> resetPassword(@RequestBody ResetPasswordVO resetPasswordVO) {
        return userFacade.resetPassword(resetPasswordVO.getUsername(), resetPasswordVO.getPassword(), resetPasswordVO.getDiffPassword());
    }


    @ApiOperation(value = "修改密码[by:zhoutg]",
            notes = "password：原密码,必填<br>" +
                    "modifyPassword：新密码, 必填<br> ")
    @PostMapping("/midifyPassword")
    @SysLogger("midifyPassword")
    @Transactional
    public RespDTO<Boolean> midifyPassword(@RequestBody ModifyPasswordVO modifyPasswordVO) {
        Boolean flag = userFacade.modifyPassword(modifyPasswordVO.getPassword(), modifyPasswordVO.getModifyPassword());
        return RespDTO.onSuc(flag);
    }


    @PostMapping(value = "/getUserAndOrg")
    @SysLogger("getUserAndOrg")
    @ApiOperation(value = "获取用户和机构信息[by:zhoutg]")
    @ApiIgnore
    RespDTO<Map<Long, UserOrgDTO>> getUserAndOrg(@RequestBody List<Long> userIds) {
        Map<Long, UserOrgDTO> result = userFacade.getUserAndOrg(userIds);
        return RespDTO.onSuc(result);
    }

    @PostMapping(value = "/getUserAuthStatus")
    @SysLogger("getUserAuthStatus")
    @ApiOperation(value = "远程调用，获取用户认证状态[by:wangyu]")
    @ApiIgnore
    RespDTO<User> getUserAuthStatus(@RequestBody Long userId) {
        return userFacade.getUserAuthStatus(userId);
    }

    @PostMapping(value = "/getUserAllInfo")
    @SysLogger("getUserAllInfo")
    @ApiOperation(value = "远程调用，获取用户信息[by:wangyu]")
    @ApiIgnore
    RespDTO<List<User>> getUserAllInfo() {
        return RespDTO.onSuc(userFacade.getAllUserInfos());
    }

    @PostMapping(value = "/getUserByOrgName")
    @SysLogger("getUserByOrgName")
    @ApiOperation(value = "远程调用，根据机构名称获取用户信息[by:zhoutg]")
    @ApiIgnore
    RespDTO<List<Long>> getUserByOrgName(@RequestBody String name) {
        List<Long> data = userFacade.getUserByOrgNameFac(name);
        return RespDTO.onSuc(data);
    }


    @ApiOperation(value = "获取资源信息，接口未用[by:zhoutg]",
            notes = "appkey：用户名,必填<br>" +
                    "secret：密码, 必填<br> ")
    @PostMapping("/getPermission")
    @ApiIgnore
    public RespDTO<Permission> getPermission(@RequestBody AppkeySecretVO appkeySecretVO) {
        return permissionFacade.getPermission(appkeySecretVO.getAppkey(), appkeySecretVO.getSecret());
    }


    @ApiOperation(value = "根据用户名获取用户(示例)[by:gaodm]", notes = "根据用户名获取用户")
    @PostMapping("/getByUsername")
    @SysLogger("getByUsername")
    @ApiIgnore
    //    @PreAuthorize("hasAnyAuthority('ROLE_USER')")
    public RespDTO getUserInfo(@RequestBody UsernameVO usernameVO) {
        //参数判读省略
        User user = userFacade.getUserInfo(usernameVO.getUsername());
        return RespDTO.onSuc(user);
    }

    @ApiOperation(value = "根据用户id获取用户信息(示例)[by:gaodm]", notes = "根据用户id获取用户信息")
    @PostMapping("/getUserInfoByID")
    @SysLogger("getUserInfoByID")
    @ApiIgnore
    public RespDTO getUserInfoByID(@RequestBody UserInfoByIdPageVO userInfoByIdPageVO) {
        User userVo = new User();
        userVo.setId(userInfoByIdPageVO.getId());
        IPage<User> user = userFacade.selectUserListPage(userInfoByIdPageVO, userVo);
        return RespDTO.onSuc(user);
    }

    //    @ApiOperation(value = "注册事务", notes = "username和password为必选项")
    //    @PostMapping("/registryTran")
    //    @SysLogger("registryTran")
    //    @Transactional
    //    public RespDTO createUserTran(@RequestBody User user){
    //        //参数判读省略,判读该用户在数据库是否已经存在省略
    //        userFacade.createUser(user);
    //        throw new CommonException(CommonErrorCode.FAIL);
    ////        return RespDTO.onSuc(user);
    //    }

    //    @Autowired
    //    private AmqpTemplate rabbitTemplate;
    //    @GetMapping("/test")
    //    public void test(){
    //        rabbitTemplate.convertAndSend(RabbitConfig.queueName, "Hello from RabbitMQ!");
    //    }

    /**
     * 增加用户
     *
     * @param user 用户信息
     * @return 增加是否成功
     */
    @ApiOperation(value = "增加用户(示例)[by:gaodm]", notes = "username和password为必选项")
    @PostMapping("/addUser")
    @SysLogger("addUser")
    @Transactional
    @ApiIgnore
    public RespDTO addUser(@RequestBody User user) {
        //参数判读省略,判读该用户在数据库是否已经存在省略
        userFacade.saveUser(user);
        //        throw new CommonException(ErrorCode.FAIL);
        return RespDTO.onSuc(user);
    }

    /**
     * 修改用户
     *
     * @param user 用户信息
     * @return 修改是否成功
     */
    @ApiOperation(value = "修改用户(示例)[by:gaodm]", notes = "username和password为必选项")
    @PostMapping("/updateUser")
    @SysLogger("updateUser")
    @Transactional
    @ApiIgnore
    public RespDTO updateUser(@RequestBody User user) {
        //参数判读省略,判读该用户在数据库是否已经存在省略
        userFacade.updateUser(user);
        return RespDTO.onSuc(user);
    }

    /**
     * 查询用户信息
     *
     * @param baseIdVO 用户ID
     * @return 用户信息
     */
    @ApiOperation(value = "查询用户(示例)[by:gaodm]", notes = "查询用户")
    @GetMapping("/getUser")
    @SysLogger("getUser")
    @Transactional
    @ApiIgnore
    public RespDTO getUser(@RequestBody BaseIdVO baseIdVO) {
        return RespDTO.onSuc(userFacade.getById(baseIdVO.getId()));
    }

    /**
     * 删除用户
     *
     * @param baseIdVO 用户ID
     * @return 删除是否成功
     */
    @ApiOperation(value = "删除用户(示例)[by:gaodm]", notes = "删除用户")
    @PostMapping("/delUser")
    @SysLogger("delUser")
    @Transactional
    @ApiIgnore
    public RespDTO delUser(@RequestBody BaseIdVO baseIdVO) {
        return RespDTO.onSuc(userFacade.removeById(baseIdVO.getId()));
    }

    @ApiOperation(value = "控制台账户信息[by:rengb]", notes = "控制台账户信息no")
    @PostMapping("/getConsoleUserInfo")
    @SysLogger("getConsoleUserInfo")
    public RespDTO<GetConsoleUserInfoDTO> getConsoleUserInfo() {
        return RespDTO.onSuc(userFacade.getConsoleUserInfo());
    }

    @ApiOperation(value = "根据用户ID列表获取用户数据(远程调用)[by:gaodm]", notes = "根据用户ID列表获取用户数据")
    @PostMapping("/getUserInfoByIds")
    @SysLogger("getUserInfoByIds")
    @ApiIgnore
    public RespDTO<Map<String, String>> getUserInfoByIds(@RequestBody List<String> ids){
        return RespDTO.onSuc(userFacade.getUserInfoByIds(ids));
    }
}