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