auth/auth-service/src/main/java/org/onap/aaf/auth/service/facade/AuthzFacadeImpl.java

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