authz-service/src/main/java/org/onap/aaf/authz/facade/AuthzFacadeImpl.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.facade;\r
  24 \r
  25 import static org.onap.aaf.authz.layer.Result.ERR_ActionNotCompleted;\r
  26 import static org.onap.aaf.authz.layer.Result.ERR_Backend;\r
  27 import static org.onap.aaf.authz.layer.Result.ERR_BadData;\r
  28 import static org.onap.aaf.authz.layer.Result.ERR_ConflictAlreadyExists;\r
  29 import static org.onap.aaf.authz.layer.Result.ERR_Denied;\r
  30 import static org.onap.aaf.authz.layer.Result.ERR_NotFound;\r
  31 import static org.onap.aaf.authz.layer.Result.ERR_NotImplemented;\r
  32 import static org.onap.aaf.authz.layer.Result.ERR_Policy;\r
  33 import static org.onap.aaf.authz.layer.Result.ERR_Security;\r
  34 import static org.onap.aaf.authz.layer.Result.OK;\r
  35 import static org.onap.aaf.dao.aaf.cass.Status.ERR_ChoiceNeeded;\r
  36 import static org.onap.aaf.dao.aaf.cass.Status.ERR_DelegateNotFound;\r
  37 import static org.onap.aaf.dao.aaf.cass.Status.ERR_DependencyExists;\r
  38 import static org.onap.aaf.dao.aaf.cass.Status.ERR_FutureNotRequested;\r
  39 import static org.onap.aaf.dao.aaf.cass.Status.ERR_InvalidDelegate;\r
  40 import static org.onap.aaf.dao.aaf.cass.Status.ERR_NsNotFound;\r
  41 import static org.onap.aaf.dao.aaf.cass.Status.ERR_PermissionNotFound;\r
  42 import static org.onap.aaf.dao.aaf.cass.Status.ERR_RoleNotFound;\r
  43 import static org.onap.aaf.dao.aaf.cass.Status.ERR_UserNotFound;\r
  44 import static org.onap.aaf.dao.aaf.cass.Status.ERR_UserRoleNotFound;\r
  45 \r
  46 import java.io.IOException;\r
  47 import java.lang.reflect.Method;\r
  48 import java.util.Date;\r
  49 \r
  50 import javax.servlet.http.HttpServletRequest;\r
  51 import javax.servlet.http.HttpServletResponse;\r
  52 \r
  53 import org.onap.aaf.authz.env.AuthzEnv;\r
  54 import org.onap.aaf.authz.env.AuthzTrans;\r
  55 import org.onap.aaf.authz.layer.FacadeImpl;\r
  56 import org.onap.aaf.authz.layer.Result;\r
  57 import org.onap.aaf.authz.service.AuthzCassServiceImpl;\r
  58 import org.onap.aaf.authz.service.AuthzService;\r
  59 import org.onap.aaf.authz.service.mapper.Mapper;\r
  60 import org.onap.aaf.authz.service.mapper.Mapper.API;\r
  61 import org.onap.aaf.cssa.rserv.RServlet;\r
  62 import org.onap.aaf.cssa.rserv.RouteReport;\r
  63 import org.onap.aaf.cssa.rserv.doc.ApiDoc;\r
  64 import org.onap.aaf.dao.aaf.cass.NsType;\r
  65 import org.onap.aaf.dao.aaf.cass.Status;\r
  66 import org.onap.aaf.dao.aaf.hl.Question;\r
  67 \r
  68 import org.onap.aaf.cadi.aaf.client.Examples;\r
  69 import org.onap.aaf.inno.env.APIException;\r
  70 import org.onap.aaf.inno.env.Data;\r
  71 import org.onap.aaf.inno.env.Data.TYPE;\r
  72 import org.onap.aaf.inno.env.Env;\r
  73 import org.onap.aaf.inno.env.TimeTaken;\r
  74 import org.onap.aaf.inno.env.util.Chrono;\r
  75 import org.onap.aaf.rosetta.Marshal;\r
  76 import org.onap.aaf.rosetta.env.RosettaDF;\r
  77 import org.onap.aaf.rosetta.env.RosettaData;\r
  78 \r
  79 import aaf.v2_0.Api;\r
  80 \r
  81 /**\r
  82  * AuthzFacade\r
  83  * \r
  84  * This Service Facade encapsulates the essence of the API Service can do, and provides\r
  85  * a single created object for elements such as RosettaDF.\r
  86  *\r
  87  * The Responsibilities of this class are to:\r
  88  * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)\r
  89  * 2) Validate incoming data (if applicable)\r
  90  * 3) Convert the Service response into the right Format, and mark the Content Type\r
  91  *              a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.\r
  92  * 4) Log Service info, warnings and exceptions as necessary\r
  93  * 5) When asked by the API layer, this will create and write Error content to the OutputStream\r
  94  * \r
  95  * Note: This Class does NOT set the HTTP Status Code.  That is up to the API layer, so that it can be \r
  96  * clearly coordinated with the API Documentation\r
  97  * \r
  98  *\r
  99  */\r
 100 public abstract class AuthzFacadeImpl<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> extends FacadeImpl implements AuthzFacade \r
 101         {\r
 102         private static final String FORBIDDEN = "Forbidden";\r
 103         private static final String NOT_FOUND = "Not Found";\r
 104         private static final String NOT_ACCEPTABLE = "Not Acceptable";\r
 105         private static final String GENERAL_SERVICE_ERROR = "General Service Error";\r
 106         private static final String NO_DATA = "***No Data***";\r
 107         private AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service = null;\r
 108         private final RosettaDF<NSS> nssDF;\r
 109         private final RosettaDF<PERMS> permsDF;\r
 110         private final RosettaDF<ROLES> roleDF;\r
 111         private final RosettaDF<USERS> usersDF;\r
 112         private final RosettaDF<USERROLES> userrolesDF;\r
 113         private final RosettaDF<CERTS> certsDF;\r
 114         private final RosettaDF<DELGS> delgDF;\r
 115         private final RosettaDF<REQUEST> permRequestDF;\r
 116         private final RosettaDF<REQUEST> roleRequestDF;\r
 117         private final RosettaDF<REQUEST> userRoleRequestDF;\r
 118         private final RosettaDF<REQUEST> rolePermRequestDF;\r
 119         private final RosettaDF<REQUEST> nsRequestDF;\r
 120         private final RosettaDF<REQUEST> credRequestDF;\r
 121         private final RosettaDF<REQUEST> delgRequestDF;\r
 122         private final RosettaDF<HISTORY> historyDF;\r
 123         private final RosettaDF<KEYS>    keysDF;\r
 124 \r
 125         private final RosettaDF<ERR>            errDF;\r
 126         private final RosettaDF<APPROVALS>  approvalDF;\r
 127         // Note: Api is not different per Version\r
 128         private final RosettaDF<Api>            apiDF;\r
 129 \r
 130 \r
 131         @SuppressWarnings("unchecked")\r
 132         public AuthzFacadeImpl(AuthzEnv env, AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service, Data.TYPE dataType) throws APIException {\r
 133                 this.service = service;\r
 134                 (nssDF                          = env.newDataFactory(service.mapper().getClass(API.NSS))).in(dataType).out(dataType);\r
 135                 (permRequestDF          = env.newDataFactory(service.mapper().getClass(API.PERM_REQ))).in(dataType).out(dataType);\r
 136                 (permsDF                        = env.newDataFactory(service.mapper().getClass(API.PERMS))).in(dataType).out(dataType);\r
 137 //              (permKeyDF                      = env.newDataFactory(service.mapper().getClass(API.PERM_KEY))).in(dataType).out(dataType);\r
 138                 (roleDF                         = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);\r
 139                 (roleRequestDF          = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);\r
 140                 (usersDF                        = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);\r
 141                 (userrolesDF                    = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);\r
 142                 (certsDF                        = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)\r
 143                         .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));\r
 144                 ;\r
 145                 (userRoleRequestDF      = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);\r
 146                 (rolePermRequestDF      = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);\r
 147                 (nsRequestDF            = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);\r
 148                 (credRequestDF          = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);\r
 149                 (delgRequestDF          = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);\r
 150                 (historyDF                      = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);\r
 151                 ( keysDF                        = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);\r
 152                 (delgDF                         = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);\r
 153                 (approvalDF             = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);\r
 154                 (errDF                          = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);\r
 155                 (apiDF                          = env.newDataFactory(Api.class)).in(dataType).out(dataType);\r
 156         }\r
 157         \r
 158         public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {\r
 159                 return service.mapper();\r
 160         }\r
 161         \r
 162         /* (non-Javadoc)\r
 163          * @see org.onap.aaf.authz.facade.AuthzFacade#error(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, int)\r
 164          * \r
 165          * Note: Conforms to AT&T TSS RESTful Error Structure\r
 166          */\r
 167         @Override\r
 168         public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {\r
 169                 String msg = result.details==null?"%s":"%s - " + result.details.trim();\r
 170                 String msgId;\r
 171                 String[] detail;\r
 172                 if(result.variables==null) {\r
 173                         detail = new String[1];\r
 174                 } else {\r
 175                         int l = result.variables.length;\r
 176                         detail=new String[l+1];\r
 177                         System.arraycopy(result.variables, 0, detail, 1, l);\r
 178                 }\r
 179                 //int httpstatus;\r
 180                 \r
 181                 switch(result.status) {\r
 182                         case ERR_ActionNotCompleted:\r
 183                                 msgId = "SVC1202";\r
 184                                 detail[0] = "Accepted, Action not complete";\r
 185                                 response.setStatus(/*httpstatus=*/202);\r
 186                                 break;\r
 187 \r
 188                         case ERR_Policy:\r
 189                                 msgId = "SVC3403";\r
 190                                 detail[0] = FORBIDDEN;\r
 191                                 response.setStatus(/*httpstatus=*/403);\r
 192                                 break;\r
 193                         case ERR_Security:\r
 194                                 msgId = "SVC2403";\r
 195                                 detail[0] = FORBIDDEN;\r
 196                                 response.setStatus(/*httpstatus=*/403);\r
 197                                 break;\r
 198                         case ERR_Denied:\r
 199                                 msgId = "SVC1403";\r
 200                                 detail[0] = FORBIDDEN;\r
 201                                 response.setStatus(/*httpstatus=*/403);\r
 202                                 break;\r
 203                         // This is still forbidden to directly impact, but can be Requested when passed\r
 204                         // with "request=true" query Param\r
 205                         case ERR_FutureNotRequested:\r
 206                                 msgId = "SVC2403";\r
 207                                 detail[0] = msg;\r
 208                                 response.setStatus(/*httpstatus=*/403);\r
 209                                 break;\r
 210                                 \r
 211                         case ERR_NsNotFound:\r
 212                                 msgId = "SVC2404";\r
 213                                 detail[0] = NOT_FOUND;\r
 214                                 response.setStatus(/*httpstatus=*/404);\r
 215                                 break;\r
 216                         case ERR_RoleNotFound:\r
 217                                 msgId = "SVC3404";\r
 218                                 detail[0] = NOT_FOUND;\r
 219                                 response.setStatus(/*httpstatus=*/404);\r
 220                                 break;\r
 221                         case ERR_PermissionNotFound:\r
 222                                 msgId = "SVC4404";\r
 223                                 detail[0] = NOT_FOUND;\r
 224                                 response.setStatus(/*httpstatus=*/404);\r
 225                                 break;\r
 226                         case ERR_UserNotFound:\r
 227                                 msgId = "SVC5404";\r
 228                                 detail[0] = NOT_FOUND;\r
 229                                 response.setStatus(/*httpstatus=*/404);\r
 230                                 break;\r
 231                         case ERR_UserRoleNotFound:\r
 232                                 msgId = "SVC6404";\r
 233                                 detail[0] = NOT_FOUND;\r
 234                                 response.setStatus(/*httpstatus=*/404);\r
 235                                 break;\r
 236                         case ERR_DelegateNotFound:\r
 237                                 msgId = "SVC7404";\r
 238                                 detail[0] = NOT_FOUND;\r
 239                                 response.setStatus(/*httpstatus=*/404);\r
 240                                 break;\r
 241                         case ERR_NotFound:\r
 242                                 msgId = "SVC1404";\r
 243                                 detail[0] = NOT_FOUND;\r
 244                                 response.setStatus(/*httpstatus=*/404);\r
 245                                 break;\r
 246 \r
 247                         case ERR_InvalidDelegate:\r
 248                                 msgId="SVC2406";\r
 249                                 detail[0] = NOT_ACCEPTABLE;\r
 250                                 response.setStatus(/*httpstatus=*/406);\r
 251                                 break;\r
 252                         case ERR_BadData:\r
 253                                 msgId="SVC1406";\r
 254                                 detail[0] = NOT_ACCEPTABLE;\r
 255                                 response.setStatus(/*httpstatus=*/406);\r
 256                                 break;\r
 257                                 \r
 258                         case ERR_ConflictAlreadyExists:\r
 259                                 msgId = "SVC1409";\r
 260                                 detail[0] = "Conflict Already Exists";\r
 261                                 response.setStatus(/*httpstatus=*/409);\r
 262                                 break;\r
 263                         \r
 264                         case ERR_DependencyExists:\r
 265                                 msgId = "SVC1424";\r
 266                                 detail[0] = "Failed Dependency";\r
 267                                 response.setStatus(/*httpstatus=*/424);\r
 268                                 break;\r
 269                         \r
 270                         case ERR_NotImplemented:\r
 271                                 msgId = "SVC1501";\r
 272                                 detail[0] = "Not Implemented"; \r
 273                                 response.setStatus(/*httpstatus=*/501);\r
 274                                 break;\r
 275                                 \r
 276                         case Status.ACC_Future:\r
 277                                 msgId = "SVC1202";\r
 278                                 detail[0] = "Accepted for Future, pending Approvals";\r
 279                                 response.setStatus(/*httpstatus=*/202);\r
 280                                 break;\r
 281                         case ERR_ChoiceNeeded:\r
 282                                 msgId = "SVC1300";\r
 283                                 detail = result.variables;\r
 284                                 response.setStatus(/*httpstatus=*/300);\r
 285                                 break;\r
 286                         case ERR_Backend: \r
 287                                 msgId = "SVC2500";\r
 288                                 detail[0] = GENERAL_SERVICE_ERROR;\r
 289                                 response.setStatus(/*httpstatus=*/500);\r
 290                                 break;\r
 291 \r
 292                         default: \r
 293                                 msgId = "SVC1500";\r
 294                                 detail[0] = GENERAL_SERVICE_ERROR;\r
 295                                 response.setStatus(/*httpstatus=*/500);\r
 296                                 break;\r
 297                 }\r
 298 \r
 299                 try {\r
 300                         StringBuilder holder = new StringBuilder();\r
 301                         errDF.newData(trans).load(\r
 302                                 service.mapper()\r
 303                                         .errorFromMessage(holder,msgId,msg,detail))\r
 304                                                 .to(response.getOutputStream());\r
 305                         trans.checkpoint(\r
 306                                         holder.toString(),\r
 307 //                                      String.format("ErrResp [" +     msgId + "] " + msg,(Object[])detail),\r
 308                                         Env.ALWAYS);\r
 309                 } catch (Exception e) {\r
 310                         trans.error().log(e,"unable to send response for",msg);\r
 311                 }\r
 312         }\r
 313         \r
 314         ///////////////////////////\r
 315         // Namespace\r
 316         ///////////////////////////\r
 317         public static final String CREATE_NS = "createNamespace";\r
 318         public static final String ADD_NS_ADMIN = "addNamespaceAdmin";\r
 319         public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";\r
 320         public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";\r
 321         public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";\r
 322         public static final String GET_NS_BY_NAME = "getNamespaceByName";\r
 323         public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";\r
 324         public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";\r
 325         public static final String GET_NS_BY_EITHER = "getNamespaceByEither";\r
 326         public static final String GET_NS_CHILDREN = "getNamespaceChildren";\r
 327         public static final String UPDATE_NS_DESC = "updateNamespaceDescription";\r
 328         public static final String DELETE_NS = "deleteNamespace";\r
 329         \r
 330 \r
 331         /* (non-Javadoc)\r
 332          * @see org.onap.aaf.authz.facade.AuthzFacade#createNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
 333          */\r
 334         @Override\r
 335         public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {\r
 336                 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);\r
 337                 try {\r
 338                         REQUEST request;\r
 339                         try {\r
 340                                 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());\r
 341                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 342                                         Question.logEncryptTrace(trans,rd.asString());\r
 343                                 }\r
 344                                 request = rd.asObject();\r
 345                         } catch(APIException e) {\r
 346                                 trans.error().log("Invalid Input",IN,CREATE_NS);\r
 347                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 348                         }\r
 349                         \r
 350                         Result<Void> rp = service.createNS(trans,request,type);\r
 351                         switch(rp.status) {\r
 352                                 case OK: \r
 353                                         setContentType(resp,nsRequestDF.getOutType());\r
 354                                         return Result.ok();\r
 355                                 default:\r
 356                                         return Result.err(rp);\r
 357                         }\r
 358                 } catch (Exception e) {\r
 359                         trans.error().log(e,IN,CREATE_NS);\r
 360                         return Result.err(e);\r
 361                 } finally {\r
 362                         tt.done();\r
 363                 }\r
 364         }\r
 365 \r
 366         /* (non-Javadoc)\r
 367          * @see org.onap.aaf.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 368          */\r
 369         @Override\r
 370         public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 371                 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 372                 try {\r
 373                         Result<Void> rp = service.addAdminNS(trans,ns,id);\r
 374                         switch(rp.status) {\r
 375                                 case OK: \r
 376                                         //TODO Perms??\r
 377                                         setContentType(resp,nsRequestDF.getOutType());\r
 378                                         resp.getOutputStream().println();\r
 379                                         return Result.ok();\r
 380                                 default:\r
 381                                         return Result.err(rp);\r
 382                         }\r
 383                 } catch (Exception e) {\r
 384                         trans.error().log(e,IN,ADD_NS_ADMIN);\r
 385                         return Result.err(e);\r
 386                 } finally {\r
 387                         tt.done();\r
 388                 }\r
 389         }\r
 390 \r
 391         /* (non-Javadoc)\r
 392          * @see org.onap.aaf.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 393          */\r
 394         @Override\r
 395         public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 396                 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 397                 try {\r
 398                         Result<Void> rp = service.delAdminNS(trans, ns, id);\r
 399                         switch(rp.status) {\r
 400                                 case OK: \r
 401                                         setContentType(resp,nsRequestDF.getOutType());\r
 402                                         return Result.ok();\r
 403                                 default:\r
 404                                         return Result.err(rp);\r
 405                         }\r
 406                 } catch (Exception e) {\r
 407                         trans.error().log(e,IN,DELETE_NS_ADMIN);\r
 408                         return Result.err(e);\r
 409                 } finally {\r
 410                         tt.done();\r
 411                 }\r
 412         }\r
 413 \r
 414         /* (non-Javadoc)\r
 415          * @see org.onap.aaf.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 416          */\r
 417         @Override\r
 418         public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 419                 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 420                 try {\r
 421                         Result<Void> rp = service.addResponsibleNS(trans,ns,id);\r
 422                         switch(rp.status) {\r
 423                                 case OK: \r
 424                                         setContentType(resp,nsRequestDF.getOutType());\r
 425                                         resp.getOutputStream().println();\r
 426                                         return Result.ok();\r
 427                                 default:\r
 428                                         return Result.err(rp);\r
 429                         }\r
 430                 } catch (Exception e) {\r
 431                         trans.error().log(e,IN,ADD_NS_RESPONSIBLE);\r
 432                         return Result.err(e);\r
 433                 } finally {\r
 434                         tt.done();\r
 435                 }\r
 436         }\r
 437 \r
 438         /* (non-Javadoc)\r
 439          * @see org.onap.aaf.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 440          */\r
 441         @Override\r
 442         public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 443                 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 444                 try {\r
 445                         Result<Void> rp = service.delResponsibleNS(trans, ns, id);\r
 446                         switch(rp.status) {\r
 447                                 case OK: \r
 448                                         setContentType(resp,nsRequestDF.getOutType());\r
 449                                         resp.getOutputStream().println();\r
 450                                         return Result.ok();\r
 451                                 default:\r
 452                                         return Result.err(rp);\r
 453                         }\r
 454                 } catch (Exception e) {\r
 455                         trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);\r
 456                         return Result.err(e);\r
 457                 } finally {\r
 458                         tt.done();\r
 459                 }\r
 460         }\r
 461 \r
 462         /* (non-Javadoc)\r
 463          * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 464          */\r
 465         @Override\r
 466         public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns) {\r
 467                 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 468                 try {\r
 469                         Result<NSS> rp = service.getNSbyName(trans, ns);\r
 470                         switch(rp.status) {\r
 471                                 case OK: \r
 472                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 473                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 474                                                 Question.logEncryptTrace(trans,data.asString());\r
 475                                         }\r
 476                                         data.to(resp.getOutputStream());\r
 477                                         setContentType(resp,nssDF.getOutType());\r
 478                                         return Result.ok();\r
 479                                 default:\r
 480                                         return Result.err(rp);\r
 481                         }\r
 482                 } catch (Exception e) {\r
 483                         trans.error().log(e,IN,GET_NS_BY_NAME);\r
 484                         return Result.err(e);\r
 485                 } finally {\r
 486                         tt.done();\r
 487                 }\r
 488         }\r
 489         \r
 490 //      TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page\r
 491         /* (non-Javadoc)\r
 492          * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 493          */\r
 494         @Override\r
 495         public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 496                 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);\r
 497                 try {\r
 498                         Result<NSS> rp = service.getNSbyAdmin(trans, user, full);\r
 499                         switch(rp.status) {\r
 500                                 case OK: \r
 501                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 502                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 503                                                 Question.logEncryptTrace(trans,data.asString());\r
 504                                         }\r
 505                                         data.to(resp.getOutputStream());\r
 506                                         setContentType(resp,nssDF.getOutType());\r
 507                                         return Result.ok();\r
 508                                 default:\r
 509                                         return Result.err(rp);\r
 510                         }\r
 511                 } catch (Exception e) {\r
 512                         trans.error().log(e,IN,GET_NS_BY_ADMIN);\r
 513                         return Result.err(e);\r
 514                 } finally {\r
 515                         tt.done();\r
 516                 }\r
 517         }\r
 518         \r
 519 //      TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page\r
 520         /* (non-Javadoc)\r
 521          * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 522          */\r
 523         @Override\r
 524         public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 525                 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);\r
 526                 try {\r
 527                         Result<NSS> rp = service.getNSbyResponsible(trans, user, full);\r
 528                         switch(rp.status) {\r
 529                                 case OK: \r
 530                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 531                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 532                                                 Question.logEncryptTrace(trans,data.asString());\r
 533                                         }\r
 534                                         data.to(resp.getOutputStream());\r
 535 \r
 536                                         setContentType(resp,nssDF.getOutType());\r
 537                                         return Result.ok();\r
 538                                 default:\r
 539                                         return Result.err(rp);\r
 540                         }\r
 541                 } catch (Exception e) {\r
 542                         trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);\r
 543                         return Result.err(e);\r
 544                 } finally {\r
 545                         tt.done();\r
 546                 }\r
 547         }\r
 548 \r
 549         /* (non-Javadoc)\r
 550          * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 551          */\r
 552         @Override\r
 553         public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 554                 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);\r
 555                 try {\r
 556                         Result<NSS> rp = service.getNSbyEither(trans, user, full);\r
 557                         \r
 558                         switch(rp.status) {\r
 559                                 case OK: \r
 560                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 561                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 562                                                 Question.logEncryptTrace(trans,data.asString());\r
 563                                         }\r
 564                                         data.to(resp.getOutputStream());\r
 565 \r
 566                                         setContentType(resp,nssDF.getOutType());\r
 567                                         return Result.ok();\r
 568                                 default:\r
 569                                         return Result.err(rp);\r
 570                         }\r
 571                 } catch (Exception e) {\r
 572                         trans.error().log(e,IN,GET_NS_BY_EITHER);\r
 573                         return Result.err(e);\r
 574                 } finally {\r
 575                         tt.done();\r
 576                 }\r
 577         }\r
 578 \r
 579         /* (non-Javadoc)\r
 580          * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 581          */\r
 582         @Override\r
 583         public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){\r
 584                 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);\r
 585                 try {\r
 586                         Result<NSS> rp = service.getNSsChildren(trans, parent);\r
 587                         switch(rp.status) {\r
 588                                 case OK: \r
 589                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 590                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 591                                                 Question.logEncryptTrace(trans,data.asString());\r
 592                                         }\r
 593                                         data.to(resp.getOutputStream());\r
 594                                         setContentType(resp,nssDF.getOutType());\r
 595                                         return Result.ok();\r
 596                                 default:\r
 597                                         return Result.err(rp);\r
 598                         }\r
 599                 } catch (Exception e) {\r
 600                         trans.error().log(e,IN,GET_NS_CHILDREN);\r
 601                         return Result.err(e);\r
 602                 } finally {\r
 603                         tt.done();\r
 604                 }\r
 605         }\r
 606 \r
 607         @Override\r
 608         public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
 609                 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);\r
 610                 try {\r
 611                         REQUEST rreq;\r
 612                         try {\r
 613                                 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());\r
 614                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 615                                         Question.logEncryptTrace(trans,data.asString());\r
 616                                 }\r
 617                                 rreq = data.asObject();\r
 618                         } catch(APIException e) {\r
 619                                 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);\r
 620                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 621 \r
 622                         }\r
 623                         Result<Void> rp = service.updateNsDescription(trans, rreq);\r
 624                         switch(rp.status) {\r
 625                                 case OK: \r
 626                                         setContentType(resp,nsRequestDF.getOutType());\r
 627                                         return Result.ok();\r
 628                                 default:\r
 629                                         return Result.err(rp);\r
 630                         }\r
 631                 } catch (Exception e) {\r
 632                         trans.error().log(e,IN,UPDATE_NS_DESC);\r
 633                         return Result.err(e);\r
 634                 } finally {\r
 635                         tt.done();\r
 636                 }\r
 637         }\r
 638         \r
 639         /*\r
 640          * (non-Javadoc)\r
 641          * @see org.onap.aaf.authz.facade.AuthzFacade#requestNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
 642          */\r
 643         @Override\r
 644         public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {\r
 645                 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 646                 try {\r
 647                         Result<Void> rp = service.deleteNS(trans,ns);\r
 648                         switch(rp.status) {\r
 649                                 case OK: \r
 650                                         setContentType(resp,nsRequestDF.getOutType());\r
 651                                         return Result.ok();\r
 652                                 default:\r
 653                                         return Result.err(rp);\r
 654                         }\r
 655                 } catch (Exception e) {\r
 656                         trans.error().log(e,IN,DELETE_NS);\r
 657                         return Result.err(e);\r
 658                 } finally {\r
 659                         tt.done();\r
 660                 }\r
 661         }\r
 662 \r
 663         private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";\r
 664         private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";\r
 665         private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";\r
 666         private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";\r
 667         \r
 668         /* (non-Javadoc)\r
 669          * @see org.onap.aaf.authz.facade.AuthzFacade#createAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
 670          */\r
 671         @Override\r
 672         public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {\r
 673                 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);\r
 674                 try {\r
 675                         Result<?> rp = service.createNsAttrib(trans,ns,key,value);\r
 676                         switch(rp.status) {\r
 677                                 case OK: \r
 678                                         setContentType(resp, keysDF.getOutType());\r
 679                                         resp.getOutputStream().println();\r
 680                                         return Result.ok();\r
 681                                 default:\r
 682                                         return Result.err(rp);\r
 683                         }\r
 684                 } catch (Exception e) {\r
 685                         trans.error().log(e,IN,NS_CREATE_ATTRIB);\r
 686                         return Result.err(e);\r
 687                 } finally {\r
 688                         tt.done();\r
 689                 }\r
 690         }\r
 691 \r
 692         /* (non-Javadoc)\r
 693          * @see org.onap.aaf.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 694          */\r
 695         @Override\r
 696         public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {\r
 697                 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);\r
 698                 try {\r
 699                         Result<KEYS> rp = service.readNsByAttrib(trans, key);\r
 700                         switch(rp.status) {\r
 701                                 case OK: \r
 702                                         RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);\r
 703                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 704                                                 Question.logEncryptTrace(trans,data.asString());\r
 705                                         }\r
 706                                         data.to(resp.getOutputStream());\r
 707                                         setContentType(resp,keysDF.getOutType());\r
 708                                         return Result.ok();\r
 709                                 default:\r
 710                                         return Result.err(rp);\r
 711                         }\r
 712                 } catch (Exception e) {\r
 713                         trans.error().log(e,IN,READ_NS_BY_ATTRIB);\r
 714                         return Result.err(e);\r
 715                 } finally {\r
 716                         tt.done();\r
 717                 }\r
 718         }\r
 719 \r
 720         /* (non-Javadoc)\r
 721          * @see org.onap.aaf.authz.facade.AuthzFacade#updAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
 722          */\r
 723         @Override\r
 724         public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {\r
 725                 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);\r
 726                 try {\r
 727                         Result<?> rp = service.updateNsAttrib(trans,ns,key,value);\r
 728                         switch(rp.status) {\r
 729                                 case OK: \r
 730                                         setContentType(resp, keysDF.getOutType());\r
 731                                         resp.getOutputStream().println();\r
 732                                         return Result.ok();\r
 733                                 default:\r
 734                                         return Result.err(rp);\r
 735                         }\r
 736                 } catch (Exception e) {\r
 737                         trans.error().log(e,IN,NS_UPDATE_ATTRIB);\r
 738                         return Result.err(e);\r
 739                 } finally {\r
 740                         tt.done();\r
 741                 }\r
 742 \r
 743         }\r
 744 \r
 745         /* (non-Javadoc)\r
 746          * @see org.onap.aaf.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)\r
 747          */\r
 748         @Override\r
 749         public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {\r
 750                 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);\r
 751                 try {\r
 752                         Result<?> rp = service.deleteNsAttrib(trans,ns,key);\r
 753                         switch(rp.status) {\r
 754                                 case OK: \r
 755                                         setContentType(resp, keysDF.getOutType());\r
 756                                         resp.getOutputStream().println();\r
 757                                         return Result.ok();\r
 758                                 default:\r
 759                                         return Result.err(rp);\r
 760                         }\r
 761                 } catch (Exception e) {\r
 762                         trans.error().log(e,IN,NS_DELETE_ATTRIB);\r
 763                         return Result.err(e);\r
 764                 } finally {\r
 765                         tt.done();\r
 766                 }\r
 767         }\r
 768 \r
 769 //\r
 770 // PERMISSION\r
 771 //\r
 772         public static final String CREATE_PERMISSION = "createPermission";\r
 773         public static final String GET_PERMS_BY_TYPE = "getPermsByType";\r
 774         public static final String GET_PERMS_BY_NAME = "getPermsByName";\r
 775         public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";\r
 776         public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";\r
 777         public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";\r
 778         public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";\r
 779         public static final String UPDATE_PERMISSION = "updatePermission";\r
 780         public static final String UPDATE_PERM_DESC = "updatePermissionDescription";\r
 781         public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";\r
 782         public static final String DELETE_PERMISSION = "deletePermission";\r
 783         \r
 784         /*\r
 785          * (non-Javadoc)\r
 786          * @see org.onap.aaf.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)\r
 787          */\r
 788         @Override\r
 789         public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
 790                 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);     \r
 791                 try {\r
 792                         REQUEST rreq;\r
 793                         try {\r
 794                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
 795                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 796                                         Question.logEncryptTrace(trans,data.asString());\r
 797                                 }\r
 798                                 rreq = data.asObject();                 \r
 799                         } catch(APIException e) {\r
 800                                 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);\r
 801                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 802                         }\r
 803                         \r
 804                         Result<Void> rp = service.createPerm(trans,rreq);\r
 805                         switch(rp.status) {\r
 806                                 case OK: \r
 807                                         setContentType(resp,permsDF.getOutType());\r
 808                                         return Result.ok();\r
 809                                 default:\r
 810                                         return Result.err(rp);\r
 811                         }\r
 812                 } catch (Exception e) {\r
 813                         trans.error().log(e,IN,CREATE_PERMISSION);\r
 814                         return Result.err(e);\r
 815                 } finally {\r
 816                         tt.done();\r
 817                 }\r
 818         }\r
 819         \r
 820         /* (non-Javadoc)\r
 821          * @see org.onap.aaf.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 822          */\r
 823         @Override\r
 824         public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {\r
 825                 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);\r
 826                 try {\r
 827                         \r
 828                         Result<PERMS> rp = service.getPermsByType(trans, perm);\r
 829                         switch(rp.status) {\r
 830                                 case OK:\r
 831                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 832                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 833                                                 Question.logEncryptTrace(trans,data.asString());\r
 834                                         }\r
 835                                         data.to(resp.getOutputStream());\r
 836                                         setContentType(resp,permsDF.getOutType());\r
 837                                         return Result.ok();\r
 838                                 default:\r
 839                                         return Result.err(rp);\r
 840                         }\r
 841                 } catch (Exception e) {\r
 842                         trans.error().log(e,IN,GET_PERMS_BY_TYPE);\r
 843                         return Result.err(e);\r
 844                 } finally {\r
 845                         tt.done();\r
 846                 }\r
 847         }\r
 848         \r
 849         @Override\r
 850         public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp, \r
 851                         String type, String instance, String action) {\r
 852                 \r
 853                 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type\r
 854                                 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);\r
 855                 try {\r
 856                         \r
 857                         Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);\r
 858                         switch(rp.status) {\r
 859                                 case OK:\r
 860                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 861                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 862                                                 Question.logEncryptTrace(trans,data.asString());\r
 863                                         }\r
 864                                         data.to(resp.getOutputStream());\r
 865                                         setContentType(resp,permsDF.getOutType());\r
 866                                         return Result.ok();\r
 867                                 default:\r
 868                                         return Result.err(rp);\r
 869                         }\r
 870                 } catch (Exception e) {\r
 871                         trans.error().log(e,IN,GET_PERMS_BY_TYPE);\r
 872                         return Result.err(e);\r
 873                 } finally {\r
 874                         tt.done();\r
 875                 }\r
 876         }\r
 877 \r
 878         /* (non-Javadoc)\r
 879          * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 880          */\r
 881         @Override\r
 882         public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp,  String user) {\r
 883                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
 884                 try {\r
 885                         Result<PERMS> rp = service.getPermsByUser(trans, user);\r
 886                         switch(rp.status) {\r
 887                                 case OK: \r
 888                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 889                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 890                                                 Question.logEncryptTrace(trans,data.asString());\r
 891                                         }\r
 892                                         data.to(resp.getOutputStream());\r
 893                                         setContentType(resp,permsDF.getOutType());\r
 894                                         return Result.ok();\r
 895                                 default:\r
 896                                         return Result.err(rp);\r
 897                         }\r
 898                 } catch (Exception e) {\r
 899                         trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);\r
 900                         return Result.err(e);\r
 901                 } finally {\r
 902                         tt.done();\r
 903                 }\r
 904         }\r
 905         \r
 906         /* (non-Javadoc)\r
 907          * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 908          */\r
 909         @Override\r
 910         public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {\r
 911                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);\r
 912                 try {\r
 913                         PERMS perms;\r
 914                         try {\r
 915                                 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());\r
 916                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 917                                         Question.logEncryptTrace(trans,data.asString());\r
 918                                 }\r
 919                                 perms = data.asObject();                        \r
 920                         } catch(APIException e) {\r
 921                                 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);\r
 922                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 923                         }\r
 924 \r
 925                         Result<PERMS> rp = service.getPermsByUser(trans, perms, user);\r
 926                         switch(rp.status) {\r
 927                                 case OK: \r
 928                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 929                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 930                                                 Question.logEncryptTrace(trans,data.asString());\r
 931                                         }\r
 932                                         data.to(resp.getOutputStream());\r
 933                                         setContentType(resp,permsDF.getOutType());\r
 934                                         return Result.ok();\r
 935                                 default:\r
 936                                         return Result.err(rp);\r
 937                         }\r
 938                 } catch (Exception e) {\r
 939                         trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);\r
 940                         return Result.err(e);\r
 941                 } finally {\r
 942                         tt.done();\r
 943                 }\r
 944         }\r
 945 \r
 946 \r
 947         /* (non-Javadoc)\r
 948          * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 949          */\r
 950         @Override\r
 951         public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {\r
 952                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);\r
 953                 try {\r
 954                         Result<PERMS> rp = service.getPermsByRole(trans, roleName);\r
 955                         switch(rp.status) {\r
 956                                 case OK:\r
 957                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 958                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 959                                                 Question.logEncryptTrace(trans,data.asString());\r
 960                                         }\r
 961                                         data.to(resp.getOutputStream());\r
 962                                         setContentType(resp,permsDF.getOutType());\r
 963                                         return Result.ok();\r
 964                                 default:\r
 965                                         return Result.err(rp);\r
 966                         }\r
 967                 } catch (Exception e) {\r
 968                         trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);\r
 969                         return Result.err(e);\r
 970                 } finally {\r
 971                         tt.done();\r
 972                 }\r
 973         }\r
 974         \r
 975         @Override\r
 976         public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {\r
 977                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 978                 try {\r
 979                         Result<PERMS> rp = service.getPermsByNS(trans, ns);\r
 980                         switch(rp.status) {\r
 981                                 case OK:\r
 982                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 983                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 984                                                 Question.logEncryptTrace(trans,data.asString());\r
 985                                         }\r
 986                                         data.to(resp.getOutputStream());\r
 987                                         setContentType(resp,permsDF.getOutType());\r
 988                                         return Result.ok();\r
 989                                 default:\r
 990                                         return Result.err(rp);\r
 991                         }\r
 992                 } catch (Exception e) {\r
 993                         trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);\r
 994                         return Result.err(e);\r
 995                 } finally {\r
 996                         tt.done();\r
 997                 }\r
 998         }\r
 999 \r
1000         /*\r
1001          * (non-Javadoc)\r
1002          * @see org.onap.aaf.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)\r
1003          */\r
1004         @Override\r
1005         public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,\r
1006                         String origType, String origInstance, String origAction) {\r
1007                 String cmdDescription = UPDATE_PERMISSION;\r
1008                 TimeTaken tt = trans.start( cmdDescription      + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);  \r
1009                 try {\r
1010                         REQUEST rreq;\r
1011                         try {\r
1012                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1013                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1014                                         Question.logEncryptTrace(trans,data.asString());\r
1015                                 }\r
1016                                 rreq = data.asObject();                 \r
1017                         } catch(APIException e) {\r
1018                                 trans.error().log("Invalid Input",IN,cmdDescription);\r
1019                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1020                         }\r
1021                         \r
1022                         Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);\r
1023                         switch(rp.status) {\r
1024                                 case OK: \r
1025                                         setContentType(resp,permsDF.getOutType());\r
1026                                         return Result.ok();\r
1027                                 default:\r
1028                                         return Result.err(rp);\r
1029                         }\r
1030                 } catch (Exception e) {\r
1031                         trans.error().log(e,IN,cmdDescription);\r
1032                         return Result.err(e);\r
1033                 } finally {\r
1034                         tt.done();\r
1035                 }\r
1036         }\r
1037         \r
1038         @Override\r
1039         public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1040                 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);\r
1041                 try {\r
1042                         REQUEST rreq;\r
1043                         try {\r
1044                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1045                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1046                                         Question.logEncryptTrace(trans,data.asString());\r
1047                                 }\r
1048                                 rreq = data.asObject();\r
1049                         } catch(APIException e) {\r
1050                                 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);\r
1051                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1052 \r
1053                         }\r
1054                         Result<Void> rp = service.updatePermDescription(trans, rreq);\r
1055                         switch(rp.status) {\r
1056                                 case OK: \r
1057                                         setContentType(resp,permRequestDF.getOutType());\r
1058                                         return Result.ok();\r
1059                                 default:\r
1060                                         return Result.err(rp);\r
1061                         }\r
1062                 } catch (Exception e) {\r
1063                         trans.error().log(e,IN,UPDATE_PERM_DESC);\r
1064                         return Result.err(e);\r
1065                 } finally {\r
1066                         tt.done();\r
1067                 }\r
1068         }\r
1069         \r
1070         \r
1071         @Override\r
1072         public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1073                 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);\r
1074                 try {\r
1075                         REQUEST rreq;\r
1076                         try {\r
1077                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1078                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1079                                         Question.logEncryptTrace(trans,data.asString());\r
1080                                 }\r
1081                                 rreq = data.asObject();\r
1082                         } catch(APIException e) {\r
1083                                 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);\r
1084                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1085                         }\r
1086                         \r
1087                         Result<Void> rp = service.resetPermRoles(trans, rreq);\r
1088                         \r
1089                         switch(rp.status) {\r
1090                                 case OK: \r
1091                                         setContentType(resp,permsDF.getOutType());\r
1092                                         return Result.ok();\r
1093                                 default:\r
1094                                         return Result.err(rp);\r
1095                         }\r
1096                 } catch (Exception e) {\r
1097                         trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);\r
1098                         return Result.err(e);\r
1099                 } finally {\r
1100                         tt.done();\r
1101                 }\r
1102         }\r
1103         \r
1104         @Override\r
1105         public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1106                 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);\r
1107                 try {\r
1108                         REQUEST rreq;\r
1109                         try {\r
1110                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1111                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1112                                         Question.logEncryptTrace(trans,data.asString());\r
1113                                 }\r
1114                                 rreq = data.asObject();\r
1115                         } catch(APIException e) {\r
1116                                 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);\r
1117                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1118 \r
1119                         }\r
1120 \r
1121                         Result<Void> rp = service.deletePerm(trans,rreq);\r
1122                         switch(rp.status) {\r
1123                                 case OK: \r
1124                                         setContentType(resp,permsDF.getOutType());\r
1125                                         return Result.ok();\r
1126                                 default:\r
1127                                         return Result.err(rp);\r
1128                         }\r
1129                 } catch (Exception e) {\r
1130                         trans.error().log(e,IN,DELETE_PERMISSION);\r
1131                         return Result.err(e);\r
1132                 } finally {\r
1133                         tt.done();\r
1134                 }\r
1135         }\r
1136 \r
1137         @Override\r
1138         public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {\r
1139                 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);\r
1140                 try {\r
1141                         Result<Void> rp = service.deletePerm(trans,type,instance,action);\r
1142                         switch(rp.status) {\r
1143                                 case OK: \r
1144                                         setContentType(resp,permsDF.getOutType());\r
1145                                         return Result.ok();\r
1146                                 default:\r
1147                                         return Result.err(rp);\r
1148                         }\r
1149                 } catch (Exception e) {\r
1150                         trans.error().log(e,IN,DELETE_PERMISSION);\r
1151                         return Result.err(e);\r
1152                 } finally {\r
1153                         tt.done();\r
1154                 }\r
1155         }\r
1156 \r
1157         public static final String CREATE_ROLE = "createRole";\r
1158         public static final String GET_ROLES_BY_USER = "getRolesByUser";\r
1159         public static final String GET_ROLES_BY_NS = "getRolesByNS";\r
1160         public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";\r
1161         public static final String GET_ROLES_BY_NAME = "getRolesByName";\r
1162         public static final String GET_ROLES_BY_PERM = "getRolesByPerm";\r
1163         public static final String UPDATE_ROLE_DESC = "updateRoleDescription"; \r
1164         public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";\r
1165         public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";\r
1166         public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";\r
1167         public static final String DELETE_ROLE = "deleteRole";\r
1168         public static final String GET_CERT_BY_ID = "getCertByID";\r
1169 \r
1170         @Override\r
1171         public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1172                 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);\r
1173                 try {\r
1174                         REQUEST rreq;\r
1175                         try {\r
1176                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1177                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1178                                         Question.logEncryptTrace(trans,data.asString());\r
1179                                 }\r
1180                                 rreq = data.asObject();\r
1181                         } catch(APIException e) {\r
1182                                 trans.error().log("Invalid Input",IN,CREATE_ROLE);\r
1183                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1184 \r
1185                         }\r
1186                         Result<Void> rp = service.createRole(trans, rreq);\r
1187                         switch(rp.status) {\r
1188                                 case OK: \r
1189                                         setContentType(resp,roleRequestDF.getOutType());\r
1190                                         return Result.ok();\r
1191                                 default:\r
1192                                         return Result.err(rp);\r
1193                         }\r
1194                 } catch (Exception e) {\r
1195                         trans.error().log(e,IN,CREATE_ROLE);\r
1196                         return Result.err(e);\r
1197                 } finally {\r
1198                         tt.done();\r
1199                 }\r
1200         }\r
1201 \r
1202         /* (non-Javadoc)\r
1203          * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1204          */\r
1205         @Override\r
1206         public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1207                 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);\r
1208                 try {\r
1209                         Result<ROLES> rp = service.getRolesByName(trans, role);\r
1210                         switch(rp.status) {\r
1211                                 case OK: \r
1212                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1213                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1214                                                 Question.logEncryptTrace(trans,data.asString());\r
1215                                         }\r
1216                                         data.to(resp.getOutputStream());\r
1217                                         setContentType(resp,roleDF.getOutType());\r
1218                                         return Result.ok();\r
1219                                 default:\r
1220                                         return Result.err(rp);\r
1221                         }\r
1222                 } catch (Exception e) {\r
1223                         trans.error().log(e,IN,GET_ROLES_BY_NAME);\r
1224                         return Result.err(e);\r
1225                 } finally {\r
1226                         tt.done();\r
1227                 }\r
1228         }\r
1229 \r
1230         /* (non-Javadoc)\r
1231          * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1232          */\r
1233         @Override\r
1234         public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {\r
1235                 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
1236                 try {\r
1237                         Result<ROLES> rp = service.getRolesByUser(trans, user);\r
1238                         switch(rp.status) {\r
1239                                 case OK: \r
1240                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1241                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1242                                                 Question.logEncryptTrace(trans,data.asString());\r
1243                                         }\r
1244                                         data.to(resp.getOutputStream());\r
1245                                         setContentType(resp,roleDF.getOutType());\r
1246                                         return Result.ok();\r
1247                                 default:\r
1248                                         return Result.err(rp);\r
1249                         }\r
1250                 } catch (Exception e) {\r
1251                         trans.error().log(e,IN,GET_ROLES_BY_USER, user);\r
1252                         return Result.err(e);\r
1253                 } finally {\r
1254                         tt.done();\r
1255                 }\r
1256         }\r
1257 \r
1258         /* (non-Javadoc)\r
1259          * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1260          */\r
1261         @Override\r
1262         public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {\r
1263                 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
1264                 try {\r
1265                         Result<ROLES> rp = service.getRolesByNS(trans, ns);\r
1266                         switch(rp.status) {\r
1267                                 case OK: \r
1268                                         if(!rp.isEmpty()) {\r
1269                                                 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1270                                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1271                                                         Question.logEncryptTrace(trans,data.asString());\r
1272                                                 }\r
1273                                                 data.to(resp.getOutputStream());\r
1274                                         } else {\r
1275                                                 Question.logEncryptTrace(trans, NO_DATA);\r
1276                                         }\r
1277                                         setContentType(resp,roleDF.getOutType());\r
1278                                         return Result.ok();\r
1279                                 default:\r
1280                                         return Result.err(rp);\r
1281                         }\r
1282                 } catch (Exception e) {\r
1283                         trans.error().log(e,IN,GET_ROLES_BY_NS);\r
1284                         return Result.err(e);\r
1285                 } finally {\r
1286                         tt.done();\r
1287                 }\r
1288         }\r
1289 \r
1290 \r
1291         /* (non-Javadoc)\r
1292          * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1293          */\r
1294         @Override\r
1295         public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {\r
1296                 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);\r
1297                 try {\r
1298                         Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);\r
1299                         switch(rp.status) {\r
1300                                 case OK: \r
1301                                         if(!rp.isEmpty()) {\r
1302                                                 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1303                                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1304                                                         Question.logEncryptTrace(trans,data.asString());\r
1305                                                 }\r
1306                                                 data.to(resp.getOutputStream());\r
1307                                         } else {\r
1308                                                 Question.logEncryptTrace(trans, NO_DATA);\r
1309                                         }\r
1310                                         setContentType(resp,roleDF.getOutType());\r
1311                                         return Result.ok();\r
1312                                 default:\r
1313                                         return Result.err(rp);\r
1314                         }\r
1315                 } catch (Exception e) {\r
1316                         trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);\r
1317                         return Result.err(e);\r
1318                 } finally {\r
1319                         tt.done();\r
1320                 }\r
1321         }\r
1322 \r
1323         /* (non-Javadoc)\r
1324          * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1325          */\r
1326         @Override\r
1327         public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {\r
1328                 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);\r
1329                 try {\r
1330                         Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);\r
1331                         switch(rp.status) {\r
1332                                 case OK: \r
1333                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1334                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1335                                                 Question.logEncryptTrace(trans,data.asString());\r
1336                                         }\r
1337                                         data.to(resp.getOutputStream());\r
1338                                         setContentType(resp,roleDF.getOutType());\r
1339                                         return Result.ok();\r
1340                                 default:\r
1341                                         return Result.err(rp);\r
1342                         }\r
1343                 } catch (Exception e) {\r
1344                         trans.error().log(e,IN,GET_ROLES_BY_PERM);\r
1345                         return Result.err(e);\r
1346                 } finally {\r
1347                         tt.done();\r
1348                 }\r
1349         }\r
1350 \r
1351         /*\r
1352          * (non-Javadoc)\r
1353          * @see org.onap.aaf.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
1354          */\r
1355         @Override\r
1356         public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1357                 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);\r
1358                 try {\r
1359                         REQUEST rreq;\r
1360                         try {\r
1361                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1362                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1363                                         Question.logEncryptTrace(trans,data.asString());\r
1364                                 }\r
1365                                 rreq = data.asObject();\r
1366                         } catch(APIException e) {\r
1367                                 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);\r
1368                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1369 \r
1370                         }\r
1371                         Result<Void> rp = service.updateRoleDescription(trans, rreq);\r
1372                         switch(rp.status) {\r
1373                                 case OK: \r
1374                                         setContentType(resp,roleRequestDF.getOutType());\r
1375                                         return Result.ok();\r
1376                                 default:\r
1377                                         return rp;\r
1378                         }\r
1379                 } catch (Exception e) {\r
1380                         trans.error().log(e,IN,UPDATE_ROLE_DESC);\r
1381                         return Result.err(e);\r
1382                 } finally {\r
1383                         tt.done();\r
1384                 }\r
1385         }\r
1386 \r
1387         @Override\r
1388         public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1389                 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);\r
1390                 try {\r
1391                         REQUEST rreq;\r
1392                         try {\r
1393                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1394                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1395                                         Question.logEncryptTrace(trans,data.asString());\r
1396                                 }\r
1397                                 rreq = data.asObject();\r
1398                         } catch(APIException e) {\r
1399                                 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);\r
1400                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1401 \r
1402                         }\r
1403                         Result<Void> rp = service.addPermToRole(trans, rreq);\r
1404                         switch(rp.status) {\r
1405                                 case OK: \r
1406                                         setContentType(resp,permsDF.getOutType());\r
1407                                         resp.getOutputStream().println();\r
1408                                         return Result.ok();\r
1409                                 default:\r
1410                                         return Result.err(rp);\r
1411                         }\r
1412                 } catch (Exception e) {\r
1413                         trans.error().log(e,IN,ADD_PERM_TO_ROLE);\r
1414                         return Result.err(e);\r
1415                 } finally {\r
1416                         tt.done();\r
1417                 }\r
1418         }\r
1419 \r
1420         @Override\r
1421         public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1422                 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);\r
1423                 try {\r
1424                         REQUEST rreq;\r
1425                         try {\r
1426                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1427                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1428                                         Question.logEncryptTrace(trans,data.asString());\r
1429                                 }\r
1430                                 rreq = data.asObject();\r
1431                         } catch(APIException e) {\r
1432                                 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);\r
1433                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1434 \r
1435                         }\r
1436                         Result<Void> rp = service.delPermFromRole(trans, rreq);\r
1437                         switch(rp.status) {\r
1438                                 case OK: \r
1439                                         setContentType(resp,permsDF.getOutType());\r
1440                                         resp.getOutputStream().println();\r
1441                                         return Result.ok();\r
1442                                 default:\r
1443                                         return Result.err(rp);\r
1444                         }\r
1445                 } catch (Exception e) {\r
1446                         trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);\r
1447                         return Result.err(e);\r
1448                 } finally {\r
1449                         tt.done();\r
1450                 }\r
1451         }\r
1452 \r
1453         @Override\r
1454         public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1455                 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
1456                 try {\r
1457                         Result<Void> rp = service.deleteRole(trans, role);\r
1458                         switch(rp.status) {\r
1459                                 case OK: \r
1460                                         setContentType(resp,permsDF.getOutType());\r
1461                                         return Result.ok();\r
1462                                 default:\r
1463                                         return Result.err(rp);\r
1464                         }\r
1465                 } catch (Exception e) {\r
1466                         trans.error().log(e,IN,DELETE_ROLE);\r
1467                         return Result.err(e);\r
1468                 } finally {\r
1469                         tt.done();\r
1470                 }\r
1471         }\r
1472 \r
1473         @Override\r
1474         public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1475                 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);\r
1476                 try {\r
1477                         REQUEST rreq;\r
1478                         try {\r
1479                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1480                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1481                                         Question.logEncryptTrace(trans,data.asString());\r
1482                                 }\r
1483                                 rreq = data.asObject();\r
1484                         } catch(APIException e) {\r
1485                                 trans.error().log("Invalid Input",IN,CREATE_ROLE);\r
1486                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1487                         }\r
1488 \r
1489                         Result<Void> rp = service.deleteRole(trans, rreq);\r
1490                         switch(rp.status) {\r
1491                                 case OK: \r
1492                                         setContentType(resp,permsDF.getOutType());\r
1493                                         return Result.ok();\r
1494                                 default:\r
1495                                         return Result.err(rp);\r
1496                         }\r
1497                 } catch (Exception e) {\r
1498                         trans.error().log(e,IN,DELETE_ROLE);\r
1499                         return Result.err(e);\r
1500                 } finally {\r
1501                         tt.done();\r
1502                 }\r
1503         }\r
1504 \r
1505         public static final String CREATE_CRED = "createUserCred";\r
1506         private static final String GET_CREDS_BY_NS = "getCredsByNS";\r
1507         private static final String GET_CREDS_BY_ID = "getCredsByID";\r
1508         public static final String UPDATE_CRED = "updateUserCred";\r
1509         public static final String EXTEND_CRED = "extendUserCred";\r
1510         public static final String DELETE_CRED = "deleteUserCred";\r
1511         public static final String DOES_CRED_MATCH = "doesCredMatch";\r
1512         public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";\r
1513 \r
1514 \r
1515 \r
1516         @Override\r
1517         /**\r
1518          * Create Credential\r
1519          * \r
1520          */\r
1521         public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1522                 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);\r
1523                 try {\r
1524                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1525                         if(Question.willSpecialLog(trans, trans.user())) {\r
1526                                 Question.logEncryptTrace(trans,data.asString());\r
1527                         }\r
1528                         return service.createUserCred(trans, data.asObject());\r
1529                 } catch(APIException e) {\r
1530                         trans.error().log(e,"Bad Input data");\r
1531                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1532                 } catch (Exception e) {\r
1533                         trans.error().log(e,IN,CREATE_CRED);\r
1534                         return Result.err(e);\r
1535                 } finally {\r
1536                         tt.done();\r
1537                 }\r
1538         }\r
1539 \r
1540         @Override\r
1541         public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1542                 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);\r
1543                 try {\r
1544                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1545                         if(Question.willSpecialLog(trans, trans.user())) {\r
1546                                 Question.logEncryptTrace(trans,data.asString());\r
1547                         }\r
1548 \r
1549                         return service.changeUserCred(trans, data.asObject());\r
1550                 } catch(APIException e) {\r
1551                         trans.error().log(e,"Bad Input data");\r
1552                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1553                 } catch (Exception e) {\r
1554                         trans.error().log(e,IN,UPDATE_CRED);\r
1555                         return Result.err(e);\r
1556                 } finally {\r
1557                         tt.done();\r
1558                 }\r
1559         }\r
1560 \r
1561         /* (non-Javadoc)\r
1562          * @see org.onap.aaf.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, int)\r
1563          */\r
1564         @Override\r
1565         public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {\r
1566                 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);\r
1567                 try {\r
1568                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1569                         if(Question.willSpecialLog(trans, trans.user())) {\r
1570                                 Question.logEncryptTrace(trans,data.asString());\r
1571                         }\r
1572 \r
1573                         return service.extendUserCred(trans, data.asObject(), days);\r
1574                 } catch(APIException e) {\r
1575                         trans.error().log(e,"Bad Input data");\r
1576                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1577                 } catch (Exception e) {\r
1578                         trans.error().log(e,IN,EXTEND_CRED);\r
1579                         return Result.err(e);\r
1580                 } finally {\r
1581                         tt.done();\r
1582                 }\r
1583         }\r
1584 \r
1585         @Override\r
1586         public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {\r
1587                 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
1588                 \r
1589                 try {\r
1590                         Result<USERS> ru = service.getCredsByNS(trans,ns);\r
1591                         switch(ru.status) {\r
1592                                 case OK: \r
1593                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1594                                         if(Question.willSpecialLog(trans,trans.user())) {\r
1595                                                 Question.logEncryptTrace(trans,data.asString());\r
1596                                         }\r
1597                                         data.to(resp.getOutputStream());\r
1598                                         setContentType(resp,usersDF.getOutType());\r
1599                                         return Result.ok();\r
1600                                 default:\r
1601                                         return Result.err(ru);\r
1602                         }\r
1603                 } catch (Exception e) {\r
1604                         trans.error().log(e,IN,GET_CREDS_BY_NS);\r
1605                         return Result.err(e);\r
1606                 } finally {\r
1607                         tt.done();\r
1608                 }\r
1609                 \r
1610         }\r
1611         \r
1612         \r
1613         /* (non-Javadoc)\r
1614          * @see org.onap.aaf.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1615          */\r
1616         @Override\r
1617         public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {\r
1618                 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);\r
1619                 \r
1620                 try {\r
1621                         Result<USERS> ru = service.getCredsByID(trans,id);\r
1622                         switch(ru.status) {\r
1623                                 case OK: \r
1624                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1625                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1626                                                 Question.logEncryptTrace(trans,data.asString());\r
1627                                         }\r
1628                                         data.to(resp.getOutputStream());\r
1629                                         setContentType(resp,usersDF.getOutType());\r
1630                                         return Result.ok();\r
1631                                 default:\r
1632                                         return Result.err(ru);\r
1633                         }\r
1634                 } catch (Exception e) {\r
1635                         trans.error().log(e,IN,GET_CREDS_BY_ID);\r
1636                         return Result.err(e);\r
1637                 } finally {\r
1638                         tt.done();\r
1639                 }\r
1640                 \r
1641         }\r
1642 \r
1643         @Override\r
1644         public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1645                 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);\r
1646                 try {\r
1647                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1648                         if(Question.willSpecialLog(trans, trans.user())) {\r
1649                                 Question.logEncryptTrace(trans,data.asString());\r
1650                         }\r
1651 \r
1652                         return service.deleteUserCred(trans, data.asObject());\r
1653                 } catch(APIException e) {\r
1654                         trans.error().log(e,"Bad Input data");\r
1655                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1656                 } catch (Exception e) {\r
1657                         trans.error().log(e,IN,DELETE_CRED);\r
1658                         return Result.err(e);\r
1659                 } finally {\r
1660                         tt.done();\r
1661                 }       \r
1662         }\r
1663         \r
1664         \r
1665         @Override\r
1666         public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1667                 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);\r
1668                 try {\r
1669                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1670                         if(Question.willSpecialLog(trans, trans.user())) {\r
1671                                 Question.logEncryptTrace(trans,data.asString());\r
1672                         }\r
1673 \r
1674                         return service.doesCredentialMatch(trans, data.asObject());\r
1675                 } catch(APIException e) {\r
1676                         trans.error().log(e,"Bad Input data");\r
1677                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1678                 } catch (IOException e) {\r
1679                         trans.error().log(e,IN,DOES_CRED_MATCH);\r
1680                         return Result.err(e);\r
1681                 } finally {\r
1682                         tt.done();\r
1683                 }       \r
1684         }\r
1685 \r
1686 \r
1687         @Override\r
1688         public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {\r
1689                 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);\r
1690                 try {\r
1691                         Result<Date> result = service.validateBasicAuth(trans,basicAuth);\r
1692                         switch(result.status){\r
1693                                 case OK:\r
1694                                         resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());\r
1695                                         return Result.ok();\r
1696                         }\r
1697                         return Result.err(result);\r
1698                 } catch (Exception e) {\r
1699                         trans.error().log(e,IN,VALIDATE_BASIC_AUTH);\r
1700                         return Result.err(e);\r
1701                 } finally {\r
1702                         tt.done();\r
1703                 }\r
1704         }\r
1705 \r
1706         /* (non-Javadoc)\r
1707          * @see org.onap.aaf.authz.facade.AuthzFacade#getCertInfoByID(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1708          */\r
1709         @Override\r
1710         public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {\r
1711                 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);\r
1712                 try {   \r
1713                         Result<CERTS> rci = service.getCertInfoByID(trans,req,id);\r
1714                         \r
1715                         switch(rci.status) {\r
1716                                 case OK: \r
1717                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1718                                                 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);\r
1719                                                 Question.logEncryptTrace(trans,data.asString());\r
1720                                                 data.to(resp.getOutputStream());\r
1721                                         } else {\r
1722                                                 certsDF.direct(trans, rci.value, resp.getOutputStream());\r
1723                                         }\r
1724                                         setContentType(resp,certsDF.getOutType());\r
1725                                         return Result.ok();\r
1726                                 default:\r
1727                                         return Result.err(rci);\r
1728                         }\r
1729                 } catch (Exception e) {\r
1730                         trans.error().log(e,IN,GET_CERT_BY_ID);\r
1731                         return Result.err(e);\r
1732                 } finally {\r
1733                         tt.done();\r
1734                 }\r
1735         }\r
1736 \r
1737         public static final String CREATE_DELEGATE = "createDelegate";\r
1738         public static final String UPDATE_DELEGATE = "updateDelegate";\r
1739         public static final String DELETE_DELEGATE = "deleteDelegate";\r
1740         public static final String GET_DELEGATE_USER = "getDelegatesByUser";\r
1741         public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";\r
1742         \r
1743         @Override\r
1744         public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1745                 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1746                 try {   \r
1747                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1748                         if(Question.willSpecialLog(trans, trans.user())) {\r
1749                                 Question.logEncryptTrace(trans,data.asString());\r
1750                         }\r
1751 \r
1752                         return service.createDelegate(trans, data.asObject());\r
1753                 } catch (Exception e) {\r
1754                         trans.error().log(e,IN,CREATE_DELEGATE);\r
1755                         return Result.err(e);\r
1756                 } finally {\r
1757                         tt.done();\r
1758                 }\r
1759         }\r
1760         \r
1761         @Override\r
1762         public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1763                 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1764                 try {   \r
1765                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1766                         if(Question.willSpecialLog(trans, trans.user())) {\r
1767                                 Question.logEncryptTrace(trans,data.asString());\r
1768                         }\r
1769 \r
1770                         return service.updateDelegate(trans, data.asObject());\r
1771                 } catch (Exception e) {\r
1772                         trans.error().log(e,IN,UPDATE_DELEGATE);\r
1773                         return Result.err(e);\r
1774                 } finally {\r
1775                         tt.done();\r
1776                 }\r
1777         }\r
1778         \r
1779         @Override\r
1780         public Result<Void> deleteDelegate(AuthzTrans trans,  HttpServletRequest req, HttpServletResponse resp) {\r
1781                 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1782                 try {\r
1783                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1784                         if(Question.willSpecialLog(trans, trans.user())) {\r
1785                                 Question.logEncryptTrace(trans,data.asString());\r
1786                         }\r
1787 \r
1788                         return service.deleteDelegate(trans, data.asObject());\r
1789                 } catch (Exception e) {\r
1790                         trans.error().log(e,IN,DELETE_DELEGATE);\r
1791                         return Result.err(e);\r
1792                 } finally {\r
1793                         tt.done();\r
1794                 }\r
1795         }\r
1796         \r
1797         @Override\r
1798         public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {\r
1799                 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);\r
1800                 try {\r
1801                         return service.deleteDelegate(trans, userName);\r
1802                 } catch (Exception e) {\r
1803                         trans.error().log(e,IN,DELETE_DELEGATE);\r
1804                         return Result.err(e);\r
1805                 } finally {\r
1806                         tt.done();\r
1807                 }\r
1808         }\r
1809         \r
1810         @Override\r
1811         public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {\r
1812                 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);\r
1813                 try {\r
1814                         Result<DELGS> rd = service.getDelegatesByUser(trans, user);\r
1815                         \r
1816                         switch(rd.status) {\r
1817                                 case OK: \r
1818                                         RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);\r
1819                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1820                                                 Question.logEncryptTrace(trans,data.asString());\r
1821                                         }\r
1822                                         data.to(resp.getOutputStream());\r
1823                                         setContentType(resp,delgDF.getOutType());\r
1824                                         return Result.ok();\r
1825                                 default:\r
1826                                         return Result.err(rd);\r
1827                         }\r
1828                 } catch (Exception e) {\r
1829                         trans.error().log(e,IN,GET_DELEGATE_USER);\r
1830                         return Result.err(e);\r
1831                 } finally {\r
1832                         tt.done();\r
1833                 }\r
1834         }\r
1835 \r
1836         @Override\r
1837         public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {\r
1838                 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);\r
1839                 try {\r
1840                         Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);\r
1841                         switch(rd.status) {\r
1842                                 case OK: \r
1843                                         RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);\r
1844                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1845                                                 Question.logEncryptTrace(trans,data.asString());\r
1846                                         }\r
1847                                         data.to(resp.getOutputStream());\r
1848                                         setContentType(resp,delgDF.getOutType());\r
1849                                         return Result.ok();\r
1850                                 default:\r
1851                                         return Result.err(rd);\r
1852                         }\r
1853                 } catch (Exception e) {\r
1854                         trans.error().log(e,IN,GET_DELEGATE_DELG);\r
1855                         return Result.err(e);\r
1856                 } finally {\r
1857                         tt.done();\r
1858                 }\r
1859         }\r
1860 \r
1861         private static final String REQUEST_USER_ROLE = "createUserRole";\r
1862         private static final String GET_USERROLES = "getUserRoles";\r
1863         private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";\r
1864         private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";\r
1865         private static final String SET_ROLES_FOR_USER = "setRolesForUser";\r
1866         private static final String SET_USERS_FOR_ROLE = "setUsersForRole";\r
1867         private static final String EXTEND_USER_ROLE = "extendUserRole";\r
1868         private static final String DELETE_USER_ROLE = "deleteUserRole";\r
1869         @Override\r
1870         public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1871                 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);\r
1872                 try {\r
1873                         REQUEST request;\r
1874                         try {\r
1875                                 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
1876                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1877                                         Question.logEncryptTrace(trans,data.asString());\r
1878                                 }\r
1879 \r
1880                                 request = data.asObject();\r
1881                         } catch(APIException e) {\r
1882                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1883                         }\r
1884                         \r
1885                         Result<Void> rp = service.createUserRole(trans,request);\r
1886                         switch(rp.status) {\r
1887                                 case OK: \r
1888                                         setContentType(resp,permsDF.getOutType());\r
1889                                         return Result.ok();\r
1890                                 default:\r
1891                                         return Result.err(rp);\r
1892                         }\r
1893                 } catch (Exception e) {\r
1894                         trans.error().log(e,IN,REQUEST_USER_ROLE);\r
1895                         return Result.err(e);\r
1896                 } finally {\r
1897                         tt.done();\r
1898                 }\r
1899         }\r
1900         \r
1901         @Override\r
1902         public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
1903                 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);\r
1904                 try {\r
1905                         Result<USERS> ru = service.getUserInRole(trans,user,role);\r
1906                         switch(ru.status) {\r
1907                                 case OK: \r
1908                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1909                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1910                                                 Question.logEncryptTrace(trans,data.asString());\r
1911                                         }\r
1912 \r
1913                                         data.to(resp.getOutputStream());\r
1914                                         setContentType(resp,usersDF.getOutType());\r
1915                                         return Result.ok();\r
1916                                 default:\r
1917                                         return Result.err(ru);\r
1918                         }\r
1919                 } catch (Exception e) {\r
1920                         trans.error().log(e,IN,GET_USERROLES);\r
1921                         return Result.err(e);\r
1922                 } finally {\r
1923                         tt.done();\r
1924                 }\r
1925 \r
1926         }\r
1927 \r
1928         @Override\r
1929         public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {\r
1930                 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
1931                 try {\r
1932                         Result<USERROLES> ru = service.getUserRolesByUser(trans,user);\r
1933                         switch(ru.status) {\r
1934                                 case OK: \r
1935                                         RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);\r
1936                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1937                                                 Question.logEncryptTrace(trans,data.asString());\r
1938                                         }\r
1939 \r
1940                                         data.to(resp.getOutputStream());\r
1941                                         setContentType(resp,usersDF.getOutType());\r
1942                                         return Result.ok();\r
1943                                 default:\r
1944                                         return Result.err(ru);\r
1945                         }\r
1946                 } catch (Exception e) {\r
1947                         trans.error().log(e,IN,GET_USERROLES_BY_USER);\r
1948                         return Result.err(e);\r
1949                 } finally {\r
1950                         tt.done();\r
1951                 }\r
1952 \r
1953         }\r
1954         \r
1955         @Override\r
1956         public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1957                 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
1958                 try {\r
1959                         Result<USERROLES> ru = service.getUserRolesByRole(trans,role);\r
1960                         switch(ru.status) {\r
1961                                 case OK: \r
1962                                         RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);\r
1963                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1964                                                 Question.logEncryptTrace(trans,data.asString());\r
1965                                         }\r
1966 \r
1967                                         data.to(resp.getOutputStream());\r
1968                                         setContentType(resp,usersDF.getOutType());\r
1969                                         return Result.ok();\r
1970                                 default:\r
1971                                         return Result.err(ru);\r
1972                         }\r
1973                 } catch (Exception e) {\r
1974                         trans.error().log(e,IN,GET_USERROLES_BY_ROLE);\r
1975                         return Result.err(e);\r
1976                 } finally {\r
1977                         tt.done();\r
1978                 }\r
1979 \r
1980         }\r
1981         \r
1982 \r
1983         @Override\r
1984         public Result<Void> resetUsersForRole(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {\r
1985                 TimeTaken tt = trans.start(SET_USERS_FOR_ROLE, Env.SUB|Env.ALWAYS);\r
1986                 try {\r
1987                         REQUEST rreq;\r
1988                         try {\r
1989                                 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
1990                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1991                                         Question.logEncryptTrace(trans,data.asString());\r
1992                                 }\r
1993                                 rreq = data.asObject();\r
1994                         } catch(APIException e) {\r
1995                                 trans.error().log("Invalid Input",IN, SET_USERS_FOR_ROLE);\r
1996                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1997                         }\r
1998                         \r
1999                         Result<Void> rp = service.resetUsersForRole(trans, rreq);\r
2000                         \r
2001                         switch(rp.status) {\r
2002                                 case OK: \r
2003                                         setContentType(resp,permsDF.getOutType());\r
2004                                         return Result.ok();\r
2005                                 default:\r
2006                                         return Result.err(rp);\r
2007                         }\r
2008                 } catch (Exception e) {\r
2009                         trans.error().log(e,IN,SET_USERS_FOR_ROLE);\r
2010                         return Result.err(e);\r
2011                 } finally {\r
2012                         tt.done();\r
2013                 }\r
2014                 \r
2015         }\r
2016 \r
2017         @Override\r
2018         public Result<Void> resetRolesForUser(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {\r
2019                 TimeTaken tt = trans.start(SET_ROLES_FOR_USER, Env.SUB|Env.ALWAYS);\r
2020                 try {\r
2021                         REQUEST rreq;\r
2022                         try {\r
2023                                 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
2024                                 if(Question.willSpecialLog(trans, trans.user())) {\r
2025                                         Question.logEncryptTrace(trans,data.asString());\r
2026                                 }\r
2027 \r
2028                                 rreq = data.asObject();\r
2029                         } catch(APIException e) {\r
2030                                 trans.error().log("Invalid Input",IN, SET_ROLES_FOR_USER);\r
2031                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
2032                         }\r
2033                         \r
2034                         Result<Void> rp = service.resetRolesForUser(trans, rreq);\r
2035                         \r
2036                         switch(rp.status) {\r
2037                                 case OK: \r
2038                                         setContentType(resp,permsDF.getOutType());\r
2039                                         return Result.ok();\r
2040                                 default:\r
2041                                         return Result.err(rp);\r
2042                         }\r
2043                 } catch (Exception e) {\r
2044                         trans.error().log(e,IN,SET_ROLES_FOR_USER);\r
2045                         return Result.err(e);\r
2046                 } finally {\r
2047                         tt.done();\r
2048                 }\r
2049                 \r
2050         }\r
2051 \r
2052         /* (non-Javadoc)\r
2053          * @see org.onap.aaf.authz.facade.AuthzFacade#extendUserRoleExpiration(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)\r
2054          */\r
2055         @Override\r
2056         public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
2057                 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);\r
2058                 try {\r
2059                         return service.extendUserRole(trans,user,role);\r
2060                 } catch (Exception e) {\r
2061                         trans.error().log(e,IN,EXTEND_USER_ROLE);\r
2062                         return Result.err(e);\r
2063                 } finally {\r
2064                         tt.done();\r
2065                 }\r
2066         }\r
2067 \r
2068         @Override\r
2069         public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
2070                 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);\r
2071                 try {\r
2072                         Result<Void> rp = service.deleteUserRole(trans,user,role);\r
2073                         switch(rp.status) {\r
2074                                 case OK: \r
2075                                         setContentType(resp,permsDF.getOutType());\r
2076                                         return Result.ok();\r
2077                                 default:\r
2078                                         return Result.err(rp);\r
2079                         }\r
2080                 } catch (Exception e) {\r
2081                         trans.error().log(e,IN,DELETE_USER_ROLE);\r
2082                         return Result.err(e);\r
2083                 } finally {\r
2084                         tt.done();\r
2085                 }\r
2086         }\r
2087 \r
2088         private static final String UPDATE_APPROVAL = "updateApproval";\r
2089         private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";\r
2090         private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";\r
2091         private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";\r
2092         \r
2093         @Override\r
2094         public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
2095                 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);\r
2096                 try {\r
2097                         Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());\r
2098                         if(Question.willSpecialLog(trans, trans.user())) {\r
2099                                 Question.logEncryptTrace(trans,data.asString());\r
2100                         }\r
2101 \r
2102                         Result<Void> rp = service.updateApproval(trans, data.asObject());\r
2103                         \r
2104                         switch(rp.status) {\r
2105                                 case OK: \r
2106                                         setContentType(resp,approvalDF.getOutType());\r
2107                                         return Result.ok();\r
2108                                 default:\r
2109                                         return Result.err(rp);\r
2110                         }\r
2111                 } catch (Exception e) {\r
2112                         trans.error().log(e,IN,UPDATE_APPROVAL);\r
2113                         return Result.err(e);\r
2114                 } finally {\r
2115                         tt.done();\r
2116                 }\r
2117         }\r
2118         \r
2119         @Override\r
2120         public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {\r
2121                 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
2122                 try {\r
2123                         Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);\r
2124                         switch(rp.status) {\r
2125                                 case OK: \r
2126                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2127                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2128                                                 Question.logEncryptTrace(trans,data.asString());\r
2129                                         }\r
2130                                         data.to(resp.getOutputStream());\r
2131                                         \r
2132                                         setContentType(resp,permsDF.getOutType());\r
2133                                         return Result.ok();\r
2134                                 default:\r
2135                                         return Result.err(rp);\r
2136                         }\r
2137                 } catch (Exception e) {\r
2138                         trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);\r
2139                         return Result.err(e);\r
2140                 } finally {\r
2141                         tt.done();\r
2142                 }\r
2143         }\r
2144 \r
2145         @Override\r
2146         public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {\r
2147                 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);\r
2148                 try {\r
2149                         Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);\r
2150                         switch(rp.status) {\r
2151                                 case OK: \r
2152                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2153                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2154                                                 Question.logEncryptTrace(trans,data.asString());\r
2155                                         }\r
2156 \r
2157                                         data.to(resp.getOutputStream());\r
2158                                         setContentType(resp,permsDF.getOutType());\r
2159                                         return Result.ok();\r
2160                                 default:\r
2161                                         return Result.err(rp);\r
2162                         }\r
2163                 } catch (Exception e) {\r
2164                         trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);\r
2165                         return Result.err(e);\r
2166                 } finally {\r
2167                         tt.done();\r
2168                 }\r
2169         }\r
2170 \r
2171         @Override\r
2172         public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {\r
2173                 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);\r
2174                 try {\r
2175                         Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);\r
2176                         switch(rp.status) {\r
2177                                 case OK: \r
2178                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2179                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2180                                                 Question.logEncryptTrace(trans,data.asString());\r
2181                                         }\r
2182 \r
2183                                         data.to(resp.getOutputStream());\r
2184                                         setContentType(resp,permsDF.getOutType());\r
2185                                         return Result.ok();\r
2186                                 default:\r
2187                                         return Result.err(rp);\r
2188                         }\r
2189                 } catch (Exception e) {\r
2190                         trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);\r
2191                         return Result.err(e);\r
2192                 } finally {\r
2193                         tt.done();\r
2194                 }\r
2195         }\r
2196 \r
2197 \r
2198         \r
2199         public static final String GET_USERS_PERMISSION = "getUsersByPermission";\r
2200         public static final String GET_USERS_ROLE = "getUsersByRole";\r
2201 \r
2202         /* (non-Javadoc)\r
2203          * @see org.onap.aaf.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
2204          */\r
2205         @Override\r
2206         public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
2207                 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
2208                 try {\r
2209                         Result<USERS> ru = service.getUsersByRole(trans,role);\r
2210                         switch(ru.status) {\r
2211                                 case OK: \r
2212                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
2213                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2214                                                 Question.logEncryptTrace(trans,data.asString());\r
2215                                         }\r
2216 \r
2217                                         data.to(resp.getOutputStream());\r
2218                                         setContentType(resp,usersDF.getOutType());\r
2219                                         return Result.ok();\r
2220                                 default:\r
2221                                         return Result.err(ru);\r
2222                         }\r
2223                 } catch (Exception e) {\r
2224                         trans.error().log(e,IN,GET_USERS_ROLE);\r
2225                         return Result.err(e);\r
2226                 } finally {\r
2227                         tt.done();\r
2228                 }\r
2229         }\r
2230 \r
2231         /* (non-Javadoc)\r
2232          * @see org.onap.aaf.authz.facade.AuthzFacade#getUsersByPermission(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
2233          */\r
2234         @Override\r
2235         public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp, \r
2236                         String type, String instance, String action) {\r
2237                 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);\r
2238                 try {\r
2239                         Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);\r
2240                         switch(ru.status) {\r
2241                                 case OK: \r
2242                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
2243                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2244                                                 Question.logEncryptTrace(trans,data.asString());\r
2245                                         }\r
2246 \r
2247                                         data.to(resp.getOutputStream());\r
2248                                         setContentType(resp,usersDF.getOutType());\r
2249                                         return Result.ok();\r
2250                                 default:\r
2251                                         return Result.err(ru);\r
2252                         }\r
2253                 } catch (Exception e) {\r
2254                         trans.error().log(e,IN,GET_USERS_PERMISSION);\r
2255                         return Result.err(e);\r
2256                 } finally {\r
2257                         tt.done();\r
2258                 }\r
2259         }\r
2260 \r
2261         \r
2262         public static final String GET_HISTORY_USER = "getHistoryByUser";\r
2263         public static final String GET_HISTORY_ROLE = "getHistoryByRole";\r
2264         public static final String GET_HISTORY_PERM = "getHistoryByPerm";\r
2265         public static final String GET_HISTORY_NS = "getHistoryByNS";\r
2266         /* (non-Javadoc)\r
2267          * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
2268          */\r
2269         @Override\r
2270         public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {\r
2271                 StringBuilder sb = new StringBuilder();\r
2272                 sb.append(GET_HISTORY_USER);\r
2273                 sb.append(' ');\r
2274                 sb.append(user);\r
2275                 sb.append(" for ");\r
2276                 boolean first = true;\r
2277                 for(int i : yyyymm) {\r
2278                         if(first) {\r
2279                             first = false;\r
2280                         } else {\r
2281                             sb.append(',');\r
2282                         }\r
2283                         sb.append(i);\r
2284                 }\r
2285                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2286 \r
2287                 try {\r
2288                         Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);\r
2289                         switch(rh.status) {\r
2290                                 case OK: \r
2291                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2292                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2293                                                 Question.logEncryptTrace(trans,data.asString());\r
2294                                         }\r
2295 \r
2296                                         data.to(resp.getOutputStream());\r
2297                                         setContentType(resp,historyDF.getOutType());\r
2298                                         return Result.ok();\r
2299                                 default:\r
2300                                         return Result.err(rh);\r
2301                         }\r
2302                 } catch (Exception e) {\r
2303                         trans.error().log(e,IN,GET_HISTORY_USER);\r
2304                         return Result.err(e);\r
2305                 } finally {\r
2306                         tt.done();\r
2307                 }\r
2308         }\r
2309 \r
2310         /* (non-Javadoc)\r
2311          * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2312          */\r
2313         @Override\r
2314         public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {\r
2315                 StringBuilder sb = new StringBuilder();\r
2316                 sb.append(GET_HISTORY_ROLE);\r
2317                 sb.append(' ');\r
2318                 sb.append(role);\r
2319                 sb.append(" for ");\r
2320                 boolean first = true;\r
2321                 for(int i : yyyymm) {\r
2322                         if(first) {\r
2323                             first = false;\r
2324                         } else {\r
2325                             sb.append(',');\r
2326                         }\r
2327                         sb.append(i);\r
2328                 }\r
2329                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2330                 try {\r
2331                         Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);\r
2332                         switch(rh.status) {\r
2333                                 case OK: \r
2334                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2335                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2336                                                 Question.logEncryptTrace(trans,data.asString());\r
2337                                         }\r
2338 \r
2339                                         data.to(resp.getOutputStream());\r
2340                                         setContentType(resp,historyDF.getOutType());\r
2341                                         return Result.ok();\r
2342                                 default:\r
2343                                         return Result.err(rh);\r
2344                         }\r
2345                 } catch (Exception e) {\r
2346                         trans.error().log(e,IN,GET_HISTORY_ROLE);\r
2347                         return Result.err(e);\r
2348                 } finally {\r
2349                         tt.done();\r
2350                 }\r
2351         }\r
2352 \r
2353         /* (non-Javadoc)\r
2354          * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2355          */\r
2356         @Override\r
2357         public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {\r
2358                 StringBuilder sb = new StringBuilder();\r
2359                 sb.append(GET_HISTORY_NS);\r
2360                 sb.append(' ');\r
2361                 sb.append(ns);\r
2362                 sb.append(" for ");\r
2363                 boolean first = true;\r
2364                 for(int i : yyyymm) {\r
2365                         if(first) {\r
2366                             first = false;\r
2367                         } else {\r
2368                             sb.append(',');\r
2369                         }\r
2370                         sb.append(i);\r
2371                 }\r
2372                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2373                 try {\r
2374                         Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);\r
2375                         switch(rh.status) {\r
2376                                 case OK: \r
2377                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2378                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2379                                                 Question.logEncryptTrace(trans,data.asString());\r
2380                                         }\r
2381 \r
2382                                         data.to(resp.getOutputStream());\r
2383                                         setContentType(resp,historyDF.getOutType());\r
2384                                         return Result.ok();\r
2385                                 default:\r
2386                                         return Result.err(rh);\r
2387                         }\r
2388                 } catch (Exception e) {\r
2389                         trans.error().log(e,IN,GET_HISTORY_NS);\r
2390                         return Result.err(e);\r
2391                 } finally {\r
2392                         tt.done();\r
2393                 }\r
2394         }\r
2395 \r
2396         /* (non-Javadoc)\r
2397          * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2398          */\r
2399         @Override\r
2400         public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {\r
2401                 StringBuilder sb = new StringBuilder();\r
2402                 sb.append(GET_HISTORY_PERM);\r
2403                 sb.append(' ');\r
2404                 sb.append(perm);\r
2405                 sb.append(" for ");\r
2406                 boolean first = true;\r
2407                 for(int i : yyyymm) {\r
2408                         if(first) {\r
2409                             first = false;\r
2410                         } else {\r
2411                             sb.append(',');\r
2412                         }\r
2413                         sb.append(i);\r
2414                 }\r
2415                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2416                 try {\r
2417                         Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);\r
2418                         switch(rh.status) {\r
2419                                 case OK: \r
2420                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2421                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2422                                                 Question.logEncryptTrace(trans,data.asString());\r
2423                                         }\r
2424 \r
2425                                         data.to(resp.getOutputStream());\r
2426                                         setContentType(resp,historyDF.getOutType());\r
2427                                         return Result.ok();\r
2428                                 default:\r
2429                                         return Result.err(rh);\r
2430                         }\r
2431                 } catch (Exception e) {\r
2432                         trans.error().log(e,IN,GET_HISTORY_PERM);\r
2433                         return Result.err(e);\r
2434                 } finally {\r
2435                         tt.done();\r
2436                 }\r
2437         }\r
2438 \r
2439         public final static String CACHE_CLEAR = "cacheClear "; \r
2440 //      public final static String CACHE_VALIDATE = "validateCache";\r
2441         \r
2442         /* (non-Javadoc)\r
2443          * @see org.onap.aaf.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.authz.env.AuthzTrans, java.lang.String)\r
2444          */\r
2445         @Override\r
2446         public Result<Void> cacheClear(AuthzTrans trans, String cname) {\r
2447                 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);\r
2448                 try {\r
2449                         return service.cacheClear(trans,cname);\r
2450                 } catch (Exception e) {\r
2451                         trans.error().log(e,IN,CACHE_CLEAR);\r
2452                         return Result.err(e);\r
2453                 } finally {\r
2454                         tt.done();\r
2455                 }\r
2456         }\r
2457 \r
2458         /* (non-Javadoc)\r
2459  * @see org.onap.aaf.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.Integer)\r
2460  */\r
2461         @Override\r
2462         public Result<Void> cacheClear(AuthzTrans trans, String cname,  String segments) {\r
2463                 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);\r
2464                 try {\r
2465                         String[] segs = segments.split("\\s*,\\s*");\r
2466                         int isegs[] = new int[segs.length];\r
2467                         for(int i=0;i<segs.length;++i) {\r
2468                                 try {\r
2469                                         isegs[i] = Integer.parseInt(segs[i]);\r
2470                                 } catch(NumberFormatException nfe) {\r
2471                                         isegs[i] = -1;\r
2472                                 }\r
2473                         }\r
2474                         return service.cacheClear(trans,cname, isegs);\r
2475                 } catch (Exception e) {\r
2476                         trans.error().log(e,IN,CACHE_CLEAR);\r
2477                         return Result.err(e);\r
2478                 } finally {\r
2479                         tt.done();\r
2480                 }\r
2481         }\r
2482 \r
2483         /* (non-Javadoc)\r
2484          * @see org.onap.aaf.authz.facade.AuthzFacade#dbReset(org.onap.aaf.authz.env.AuthzTrans)\r
2485          */\r
2486         @Override\r
2487         public void dbReset(AuthzTrans trans) {\r
2488                 service.dbReset(trans);\r
2489         }\r
2490 \r
2491         /* (non-Javadoc)\r
2492          * @see org.onap.aaf.authz.facade.AuthzFacade#getAPI(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse)\r
2493          */\r
2494         public final static String API_REPORT = "apiReport";\r
2495         @Override\r
2496         public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {\r
2497                 TimeTaken tt = trans.start(API_REPORT, Env.SUB);\r
2498                 try {\r
2499                         Api api = new Api();\r
2500                         Api.Route ar;\r
2501                         Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();\r
2502                         for(RouteReport rr : rservlet.routeReport()) {\r
2503                                 api.getRoute().add(ar = new Api.Route());\r
2504                                 ar.setMeth(rr.meth.name());\r
2505                                 ar.setPath(rr.path);\r
2506                                 ar.setDesc(rr.desc);\r
2507                                 ar.getContentType().addAll(rr.contextTypes);\r
2508                                 for(Method m : meths) {\r
2509                                         ApiDoc ad;\r
2510                                         if((ad = m.getAnnotation(ApiDoc.class))!=null &&\r
2511                                                         rr.meth.equals(ad.method()) &&\r
2512                                                     rr.path.equals(ad.path())) {\r
2513                                                 for(String param : ad.params()) {\r
2514                                                         ar.getParam().add(param);\r
2515                                                 }\r
2516                                                 for(String text : ad.text()) {\r
2517                                                         ar.getComments().add(text);\r
2518                                                 }\r
2519                                                 ar.setExpected(ad.expectedCode());\r
2520                                                 for(int ec : ad.errorCodes()) {\r
2521                                                         ar.getExplicitErr().add(ec);\r
2522                                                 }\r
2523                                         }\r
2524                                 }\r
2525                         }\r
2526                         RosettaData<Api> data = apiDF.newData(trans).load(api);\r
2527                         if(Question.willSpecialLog(trans, trans.user())) {\r
2528                                 Question.logEncryptTrace(trans,data.asString());\r
2529                         }\r
2530 \r
2531                         data.to(resp.getOutputStream());\r
2532                         setContentType(resp,apiDF.getOutType());\r
2533                         return Result.ok();\r
2534 \r
2535                 } catch (Exception e) {\r
2536                         trans.error().log(e,IN,API_REPORT);\r
2537                         return Result.err(e);\r
2538                 } finally {\r
2539                         tt.done();\r
2540                 }\r
2541         }\r
2542         \r
2543 \r
2544         public final static String API_EXAMPLE = "apiExample";\r
2545 \r
2546         /* (non-Javadoc)\r
2547          * @see org.onap.aaf.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
2548          */\r
2549         @Override\r
2550         public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {\r
2551                 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);\r
2552                 try {\r
2553                         String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional); \r
2554                         resp.getOutputStream().print(content);\r
2555                         setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);\r
2556                         return Result.ok();\r
2557                 } catch (Exception e) {\r
2558                         trans.error().log(e,IN,API_EXAMPLE);\r
2559                         return Result.err(Status.ERR_NotImplemented,e.getMessage());\r
2560                 } finally {\r
2561                         tt.done();\r
2562                 }\r
2563         }\r
2564 \r
2565 }\r