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 }