auth/auth-service/src/main/java/org/onap/aaf/auth/service/api/API_NS.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.NsType;
  35 import org.onap.aaf.auth.dao.cass.Status;
  36 import org.onap.aaf.auth.env.AuthzTrans;
  37 import org.onap.aaf.auth.layer.Result;
  38 import org.onap.aaf.auth.service.AAF_Service;
  39 import org.onap.aaf.auth.service.Code;
  40 import org.onap.aaf.auth.service.facade.AuthzFacade;
  41 import org.onap.aaf.auth.service.mapper.Mapper.API;
  42
  43 public class API_NS {
  44         private static final String FULL = "full";
  45         private static final String TRUE = "true";
  46
  47         public static void init(AAF_Service authzAPI, AuthzFacade facade) throws Exception {
  48                 /**
  49                  * puts a new Namespace in Authz DB
  50                  *
  51                  * TESTCASES: TC_NS1, TC_NSdelete1
  52                  */
  53                 authzAPI.route(POST,"/authz/ns",API.NS_REQ, new Code(facade,"Create a Namespace",true) {
  54                                         @Override
  55                                         public void handle(
  56                                                         AuthzTrans trans,
  57                                                         HttpServletRequest req,
  58                                                         HttpServletResponse resp) throws Exception {
  59                                                 NsType nst = NsType.fromString(req.getParameter("type"));
  60                                                 Result<Void> r = context.requestNS(trans, req, resp,nst);
  61
  62                                                 switch(r.status) {
  63                                                         case OK:
  64                                                                 resp.setStatus(HttpStatus.CREATED_201);
  65                                                                 break;
  66                                                         case Status.ACC_Future:
  67                                                                 resp.setStatus(HttpStatus.ACCEPTED_202);
  68                                                                 break;
  69                                                         default:
  70                                                                 context.error(trans,resp,r);
  71                                                 }
  72                                         }
  73                                 }
  74                 );
  75
  76                 /**
  77                  * removes a Namespace from Authz DB
  78                  *
  79                  * TESTCASES: TC_NS1, TC_NSdelete1
  80                  */
  81                 authzAPI.route(DELETE,"/authz/ns/:ns",API.VOID, new Code(facade,"Delete a Namespace",true) {
  82                                 @Override
  83                                 public void handle(
  84                                                 AuthzTrans trans,
  85                                                 HttpServletRequest req,
  86                                                 HttpServletResponse resp) throws Exception {
  87                                         Result<Void> r = context.deleteNS(trans, req, resp, pathParam(req,":ns"));
  88                                         switch(r.status) {
  89                                                 case OK:
  90                                                         resp.setStatus(HttpStatus.OK_200);
  91                                                         break;
  92                                                 default:
  93                                                         context.error(trans,resp,r);
  94                                         }
  95                                 }
  96                         }
  97                 );
  98
  99                 /**
 100                  * Add an Admin in NS in Authz DB
 101                  *
 102                  * TESTCASES: TC_NS1
 103                  */
 104                 authzAPI.route(POST,"/authz/ns/:ns/admin/:id",API.VOID, new Code(facade,"Add an Admin to a Namespace",true) {
 105                         @Override
 106                         public void handle(
 107                                 AuthzTrans trans,
 108                                 HttpServletRequest req,
 109                                 HttpServletResponse resp) throws Exception {
 110                                 Result<Void> r = context.addAdminToNS(trans, resp, pathParam(req,":ns"), pathParam(req,":id"));
 111                                         switch(r.status) {
 112                                                 case OK:
 113                                                         resp.setStatus(HttpStatus.CREATED_201);
 114                                                         break;
 115                                                 case Status.ACC_Future:
 116                                                         resp.setStatus(HttpStatus.ACCEPTED_202);
 117                                                         break;
 118                                                 default:
 119                                                         context.error(trans,resp,r);
 120                                         }
 121                                 }
 122                         }
 123                 );
 124
 125                 /**
 126                  * Removes an Admin from Namespace in Authz DB
 127                  *
 128                  * TESTCASES: TC_NS1
 129                  */
 130                 authzAPI.route(DELETE,"/authz/ns/:ns/admin/:id",API.VOID, new Code(facade,"Remove an Admin from a Namespace",true) {
 131                         @Override
 132                         public void handle(
 133                                 AuthzTrans trans,
 134                                 HttpServletRequest req,
 135                                 HttpServletResponse resp) throws Exception {
 136                                         Result<Void> r = context.delAdminFromNS(trans, resp, pathParam(req,":ns"), pathParam(req,":id"));
 137                                         switch(r.status) {
 138                                                 case OK:
 139                                                         resp.setStatus(HttpStatus.OK_200);
 140                                                         break;
 141                                                 default:
 142                                                         context.error(trans,resp,r);
 143                                         }
 144                                 }
 145                         }
 146                 );
 147
 148         /**
 149          * Add an Admin in NS in Authz DB
 150          *
 151          * TESTCASES: TC_NS1
 152          */
 153                 authzAPI.route(POST,"/authz/ns/:ns/responsible/:id",API.VOID, new Code(facade,"Add a Responsible Identity to a Namespace",true) {
 154                         @Override
 155                         public void handle(
 156                                 AuthzTrans trans,
 157                                 HttpServletRequest req,
 158                                 HttpServletResponse resp) throws Exception {
 159                                 Result<Void> r = context.addResponsibilityForNS(trans, resp, pathParam(req,":ns"), pathParam(req,":id"));
 160                                         switch(r.status) {
 161                                                 case OK:
 162                                                         resp.setStatus(HttpStatus.CREATED_201);
 163                                                         break;
 164                                                 case Status.ACC_Future:
 165                                                         resp.setStatus(HttpStatus.ACCEPTED_202);
 166                                                         break;
 167                                                 default:
 168                                                         context.error(trans,resp,r);
 169                                         }
 170                                 }
 171                         }
 172                 );
 173
 174
 175                 /**
 176                  *
 177                  */
 178                 authzAPI.route(GET,"/authz/nss/:id",API.NSS, new Code(facade,"Return Information about Namespaces", true) {
 179                         @Override
 180                         public void handle(
 181                                 AuthzTrans trans,
 182                                 HttpServletRequest req,
 183                                 HttpServletResponse resp) throws Exception {
 184                                         Result<Void> r = context.getNSsByName(trans, resp, pathParam(req,":id"));
 185                                         switch(r.status) {
 186                                                 case OK:
 187                                                         resp.setStatus(HttpStatus.OK_200);
 188                                                         break;
 189                                                 default:
 190                                                         context.error(trans,resp,r);
 191                                         }
 192                                 }
 193                         }
 194                 );
 195
 196                 /**
 197                  * Get all Namespaces where user is an admin
 198                  */
 199                 authzAPI.route(GET,"/authz/nss/admin/:user",API.NSS, new Code(facade,"Return Namespaces where User is an Admin", true) {
 200                         @Override
 201                         public void handle(
 202                                 AuthzTrans trans,
 203                                 HttpServletRequest req,
 204                                 HttpServletResponse resp) throws Exception {
 205                                         Result<Void> r = context.getNSsByAdmin(trans, resp, pathParam(req,":user"),TRUE.equals(req.getParameter(FULL)));
 206                                         switch(r.status) {
 207                                                 case OK:
 208                                                         resp.setStatus(HttpStatus.OK_200);
 209                                                         break;
 210                                                 default:
 211                                                         context.error(trans,resp,r);
 212                                         }
 213                                 }
 214                         }
 215                 );
 216
 217                 /**
 218                  * Get all Namespaces where user is a responsible party
 219                  */
 220                 authzAPI.route(GET,"/authz/nss/responsible/:user",API.NSS, new Code(facade,"Return Namespaces where User is Responsible", true) {
 221                         @Override
 222                         public void handle(
 223                                 AuthzTrans trans,
 224                                 HttpServletRequest req,
 225                                 HttpServletResponse resp) throws Exception {
 226                                         Result<Void> r = context.getNSsByResponsible(trans, resp, pathParam(req,":user"),TRUE.equals(req.getParameter(FULL)));
 227                                         switch(r.status) {
 228                                                 case OK:
 229                                                         resp.setStatus(HttpStatus.OK_200);
 230                                                         break;
 231                                                 default:
 232                                                         context.error(trans,resp,r);
 233                                         }
 234                                 }
 235                         }
 236                 );
 237
 238                 /**
 239                  * Get all Namespaces where user is an admin or owner
 240                  */
 241                 authzAPI.route(GET,"/authz/nss/either/:user",API.NSS, new Code(facade,"Return Namespaces where User Admin or Owner", true) {
 242                         @Override
 243                         public void handle(
 244                                 AuthzTrans trans,
 245                                 HttpServletRequest req,
 246                                 HttpServletResponse resp) throws Exception {
 247                                         Result<Void> r = context.getNSsByEither(trans, resp, pathParam(req,":user"),TRUE.equals(req.getParameter(FULL)));
 248                                         switch(r.status) {
 249                                                 case OK:
 250                                                         resp.setStatus(HttpStatus.OK_200);
 251                                                         break;
 252                                                 default:
 253                                                         context.error(trans,resp,r);
 254                                         }
 255                                 }
 256                         }
 257                 );
 258
 259                 /**
 260                  * Get all children Namespaces
 261                  */
 262                 authzAPI.route(GET,"/authz/nss/children/:id",API.NSS, new Code(facade,"Return Child Namespaces", true) {
 263                         @Override
 264                         public void handle(
 265                                 AuthzTrans trans,
 266                                 HttpServletRequest req,
 267                                 HttpServletResponse resp) throws Exception {
 268                                         Result<Void> r = context.getNSsChildren(trans, resp, pathParam(req,":id"));
 269                                         switch(r.status) {
 270                                                 case OK:
 271                                                         resp.setStatus(HttpStatus.OK_200);
 272                                                         break;
 273                                                 default:
 274                                                         context.error(trans,resp,r);
 275                                         }
 276                                 }
 277                         }
 278                 );
 279
 280                 /**
 281                  * Set a description of a Namespace
 282                  */
 283                 authzAPI.route(PUT,"/authz/ns",API.NS_REQ,new Code(facade,"Set a Description for a Namespace",true) {
 284                         @Override
 285                         public void handle(
 286                                         AuthzTrans trans,
 287                                         HttpServletRequest req,
 288                                         HttpServletResponse resp) throws Exception {
 289
 290                                 Result<Void> r = context.updateNsDescription(trans, req, resp);
 291                                 switch(r.status) {
 292                                         case OK:
 293                                                 resp.setStatus(HttpStatus.OK_200);
 294                                                 break;
 295                                         default:
 296                                                 context.error(trans,resp,r);
 297                                 }
 298                         }
 299                 });
 300
 301                 /**
 302                  * Removes an Owner from Namespace in Authz DB
 303                  *
 304                  * TESTCASES: TC_NS1
 305                  */
 306                 authzAPI.route(DELETE,"/authz/ns/:ns/responsible/:id",API.VOID, new Code(facade,"Remove a Responsible Identity from Namespace",true) {
 307                         @Override
 308                         public void handle(
 309                                 AuthzTrans trans,
 310                                 HttpServletRequest req,
 311                                 HttpServletResponse resp) throws Exception {
 312                                         Result<Void> r = context.delResponsibilityForNS(trans, resp, pathParam(req,":ns"), pathParam(req,":id"));
 313                                         switch(r.status) {
 314                                                 case OK:
 315                                                         resp.setStatus(HttpStatus.OK_200);
 316                                                         break;
 317                                                 default:
 318                                                         context.error(trans,resp,r);
 319                                         }
 320                                 }
 321                         }
 322                 );
 323
 324                 authzAPI.route(POST,"/authz/ns/:ns/attrib/:key/:value",API.VOID, new Code(facade,"Add an Attribute from a Namespace",true) {
 325                         @Override
 326                         public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
 327                                         Result<Void> r = context.createAttribForNS(trans, resp,
 328                                                 pathParam(req,":ns"),
 329                                                 pathParam(req,":key"),
 330                                                 pathParam(req,":value"));
 331                                         switch(r.status) {
 332                                                 case OK:
 333                                                         resp.setStatus(HttpStatus.CREATED_201);
 334                                                         break;
 335                                                 default:
 336                                                         context.error(trans,resp,r);
 337                                         }
 338                                 }
 339                         }
 340                 );
 341
 342                 authzAPI.route(GET,"/authz/ns/attrib/:key",API.KEYS, new Code(facade,"get Ns Key List From Attribute",true) {
 343                         @Override
 344                         public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
 345                                         Result<Void> r = context.readNsByAttrib(trans, resp, pathParam(req,":key"));
 346                                         switch(r.status) {
 347                                                 case OK:
 348                                                         resp.setStatus(HttpStatus.OK_200);
 349                                                         break;
 350                                                 default:
 351                                                         context.error(trans,resp,r);
 352                                         }
 353                                 }
 354                         }
 355                 );
 356
 357                 authzAPI.route(PUT,"/authz/ns/:ns/attrib/:key/:value",API.VOID, new Code(facade,"update an Attribute from a Namespace",true) {
 358                         @Override
 359                         public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
 360                                         Result<Void> r = context.updAttribForNS(trans, resp,
 361                                                 pathParam(req,":ns"),
 362                                                 pathParam(req,":key"),
 363                                                 pathParam(req,":value"));
 364                                         switch(r.status) {
 365                                                 case OK:
 366                                                         resp.setStatus(HttpStatus.OK_200);
 367                                                         break;
 368                                                 default:
 369                                                         context.error(trans,resp,r);
 370                                         }
 371                                 }
 372                         }
 373                 );
 374
 375                 authzAPI.route(DELETE,"/authz/ns/:ns/attrib/:key",API.VOID, new Code(facade,"delete an Attribute from a Namespace",true) {
 376                         @Override
 377                         public void handle(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) throws Exception {
 378                                         Result<Void> r = context.delAttribForNS(trans, resp,
 379                                                 pathParam(req,":ns"),
 380                                                 pathParam(req,":key"));
 381                                         switch(r.status) {
 382                                                 case OK:
 383                                                         resp.setStatus(HttpStatus.OK_200);
 384                                                         break;
 385                                                 default:
 386                                                         context.error(trans,resp,r);
 387                                         }
 388                                 }
 389                         }
 390                 );
 391
 392         }
 393
 394
 395 }