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