authz-service/src/main/java/org/onap/aaf/authz/service/api/API_NS.java

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