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

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