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

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