auth/auth-service/src/main/java/org/onap/aaf/auth/service/api/API_Roles.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.auth.service.api;
  23
  24 import static org.onap.aaf.auth.layer.Result.OK;
  25 import static org.onap.aaf.auth.rserv.HttpMethods.DELETE;
  26 import static org.onap.aaf.auth.rserv.HttpMethods.GET;
  27 import static org.onap.aaf.auth.rserv.HttpMethods.POST;
  28 import static org.onap.aaf.auth.rserv.HttpMethods.PUT;
  29
  30 import javax.servlet.http.HttpServletRequest;
  31 import javax.servlet.http.HttpServletResponse;
  32
  33 import org.eclipse.jetty.http.HttpStatus;
  34 import org.onap.aaf.auth.dao.cass.Status;
  35 import org.onap.aaf.auth.env.AuthzTrans;
  36 import org.onap.aaf.auth.layer.Result;
  37 import org.onap.aaf.auth.service.AAF_Service;
  38 import org.onap.aaf.auth.service.Code;
  39 import org.onap.aaf.auth.service.facade.AuthzFacade;
  40 import org.onap.aaf.auth.service.mapper.Mapper.API;
  41
  42 public class API_Roles {
  43     public static void init(AAF_Service authzAPI, AuthzFacade facade) throws Exception {
  44         /**
  45          * puts a new role in Authz DB
  46          */
  47         authzAPI.route(POST,"/authz/role",API.ROLE_REQ, new Code(facade,"Create Role",true) {
  48                     @Override
  49                     public void handle(
  50                             AuthzTrans trans,
  51                             HttpServletRequest req,
  52                             HttpServletResponse resp) throws Exception {
  53                         Result<Void> r = context.createRole(trans, req, resp);
  54
  55                         switch(r.status) {
  56                             case OK:
  57                                 resp.setStatus(HttpStatus.CREATED_201);
  58                                 break;
  59                             case Status.ACC_Future:
  60                                 resp.setStatus(HttpStatus.ACCEPTED_202);
  61                                 break;
  62                             default:
  63                                 context.error(trans,resp,r);
  64                         }
  65                     }
  66                 }
  67             );
  68
  69         /**
  70          *  get Role by name
  71          */
  72         authzAPI.route(GET, "/authz/roles/:role", API.ROLES, new Code(facade,"GetRolesByFullName",true) {
  73             public void handle(
  74                     AuthzTrans trans,
  75                     HttpServletRequest req,
  76                     HttpServletResponse resp) throws Exception {
  77
  78                 Result<Void> r = context.getRolesByName(trans, resp, pathParam(req, "role"));
  79                 switch(r.status) {
  80                     case OK:
  81                         resp.setStatus(HttpStatus.OK_200);
  82                         break;
  83                     default:
  84                         context.error(trans,resp,r);
  85                 }
  86             }
  87
  88         });
  89
  90
  91         /**
  92          *  gets all Roles by user name
  93          */
  94         authzAPI.route(GET, "/authz/roles/user/:name", API.ROLES, new Code(facade,"GetRolesByUser",true) {
  95             public void handle(
  96                     AuthzTrans trans,
  97                     HttpServletRequest req,
  98                     HttpServletResponse resp) throws Exception {
  99
 100                 Result<Void> r = context.getRolesByUser(trans, resp, pathParam(req, "name"));
 101                 switch(r.status) {
 102                     case OK:
 103                         resp.setStatus(HttpStatus.OK_200);
 104                         break;
 105                     default:
 106                         context.error(trans,resp,r);
 107                 }
 108             }
 109
 110         });
 111
 112         /**
 113          *  gets all Roles by Namespace
 114          */
 115         authzAPI.route(GET, "/authz/roles/ns/:ns", API.ROLES, new Code(facade,"GetRolesByNS",true) {
 116             public void handle(
 117                     AuthzTrans trans,
 118                     HttpServletRequest req,
 119                     HttpServletResponse resp) throws Exception {
 120
 121                 Result<Void> r = context.getRolesByNS(trans, resp, pathParam(req, "ns"));
 122                 switch(r.status) {
 123                     case OK:
 124                         resp.setStatus(HttpStatus.OK_200);
 125                         break;
 126                     default:
 127                         context.error(trans,resp,r);
 128                 }
 129             }
 130         });
 131
 132         /**
 133          *  gets all Roles by Name without the Namespace
 134          */
 135         authzAPI.route(GET, "/authz/roles/name/:name", API.ROLES, new Code(facade,"GetRolesByNameOnly",true) {
 136             public void handle(
 137                     AuthzTrans trans,
 138                     HttpServletRequest req,
 139                     HttpServletResponse resp) throws Exception {
 140                 Result<Void> r = context.getRolesByNameOnly(trans, resp, pathParam(req, ":name"));
 141                 switch(r.status) {
 142                     case OK:
 143                         resp.setStatus(HttpStatus.OK_200);
 144                         break;
 145                     default:
 146                         context.error(trans,resp,r);
 147                 }
 148             }
 149         });
 150
 151         /**
 152          * Deletes a Role from Authz DB by Object
 153          */
 154         authzAPI.route(DELETE,"/authz/role",API.ROLE_REQ, new Code(facade,"Delete Role",true) {
 155                 @Override
 156                 public void handle(
 157                         AuthzTrans trans,
 158                         HttpServletRequest req,
 159                         HttpServletResponse resp) throws Exception {
 160                     Result<Void> r = context.deleteRole(trans, req, resp);
 161
 162                     switch(r.status) {
 163                         case OK:
 164                             resp.setStatus(HttpStatus.OK_200);
 165                             break;
 166                         default:
 167                             context.error(trans,resp,r);
 168                     }
 169                 }
 170
 171             }
 172         );
 173
 174
 175
 176         /**
 177          * Deletes a Role from Authz DB by Key
 178          */
 179         authzAPI.route(DELETE,"/authz/role/:role",API.ROLE, new Code(facade,"Delete Role",true) {
 180                 @Override
 181                 public void handle(
 182                         AuthzTrans trans,
 183                         HttpServletRequest req,
 184                         HttpServletResponse resp) throws Exception {
 185                     Result<Void> r = context.deleteRole(trans, resp, pathParam(req,":role"));
 186
 187                     switch(r.status) {
 188                         case OK:
 189                             resp.setStatus(HttpStatus.OK_200);
 190                             break;
 191                         default:
 192                             context.error(trans,resp,r);
 193                     }
 194                 }
 195
 196             }
 197         );
 198
 199
 200         /**
 201          * Add a Permission to a Role (Grant)
 202          */
 203         authzAPI.route(POST,"/authz/role/perm",API.ROLE_PERM_REQ, new Code(facade,"Add Permission to Role",true) {
 204                 @Override
 205                 public void handle(
 206                         AuthzTrans trans,
 207                         HttpServletRequest req,
 208                         HttpServletResponse resp) throws Exception {
 209
 210                     Result<Void> r = context.addPermToRole(trans, req, resp);
 211
 212                     switch(r.status) {
 213                         case OK:
 214                             resp.setStatus(HttpStatus.CREATED_201);
 215                             break;
 216                         default:
 217                             context.error(trans,resp,r);
 218                     }
 219                 }
 220             }
 221         );
 222
 223         /**
 224          * Get all Roles by Permission
 225          */
 226         authzAPI.route(GET,"/authz/roles/perm/:type/:instance/:action",API.ROLES,new Code(facade,"GetRolesByPerm",true) {
 227             public void handle(
 228                     AuthzTrans trans,
 229                     HttpServletRequest req,
 230                     HttpServletResponse resp) throws Exception {
 231
 232                 Result<Void> r = context.getRolesByPerm(trans, resp,
 233                         pathParam(req, "type"),
 234                         pathParam(req, "instance"),
 235                         pathParam(req, "action"));
 236                 switch(r.status) {
 237                     case OK:
 238                         resp.setStatus(HttpStatus.OK_200);
 239                         break;
 240                     default:
 241                         context.error(trans,resp,r);
 242                 }
 243             }
 244         });
 245
 246         /**
 247          * Set a role's description
 248          */
 249         authzAPI.route(PUT,"/authz/role",API.ROLE_REQ,new Code(facade,"Set Description for role",true) {
 250             @Override
 251             public void handle(
 252                     AuthzTrans trans,
 253                     HttpServletRequest req,
 254                     HttpServletResponse resp) throws Exception {
 255
 256                 Result<Void> r = context.updateRoleDescription(trans, req, resp);
 257                 switch(r.status) {
 258                     case OK:
 259                         resp.setStatus(HttpStatus.OK_200);
 260                         break;
 261                     default:
 262                         context.error(trans,resp,r);
 263                 }
 264             }
 265         });
 266
 267         /**
 268          * Set a permission's roles to roles given
 269          */
 270         authzAPI.route(PUT,"/authz/role/perm",API.ROLE_PERM_REQ,new Code(facade,"Set a Permission's Roles",true) {
 271             @Override
 272             public void handle(
 273                     AuthzTrans trans,
 274                     HttpServletRequest req,
 275                     HttpServletResponse resp) throws Exception {
 276
 277                 Result<Void> r = context.resetPermRoles(trans, req, resp);
 278                 switch(r.status) {
 279                     case OK:
 280                         resp.setStatus(HttpStatus.OK_200);
 281                         break;
 282                     default:
 283                         context.error(trans,resp,r);
 284                 }
 285             }
 286         });
 287
 288         /**
 289          * Delete a Permission from a Role
 290          * With multiple perms
 291          */
 292         authzAPI.route(DELETE,"/authz/role/:role/perm",API.ROLE_PERM_REQ, new Code(facade,"Delete Permission from Role",true) {
 293             @Override
 294             public void handle(
 295                     AuthzTrans trans,
 296                     HttpServletRequest req,
 297                     HttpServletResponse resp) throws Exception {
 298                 Result<Void> r = context.delPermFromRole(trans, req, resp);
 299
 300                 switch(r.status) {
 301                     case OK:
 302                         resp.setStatus(HttpStatus.OK_200);
 303                         break;
 304                     default:
 305                         context.error(trans,resp,r);
 306                 }
 307             }
 308         });
 309
 310
 311         /*
 312          * Delete a Permission from a Role by key only
 313          * /
 314         authzAPI.route(DELETE,"/authz/role/:role/perm/:type/:instance/:action",API.ROLE_PERM_REQ, new Code(facade,"Delete Permission from Role",true) {
 315             @Override
 316             public void handle(
 317                     AuthzTrans trans,
 318                     HttpServletRequest req,
 319                     HttpServletResponse resp) throws Exception {
 320                 Result<Void> r = context.delPermFromRole(trans, resp,
 321                         pathParam(req,":role"),
 322                         pathParam(req,":type"),
 323                         pathParam(req,":instance"),
 324                         pathParam(req,":action"));
 325
 326                 switch(r.status) {
 327                     case OK:
 328                         resp.setStatus(HttpStatus.OK_200);
 329                         break;
 330                     default:
 331                         context.error(trans,resp,r);
 332                 }
 333             }
 334         });
 335         */
 336     }
 337 }