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 = result.variables;
284 response.setStatus(/*httpstatus=*/300);
288 detail[0] = GENERAL_SERVICE_ERROR;
289 response.setStatus(/*httpstatus=*/500);
295 detail[0] = GENERAL_SERVICE_ERROR;
296 response.setStatus(/*httpstatus=*/500);
302 StringBuilder holder = new StringBuilder();
303 ERR em = service.mapper().errorFromMessage(holder,msgId,msg,detail);
312 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
314 errDF.newData(trans).load(em).to(response.getOutputStream());
315 } catch (Exception e) {
316 trans.error().log(e,"unable to send response for",msg);
320 ///////////////////////////
322 ///////////////////////////
323 public static final String CREATE_NS = "createNamespace";
324 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
325 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
326 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
327 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
328 public static final String GET_NS_BY_NAME = "getNamespaceByName";
329 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
330 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
331 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
332 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
333 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
334 public static final String DELETE_NS = "deleteNamespace";
338 * @see com.att.authz.facade.AuthzFacade#createNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
341 public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {
342 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);
346 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());
347 if(Question.willSpecialLog(trans, trans.user())) {
348 Question.logEncryptTrace(trans,rd.asString());
350 request = rd.asObject();
351 } catch(APIException e) {
352 trans.error().log("Invalid Input",IN,CREATE_NS);
353 return Result.err(Status.ERR_BadData,"Invalid Input");
356 Result<Void> rp = service.createNS(trans,request,type);
359 setContentType(resp,nsRequestDF.getOutType());
362 return Result.err(rp);
364 } catch (Exception e) {
365 trans.error().log(e,IN,CREATE_NS);
366 return Result.err(e);
373 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
376 public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
377 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
379 Result<Void> rp = service.addAdminNS(trans,ns,id);
383 setContentType(resp,nsRequestDF.getOutType());
384 resp.getOutputStream().println();
387 return Result.err(rp);
389 } catch (Exception e) {
390 trans.error().log(e,IN,ADD_NS_ADMIN);
391 return Result.err(e);
398 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
401 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
402 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
404 Result<Void> rp = service.delAdminNS(trans, ns, id);
407 setContentType(resp,nsRequestDF.getOutType());
410 return Result.err(rp);
412 } catch (Exception e) {
413 trans.error().log(e,IN,DELETE_NS_ADMIN);
414 return Result.err(e);
421 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
424 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
425 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
427 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
430 setContentType(resp,nsRequestDF.getOutType());
431 resp.getOutputStream().println();
434 return Result.err(rp);
436 } catch (Exception e) {
437 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
438 return Result.err(e);
445 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
448 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
449 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
451 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
454 setContentType(resp,nsRequestDF.getOutType());
455 resp.getOutputStream().println();
458 return Result.err(rp);
460 } catch (Exception e) {
461 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
462 return Result.err(e);
469 * @see com.att.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
472 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns) {
473 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
475 Result<NSS> rp = service.getNSbyName(trans, ns);
478 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
479 if(Question.willSpecialLog(trans, trans.user())) {
480 Question.logEncryptTrace(trans,data.asString());
482 data.to(resp.getOutputStream());
483 setContentType(resp,nssDF.getOutType());
486 return Result.err(rp);
488 } catch (Exception e) {
489 trans.error().log(e,IN,GET_NS_BY_NAME);
490 return Result.err(e);
496 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
498 * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
501 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
502 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
504 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
507 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
508 if(Question.willSpecialLog(trans, trans.user())) {
509 Question.logEncryptTrace(trans,data.asString());
511 data.to(resp.getOutputStream());
512 setContentType(resp,nssDF.getOutType());
515 return Result.err(rp);
517 } catch (Exception e) {
518 trans.error().log(e,IN,GET_NS_BY_ADMIN);
519 return Result.err(e);
525 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
527 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
530 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
531 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
533 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
536 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
537 if(Question.willSpecialLog(trans, trans.user())) {
538 Question.logEncryptTrace(trans,data.asString());
540 data.to(resp.getOutputStream());
542 setContentType(resp,nssDF.getOutType());
545 return Result.err(rp);
547 } catch (Exception e) {
548 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
549 return Result.err(e);
556 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
559 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
560 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
562 Result<NSS> rp = service.getNSbyEither(trans, user, full);
566 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
567 if(Question.willSpecialLog(trans, trans.user())) {
568 Question.logEncryptTrace(trans,data.asString());
570 data.to(resp.getOutputStream());
572 setContentType(resp,nssDF.getOutType());
575 return Result.err(rp);
577 } catch (Exception e) {
578 trans.error().log(e,IN,GET_NS_BY_EITHER);
579 return Result.err(e);
586 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
589 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
590 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
592 Result<NSS> rp = service.getNSsChildren(trans, parent);
595 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
596 if(Question.willSpecialLog(trans, trans.user())) {
597 Question.logEncryptTrace(trans,data.asString());
599 data.to(resp.getOutputStream());
600 setContentType(resp,nssDF.getOutType());
603 return Result.err(rp);
605 } catch (Exception e) {
606 trans.error().log(e,IN,GET_NS_CHILDREN);
607 return Result.err(e);
614 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
615 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
619 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
620 if(Question.willSpecialLog(trans, trans.user())) {
621 Question.logEncryptTrace(trans,data.asString());
623 rreq = data.asObject();
624 } catch(APIException e) {
625 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);
626 return Result.err(Status.ERR_BadData,"Invalid Input");
629 Result<Void> rp = service.updateNsDescription(trans, rreq);
632 setContentType(resp,nsRequestDF.getOutType());
635 return Result.err(rp);
637 } catch (Exception e) {
638 trans.error().log(e,IN,UPDATE_NS_DESC);
639 return Result.err(e);
647 * @see com.att.authz.facade.AuthzFacade#requestNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
650 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
651 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
653 Result<Void> rp = service.deleteNS(trans,ns);
656 setContentType(resp,nsRequestDF.getOutType());
659 return Result.err(rp);
661 } catch (Exception e) {
662 trans.error().log(e,IN,DELETE_NS);
663 return Result.err(e);
669 private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";
670 private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
671 private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";
672 private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";
675 * @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)
678 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
679 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
681 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
684 setContentType(resp, keysDF.getOutType());
685 resp.getOutputStream().println();
688 return Result.err(rp);
690 } catch (Exception e) {
691 trans.error().log(e,IN,NS_CREATE_ATTRIB);
692 return Result.err(e);
699 * @see com.att.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
702 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
703 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
705 Result<KEYS> rp = service.readNsByAttrib(trans, key);
708 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
709 if(Question.willSpecialLog(trans, trans.user())) {
710 Question.logEncryptTrace(trans,data.asString());
712 data.to(resp.getOutputStream());
713 setContentType(resp,keysDF.getOutType());
716 return Result.err(rp);
718 } catch (Exception e) {
719 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
720 return Result.err(e);
727 * @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)
730 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
731 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
733 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
736 setContentType(resp, keysDF.getOutType());
737 resp.getOutputStream().println();
740 return Result.err(rp);
742 } catch (Exception e) {
743 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
744 return Result.err(e);
752 * @see com.att.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
755 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
756 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
758 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
761 setContentType(resp, keysDF.getOutType());
762 resp.getOutputStream().println();
765 return Result.err(rp);
767 } catch (Exception e) {
768 trans.error().log(e,IN,NS_DELETE_ATTRIB);
769 return Result.err(e);
778 public static final String CREATE_PERMISSION = "createPermission";
779 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
780 public static final String GET_PERMS_BY_NAME = "getPermsByName";
781 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
782 public static final String GET_PERMISSIONS_BY_USER_SCOPE = "getPermissionsByUserScope";
783 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
784 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
785 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
786 public static final String UPDATE_PERMISSION = "updatePermission";
787 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
788 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
789 public static final String DELETE_PERMISSION = "deletePermission";
793 * @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)
796 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
797 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
801 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
802 if(Question.willSpecialLog(trans, trans.user())) {
803 Question.logEncryptTrace(trans,data.asString());
805 rreq = data.asObject();
806 } catch(APIException e) {
807 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
808 return Result.err(Status.ERR_BadData,"Invalid Input");
811 Result<Void> rp = service.createPerm(trans,rreq);
814 setContentType(resp,permsDF.getOutType());
817 return Result.err(rp);
819 } catch (Exception e) {
820 trans.error().log(e,IN,CREATE_PERMISSION);
821 return Result.err(e);
828 * @see com.att.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
831 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
832 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
835 Result<PERMS> rp = service.getPermsByType(trans, perm);
838 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
839 if(Question.willSpecialLog(trans, trans.user())) {
840 Question.logEncryptTrace(trans,data.asString());
842 data.to(resp.getOutputStream());
843 setContentType(resp,permsDF.getOutType());
844 setCacheControlOff(resp);
847 return Result.err(rp);
849 } catch (Exception e) {
850 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
851 return Result.err(e);
858 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
859 String type, String instance, String action) {
861 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
862 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
865 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
868 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
869 if(Question.willSpecialLog(trans, trans.user())) {
870 Question.logEncryptTrace(trans,data.asString());
872 data.to(resp.getOutputStream());
873 setContentType(resp,permsDF.getOutType());
874 setCacheControlOff(resp);
877 return Result.err(rp);
879 } catch (Exception e) {
880 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
881 return Result.err(e);
888 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
891 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
892 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
894 Result<PERMS> rp = service.getPermsByUser(trans, user);
897 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
898 if(Question.willSpecialLog(trans, trans.user())) {
899 Question.logEncryptTrace(trans,data.asString());
901 data.to(resp.getOutputStream());
902 setContentType(resp,permsDF.getOutType());
903 setCacheControlOff(resp);
906 return Result.err(rp);
908 } catch (Exception e) {
909 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
910 return Result.err(e);
917 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
920 public Result<Void> getPermsByUserScope(AuthzTrans trans, HttpServletResponse resp, String user, String[] scopes) {
921 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_SCOPE + ' ' + user, Env.SUB|Env.ALWAYS);
923 Result<PERMS> rp = service.getPermsByUserScope(trans, user, scopes);
926 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
927 if(Question.willSpecialLog(trans, trans.user())) {
928 Question.logEncryptTrace(trans,data.asString());
930 data.to(resp.getOutputStream());
931 setContentType(resp,permsDF.getOutType());
932 setCacheControlOff(resp);
935 return Result.err(rp);
937 } catch (Exception e) {
938 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_SCOPE, user);
939 return Result.err(e);
948 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
951 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
952 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
956 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
957 if(Question.willSpecialLog(trans, trans.user())) {
958 Question.logEncryptTrace(trans,data.asString());
960 perms = data.asObject();
961 } catch(APIException e) {
962 trans.error().log("Invalid Input",IN,GET_PERMISSIONS_BY_USER_WITH_QUERY);
963 return Result.err(Status.ERR_BadData,"Invalid Input");
966 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
969 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
970 if(Question.willSpecialLog(trans, trans.user())) {
971 Question.logEncryptTrace(trans,data.asString());
973 data.to(resp.getOutputStream());
974 setContentType(resp,permsDF.getOutType());
975 setCacheControlOff(resp);
978 return Result.err(rp);
980 } catch (Exception e) {
981 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
982 return Result.err(e);
990 * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
993 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
994 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
996 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
999 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1000 if(Question.willSpecialLog(trans, trans.user())) {
1001 Question.logEncryptTrace(trans,data.asString());
1003 data.to(resp.getOutputStream());
1004 setContentType(resp,permsDF.getOutType());
1005 setCacheControlOff(resp);
1008 return Result.err(rp);
1010 } catch (Exception e) {
1011 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
1012 return Result.err(e);
1019 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
1020 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1022 Result<PERMS> rp = service.getPermsByNS(trans, ns);
1025 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1026 if(Question.willSpecialLog(trans, trans.user())) {
1027 Question.logEncryptTrace(trans,data.asString());
1029 data.to(resp.getOutputStream());
1030 setContentType(resp,permsDF.getOutType());
1031 setCacheControlOff(resp);
1034 return Result.err(rp);
1036 } catch (Exception e) {
1037 trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);
1038 return Result.err(e);
1046 * @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)
1049 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
1050 String origType, String origInstance, String origAction) {
1051 String cmdDescription = UPDATE_PERMISSION;
1052 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
1056 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1057 if(Question.willSpecialLog(trans, trans.user())) {
1058 Question.logEncryptTrace(trans,data.asString());
1060 rreq = data.asObject();
1061 } catch(APIException e) {
1062 trans.error().log("Invalid Input",IN,cmdDescription);
1063 return Result.err(Status.ERR_BadData,"Invalid Input");
1066 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
1069 setContentType(resp,permsDF.getOutType());
1072 return Result.err(rp);
1074 } catch (Exception e) {
1075 trans.error().log(e,IN,cmdDescription);
1076 return Result.err(e);
1083 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1084 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
1088 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1089 if(Question.willSpecialLog(trans, trans.user())) {
1090 Question.logEncryptTrace(trans,data.asString());
1092 rreq = data.asObject();
1093 } catch(APIException e) {
1094 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);
1095 return Result.err(Status.ERR_BadData,"Invalid Input");
1098 Result<Void> rp = service.updatePermDescription(trans, rreq);
1101 setContentType(resp,permRequestDF.getOutType());
1104 return Result.err(rp);
1106 } catch (Exception e) {
1107 trans.error().log(e,IN,UPDATE_PERM_DESC);
1108 return Result.err(e);
1116 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1117 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
1121 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1122 if(Question.willSpecialLog(trans, trans.user())) {
1123 Question.logEncryptTrace(trans,data.asString());
1125 rreq = data.asObject();
1126 } catch(APIException e) {
1127 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);
1128 return Result.err(Status.ERR_BadData,"Invalid Input");
1131 Result<Void> rp = service.resetPermRoles(trans, rreq);
1135 setContentType(resp,permsDF.getOutType());
1138 return Result.err(rp);
1140 } catch (Exception e) {
1141 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
1142 return Result.err(e);
1149 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1150 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
1154 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1155 if(Question.willSpecialLog(trans, trans.user())) {
1156 Question.logEncryptTrace(trans,data.asString());
1158 rreq = data.asObject();
1159 } catch(APIException e) {
1160 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);
1161 return Result.err(Status.ERR_BadData,"Invalid Input");
1165 Result<Void> rp = service.deletePerm(trans,rreq);
1168 setContentType(resp,permsDF.getOutType());
1171 return Result.err(rp);
1173 } catch (Exception e) {
1174 trans.error().log(e,IN,DELETE_PERMISSION);
1175 return Result.err(e);
1182 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
1183 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
1185 Result<Void> rp = service.deletePerm(trans,type,instance,action);
1188 setContentType(resp,permsDF.getOutType());
1191 return Result.err(rp);
1193 } catch (Exception e) {
1194 trans.error().log(e,IN,DELETE_PERMISSION);
1195 return Result.err(e);
1201 public static final String CREATE_ROLE = "createRole";
1202 public static final String GET_ROLES_BY_USER = "getRolesByUser";
1203 public static final String GET_ROLES_BY_NS = "getRolesByNS";
1204 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
1205 public static final String GET_ROLES_BY_NAME = "getRolesByName";
1206 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
1207 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
1208 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
1209 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
1210 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
1211 public static final String DELETE_ROLE = "deleteRole";
1212 public static final String GET_CERT_BY_ID = "getCertByID";
1215 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1216 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
1220 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1221 if(Question.willSpecialLog(trans, trans.user())) {
1222 Question.logEncryptTrace(trans,data.asString());
1224 rreq = data.asObject();
1225 } catch(APIException e) {
1226 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1227 return Result.err(Status.ERR_BadData,"Invalid Input");
1230 Result<Void> rp = service.createRole(trans, rreq);
1233 setContentType(resp,roleRequestDF.getOutType());
1236 return Result.err(rp);
1238 } catch (Exception e) {
1239 trans.error().log(e,IN,CREATE_ROLE);
1240 return Result.err(e);
1247 * @see com.att.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1250 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
1251 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
1253 Result<ROLES> rp = service.getRolesByName(trans, role);
1256 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1257 if(Question.willSpecialLog(trans, trans.user())) {
1258 Question.logEncryptTrace(trans,data.asString());
1260 data.to(resp.getOutputStream());
1261 setContentType(resp,roleDF.getOutType());
1262 setCacheControlOff(resp);
1265 return Result.err(rp);
1267 } catch (Exception e) {
1268 trans.error().log(e,IN,GET_ROLES_BY_NAME);
1269 return Result.err(e);
1276 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1279 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
1280 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1282 Result<ROLES> rp = service.getRolesByUser(trans, user);
1285 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1286 if(Question.willSpecialLog(trans, trans.user())) {
1287 Question.logEncryptTrace(trans,data.asString());
1289 data.to(resp.getOutputStream());
1290 setContentType(resp,roleDF.getOutType());
1291 setCacheControlOff(resp);
1294 return Result.err(rp);
1296 } catch (Exception e) {
1297 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
1298 return Result.err(e);
1305 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1308 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
1309 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1311 Result<ROLES> rp = service.getRolesByNS(trans, ns);
1315 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1316 if(Question.willSpecialLog(trans, trans.user())) {
1317 Question.logEncryptTrace(trans,data.asString());
1319 data.to(resp.getOutputStream());
1321 Question.logEncryptTrace(trans, NO_DATA);
1323 setContentType(resp,roleDF.getOutType());
1324 setCacheControlOff(resp);
1327 return Result.err(rp);
1329 } catch (Exception e) {
1330 trans.error().log(e,IN,GET_ROLES_BY_NS);
1331 return Result.err(e);
1339 * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1342 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
1343 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
1345 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
1349 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1350 if(Question.willSpecialLog(trans, trans.user())) {
1351 Question.logEncryptTrace(trans,data.asString());
1353 data.to(resp.getOutputStream());
1355 Question.logEncryptTrace(trans, NO_DATA);
1357 setContentType(resp,roleDF.getOutType());
1358 setCacheControlOff(resp);
1361 return Result.err(rp);
1363 } catch (Exception e) {
1364 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
1365 return Result.err(e);
1372 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1375 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
1376 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
1378 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
1381 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1382 if(Question.willSpecialLog(trans, trans.user())) {
1383 Question.logEncryptTrace(trans,data.asString());
1385 data.to(resp.getOutputStream());
1386 setContentType(resp,roleDF.getOutType());
1387 setCacheControlOff(resp);
1390 return Result.err(rp);
1392 } catch (Exception e) {
1393 trans.error().log(e,IN,GET_ROLES_BY_PERM);
1394 return Result.err(e);
1402 * @see com.att.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
1405 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1406 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
1410 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1411 if(Question.willSpecialLog(trans, trans.user())) {
1412 Question.logEncryptTrace(trans,data.asString());
1414 rreq = data.asObject();
1415 } catch(APIException e) {
1416 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);
1417 return Result.err(Status.ERR_BadData,"Invalid Input");
1420 Result<Void> rp = service.updateRoleDescription(trans, rreq);
1423 setContentType(resp,roleRequestDF.getOutType());
1428 } catch (Exception e) {
1429 trans.error().log(e,IN,UPDATE_ROLE_DESC);
1430 return Result.err(e);
1437 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1438 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
1442 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1443 if(Question.willSpecialLog(trans, trans.user())) {
1444 Question.logEncryptTrace(trans,data.asString());
1446 rreq = data.asObject();
1447 } catch(APIException e) {
1448 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);
1449 return Result.err(Status.ERR_BadData,"Invalid Input");
1452 Result<Void> rp = service.addPermToRole(trans, rreq);
1455 setContentType(resp,permsDF.getOutType());
1456 resp.getOutputStream().println();
1459 return Result.err(rp);
1461 } catch (Exception e) {
1462 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
1463 return Result.err(e);
1470 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1471 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1475 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1476 if(Question.willSpecialLog(trans, trans.user())) {
1477 Question.logEncryptTrace(trans,data.asString());
1479 rreq = data.asObject();
1480 } catch(APIException e) {
1481 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);
1482 return Result.err(Status.ERR_BadData,"Invalid Input");
1485 Result<Void> rp = service.delPermFromRole(trans, rreq);
1488 setContentType(resp,permsDF.getOutType());
1489 resp.getOutputStream().println();
1492 return Result.err(rp);
1494 } catch (Exception e) {
1495 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1496 return Result.err(e);
1503 * @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)
1506 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletResponse resp, String role, String type,
1507 String instance, String action) {
1508 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1510 Result<Void> rp = service.delPermFromRole(trans, role, type, instance, action);
1513 setContentType(resp,permsDF.getOutType());
1514 resp.getOutputStream().println();
1517 return Result.err(rp);
1519 } catch (Exception e) {
1520 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1521 return Result.err(e);
1528 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1529 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1531 Result<Void> rp = service.deleteRole(trans, role);
1534 setContentType(resp,permsDF.getOutType());
1537 return Result.err(rp);
1539 } catch (Exception e) {
1540 trans.error().log(e,IN,DELETE_ROLE);
1541 return Result.err(e);
1548 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1549 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
1553 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1554 if(Question.willSpecialLog(trans, trans.user())) {
1555 Question.logEncryptTrace(trans,data.asString());
1557 rreq = data.asObject();
1558 } catch(APIException e) {
1559 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1560 return Result.err(Status.ERR_BadData,"Invalid Input");
1563 Result<Void> rp = service.deleteRole(trans, rreq);
1566 setContentType(resp,permsDF.getOutType());
1569 return Result.err(rp);
1571 } catch (Exception e) {
1572 trans.error().log(e,IN,DELETE_ROLE);
1573 return Result.err(e);
1579 public static final String CREATE_CRED = "createUserCred";
1580 private static final String GET_CREDS_BY_NS = "getCredsByNS";
1581 private static final String GET_CREDS_BY_ID = "getCredsByID";
1582 public static final String UPDATE_CRED = "updateUserCred";
1583 public static final String EXTEND_CRED = "extendUserCred";
1584 public static final String DELETE_CRED = "deleteUserCred";
1585 public static final String DOES_CRED_MATCH = "doesCredMatch";
1586 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
1595 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
1596 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
1598 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1599 if(Question.willSpecialLog(trans, trans.user())) {
1600 Question.logEncryptTrace(trans,data.asString());
1602 return service.createUserCred(trans, data.asObject());
1603 } catch(APIException e) {
1604 trans.error().log(e,"Bad Input data");
1605 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1606 } catch (Exception e) {
1607 trans.error().log(e,IN,CREATE_CRED);
1608 return Result.err(e);
1615 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
1616 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
1618 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1619 if(Question.willSpecialLog(trans, trans.user())) {
1620 Question.logEncryptTrace(trans,data.asString());
1623 return service.changeUserCred(trans, data.asObject());
1624 } catch(APIException e) {
1625 trans.error().log(e,"Bad Input data");
1626 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1627 } catch (Exception e) {
1628 trans.error().log(e,IN,UPDATE_CRED);
1629 return Result.err(e);
1636 * @see com.att.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
1639 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
1640 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
1642 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1643 if(Question.willSpecialLog(trans, trans.user())) {
1644 Question.logEncryptTrace(trans,data.asString());
1647 return service.extendUserCred(trans, data.asObject(), days);
1648 } catch(APIException e) {
1649 trans.error().log(e,"Bad Input data");
1650 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1651 } catch (Exception e) {
1652 trans.error().log(e,IN,EXTEND_CRED);
1653 return Result.err(e);
1660 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
1661 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1664 Result<USERS> ru = service.getCredsByNS(trans,ns);
1667 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1668 if(Question.willSpecialLog(trans,trans.user())) {
1669 Question.logEncryptTrace(trans,data.asString());
1671 data.to(resp.getOutputStream());
1672 setContentType(resp,usersDF.getOutType());
1675 return Result.err(ru);
1677 } catch (Exception e) {
1678 trans.error().log(e,IN,GET_CREDS_BY_NS);
1679 return Result.err(e);
1688 * @see com.att.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1691 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
1692 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
1695 Result<USERS> ru = service.getCredsByID(trans,id);
1698 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1699 if(Question.willSpecialLog(trans, trans.user())) {
1700 Question.logEncryptTrace(trans,data.asString());
1702 data.to(resp.getOutputStream());
1703 setContentType(resp,usersDF.getOutType());
1706 return Result.err(ru);
1708 } catch (Exception e) {
1709 trans.error().log(e,IN,GET_CREDS_BY_ID);
1710 return Result.err(e);
1718 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
1719 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
1721 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1722 if(Question.willSpecialLog(trans, trans.user())) {
1723 Question.logEncryptTrace(trans,data.asString());
1726 return service.deleteUserCred(trans, data.asObject());
1727 } catch(APIException e) {
1728 trans.error().log(e,"Bad Input data");
1729 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1730 } catch (Exception e) {
1731 trans.error().log(e,IN,DELETE_CRED);
1732 return Result.err(e);
1740 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1741 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
1743 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1744 if(Question.willSpecialLog(trans, trans.user())) {
1745 Question.logEncryptTrace(trans,data.asString());
1748 return service.doesCredentialMatch(trans, data.asObject());
1749 } catch(APIException e) {
1750 trans.error().log(e,"Bad Input data");
1751 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1752 } catch (IOException e) {
1753 trans.error().log(e,IN,DOES_CRED_MATCH);
1754 return Result.err(e);
1762 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
1763 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
1765 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
1766 switch(result.status){
1768 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
1771 return Result.err(result);
1772 } catch (Exception e) {
1773 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
1774 return Result.err(e);
1781 * @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)
1784 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
1785 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
1787 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
1789 switch(rci.status) {
1791 if(Question.willSpecialLog(trans, trans.user())) {
1792 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
1793 Question.logEncryptTrace(trans,data.asString());
1794 data.to(resp.getOutputStream());
1796 certsDF.direct(trans, rci.value, resp.getOutputStream());
1798 setContentType(resp,certsDF.getOutType());
1801 return Result.err(rci);
1803 } catch (Exception e) {
1804 trans.error().log(e,IN,GET_CERT_BY_ID);
1805 return Result.err(e);
1811 public static final String CREATE_DELEGATE = "createDelegate";
1812 public static final String UPDATE_DELEGATE = "updateDelegate";
1813 public static final String DELETE_DELEGATE = "deleteDelegate";
1814 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
1815 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
1818 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1819 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
1821 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1822 if(Question.willSpecialLog(trans, trans.user())) {
1823 Question.logEncryptTrace(trans,data.asString());
1826 return service.createDelegate(trans, data.asObject());
1827 } catch (Exception e) {
1828 trans.error().log(e,IN,CREATE_DELEGATE);
1829 return Result.err(e);
1836 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1837 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
1839 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1840 if(Question.willSpecialLog(trans, trans.user())) {
1841 Question.logEncryptTrace(trans,data.asString());
1844 return service.updateDelegate(trans, data.asObject());
1845 } catch (Exception e) {
1846 trans.error().log(e,IN,UPDATE_DELEGATE);
1847 return Result.err(e);
1854 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1855 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
1857 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1858 if(Question.willSpecialLog(trans, trans.user())) {
1859 Question.logEncryptTrace(trans,data.asString());
1862 return service.deleteDelegate(trans, data.asObject());
1863 } catch (Exception e) {
1864 trans.error().log(e,IN,DELETE_DELEGATE);
1865 return Result.err(e);
1872 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
1873 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
1875 return service.deleteDelegate(trans, userName);
1876 } catch (Exception e) {
1877 trans.error().log(e,IN,DELETE_DELEGATE);
1878 return Result.err(e);
1885 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
1886 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
1888 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
1892 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1893 if(Question.willSpecialLog(trans, trans.user())) {
1894 Question.logEncryptTrace(trans,data.asString());
1896 data.to(resp.getOutputStream());
1897 setContentType(resp,delgDF.getOutType());
1900 return Result.err(rd);
1902 } catch (Exception e) {
1903 trans.error().log(e,IN,GET_DELEGATE_USER);
1904 return Result.err(e);
1911 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
1912 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
1914 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
1917 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1918 if(Question.willSpecialLog(trans, trans.user())) {
1919 Question.logEncryptTrace(trans,data.asString());
1921 data.to(resp.getOutputStream());
1922 setContentType(resp,delgDF.getOutType());
1925 return Result.err(rd);
1927 } catch (Exception e) {
1928 trans.error().log(e,IN,GET_DELEGATE_DELG);
1929 return Result.err(e);
1935 private static final String REQUEST_USER_ROLE = "createUserRole";
1936 private static final String GET_USERROLES = "getUserRoles";
1937 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
1938 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
1939 private static final String SET_ROLES_FOR_USER = "setRolesForUser";
1940 private static final String SET_USERS_FOR_ROLE = "setUsersForRole";
1941 private static final String EXTEND_USER_ROLE = "extendUserRole";
1942 private static final String DELETE_USER_ROLE = "deleteUserRole";
1944 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1945 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
1949 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
1950 if(Question.willSpecialLog(trans, trans.user())) {
1951 Question.logEncryptTrace(trans,data.asString());
1954 request = data.asObject();
1955 } catch(APIException e) {
1956 return Result.err(Status.ERR_BadData,"Invalid Input");
1959 Result<Void> rp = service.createUserRole(trans,request);
1962 setContentType(resp,permsDF.getOutType());
1965 return Result.err(rp);
1967 } catch (Exception e) {
1968 trans.error().log(e,IN,REQUEST_USER_ROLE);
1969 return Result.err(e);
1976 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
1977 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
1979 Result<USERS> ru = service.getUserInRole(trans,user,role);
1982 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1983 if(Question.willSpecialLog(trans, trans.user())) {
1984 Question.logEncryptTrace(trans,data.asString());
1987 data.to(resp.getOutputStream());
1988 setContentType(resp,usersDF.getOutType());
1989 setCacheControlOff(resp);
1992 return Result.err(ru);
1994 } catch (Exception e) {
1995 trans.error().log(e,IN,GET_USERROLES);
1996 return Result.err(e);
2004 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2005 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2007 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
2010 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2011 if(Question.willSpecialLog(trans, trans.user())) {
2012 Question.logEncryptTrace(trans,data.asString());
2015 data.to(resp.getOutputStream());
2016 setContentType(resp,usersDF.getOutType());
2017 setCacheControlOff(resp);
2020 return Result.err(ru);
2022 } catch (Exception e) {
2023 trans.error().log(e,IN,GET_USERROLES_BY_USER);
2024 return Result.err(e);
2032 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2033 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2035 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
2038 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2039 if(Question.willSpecialLog(trans, trans.user())) {
2040 Question.logEncryptTrace(trans,data.asString());
2043 data.to(resp.getOutputStream());
2044 setContentType(resp,usersDF.getOutType());
2045 setCacheControlOff(resp);
2048 return Result.err(ru);
2050 } catch (Exception e) {
2051 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
2052 return Result.err(e);
2061 public Result<Void> resetUsersForRole(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
2062 TimeTaken tt = trans.start(SET_USERS_FOR_ROLE, Env.SUB|Env.ALWAYS);
2066 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
2067 if(Question.willSpecialLog(trans, trans.user())) {
2068 Question.logEncryptTrace(trans,data.asString());
2070 rreq = data.asObject();
2071 } catch(APIException e) {
2072 trans.error().log("Invalid Input",IN, SET_USERS_FOR_ROLE);
2073 return Result.err(Status.ERR_BadData,"Invalid Input");
2076 Result<Void> rp = service.resetUsersForRole(trans, rreq);
2080 setContentType(resp,permsDF.getOutType());
2083 return Result.err(rp);
2085 } catch (Exception e) {
2086 trans.error().log(e,IN,SET_USERS_FOR_ROLE);
2087 return Result.err(e);
2095 public Result<Void> resetRolesForUser(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
2096 TimeTaken tt = trans.start(SET_ROLES_FOR_USER, Env.SUB|Env.ALWAYS);
2100 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
2101 if(Question.willSpecialLog(trans, trans.user())) {
2102 Question.logEncryptTrace(trans,data.asString());
2105 rreq = data.asObject();
2106 } catch(APIException e) {
2107 trans.error().log("Invalid Input",IN, SET_ROLES_FOR_USER);
2108 return Result.err(Status.ERR_BadData,"Invalid Input");
2111 Result<Void> rp = service.resetRolesForUser(trans, rreq);
2115 setContentType(resp,permsDF.getOutType());
2118 return Result.err(rp);
2120 } catch (Exception e) {
2121 trans.error().log(e,IN,SET_ROLES_FOR_USER);
2122 return Result.err(e);
2130 * @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)
2133 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2134 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2136 return service.extendUserRole(trans,user,role);
2137 } catch (Exception e) {
2138 trans.error().log(e,IN,EXTEND_USER_ROLE);
2139 return Result.err(e);
2146 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2147 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2149 Result<Void> rp = service.deleteUserRole(trans,user,role);
2152 setContentType(resp,permsDF.getOutType());
2155 return Result.err(rp);
2157 } catch (Exception e) {
2158 trans.error().log(e,IN,DELETE_USER_ROLE);
2159 return Result.err(e);
2165 private static final String UPDATE_APPROVAL = "updateApproval";
2166 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
2167 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
2168 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
2171 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
2172 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
2174 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
2175 if(Question.willSpecialLog(trans, trans.user())) {
2176 Question.logEncryptTrace(trans,data.asString());
2179 Result<Void> rp = service.updateApproval(trans, data.asObject());
2183 setContentType(resp,approvalDF.getOutType());
2186 return Result.err(rp);
2188 } catch (Exception e) {
2189 trans.error().log(e,IN,UPDATE_APPROVAL);
2190 return Result.err(e);
2197 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2198 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2200 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
2203 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2204 if(Question.willSpecialLog(trans, trans.user())) {
2205 Question.logEncryptTrace(trans,data.asString());
2207 data.to(resp.getOutputStream());
2209 setContentType(resp,permsDF.getOutType());
2212 return Result.err(rp);
2214 } catch (Exception e) {
2215 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
2216 return Result.err(e);
2223 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
2224 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
2226 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
2229 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2230 if(Question.willSpecialLog(trans, trans.user())) {
2231 Question.logEncryptTrace(trans,data.asString());
2234 data.to(resp.getOutputStream());
2235 setContentType(resp,permsDF.getOutType());
2238 return Result.err(rp);
2240 } catch (Exception e) {
2241 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
2242 return Result.err(e);
2249 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
2250 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
2252 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
2255 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2256 if(Question.willSpecialLog(trans, trans.user())) {
2257 Question.logEncryptTrace(trans,data.asString());
2260 data.to(resp.getOutputStream());
2261 setContentType(resp,permsDF.getOutType());
2264 return Result.err(rp);
2266 } catch (Exception e) {
2267 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
2268 return Result.err(e);
2276 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
2277 public static final String GET_USERS_ROLE = "getUsersByRole";
2280 * @see com.att.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2283 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2284 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2286 Result<USERS> ru = service.getUsersByRole(trans,role);
2289 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2290 if(Question.willSpecialLog(trans, trans.user())) {
2291 Question.logEncryptTrace(trans,data.asString());
2294 data.to(resp.getOutputStream());
2295 setContentType(resp,usersDF.getOutType());
2298 return Result.err(ru);
2300 } catch (Exception e) {
2301 trans.error().log(e,IN,GET_USERS_ROLE);
2302 return Result.err(e);
2309 * @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)
2312 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
2313 String type, String instance, String action) {
2314 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
2316 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
2319 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2320 if(Question.willSpecialLog(trans, trans.user())) {
2321 Question.logEncryptTrace(trans,data.asString());
2324 data.to(resp.getOutputStream());
2325 setContentType(resp,usersDF.getOutType());
2328 return Result.err(ru);
2330 } catch (Exception e) {
2331 trans.error().log(e,IN,GET_USERS_PERMISSION);
2332 return Result.err(e);
2339 public static final String GET_HISTORY_USER = "getHistoryByUser";
2340 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
2341 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
2342 public static final String GET_HISTORY_NS = "getHistoryByNS";
2344 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2347 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
2348 StringBuilder sb = new StringBuilder();
2349 sb.append(GET_HISTORY_USER);
2353 boolean first = true;
2354 for(int i : yyyymm) {
2362 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2365 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
2368 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2369 if(Question.willSpecialLog(trans, trans.user())) {
2370 Question.logEncryptTrace(trans,data.asString());
2373 data.to(resp.getOutputStream());
2374 setContentType(resp,historyDF.getOutType());
2377 return Result.err(rh);
2379 } catch (Exception e) {
2380 trans.error().log(e,IN,GET_HISTORY_USER);
2381 return Result.err(e);
2388 * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2391 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
2392 StringBuilder sb = new StringBuilder();
2393 sb.append(GET_HISTORY_ROLE);
2397 boolean first = true;
2398 for(int i : yyyymm) {
2406 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2408 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
2411 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2412 if(Question.willSpecialLog(trans, trans.user())) {
2413 Question.logEncryptTrace(trans,data.asString());
2416 data.to(resp.getOutputStream());
2417 setContentType(resp,historyDF.getOutType());
2420 return Result.err(rh);
2422 } catch (Exception e) {
2423 trans.error().log(e,IN,GET_HISTORY_ROLE);
2424 return Result.err(e);
2431 * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2434 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
2435 StringBuilder sb = new StringBuilder();
2436 sb.append(GET_HISTORY_NS);
2440 boolean first = true;
2441 for(int i : yyyymm) {
2449 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2451 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
2454 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2455 if(Question.willSpecialLog(trans, trans.user())) {
2456 Question.logEncryptTrace(trans,data.asString());
2459 data.to(resp.getOutputStream());
2460 setContentType(resp,historyDF.getOutType());
2463 return Result.err(rh);
2465 } catch (Exception e) {
2466 trans.error().log(e,IN,GET_HISTORY_NS);
2467 return Result.err(e);
2474 * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2477 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
2478 StringBuilder sb = new StringBuilder();
2479 sb.append(GET_HISTORY_PERM);
2483 boolean first = true;
2484 for(int i : yyyymm) {
2492 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2494 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
2497 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2498 if(Question.willSpecialLog(trans, trans.user())) {
2499 Question.logEncryptTrace(trans,data.asString());
2502 data.to(resp.getOutputStream());
2503 setContentType(resp,historyDF.getOutType());
2506 return Result.err(rh);
2508 } catch (Exception e) {
2509 trans.error().log(e,IN,GET_HISTORY_PERM);
2510 return Result.err(e);
2516 public final static String CACHE_CLEAR = "cacheClear ";
2517 // public final static String CACHE_VALIDATE = "validateCache";
2520 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String)
2523 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
2524 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
2526 return service.cacheClear(trans,cname);
2527 } catch (Exception e) {
2528 trans.error().log(e,IN,CACHE_CLEAR);
2529 return Result.err(e);
2536 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.Integer)
2539 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
2540 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
2542 String[] segs = segments.split("\\s*,\\s*");
2543 int isegs[] = new int[segs.length];
2544 for(int i=0;i<segs.length;++i) {
2546 isegs[i] = Integer.parseInt(segs[i]);
2547 } catch(NumberFormatException nfe) {
2551 return service.cacheClear(trans,cname, isegs);
2552 } catch (Exception e) {
2553 trans.error().log(e,IN,CACHE_CLEAR);
2554 return Result.err(e);
2561 * @see com.att.authz.facade.AuthzFacade#dbReset(org.onap.aaf.auth.env.test.AuthzTrans)
2564 public void dbReset(AuthzTrans trans) {
2565 service.dbReset(trans);
2569 * @see com.att.authz.facade.AuthzFacade#getAPI(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse)
2571 public final static String API_REPORT = "apiReport";
2573 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
2574 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
2576 Api api = new Api();
2578 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
2579 for(RouteReport rr : rservlet.routeReport()) {
2580 api.getRoute().add(ar = new Api.Route());
2581 ar.setMeth(rr.meth.name());
2582 ar.setPath(rr.path);
2583 ar.setDesc(rr.desc);
2584 ar.getContentType().addAll(rr.contextTypes);
2585 for(Method m : meths) {
2587 if((ad = m.getAnnotation(ApiDoc.class))!=null &&
2588 rr.meth.equals(ad.method()) &&
2589 rr.path.equals(ad.path())) {
2590 for(String param : ad.params()) {
2591 ar.getParam().add(param);
2593 for(String text : ad.text()) {
2594 ar.getComments().add(text);
2596 ar.setExpected(ad.expectedCode());
2597 for(int ec : ad.errorCodes()) {
2598 ar.getExplicitErr().add(ec);
2603 RosettaData<Api> data = apiDF.newData(trans).load(api);
2604 if(Question.willSpecialLog(trans, trans.user())) {
2605 Question.logEncryptTrace(trans,data.asString());
2608 data.to(resp.getOutputStream());
2609 setContentType(resp,apiDF.getOutType());
2612 } catch (Exception e) {
2613 trans.error().log(e,IN,API_REPORT);
2614 return Result.err(e);
2621 public final static String API_EXAMPLE = "apiExample";
2624 * @see com.att.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2627 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
2628 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
2630 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
2631 resp.getOutputStream().print(content);
2632 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
2634 } catch (Exception e) {
2635 trans.error().log(e,IN,API_EXAMPLE);
2636 return Result.err(Status.ERR_NotImplemented,e.getMessage());