2 * ============LICENSE_START====================================================
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
11 * http://www.apache.org/licenses/LICENSE-2.0
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====================================================
22 package org.onap.aaf.auth.service.facade;
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;
45 import java.io.IOException;
46 import java.lang.reflect.Method;
47 import java.util.Date;
49 import javax.servlet.http.HttpServletRequest;
50 import javax.servlet.http.HttpServletResponse;
52 import org.onap.aaf.auth.dao.cass.NsType;
53 import org.onap.aaf.auth.dao.cass.Status;
54 import org.onap.aaf.auth.dao.hl.Question;
55 import org.onap.aaf.auth.env.AuthzEnv;
56 import org.onap.aaf.auth.env.AuthzTrans;
57 import org.onap.aaf.auth.layer.FacadeImpl;
58 import org.onap.aaf.auth.layer.Result;
59 import org.onap.aaf.auth.rserv.RServlet;
60 import org.onap.aaf.auth.rserv.RouteReport;
61 import org.onap.aaf.auth.rserv.doc.ApiDoc;
62 import org.onap.aaf.auth.service.AuthzCassServiceImpl;
63 import org.onap.aaf.auth.service.AuthzService;
64 import org.onap.aaf.auth.service.mapper.Mapper;
65 import org.onap.aaf.auth.service.mapper.Mapper.API;
66 import org.onap.aaf.cadi.aaf.client.Examples;
67 import org.onap.aaf.misc.env.APIException;
68 import org.onap.aaf.misc.env.Data;
69 import org.onap.aaf.misc.env.Env;
70 import org.onap.aaf.misc.env.TimeTaken;
71 import org.onap.aaf.misc.env.Data.TYPE;
72 import org.onap.aaf.misc.env.util.Chrono;
73 import org.onap.aaf.misc.rosetta.Marshal;
74 import org.onap.aaf.misc.rosetta.env.RosettaDF;
75 import org.onap.aaf.misc.rosetta.env.RosettaData;
82 * This Service Facade encapsulates the essence of the API Service can do, and provides
83 * a single created object for elements such as RosettaDF.
85 * The Responsibilities of this class are to:
86 * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)
87 * 2) Validate incoming data (if applicable)
88 * 3) Convert the Service response into the right Format, and mark the Content Type
89 * a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.
90 * 4) Log Service info, warnings and exceptions as necessary
91 * 5) When asked by the API layer, this will create and write Error content to the OutputStream
93 * Note: This Class does NOT set the HTTP Status Code. That is up to the API layer, so that it can be
94 * clearly coordinated with the API Documentation
96 * @author Pavani & Jonathan
99 public abstract class AuthzFacadeImpl<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> extends FacadeImpl implements AuthzFacade
101 private static final String FORBIDDEN = "Forbidden";
102 private static final String NOT_FOUND = "Not Found";
103 private static final String NOT_ACCEPTABLE = "Not Acceptable";
104 private static final String GENERAL_SERVICE_ERROR = "General Service Error";
105 private static final String NO_DATA = "***No Data***";
106 private AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service = null;
107 private final RosettaDF<NSS> nssDF;
108 private final RosettaDF<PERMS> permsDF;
109 private final RosettaDF<ROLES> roleDF;
110 private final RosettaDF<USERS> usersDF;
111 private final RosettaDF<USERROLES> userrolesDF;
112 private final RosettaDF<CERTS> certsDF;
113 private final RosettaDF<DELGS> delgDF;
114 private final RosettaDF<REQUEST> permRequestDF;
115 private final RosettaDF<REQUEST> roleRequestDF;
116 private final RosettaDF<REQUEST> userRoleRequestDF;
117 private final RosettaDF<REQUEST> rolePermRequestDF;
118 private final RosettaDF<REQUEST> nsRequestDF;
119 private final RosettaDF<REQUEST> credRequestDF;
120 private final RosettaDF<REQUEST> delgRequestDF;
121 private final RosettaDF<HISTORY> historyDF;
122 private final RosettaDF<KEYS> keysDF;
124 private final RosettaDF<ERR> errDF;
125 private final RosettaDF<APPROVALS> approvalDF;
126 // Note: Api is not different per Version
127 private final RosettaDF<Api> apiDF;
130 @SuppressWarnings("unchecked")
131 public AuthzFacadeImpl(AuthzEnv env, AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service, Data.TYPE dataType) throws APIException {
132 this.service = service;
133 (nssDF = env.newDataFactory(service.mapper().getClass(API.NSS))).in(dataType).out(dataType);
134 (permRequestDF = env.newDataFactory(service.mapper().getClass(API.PERM_REQ))).in(dataType).out(dataType);
135 (permsDF = env.newDataFactory(service.mapper().getClass(API.PERMS))).in(dataType).out(dataType);
136 // (permKeyDF = env.newDataFactory(service.mapper().getClass(API.PERM_KEY))).in(dataType).out(dataType);
137 (roleDF = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);
138 (roleRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);
139 (usersDF = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);
140 (userrolesDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);
141 (certsDF = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)
142 .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));
144 (userRoleRequestDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);
145 (rolePermRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);
146 (nsRequestDF = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);
147 (credRequestDF = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);
148 (delgRequestDF = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);
149 (historyDF = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);
150 ( keysDF = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);
151 (delgDF = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);
152 (approvalDF = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);
153 (errDF = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);
154 (apiDF = env.newDataFactory(Api.class)).in(dataType).out(dataType);
157 public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {
158 return service.mapper();
162 * @see com.att.authz.facade.AuthzFacade#error(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
164 * Note: Conforms to AT&T TSS RESTful Error Structure
167 public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
168 String msg = result.details==null?"%s":"%s - " + result.details.trim();
171 boolean hidemsg = false;
172 if (result.variables==null) {
173 detail = new String[1];
175 int l = result.variables.length;
176 detail=new String[l+1];
177 System.arraycopy(result.variables, 0, detail, 1, l);
181 switch(result.status) {
182 case ERR_ActionNotCompleted:
184 detail[0] = "Accepted, Action not complete";
185 response.setStatus(/*httpstatus=*/202);
190 detail[0] = FORBIDDEN;
191 response.setStatus(/*httpstatus=*/403);
195 detail[0] = FORBIDDEN;
196 response.setStatus(/*httpstatus=*/403);
200 detail[0] = FORBIDDEN;
201 response.setStatus(/*httpstatus=*/403);
203 // This is still forbidden to directly impact, but can be Requested when passed
204 // with "request=true" query Param
205 case ERR_FutureNotRequested:
208 response.setStatus(/*httpstatus=*/403);
213 detail[0] = NOT_FOUND;
214 response.setStatus(/*httpstatus=*/404);
216 case ERR_RoleNotFound:
218 detail[0] = NOT_FOUND;
219 response.setStatus(/*httpstatus=*/404);
221 case ERR_PermissionNotFound:
223 detail[0] = NOT_FOUND;
224 response.setStatus(/*httpstatus=*/404);
226 case ERR_UserNotFound:
228 detail[0] = NOT_FOUND;
229 response.setStatus(/*httpstatus=*/404);
231 case ERR_UserRoleNotFound:
233 detail[0] = NOT_FOUND;
234 response.setStatus(/*httpstatus=*/404);
236 case ERR_DelegateNotFound:
238 detail[0] = NOT_FOUND;
239 response.setStatus(/*httpstatus=*/404);
243 detail[0] = NOT_FOUND;
244 response.setStatus(/*httpstatus=*/404);
247 case ERR_InvalidDelegate:
249 detail[0] = NOT_ACCEPTABLE;
250 response.setStatus(/*httpstatus=*/406);
254 detail[0] = NOT_ACCEPTABLE;
255 response.setStatus(/*httpstatus=*/406);
258 case ERR_ConflictAlreadyExists:
260 detail[0] = "Conflict Already Exists";
261 response.setStatus(/*httpstatus=*/409);
264 case ERR_DependencyExists:
266 detail[0] = "Failed Dependency";
267 response.setStatus(/*httpstatus=*/424);
270 case ERR_NotImplemented:
272 detail[0] = "Not Implemented";
273 response.setStatus(/*httpstatus=*/501);
276 case Status.ACC_Future:
278 detail[0] = "Accepted for Future, pending Approvals";
279 response.setStatus(/*httpstatus=*/202);
281 case ERR_ChoiceNeeded:
283 detail = new String[result.variables.length];
284 for(int i=0; i<result.variables.length;++i) {
285 detail[i]=result.variables[i].toString();
287 response.setStatus(/*httpstatus=*/300);
291 detail[0] = GENERAL_SERVICE_ERROR;
292 response.setStatus(/*httpstatus=*/500);
298 detail[0] = GENERAL_SERVICE_ERROR;
299 response.setStatus(/*httpstatus=*/500);
305 StringBuilder holder = new StringBuilder();
306 ERR em = service.mapper().errorFromMessage(holder,msgId,msg,detail);
315 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
317 errDF.newData(trans).load(em).to(response.getOutputStream());
318 } catch (Exception e) {
319 trans.error().log(e,"unable to send response for",msg);
323 ///////////////////////////
325 ///////////////////////////
326 public static final String CREATE_NS = "createNamespace";
327 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
328 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
329 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
330 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
331 public static final String GET_NS_BY_NAME = "getNamespaceByName";
332 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
333 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
334 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
335 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
336 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
337 public static final String DELETE_NS = "deleteNamespace";
341 * @see com.att.authz.facade.AuthzFacade#createNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
344 public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {
345 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);
349 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());
350 if (Question.willSpecialLog(trans, trans.user())) {
351 Question.logEncryptTrace(trans,rd.asString());
353 request = rd.asObject();
354 } catch (APIException e) {
355 trans.error().log("Invalid Input",IN,CREATE_NS);
356 return Result.err(Status.ERR_BadData,"Invalid Input");
359 Result<Void> rp = service.createNS(trans,request,type);
362 setContentType(resp,nsRequestDF.getOutType());
365 return Result.err(rp);
367 } catch (Exception e) {
368 trans.error().log(e,IN,CREATE_NS);
369 return Result.err(e);
376 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
379 public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
380 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
382 Result<Void> rp = service.addAdminNS(trans,ns,id);
386 setContentType(resp,nsRequestDF.getOutType());
387 resp.getOutputStream().println();
390 return Result.err(rp);
392 } catch (Exception e) {
393 trans.error().log(e,IN,ADD_NS_ADMIN);
394 return Result.err(e);
401 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
404 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
405 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
407 Result<Void> rp = service.delAdminNS(trans, ns, id);
410 setContentType(resp,nsRequestDF.getOutType());
413 return Result.err(rp);
415 } catch (Exception e) {
416 trans.error().log(e,IN,DELETE_NS_ADMIN);
417 return Result.err(e);
424 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
427 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
428 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
430 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
433 setContentType(resp,nsRequestDF.getOutType());
434 resp.getOutputStream().println();
437 return Result.err(rp);
439 } catch (Exception e) {
440 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
441 return Result.err(e);
448 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
451 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
452 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
454 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
457 setContentType(resp,nsRequestDF.getOutType());
458 resp.getOutputStream().println();
461 return Result.err(rp);
463 } catch (Exception e) {
464 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
465 return Result.err(e);
472 * @see com.att.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
475 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns) {
476 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
478 Result<NSS> rp = service.getNSbyName(trans, ns);
481 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
482 if (Question.willSpecialLog(trans, trans.user())) {
483 Question.logEncryptTrace(trans,data.asString());
485 data.to(resp.getOutputStream());
486 setContentType(resp,nssDF.getOutType());
489 return Result.err(rp);
491 } catch (Exception e) {
492 trans.error().log(e,IN,GET_NS_BY_NAME);
493 return Result.err(e);
499 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
501 * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
504 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
505 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
507 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
510 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
511 if (Question.willSpecialLog(trans, trans.user())) {
512 Question.logEncryptTrace(trans,data.asString());
514 data.to(resp.getOutputStream());
515 setContentType(resp,nssDF.getOutType());
518 return Result.err(rp);
520 } catch (Exception e) {
521 trans.error().log(e,IN,GET_NS_BY_ADMIN);
522 return Result.err(e);
528 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
530 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
533 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
534 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
536 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
539 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
540 if (Question.willSpecialLog(trans, trans.user())) {
541 Question.logEncryptTrace(trans,data.asString());
543 data.to(resp.getOutputStream());
545 setContentType(resp,nssDF.getOutType());
548 return Result.err(rp);
550 } catch (Exception e) {
551 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
552 return Result.err(e);
559 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
562 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
563 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
565 Result<NSS> rp = service.getNSbyEither(trans, user, full);
569 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
570 if (Question.willSpecialLog(trans, trans.user())) {
571 Question.logEncryptTrace(trans,data.asString());
573 data.to(resp.getOutputStream());
575 setContentType(resp,nssDF.getOutType());
578 return Result.err(rp);
580 } catch (Exception e) {
581 trans.error().log(e,IN,GET_NS_BY_EITHER);
582 return Result.err(e);
589 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
592 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
593 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
595 Result<NSS> rp = service.getNSsChildren(trans, parent);
598 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
599 if (Question.willSpecialLog(trans, trans.user())) {
600 Question.logEncryptTrace(trans,data.asString());
602 data.to(resp.getOutputStream());
603 setContentType(resp,nssDF.getOutType());
606 return Result.err(rp);
608 } catch (Exception e) {
609 trans.error().log(e,IN,GET_NS_CHILDREN);
610 return Result.err(e);
617 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
618 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
622 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
623 if (Question.willSpecialLog(trans, trans.user())) {
624 Question.logEncryptTrace(trans,data.asString());
626 rreq = data.asObject();
627 } catch (APIException e) {
628 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);
629 return Result.err(Status.ERR_BadData,"Invalid Input");
632 Result<Void> rp = service.updateNsDescription(trans, rreq);
635 setContentType(resp,nsRequestDF.getOutType());
638 return Result.err(rp);
640 } catch (Exception e) {
641 trans.error().log(e,IN,UPDATE_NS_DESC);
642 return Result.err(e);
650 * @see com.att.authz.facade.AuthzFacade#requestNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
653 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
654 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
656 Result<Void> rp = service.deleteNS(trans,ns);
659 setContentType(resp,nsRequestDF.getOutType());
662 return Result.err(rp);
664 } catch (Exception e) {
665 trans.error().log(e,IN,DELETE_NS);
666 return Result.err(e);
672 private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";
673 private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
674 private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";
675 private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";
678 * @see com.att.authz.facade.AuthzFacade#createAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
681 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
682 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
684 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
687 setContentType(resp, keysDF.getOutType());
688 resp.getOutputStream().println();
691 return Result.err(rp);
693 } catch (Exception e) {
694 trans.error().log(e,IN,NS_CREATE_ATTRIB);
695 return Result.err(e);
702 * @see com.att.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
705 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
706 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
708 Result<KEYS> rp = service.readNsByAttrib(trans, key);
711 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
712 if (Question.willSpecialLog(trans, trans.user())) {
713 Question.logEncryptTrace(trans,data.asString());
715 data.to(resp.getOutputStream());
716 setContentType(resp,keysDF.getOutType());
719 return Result.err(rp);
721 } catch (Exception e) {
722 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
723 return Result.err(e);
730 * @see com.att.authz.facade.AuthzFacade#updAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
733 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
734 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
736 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
739 setContentType(resp, keysDF.getOutType());
740 resp.getOutputStream().println();
743 return Result.err(rp);
745 } catch (Exception e) {
746 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
747 return Result.err(e);
755 * @see com.att.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
758 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
759 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
761 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
764 setContentType(resp, keysDF.getOutType());
765 resp.getOutputStream().println();
768 return Result.err(rp);
770 } catch (Exception e) {
771 trans.error().log(e,IN,NS_DELETE_ATTRIB);
772 return Result.err(e);
781 public static final String CREATE_PERMISSION = "createPermission";
782 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
783 public static final String GET_PERMS_BY_NAME = "getPermsByName";
784 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
785 public static final String GET_PERMISSIONS_BY_USER_SCOPE = "getPermissionsByUserScope";
786 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
787 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
788 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
789 public static final String UPDATE_PERMISSION = "updatePermission";
790 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
791 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
792 public static final String DELETE_PERMISSION = "deletePermission";
796 * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
799 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
800 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
804 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
805 if (Question.willSpecialLog(trans, trans.user())) {
806 Question.logEncryptTrace(trans,data.asString());
808 rreq = data.asObject();
809 } catch (APIException e) {
810 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
811 return Result.err(Status.ERR_BadData,"Invalid Input");
814 Result<Void> rp = service.createPerm(trans,rreq);
817 setContentType(resp,permsDF.getOutType());
820 return Result.err(rp);
822 } catch (Exception e) {
823 trans.error().log(e,IN,CREATE_PERMISSION);
824 return Result.err(e);
831 * @see com.att.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
834 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
835 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
838 Result<PERMS> rp = service.getPermsByType(trans, perm);
841 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
842 if (Question.willSpecialLog(trans, trans.user())) {
843 Question.logEncryptTrace(trans,data.asString());
845 data.to(resp.getOutputStream());
846 setContentType(resp,permsDF.getOutType());
847 setCacheControlOff(resp);
850 return Result.err(rp);
852 } catch (Exception e) {
853 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
854 return Result.err(e);
861 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
862 String type, String instance, String action) {
864 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
865 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
868 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
871 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
872 if (Question.willSpecialLog(trans, trans.user())) {
873 Question.logEncryptTrace(trans,data.asString());
875 data.to(resp.getOutputStream());
876 setContentType(resp,permsDF.getOutType());
877 setCacheControlOff(resp);
880 return Result.err(rp);
882 } catch (Exception e) {
883 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
884 return Result.err(e);
891 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
894 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
895 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
897 Result<PERMS> rp = service.getPermsByUser(trans, user);
900 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
901 if (Question.willSpecialLog(trans, trans.user())) {
902 Question.logEncryptTrace(trans,data.asString());
904 data.to(resp.getOutputStream());
905 setContentType(resp,permsDF.getOutType());
906 setCacheControlOff(resp);
909 return Result.err(rp);
911 } catch (Exception e) {
912 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
913 return Result.err(e);
920 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
923 public Result<Void> getPermsByUserScope(AuthzTrans trans, HttpServletResponse resp, String user, String[] scopes) {
924 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_SCOPE + ' ' + user, Env.SUB|Env.ALWAYS);
926 Result<PERMS> rp = service.getPermsByUserScope(trans, user, scopes);
929 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
930 if (Question.willSpecialLog(trans, trans.user())) {
931 Question.logEncryptTrace(trans,data.asString());
933 data.to(resp.getOutputStream());
934 setContentType(resp,permsDF.getOutType());
935 setCacheControlOff(resp);
938 return Result.err(rp);
940 } catch (Exception e) {
941 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_SCOPE, user);
942 return Result.err(e);
951 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
954 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
955 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
959 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
960 if (Question.willSpecialLog(trans, trans.user())) {
961 Question.logEncryptTrace(trans,data.asString());
963 perms = data.asObject();
964 } catch (APIException e) {
965 trans.error().log("Invalid Input",IN,GET_PERMISSIONS_BY_USER_WITH_QUERY);
966 return Result.err(Status.ERR_BadData,"Invalid Input");
969 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
972 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
973 if (Question.willSpecialLog(trans, trans.user())) {
974 Question.logEncryptTrace(trans,data.asString());
976 data.to(resp.getOutputStream());
977 setContentType(resp,permsDF.getOutType());
978 setCacheControlOff(resp);
981 return Result.err(rp);
983 } catch (Exception e) {
984 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
985 return Result.err(e);
993 * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
996 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
997 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
999 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
1002 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1003 if (Question.willSpecialLog(trans, trans.user())) {
1004 Question.logEncryptTrace(trans,data.asString());
1006 data.to(resp.getOutputStream());
1007 setContentType(resp,permsDF.getOutType());
1008 setCacheControlOff(resp);
1011 return Result.err(rp);
1013 } catch (Exception e) {
1014 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
1015 return Result.err(e);
1022 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
1023 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1025 Result<PERMS> rp = service.getPermsByNS(trans, ns);
1028 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1029 if (Question.willSpecialLog(trans, trans.user())) {
1030 Question.logEncryptTrace(trans,data.asString());
1032 data.to(resp.getOutputStream());
1033 setContentType(resp,permsDF.getOutType());
1034 setCacheControlOff(resp);
1037 return Result.err(rp);
1039 } catch (Exception e) {
1040 trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);
1041 return Result.err(e);
1049 * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
1052 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
1053 String origType, String origInstance, String origAction) {
1054 String cmdDescription = UPDATE_PERMISSION;
1055 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
1059 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1060 if (Question.willSpecialLog(trans, trans.user())) {
1061 Question.logEncryptTrace(trans,data.asString());
1063 rreq = data.asObject();
1064 } catch (APIException e) {
1065 trans.error().log("Invalid Input",IN,cmdDescription);
1066 return Result.err(Status.ERR_BadData,"Invalid Input");
1069 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
1072 setContentType(resp,permsDF.getOutType());
1075 return Result.err(rp);
1077 } catch (Exception e) {
1078 trans.error().log(e,IN,cmdDescription);
1079 return Result.err(e);
1086 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1087 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
1091 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1092 if (Question.willSpecialLog(trans, trans.user())) {
1093 Question.logEncryptTrace(trans,data.asString());
1095 rreq = data.asObject();
1096 } catch (APIException e) {
1097 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);
1098 return Result.err(Status.ERR_BadData,"Invalid Input");
1101 Result<Void> rp = service.updatePermDescription(trans, rreq);
1104 setContentType(resp,permRequestDF.getOutType());
1107 return Result.err(rp);
1109 } catch (Exception e) {
1110 trans.error().log(e,IN,UPDATE_PERM_DESC);
1111 return Result.err(e);
1119 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1120 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
1124 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1125 if (Question.willSpecialLog(trans, trans.user())) {
1126 Question.logEncryptTrace(trans,data.asString());
1128 rreq = data.asObject();
1129 } catch (APIException e) {
1130 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);
1131 return Result.err(Status.ERR_BadData,"Invalid Input");
1134 Result<Void> rp = service.resetPermRoles(trans, rreq);
1138 setContentType(resp,permsDF.getOutType());
1141 return Result.err(rp);
1143 } catch (Exception e) {
1144 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
1145 return Result.err(e);
1152 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1153 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
1157 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1158 if (Question.willSpecialLog(trans, trans.user())) {
1159 Question.logEncryptTrace(trans,data.asString());
1161 rreq = data.asObject();
1162 } catch (APIException e) {
1163 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);
1164 return Result.err(Status.ERR_BadData,"Invalid Input");
1168 Result<Void> rp = service.deletePerm(trans,rreq);
1171 setContentType(resp,permsDF.getOutType());
1174 return Result.err(rp);
1176 } catch (Exception e) {
1177 trans.error().log(e,IN,DELETE_PERMISSION);
1178 return Result.err(e);
1185 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
1186 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
1188 Result<Void> rp = service.deletePerm(trans,type,instance,action);
1191 setContentType(resp,permsDF.getOutType());
1194 return Result.err(rp);
1196 } catch (Exception e) {
1197 trans.error().log(e,IN,DELETE_PERMISSION);
1198 return Result.err(e);
1204 public static final String CREATE_ROLE = "createRole";
1205 public static final String GET_ROLES_BY_USER = "getRolesByUser";
1206 public static final String GET_ROLES_BY_NS = "getRolesByNS";
1207 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
1208 public static final String GET_ROLES_BY_NAME = "getRolesByName";
1209 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
1210 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
1211 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
1212 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
1213 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
1214 public static final String DELETE_ROLE = "deleteRole";
1215 public static final String GET_CERT_BY_ID = "getCertByID";
1218 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1219 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
1223 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1224 if (Question.willSpecialLog(trans, trans.user())) {
1225 Question.logEncryptTrace(trans,data.asString());
1227 rreq = data.asObject();
1228 } catch (APIException e) {
1229 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1230 return Result.err(Status.ERR_BadData,"Invalid Input");
1233 Result<Void> rp = service.createRole(trans, rreq);
1236 setContentType(resp,roleRequestDF.getOutType());
1239 return Result.err(rp);
1241 } catch (Exception e) {
1242 trans.error().log(e,IN,CREATE_ROLE);
1243 return Result.err(e);
1250 * @see com.att.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1253 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
1254 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
1256 Result<ROLES> rp = service.getRolesByName(trans, role);
1259 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1260 if (Question.willSpecialLog(trans, trans.user())) {
1261 Question.logEncryptTrace(trans,data.asString());
1263 data.to(resp.getOutputStream());
1264 setContentType(resp,roleDF.getOutType());
1265 setCacheControlOff(resp);
1268 return Result.err(rp);
1270 } catch (Exception e) {
1271 trans.error().log(e,IN,GET_ROLES_BY_NAME);
1272 return Result.err(e);
1279 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1282 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
1283 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1285 Result<ROLES> rp = service.getRolesByUser(trans, user);
1288 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1289 if (Question.willSpecialLog(trans, trans.user())) {
1290 Question.logEncryptTrace(trans,data.asString());
1292 data.to(resp.getOutputStream());
1293 setContentType(resp,roleDF.getOutType());
1294 setCacheControlOff(resp);
1297 return Result.err(rp);
1299 } catch (Exception e) {
1300 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
1301 return Result.err(e);
1308 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1311 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
1312 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1314 Result<ROLES> rp = service.getRolesByNS(trans, ns);
1317 if (!rp.isEmpty()) {
1318 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1319 if (Question.willSpecialLog(trans, trans.user())) {
1320 Question.logEncryptTrace(trans,data.asString());
1322 data.to(resp.getOutputStream());
1324 Question.logEncryptTrace(trans, NO_DATA);
1326 setContentType(resp,roleDF.getOutType());
1327 setCacheControlOff(resp);
1330 return Result.err(rp);
1332 } catch (Exception e) {
1333 trans.error().log(e,IN,GET_ROLES_BY_NS);
1334 return Result.err(e);
1342 * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1345 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
1346 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
1348 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
1351 if (!rp.isEmpty()) {
1352 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1353 if (Question.willSpecialLog(trans, trans.user())) {
1354 Question.logEncryptTrace(trans,data.asString());
1356 data.to(resp.getOutputStream());
1358 Question.logEncryptTrace(trans, NO_DATA);
1360 setContentType(resp,roleDF.getOutType());
1361 setCacheControlOff(resp);
1364 return Result.err(rp);
1366 } catch (Exception e) {
1367 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
1368 return Result.err(e);
1375 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1378 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
1379 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
1381 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
1384 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1385 if (Question.willSpecialLog(trans, trans.user())) {
1386 Question.logEncryptTrace(trans,data.asString());
1388 data.to(resp.getOutputStream());
1389 setContentType(resp,roleDF.getOutType());
1390 setCacheControlOff(resp);
1393 return Result.err(rp);
1395 } catch (Exception e) {
1396 trans.error().log(e,IN,GET_ROLES_BY_PERM);
1397 return Result.err(e);
1405 * @see com.att.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
1408 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1409 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
1413 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1414 if (Question.willSpecialLog(trans, trans.user())) {
1415 Question.logEncryptTrace(trans,data.asString());
1417 rreq = data.asObject();
1418 } catch (APIException e) {
1419 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);
1420 return Result.err(Status.ERR_BadData,"Invalid Input");
1423 Result<Void> rp = service.updateRoleDescription(trans, rreq);
1426 setContentType(resp,roleRequestDF.getOutType());
1431 } catch (Exception e) {
1432 trans.error().log(e,IN,UPDATE_ROLE_DESC);
1433 return Result.err(e);
1440 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1441 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
1445 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1446 if (Question.willSpecialLog(trans, trans.user())) {
1447 Question.logEncryptTrace(trans,data.asString());
1449 rreq = data.asObject();
1450 } catch (APIException e) {
1451 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);
1452 return Result.err(Status.ERR_BadData,"Invalid Input");
1455 Result<Void> rp = service.addPermToRole(trans, rreq);
1458 setContentType(resp,permsDF.getOutType());
1459 resp.getOutputStream().println();
1462 return Result.err(rp);
1464 } catch (Exception e) {
1465 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
1466 return Result.err(e);
1473 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1474 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1478 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1479 if (Question.willSpecialLog(trans, trans.user())) {
1480 Question.logEncryptTrace(trans,data.asString());
1482 rreq = data.asObject();
1483 } catch (APIException e) {
1484 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);
1485 return Result.err(Status.ERR_BadData,"Invalid Input");
1488 Result<Void> rp = service.delPermFromRole(trans, rreq);
1491 setContentType(resp,permsDF.getOutType());
1492 resp.getOutputStream().println();
1495 return Result.err(rp);
1497 } catch (Exception e) {
1498 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1499 return Result.err(e);
1506 * @see com.att.authz.facade.AuthzFacade#delPermFromRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
1509 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletResponse resp, String role, String type,
1510 String instance, String action) {
1511 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1513 Result<Void> rp = service.delPermFromRole(trans, role, type, instance, action);
1516 setContentType(resp,permsDF.getOutType());
1517 resp.getOutputStream().println();
1520 return Result.err(rp);
1522 } catch (Exception e) {
1523 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1524 return Result.err(e);
1531 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1532 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1534 Result<Void> rp = service.deleteRole(trans, role);
1537 setContentType(resp,permsDF.getOutType());
1540 return Result.err(rp);
1542 } catch (Exception e) {
1543 trans.error().log(e,IN,DELETE_ROLE);
1544 return Result.err(e);
1551 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1552 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
1556 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1557 if (Question.willSpecialLog(trans, trans.user())) {
1558 Question.logEncryptTrace(trans,data.asString());
1560 rreq = data.asObject();
1561 } catch (APIException e) {
1562 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1563 return Result.err(Status.ERR_BadData,"Invalid Input");
1566 Result<Void> rp = service.deleteRole(trans, rreq);
1569 setContentType(resp,permsDF.getOutType());
1572 return Result.err(rp);
1574 } catch (Exception e) {
1575 trans.error().log(e,IN,DELETE_ROLE);
1576 return Result.err(e);
1582 public static final String CREATE_CRED = "createUserCred";
1583 private static final String GET_CREDS_BY_NS = "getCredsByNS";
1584 private static final String GET_CREDS_BY_ID = "getCredsByID";
1585 public static final String UPDATE_CRED = "updateUserCred";
1586 public static final String EXTEND_CRED = "extendUserCred";
1587 public static final String DELETE_CRED = "deleteUserCred";
1588 public static final String DOES_CRED_MATCH = "doesCredMatch";
1589 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
1598 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
1599 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
1601 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1602 if (Question.willSpecialLog(trans, trans.user())) {
1603 Question.logEncryptTrace(trans,data.asString());
1605 return service.createUserCred(trans, data.asObject());
1606 } catch (APIException e) {
1607 trans.error().log(e,"Bad Input data");
1608 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1609 } catch (Exception e) {
1610 trans.error().log(e,IN,CREATE_CRED);
1611 return Result.err(e);
1618 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
1619 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
1621 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1622 if (Question.willSpecialLog(trans, trans.user())) {
1623 Question.logEncryptTrace(trans,data.asString());
1626 return service.changeUserCred(trans, data.asObject());
1627 } catch (APIException e) {
1628 trans.error().log(e,"Bad Input data");
1629 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1630 } catch (Exception e) {
1631 trans.error().log(e,IN,UPDATE_CRED);
1632 return Result.err(e);
1639 * @see com.att.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
1642 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
1643 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
1645 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1646 if (Question.willSpecialLog(trans, trans.user())) {
1647 Question.logEncryptTrace(trans,data.asString());
1650 return service.extendUserCred(trans, data.asObject(), days);
1651 } catch (APIException e) {
1652 trans.error().log(e,"Bad Input data");
1653 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1654 } catch (Exception e) {
1655 trans.error().log(e,IN,EXTEND_CRED);
1656 return Result.err(e);
1663 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
1664 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1667 Result<USERS> ru = service.getCredsByNS(trans,ns);
1670 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1671 if (Question.willSpecialLog(trans,trans.user())) {
1672 Question.logEncryptTrace(trans,data.asString());
1674 data.to(resp.getOutputStream());
1675 setContentType(resp,usersDF.getOutType());
1678 return Result.err(ru);
1680 } catch (Exception e) {
1681 trans.error().log(e,IN,GET_CREDS_BY_NS);
1682 return Result.err(e);
1691 * @see com.att.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1694 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
1695 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
1698 Result<USERS> ru = service.getCredsByID(trans,id);
1701 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1702 if (Question.willSpecialLog(trans, trans.user())) {
1703 Question.logEncryptTrace(trans,data.asString());
1705 data.to(resp.getOutputStream());
1706 setContentType(resp,usersDF.getOutType());
1709 return Result.err(ru);
1711 } catch (Exception e) {
1712 trans.error().log(e,IN,GET_CREDS_BY_ID);
1713 return Result.err(e);
1721 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
1722 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
1724 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1725 if (Question.willSpecialLog(trans, trans.user())) {
1726 Question.logEncryptTrace(trans,data.asString());
1729 return service.deleteUserCred(trans, data.asObject());
1730 } catch (APIException e) {
1731 trans.error().log(e,"Bad Input data");
1732 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1733 } catch (Exception e) {
1734 trans.error().log(e,IN,DELETE_CRED);
1735 return Result.err(e);
1743 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1744 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
1746 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1747 if (Question.willSpecialLog(trans, trans.user())) {
1748 Question.logEncryptTrace(trans,data.asString());
1751 return service.doesCredentialMatch(trans, data.asObject());
1752 } catch (APIException e) {
1753 trans.error().log(e,"Bad Input data");
1754 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1755 } catch (IOException e) {
1756 trans.error().log(e,IN,DOES_CRED_MATCH);
1757 return Result.err(e);
1765 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
1766 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
1768 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
1769 switch(result.status){
1771 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
1774 return Result.err(result);
1775 } catch (Exception e) {
1776 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
1777 return Result.err(e);
1784 * @see com.att.authz.facade.AuthzFacade#getCertInfoByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
1787 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
1788 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
1790 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
1792 switch(rci.status) {
1794 if (Question.willSpecialLog(trans, trans.user())) {
1795 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
1796 Question.logEncryptTrace(trans,data.asString());
1797 data.to(resp.getOutputStream());
1799 certsDF.direct(trans, rci.value, resp.getOutputStream());
1801 setContentType(resp,certsDF.getOutType());
1804 return Result.err(rci);
1806 } catch (Exception e) {
1807 trans.error().log(e,IN,GET_CERT_BY_ID);
1808 return Result.err(e);
1814 public static final String CREATE_DELEGATE = "createDelegate";
1815 public static final String UPDATE_DELEGATE = "updateDelegate";
1816 public static final String DELETE_DELEGATE = "deleteDelegate";
1817 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
1818 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
1821 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1822 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
1824 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1825 if (Question.willSpecialLog(trans, trans.user())) {
1826 Question.logEncryptTrace(trans,data.asString());
1829 return service.createDelegate(trans, data.asObject());
1830 } catch (Exception e) {
1831 trans.error().log(e,IN,CREATE_DELEGATE);
1832 return Result.err(e);
1839 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1840 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
1842 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1843 if (Question.willSpecialLog(trans, trans.user())) {
1844 Question.logEncryptTrace(trans,data.asString());
1847 return service.updateDelegate(trans, data.asObject());
1848 } catch (Exception e) {
1849 trans.error().log(e,IN,UPDATE_DELEGATE);
1850 return Result.err(e);
1857 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1858 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
1860 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1861 if (Question.willSpecialLog(trans, trans.user())) {
1862 Question.logEncryptTrace(trans,data.asString());
1865 return service.deleteDelegate(trans, data.asObject());
1866 } catch (Exception e) {
1867 trans.error().log(e,IN,DELETE_DELEGATE);
1868 return Result.err(e);
1875 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
1876 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
1878 return service.deleteDelegate(trans, userName);
1879 } catch (Exception e) {
1880 trans.error().log(e,IN,DELETE_DELEGATE);
1881 return Result.err(e);
1888 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
1889 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
1891 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
1895 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1896 if (Question.willSpecialLog(trans, trans.user())) {
1897 Question.logEncryptTrace(trans,data.asString());
1899 data.to(resp.getOutputStream());
1900 setContentType(resp,delgDF.getOutType());
1903 return Result.err(rd);
1905 } catch (Exception e) {
1906 trans.error().log(e,IN,GET_DELEGATE_USER);
1907 return Result.err(e);
1914 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
1915 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
1917 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
1920 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1921 if (Question.willSpecialLog(trans, trans.user())) {
1922 Question.logEncryptTrace(trans,data.asString());
1924 data.to(resp.getOutputStream());
1925 setContentType(resp,delgDF.getOutType());
1928 return Result.err(rd);
1930 } catch (Exception e) {
1931 trans.error().log(e,IN,GET_DELEGATE_DELG);
1932 return Result.err(e);
1938 private static final String REQUEST_USER_ROLE = "createUserRole";
1939 private static final String GET_USERROLES = "getUserRoles";
1940 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
1941 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
1942 private static final String SET_ROLES_FOR_USER = "setRolesForUser";
1943 private static final String SET_USERS_FOR_ROLE = "setUsersForRole";
1944 private static final String EXTEND_USER_ROLE = "extendUserRole";
1945 private static final String DELETE_USER_ROLE = "deleteUserRole";
1947 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1948 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
1952 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
1953 if (Question.willSpecialLog(trans, trans.user())) {
1954 Question.logEncryptTrace(trans,data.asString());
1957 request = data.asObject();
1958 } catch (APIException e) {
1959 return Result.err(Status.ERR_BadData,"Invalid Input");
1962 Result<Void> rp = service.createUserRole(trans,request);
1965 setContentType(resp,permsDF.getOutType());
1968 return Result.err(rp);
1970 } catch (Exception e) {
1971 trans.error().log(e,IN,REQUEST_USER_ROLE);
1972 return Result.err(e);
1979 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
1980 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
1982 Result<USERS> ru = service.getUserInRole(trans,user,role);
1985 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1986 if (Question.willSpecialLog(trans, trans.user())) {
1987 Question.logEncryptTrace(trans,data.asString());
1990 data.to(resp.getOutputStream());
1991 setContentType(resp,usersDF.getOutType());
1992 setCacheControlOff(resp);
1995 return Result.err(ru);
1997 } catch (Exception e) {
1998 trans.error().log(e,IN,GET_USERROLES);
1999 return Result.err(e);
2007 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2008 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2010 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
2013 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2014 if (Question.willSpecialLog(trans, trans.user())) {
2015 Question.logEncryptTrace(trans,data.asString());
2018 data.to(resp.getOutputStream());
2019 setContentType(resp,usersDF.getOutType());
2020 setCacheControlOff(resp);
2023 return Result.err(ru);
2025 } catch (Exception e) {
2026 trans.error().log(e,IN,GET_USERROLES_BY_USER);
2027 return Result.err(e);
2035 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2036 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2038 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
2041 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2042 if (Question.willSpecialLog(trans, trans.user())) {
2043 Question.logEncryptTrace(trans,data.asString());
2046 data.to(resp.getOutputStream());
2047 setContentType(resp,usersDF.getOutType());
2048 setCacheControlOff(resp);
2051 return Result.err(ru);
2053 } catch (Exception e) {
2054 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
2055 return Result.err(e);
2064 public Result<Void> resetUsersForRole(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
2065 TimeTaken tt = trans.start(SET_USERS_FOR_ROLE, Env.SUB|Env.ALWAYS);
2069 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
2070 if (Question.willSpecialLog(trans, trans.user())) {
2071 Question.logEncryptTrace(trans,data.asString());
2073 rreq = data.asObject();
2074 } catch (APIException e) {
2075 trans.error().log("Invalid Input",IN, SET_USERS_FOR_ROLE);
2076 return Result.err(Status.ERR_BadData,"Invalid Input");
2079 Result<Void> rp = service.resetUsersForRole(trans, rreq);
2083 setContentType(resp,permsDF.getOutType());
2086 return Result.err(rp);
2088 } catch (Exception e) {
2089 trans.error().log(e,IN,SET_USERS_FOR_ROLE);
2090 return Result.err(e);
2098 public Result<Void> resetRolesForUser(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
2099 TimeTaken tt = trans.start(SET_ROLES_FOR_USER, Env.SUB|Env.ALWAYS);
2103 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
2104 if (Question.willSpecialLog(trans, trans.user())) {
2105 Question.logEncryptTrace(trans,data.asString());
2108 rreq = data.asObject();
2109 } catch (APIException e) {
2110 trans.error().log("Invalid Input",IN, SET_ROLES_FOR_USER);
2111 return Result.err(Status.ERR_BadData,"Invalid Input");
2114 Result<Void> rp = service.resetRolesForUser(trans, rreq);
2118 setContentType(resp,permsDF.getOutType());
2121 return Result.err(rp);
2123 } catch (Exception e) {
2124 trans.error().log(e,IN,SET_ROLES_FOR_USER);
2125 return Result.err(e);
2133 * @see com.att.authz.facade.AuthzFacade#extendUserRoleExpiration(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
2136 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2137 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2139 return service.extendUserRole(trans,user,role);
2140 } catch (Exception e) {
2141 trans.error().log(e,IN,EXTEND_USER_ROLE);
2142 return Result.err(e);
2149 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2150 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2152 Result<Void> rp = service.deleteUserRole(trans,user,role);
2155 setContentType(resp,permsDF.getOutType());
2158 return Result.err(rp);
2160 } catch (Exception e) {
2161 trans.error().log(e,IN,DELETE_USER_ROLE);
2162 return Result.err(e);
2168 private static final String UPDATE_APPROVAL = "updateApproval";
2169 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
2170 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
2171 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
2174 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
2175 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
2177 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
2178 if (Question.willSpecialLog(trans, trans.user())) {
2179 Question.logEncryptTrace(trans,data.asString());
2182 Result<Void> rp = service.updateApproval(trans, data.asObject());
2186 setContentType(resp,approvalDF.getOutType());
2189 return Result.err(rp);
2191 } catch (Exception e) {
2192 trans.error().log(e,IN,UPDATE_APPROVAL);
2193 return Result.err(e);
2200 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2201 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2203 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
2206 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2207 if (Question.willSpecialLog(trans, trans.user())) {
2208 Question.logEncryptTrace(trans,data.asString());
2210 data.to(resp.getOutputStream());
2212 setContentType(resp,permsDF.getOutType());
2215 return Result.err(rp);
2217 } catch (Exception e) {
2218 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
2219 return Result.err(e);
2226 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
2227 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
2229 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
2232 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2233 if (Question.willSpecialLog(trans, trans.user())) {
2234 Question.logEncryptTrace(trans,data.asString());
2237 data.to(resp.getOutputStream());
2238 setContentType(resp,permsDF.getOutType());
2241 return Result.err(rp);
2243 } catch (Exception e) {
2244 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
2245 return Result.err(e);
2252 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
2253 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
2255 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
2258 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2259 if (Question.willSpecialLog(trans, trans.user())) {
2260 Question.logEncryptTrace(trans,data.asString());
2263 data.to(resp.getOutputStream());
2264 setContentType(resp,permsDF.getOutType());
2267 return Result.err(rp);
2269 } catch (Exception e) {
2270 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
2271 return Result.err(e);
2279 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
2280 public static final String GET_USERS_ROLE = "getUsersByRole";
2283 * @see com.att.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2286 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2287 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2289 Result<USERS> ru = service.getUsersByRole(trans,role);
2292 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2293 if (Question.willSpecialLog(trans, trans.user())) {
2294 Question.logEncryptTrace(trans,data.asString());
2297 data.to(resp.getOutputStream());
2298 setContentType(resp,usersDF.getOutType());
2301 return Result.err(ru);
2303 } catch (Exception e) {
2304 trans.error().log(e,IN,GET_USERS_ROLE);
2305 return Result.err(e);
2312 * @see com.att.authz.facade.AuthzFacade#getUsersByPermission(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
2315 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
2316 String type, String instance, String action) {
2317 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
2319 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
2322 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2323 if (Question.willSpecialLog(trans, trans.user())) {
2324 Question.logEncryptTrace(trans,data.asString());
2327 data.to(resp.getOutputStream());
2328 setContentType(resp,usersDF.getOutType());
2331 return Result.err(ru);
2333 } catch (Exception e) {
2334 trans.error().log(e,IN,GET_USERS_PERMISSION);
2335 return Result.err(e);
2342 public static final String GET_HISTORY_USER = "getHistoryByUser";
2343 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
2344 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
2345 public static final String GET_HISTORY_NS = "getHistoryByNS";
2347 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2350 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
2351 StringBuilder sb = new StringBuilder();
2352 sb.append(GET_HISTORY_USER);
2356 boolean first = true;
2357 for (int i : yyyymm) {
2365 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2368 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
2371 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2372 if (Question.willSpecialLog(trans, trans.user())) {
2373 Question.logEncryptTrace(trans,data.asString());
2376 data.to(resp.getOutputStream());
2377 setContentType(resp,historyDF.getOutType());
2380 return Result.err(rh);
2382 } catch (Exception e) {
2383 trans.error().log(e,IN,GET_HISTORY_USER);
2384 return Result.err(e);
2391 * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2394 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
2395 StringBuilder sb = new StringBuilder();
2396 sb.append(GET_HISTORY_ROLE);
2400 boolean first = true;
2401 for (int i : yyyymm) {
2409 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2411 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
2414 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2415 if (Question.willSpecialLog(trans, trans.user())) {
2416 Question.logEncryptTrace(trans,data.asString());
2419 data.to(resp.getOutputStream());
2420 setContentType(resp,historyDF.getOutType());
2423 return Result.err(rh);
2425 } catch (Exception e) {
2426 trans.error().log(e,IN,GET_HISTORY_ROLE);
2427 return Result.err(e);
2434 * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2437 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
2438 StringBuilder sb = new StringBuilder();
2439 sb.append(GET_HISTORY_NS);
2443 boolean first = true;
2444 for (int i : yyyymm) {
2452 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2454 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
2457 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2458 if (Question.willSpecialLog(trans, trans.user())) {
2459 Question.logEncryptTrace(trans,data.asString());
2462 data.to(resp.getOutputStream());
2463 setContentType(resp,historyDF.getOutType());
2466 return Result.err(rh);
2468 } catch (Exception e) {
2469 trans.error().log(e,IN,GET_HISTORY_NS);
2470 return Result.err(e);
2477 * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2480 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
2481 StringBuilder sb = new StringBuilder();
2482 sb.append(GET_HISTORY_PERM);
2486 boolean first = true;
2487 for (int i : yyyymm) {
2495 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2497 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
2500 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2501 if (Question.willSpecialLog(trans, trans.user())) {
2502 Question.logEncryptTrace(trans,data.asString());
2505 data.to(resp.getOutputStream());
2506 setContentType(resp,historyDF.getOutType());
2509 return Result.err(rh);
2511 } catch (Exception e) {
2512 trans.error().log(e,IN,GET_HISTORY_PERM);
2513 return Result.err(e);
2519 public final static String CACHE_CLEAR = "cacheClear ";
2520 // public final static String CACHE_VALIDATE = "validateCache";
2523 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String)
2526 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
2527 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
2529 return service.cacheClear(trans,cname);
2530 } catch (Exception e) {
2531 trans.error().log(e,IN,CACHE_CLEAR);
2532 return Result.err(e);
2539 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.Integer)
2542 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
2543 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
2545 String[] segs = segments.split("\\s*,\\s*");
2546 int isegs[] = new int[segs.length];
2547 for (int i=0;i<segs.length;++i) {
2549 isegs[i] = Integer.parseInt(segs[i]);
2550 } catch (NumberFormatException nfe) {
2554 return service.cacheClear(trans,cname, isegs);
2555 } catch (Exception e) {
2556 trans.error().log(e,IN,CACHE_CLEAR);
2557 return Result.err(e);
2564 * @see com.att.authz.facade.AuthzFacade#dbReset(org.onap.aaf.auth.env.test.AuthzTrans)
2567 public void dbReset(AuthzTrans trans) {
2568 service.dbReset(trans);
2572 * @see com.att.authz.facade.AuthzFacade#getAPI(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse)
2574 public final static String API_REPORT = "apiReport";
2576 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
2577 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
2579 Api api = new Api();
2581 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
2582 for (RouteReport rr : rservlet.routeReport()) {
2583 api.getRoute().add(ar = new Api.Route());
2584 ar.setMeth(rr.meth.name());
2585 ar.setPath(rr.path);
2586 ar.setDesc(rr.desc);
2587 ar.getContentType().addAll(rr.contextTypes);
2588 for (Method m : meths) {
2590 if ((ad = m.getAnnotation(ApiDoc.class))!=null &&
2591 rr.meth.equals(ad.method()) &&
2592 rr.path.equals(ad.path())) {
2593 for (String param : ad.params()) {
2594 ar.getParam().add(param);
2596 for (String text : ad.text()) {
2597 ar.getComments().add(text);
2599 ar.setExpected(ad.expectedCode());
2600 for (int ec : ad.errorCodes()) {
2601 ar.getExplicitErr().add(ec);
2606 RosettaData<Api> data = apiDF.newData(trans).load(api);
2607 if (Question.willSpecialLog(trans, trans.user())) {
2608 Question.logEncryptTrace(trans,data.asString());
2611 data.to(resp.getOutputStream());
2612 setContentType(resp,apiDF.getOutType());
2615 } catch (Exception e) {
2616 trans.error().log(e,IN,API_REPORT);
2617 return Result.err(e);
2624 public final static String API_EXAMPLE = "apiExample";
2627 * @see com.att.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2630 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
2631 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
2633 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
2634 resp.getOutputStream().print(content);
2635 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
2637 } catch (Exception e) {
2638 trans.error().log(e,IN,API_EXAMPLE);
2639 return Result.err(Status.ERR_NotImplemented,e.getMessage());