Supwisdom Source - institute/sw-backend.git/blob

   1 package com.supwisdom.institute.backend.base.api.v1.controller.authn;
   2
   3 import java.util.HashMap;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import io.swagger.annotations.Api;
   8 import lombok.extern.slf4j.Slf4j;
   9
  10 import org.springframework.beans.factory.annotation.Autowired;
  11 import org.springframework.http.HttpStatus;
  12 import org.springframework.util.MimeTypeUtils;
  13 import org.springframework.web.bind.annotation.GetMapping;
  14 import org.springframework.web.bind.annotation.PathVariable;
  15 import org.springframework.web.bind.annotation.RequestMapping;
  16 import org.springframework.web.bind.annotation.RequestParam;
  17 import org.springframework.web.bind.annotation.ResponseBody;
  18 import org.springframework.web.bind.annotation.ResponseStatus;
  19 import org.springframework.web.bind.annotation.RestController;
  20
  21 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnAccountPermissionsResponseData;
  22 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnAccountResourcesResponseData;
  23 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnAccountResponseData;
  24 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnAccountRolesResponseData;
  25 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnApplicationsResponseData;
  26 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnPermissionRoleListResponseData;
  27 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnResourceRoleListResponseData;
  28 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnRolesResponseData;
  29 import com.supwisdom.institute.backend.base.api.v1.vo.authn.response.AuthnRoutesResponseData;
  30 import com.supwisdom.institute.backend.base.domain.entity.Account;
  31 import com.supwisdom.institute.backend.base.domain.entity.Application;
  32 import com.supwisdom.institute.backend.base.domain.entity.Permission;
  33 import com.supwisdom.institute.backend.base.domain.entity.Resource;
  34 import com.supwisdom.institute.backend.base.domain.entity.Role;
  35 import com.supwisdom.institute.backend.base.domain.entity.Route;
  36 import com.supwisdom.institute.backend.base.domain.model.PermissionRoleSet;
  37 import com.supwisdom.institute.backend.base.domain.model.ResourceRoleSet;
  38 import com.supwisdom.institute.backend.base.domain.service.AccountService;
  39 import com.supwisdom.institute.backend.base.domain.service.ApplicationService;
  40 import com.supwisdom.institute.backend.base.domain.service.PermissionService;
  41 import com.supwisdom.institute.backend.base.domain.service.ResourceService;
  42 import com.supwisdom.institute.backend.base.domain.service.RoleService;
  43 import com.supwisdom.institute.backend.base.domain.service.RouteService;
  44 import com.supwisdom.institute.backend.common.framework.vo.response.DefaultApiResponse;
  45
  46 @Api(value = "BaseAuthn", tags = { "BaseAuthn" }, description = "认证授权接口")
  47 @Slf4j
  48 @RestController
  49 @RequestMapping("/v1/authn")
  50 public class AuthnController {
  51
  52   @Autowired
  53   private AccountService accountService;
  54
  55   @Autowired
  56   private RoleService roleService;
  57
  58   @Autowired
  59   private ApplicationService applicationService;
  60
  61   @Autowired
  62   private PermissionService permissionService;
  63
  64   @Autowired
  65   private ResourceService resourceService;
  66
  67   @Autowired
  68   private RouteService routeService;
  69
  70   @GetMapping(path = "/{username}/account", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
  71   @ResponseStatus(value = HttpStatus.OK)
  72   @ResponseBody
  73   public DefaultApiResponse<AuthnAccountResponseData> account(
  74       @PathVariable("username") String username) {
  75
  76     if (username == null || username.length() == 0) {
  77       throw new RuntimeException("exception.get.username.must.not.empty");
  78     }
  79
  80     Account account = accountService.selectByUsername(username);
  81
  82     if (account == null) {
  83       throw new RuntimeException("exception.get.account.not.exist");
  84     }
  85
  86     AuthnAccountResponseData data = AuthnAccountResponseData.of(account);
  87
  88     return new DefaultApiResponse<AuthnAccountResponseData>(data);
  89   }
  90
  91   @GetMapping(path = "/{username}/roles", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
  92   @ResponseStatus(value = HttpStatus.OK)
  93   @ResponseBody
  94   public DefaultApiResponse<AuthnAccountRolesResponseData> accountRoles(
  95       @PathVariable("username") String username) {
  96
  97     if (username == null || username.length() == 0) {
  98       throw new RuntimeException("exception.get.username.must.not.empty");
  99     }
 100
 101     Account account = accountService.selectByUsername(username);
 102
 103     if (account == null) {
 104       throw new RuntimeException("exception.get.account.not.exist");
 105     }
 106
 107     List<Role> roles = roleService.selectByUsername(username);
 108
 109     AuthnAccountRolesResponseData data = AuthnAccountRolesResponseData.of(roles);
 110
 111     return new DefaultApiResponse<AuthnAccountRolesResponseData>(data);
 112   }
 113
 114   @GetMapping(path = "/{username}/applications", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 115   @ResponseStatus(value = HttpStatus.OK)
 116   @ResponseBody
 117   public DefaultApiResponse<AuthnAccountPermissionsResponseData> accountApplications(
 118       @PathVariable("username") String username,
 119       @RequestParam(name = "applicationId", required = false) String applicationId) {
 120
 121     if (username == null || username.length() == 0) {
 122       throw new RuntimeException("exception.get.username.must.not.empty");
 123     }
 124
 125     Account account = accountService.selectByUsername(username);
 126
 127     if (account == null) {
 128       throw new RuntimeException("exception.get.account.not.exist");
 129     }
 130
 131     List<Permission> applications = permissionService.selectByUsername(username, null, Permission.TYPE_APPLICATION);
 132
 133     AuthnAccountPermissionsResponseData data = AuthnAccountPermissionsResponseData.of(applications);
 134
 135     return new DefaultApiResponse<AuthnAccountPermissionsResponseData>(data);
 136   }
 137
 138   @GetMapping(path = "/{username}/menus", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 139   @ResponseStatus(value = HttpStatus.OK)
 140   @ResponseBody
 141   public DefaultApiResponse<AuthnAccountPermissionsResponseData> accountMenus(
 142       @PathVariable("username") String username,
 143       @RequestParam(name = "applicationId", required = false) String applicationId) {
 144
 145     if (username == null || username.length() == 0) {
 146       throw new RuntimeException("exception.get.username.must.not.empty");
 147     }
 148
 149     Account account = accountService.selectByUsername(username);
 150
 151     if (account == null) {
 152       throw new RuntimeException("exception.get.account.not.exist");
 153     }
 154
 155     List<Permission> menus = permissionService.selectByUsername(username, applicationId, Permission.TYPE_MENU);
 156
 157     AuthnAccountPermissionsResponseData data = AuthnAccountPermissionsResponseData.of(menus);
 158
 159     return new DefaultApiResponse<AuthnAccountPermissionsResponseData>(data);
 160   }
 161
 162   @GetMapping(path = "/{username}/operations", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 163   @ResponseStatus(value = HttpStatus.OK)
 164   @ResponseBody
 165   public DefaultApiResponse<AuthnAccountPermissionsResponseData> accountOperations(
 166       @PathVariable("username") String username,
 167       @RequestParam(name = "applicationId", required = false) String applicationId) {
 168
 169     if (username == null || username.length() == 0) {
 170       throw new RuntimeException("exception.get.username.must.not.empty");
 171     }
 172
 173     Account account = accountService.selectByUsername(username);
 174
 175     if (account == null) {
 176       throw new RuntimeException("exception.get.account.not.exist");
 177     }
 178
 179     List<Permission> operations = permissionService.selectByUsername(username, applicationId, Permission.TYPE_OPERATION);
 180
 181     AuthnAccountPermissionsResponseData data = AuthnAccountPermissionsResponseData.of(operations);
 182
 183     return new DefaultApiResponse<AuthnAccountPermissionsResponseData>(data);
 184   }
 185
 186   @GetMapping(path = "/{username}/resources", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 187   @ResponseStatus(value = HttpStatus.OK)
 188   @ResponseBody
 189   public DefaultApiResponse<AuthnAccountResourcesResponseData> accountResources(
 190       @PathVariable("username") String username,
 191       @RequestParam(name = "applicationId", required = false) String applicationId) {
 192
 193     if (username == null || username.length() == 0) {
 194       throw new RuntimeException("exception.get.username.must.not.empty");
 195     }
 196
 197     Account account = accountService.selectByUsername(username);
 198
 199     if (account == null) {
 200       throw new RuntimeException("exception.get.account.not.exist");
 201     }
 202
 203     List<Resource> resources = null;// FIXME: resourceService.selectByUsername(username, applicationId);
 204
 205     AuthnAccountResourcesResponseData data = AuthnAccountResourcesResponseData.of(resources);
 206
 207     return new DefaultApiResponse<AuthnAccountResourcesResponseData>(data);
 208   }
 209
 210 //  @GetMapping(path = "/resources", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 211 //  @ResponseStatus(value = HttpStatus.OK)
 212 //  @ResponseBody
 213 //  public DefaultApiResponse<AuthnResourceRoleListResponseData> applicationResources(
 214 //      @RequestParam(name = "applicationId", required = false) String applicationId) {
 215 //
 216 //    List<ResourceRoleSet> resourceRoleSets = resourceService.selectByApplication(applicationId);
 217 //
 218 //    AuthnResourceRoleListResponseData data = AuthnResourceRoleListResponseData.of(resourceRoleSets);
 219 //
 220 //    return new DefaultApiResponse<AuthnResourceRoleListResponseData>(data);
 221 //  }
 222
 223
 224   @GetMapping(path = "/applications", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 225   @ResponseStatus(value = HttpStatus.OK)
 226   @ResponseBody
 227   public DefaultApiResponse<AuthnApplicationsResponseData> applications() {
 228
 229     Map<String, Object> mapBean = new HashMap<>();
 230     Map<String, String> orderBy = null;
 231
 232     mapBean.put("status", "1");
 233
 234     List<Application> applications = applicationService.selectList(mapBean, orderBy);
 235
 236     AuthnApplicationsResponseData data = AuthnApplicationsResponseData.of(applications);
 237
 238     return new DefaultApiResponse<AuthnApplicationsResponseData>(data);
 239   }
 240
 241   @GetMapping(path = "/roles", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 242   @ResponseStatus(value = HttpStatus.OK)
 243   @ResponseBody
 244   public DefaultApiResponse<AuthnRolesResponseData> roles() {
 245
 246     Map<String, Object> mapBean = new HashMap<>();
 247     Map<String, String> orderBy = null;
 248
 249     mapBean.put("status", "1");
 250
 251     List<Role> roles = roleService.selectList(mapBean, orderBy);
 252
 253     AuthnRolesResponseData data = AuthnRolesResponseData.of(roles);
 254
 255     return new DefaultApiResponse<AuthnRolesResponseData>(data);
 256   }
 257
 258
 259   @GetMapping(path = "/permissionRoleSets", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 260   @ResponseStatus(value = HttpStatus.OK)
 261   @ResponseBody
 262   public DefaultApiResponse<AuthnPermissionRoleListResponseData> permissionRoleSets(
 263       @RequestParam(name = "applicationId", required = false) String applicationId) {
 264
 265     Map<String, Object> mapBean = new HashMap<>();
 266
 267     mapBean.put("status", "1");
 268     if (applicationId != null && !applicationId.isEmpty()) {
 269       mapBean.put("applicationId", applicationId);
 270     }
 271
 272     List<PermissionRoleSet> permissionRoleSets = permissionService.selectPermissionRoleSet(mapBean);
 273
 274     AuthnPermissionRoleListResponseData data = AuthnPermissionRoleListResponseData.of(permissionRoleSets);
 275
 276     return new DefaultApiResponse<AuthnPermissionRoleListResponseData>(data);
 277   }
 278
 279
 280   @GetMapping(path = "/resourceRoleSets", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 281   @ResponseStatus(value = HttpStatus.OK)
 282   @ResponseBody
 283   public DefaultApiResponse<AuthnResourceRoleListResponseData> resourceRoleSets(
 284       @RequestParam(name = "applicationId", required = false) String applicationId) {
 285
 286     Map<String, Object> mapBean = new HashMap<>();
 287
 288     mapBean.put("status", "1");
 289
 290     List<ResourceRoleSet> resourceRoleSets = resourceService.selectResourceRoleSet(mapBean);
 291
 292     AuthnResourceRoleListResponseData data = AuthnResourceRoleListResponseData.of(resourceRoleSets);
 293
 294     return new DefaultApiResponse<AuthnResourceRoleListResponseData>(data);
 295   }
 296
 297
 298
 299   @GetMapping(path = "/routes", produces = MimeTypeUtils.APPLICATION_JSON_VALUE)
 300   @ResponseStatus(value = HttpStatus.OK)
 301   @ResponseBody
 302   public DefaultApiResponse<AuthnRoutesResponseData> routes() {
 303
 304     Map<String, Object> mapBean = new HashMap<>();
 305     Map<String, String> orderBy = null;
 306
 307     mapBean.put("status", "1");
 308
 309     List<Route> routes = routeService.selectList(mapBean, orderBy);
 310
 311     AuthnRoutesResponseData data = AuthnRoutesResponseData.of(routes);
 312
 313     return new DefaultApiResponse<AuthnRoutesResponseData>(data);
 314   }
 315
 316
 317 }