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.ArrayList;
48 import java.util.Date;
49 import java.util.List;
51 import javax.servlet.http.HttpServletRequest;
52 import javax.servlet.http.HttpServletResponse;
54 import org.onap.aaf.auth.dao.cass.NsType;
55 import org.onap.aaf.auth.dao.cass.Status;
56 import org.onap.aaf.auth.dao.hl.Question;
57 import org.onap.aaf.auth.env.AuthzEnv;
58 import org.onap.aaf.auth.env.AuthzTrans;
59 import org.onap.aaf.auth.layer.FacadeImpl;
60 import org.onap.aaf.auth.layer.Result;
61 import org.onap.aaf.auth.rserv.RServlet;
62 import org.onap.aaf.auth.rserv.RouteReport;
63 import org.onap.aaf.auth.rserv.doc.ApiDoc;
64 import org.onap.aaf.auth.service.AuthzCassServiceImpl;
65 import org.onap.aaf.auth.service.AuthzService;
66 import org.onap.aaf.auth.service.mapper.Mapper;
67 import org.onap.aaf.auth.service.mapper.Mapper.API;
68 import org.onap.aaf.cadi.aaf.client.Examples;
69 import org.onap.aaf.misc.env.APIException;
70 import org.onap.aaf.misc.env.Data;
71 import org.onap.aaf.misc.env.Data.TYPE;
72 import org.onap.aaf.misc.env.Env;
73 import org.onap.aaf.misc.env.TimeTaken;
74 import org.onap.aaf.misc.env.util.Chrono;
75 import org.onap.aaf.misc.rosetta.Marshal;
76 import org.onap.aaf.misc.rosetta.env.RosettaDF;
77 import org.onap.aaf.misc.rosetta.env.RosettaData;
84 * This Service Facade encapsulates the essence of the API Service can do, and provides
85 * a single created object for elements such as RosettaDF.
87 * The Responsibilities of this class are to:
88 * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)
89 * 2) Validate incoming data (if applicable)
90 * 3) Convert the Service response into the right Format, and mark the Content Type
91 * a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.
92 * 4) Log Service info, warnings and exceptions as necessary
93 * 5) When asked by the API layer, this will create and write Error content to the OutputStream
95 * Note: This Class does NOT set the HTTP Status Code. That is up to the API layer, so that it can be
96 * clearly coordinated with the API Documentation
98 * @author Pavani & Jonathan
101 public abstract class AuthzFacadeImpl<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> extends FacadeImpl implements AuthzFacade
103 private static final String FORBIDDEN = "Forbidden";
104 private static final String NOT_FOUND = "Not Found";
105 private static final String NOT_ACCEPTABLE = "Not Acceptable";
106 private static final String GENERAL_SERVICE_ERROR = "General Service Error";
107 private static final String NO_DATA = "***No Data***";
108 private AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service = null;
109 private final RosettaDF<NSS> nssDF;
110 private final RosettaDF<PERMS> permsDF;
111 private final RosettaDF<ROLES> roleDF;
112 private final RosettaDF<USERS> usersDF;
113 private final RosettaDF<USERROLES> userrolesDF;
114 private final RosettaDF<CERTS> certsDF;
115 private final RosettaDF<DELGS> delgDF;
116 private final RosettaDF<REQUEST> permRequestDF;
117 private final RosettaDF<REQUEST> roleRequestDF;
118 private final RosettaDF<REQUEST> userRoleRequestDF;
119 private final RosettaDF<REQUEST> rolePermRequestDF;
120 private final RosettaDF<REQUEST> nsRequestDF;
121 private final RosettaDF<REQUEST> credRequestDF;
122 private final RosettaDF<REQUEST> delgRequestDF;
123 private final RosettaDF<HISTORY> historyDF;
124 private final RosettaDF<KEYS> keysDF;
126 private final RosettaDF<ERR> errDF;
127 private final RosettaDF<APPROVALS> approvalDF;
128 // Note: Api is not different per Version
129 private final RosettaDF<Api> apiDF;
132 @SuppressWarnings("unchecked")
133 public AuthzFacadeImpl(AuthzEnv env, AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service, Data.TYPE dataType) throws APIException {
134 this.service = service;
135 (nssDF = env.newDataFactory(service.mapper().getClass(API.NSS))).in(dataType).out(dataType);
136 (permRequestDF = env.newDataFactory(service.mapper().getClass(API.PERM_REQ))).in(dataType).out(dataType);
137 (permsDF = env.newDataFactory(service.mapper().getClass(API.PERMS))).in(dataType).out(dataType);
138 // (permKeyDF = env.newDataFactory(service.mapper().getClass(API.PERM_KEY))).in(dataType).out(dataType);
139 (roleDF = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);
140 (roleRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);
141 (usersDF = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);
142 (userrolesDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);
143 (certsDF = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)
144 .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));
146 (userRoleRequestDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);
147 (rolePermRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);
148 (nsRequestDF = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);
149 (credRequestDF = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);
150 (delgRequestDF = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);
151 (historyDF = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);
152 ( keysDF = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);
153 (delgDF = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);
154 (approvalDF = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);
155 (errDF = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);
156 (apiDF = env.newDataFactory(Api.class)).in(dataType).out(dataType);
159 public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {
160 return service.mapper();
164 * @see com.att.authz.facade.AuthzFacade#error(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
166 * Note: Conforms to AT&T TSS RESTful Error Structure
169 public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
170 String msg = result.details==null?"%s":"%s - " + result.details.trim();
173 boolean hidemsg = false;
174 if (result.variables==null) {
175 detail = new String[1];
177 List<String> dlist = new ArrayList<String>();
179 for(Object s : result.variables) {
180 if(s!=null && (os=s.toString()).length()>0) {
184 detail = new String[dlist.size()];
185 dlist.toArray(detail);
189 switch(result.status) {
190 case ERR_ActionNotCompleted:
192 detail[0] = "Accepted, Action not complete";
193 response.setStatus(/*httpstatus=*/202);
198 detail[0] = FORBIDDEN;
199 response.setStatus(/*httpstatus=*/403);
203 detail[0] = FORBIDDEN;
204 response.setStatus(/*httpstatus=*/403);
208 detail[0] = FORBIDDEN;
209 response.setStatus(/*httpstatus=*/403);
211 // This is still forbidden to directly impact, but can be Requested when passed
212 // with "request=true" query Param
213 case ERR_FutureNotRequested:
216 response.setStatus(/*httpstatus=*/403);
221 detail[0] = NOT_FOUND;
222 response.setStatus(/*httpstatus=*/404);
224 case ERR_RoleNotFound:
226 detail[0] = NOT_FOUND;
227 response.setStatus(/*httpstatus=*/404);
229 case ERR_PermissionNotFound:
231 detail[0] = NOT_FOUND;
232 response.setStatus(/*httpstatus=*/404);
234 case ERR_UserNotFound:
236 detail[0] = NOT_FOUND;
237 response.setStatus(/*httpstatus=*/404);
239 case ERR_UserRoleNotFound:
241 detail[0] = NOT_FOUND;
242 response.setStatus(/*httpstatus=*/404);
244 case ERR_DelegateNotFound:
246 detail[0] = NOT_FOUND;
247 response.setStatus(/*httpstatus=*/404);
251 detail[0] = NOT_FOUND;
252 response.setStatus(/*httpstatus=*/404);
255 case ERR_InvalidDelegate:
257 detail[0] = NOT_ACCEPTABLE;
258 response.setStatus(/*httpstatus=*/406);
262 detail[0] = NOT_ACCEPTABLE;
263 response.setStatus(/*httpstatus=*/406);
266 case ERR_ConflictAlreadyExists:
268 detail[0] = "Conflict Already Exists";
269 response.setStatus(/*httpstatus=*/409);
272 case ERR_DependencyExists:
274 detail[0] = "Failed Dependency";
275 response.setStatus(/*httpstatus=*/424);
278 case ERR_NotImplemented:
280 detail[0] = "Not Implemented";
281 response.setStatus(/*httpstatus=*/501);
284 case Status.ACC_Future:
286 detail[0] = "Accepted for Future, pending Approvals";
287 response.setStatus(/*httpstatus=*/202);
289 case ERR_ChoiceNeeded:
291 response.setStatus(/*httpstatus=*/300);
295 detail[0] = GENERAL_SERVICE_ERROR;
296 response.setStatus(/*httpstatus=*/500);
302 detail[0] = GENERAL_SERVICE_ERROR;
303 response.setStatus(/*httpstatus=*/500);
309 StringBuilder holder = new StringBuilder();
310 ERR em = service.mapper().errorFromMessage(holder,msgId,msg,detail);
319 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
321 errDF.newData(trans).load(em).to(response.getOutputStream());
322 } catch (Exception e) {
323 trans.error().log(e,"unable to send response for",msg);
327 ///////////////////////////
329 ///////////////////////////
330 public static final String CREATE_NS = "createNamespace";
331 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
332 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
333 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
334 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
335 public static final String GET_NS_BY_NAME = "getNamespaceByName";
336 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
337 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
338 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
339 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
340 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
341 public static final String DELETE_NS = "deleteNamespace";
345 * @see com.att.authz.facade.AuthzFacade#createNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
348 public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {
349 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);
353 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());
354 if (Question.willSpecialLog(trans, trans.user())) {
355 Question.logEncryptTrace(trans,rd.asString());
357 request = rd.asObject();
358 } catch (APIException e) {
359 trans.error().log("Invalid Input",IN,CREATE_NS);
360 return Result.err(Status.ERR_BadData,"Invalid Input");
363 Result<Void> rp = service.createNS(trans,request,type);
366 setContentType(resp,nsRequestDF.getOutType());
369 return Result.err(rp);
371 } catch (Exception e) {
372 trans.error().log(e,IN,CREATE_NS);
373 return Result.err(e);
380 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
383 public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
384 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
386 Result<Void> rp = service.addAdminNS(trans,ns,id);
390 setContentType(resp,nsRequestDF.getOutType());
391 resp.getOutputStream().println();
394 return Result.err(rp);
396 } catch (Exception e) {
397 trans.error().log(e,IN,ADD_NS_ADMIN);
398 return Result.err(e);
405 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
408 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
409 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
411 Result<Void> rp = service.delAdminNS(trans, ns, id);
414 setContentType(resp,nsRequestDF.getOutType());
417 return Result.err(rp);
419 } catch (Exception e) {
420 trans.error().log(e,IN,DELETE_NS_ADMIN);
421 return Result.err(e);
428 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
431 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
432 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
434 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
437 setContentType(resp,nsRequestDF.getOutType());
438 resp.getOutputStream().println();
441 return Result.err(rp);
443 } catch (Exception e) {
444 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
445 return Result.err(e);
452 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
455 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
456 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
458 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
461 setContentType(resp,nsRequestDF.getOutType());
462 resp.getOutputStream().println();
465 return Result.err(rp);
467 } catch (Exception e) {
468 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
469 return Result.err(e);
476 * @see com.att.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
479 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns, boolean full) {
480 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
482 Result<NSS> rp = service.getNSbyName(trans, ns, full );
485 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
486 if (Question.willSpecialLog(trans, trans.user())) {
487 Question.logEncryptTrace(trans,data.asString());
489 data.to(resp.getOutputStream());
490 setContentType(resp,nssDF.getOutType());
493 return Result.err(rp);
495 } catch (Exception e) {
496 trans.error().log(e,IN,GET_NS_BY_NAME);
497 return Result.err(e);
503 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
505 * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
508 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
509 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
511 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
514 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
515 if (Question.willSpecialLog(trans, trans.user())) {
516 Question.logEncryptTrace(trans,data.asString());
518 data.to(resp.getOutputStream());
519 setContentType(resp,nssDF.getOutType());
522 return Result.err(rp);
524 } catch (Exception e) {
525 trans.error().log(e,IN,GET_NS_BY_ADMIN);
526 return Result.err(e);
532 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
534 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
537 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
538 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
540 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
543 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
544 if (Question.willSpecialLog(trans, trans.user())) {
545 Question.logEncryptTrace(trans,data.asString());
547 data.to(resp.getOutputStream());
549 setContentType(resp,nssDF.getOutType());
552 return Result.err(rp);
554 } catch (Exception e) {
555 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
556 return Result.err(e);
563 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
566 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
567 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
569 Result<NSS> rp = service.getNSbyEither(trans, user, full);
573 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
574 if (Question.willSpecialLog(trans, trans.user())) {
575 Question.logEncryptTrace(trans,data.asString());
577 data.to(resp.getOutputStream());
579 setContentType(resp,nssDF.getOutType());
582 return Result.err(rp);
584 } catch (Exception e) {
585 trans.error().log(e,IN,GET_NS_BY_EITHER);
586 return Result.err(e);
593 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
596 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
597 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
599 Result<NSS> rp = service.getNSsChildren(trans, parent);
602 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
603 if (Question.willSpecialLog(trans, trans.user())) {
604 Question.logEncryptTrace(trans,data.asString());
606 data.to(resp.getOutputStream());
607 setContentType(resp,nssDF.getOutType());
610 return Result.err(rp);
612 } catch (Exception e) {
613 trans.error().log(e,IN,GET_NS_CHILDREN);
614 return Result.err(e);
621 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
622 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
626 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
627 if (Question.willSpecialLog(trans, trans.user())) {
628 Question.logEncryptTrace(trans,data.asString());
630 rreq = data.asObject();
631 } catch (APIException e) {
632 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);
633 return Result.err(Status.ERR_BadData,"Invalid Input");
636 Result<Void> rp = service.updateNsDescription(trans, rreq);
639 setContentType(resp,nsRequestDF.getOutType());
642 return Result.err(rp);
644 } catch (Exception e) {
645 trans.error().log(e,IN,UPDATE_NS_DESC);
646 return Result.err(e);
654 * @see com.att.authz.facade.AuthzFacade#requestNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
657 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
658 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
660 Result<Void> rp = service.deleteNS(trans,ns);
663 setContentType(resp,nsRequestDF.getOutType());
666 return Result.err(rp);
668 } catch (Exception e) {
669 trans.error().log(e,IN,DELETE_NS);
670 return Result.err(e);
676 private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";
677 private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
678 private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";
679 private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";
682 * @see com.att.authz.facade.AuthzFacade#createAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
685 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
686 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
688 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
691 setContentType(resp, keysDF.getOutType());
692 resp.getOutputStream().println();
695 return Result.err(rp);
697 } catch (Exception e) {
698 trans.error().log(e,IN,NS_CREATE_ATTRIB);
699 return Result.err(e);
706 * @see com.att.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
709 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
710 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
712 Result<KEYS> rp = service.readNsByAttrib(trans, key);
715 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
716 if (Question.willSpecialLog(trans, trans.user())) {
717 Question.logEncryptTrace(trans,data.asString());
719 data.to(resp.getOutputStream());
720 setContentType(resp,keysDF.getOutType());
723 return Result.err(rp);
725 } catch (Exception e) {
726 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
727 return Result.err(e);
734 * @see com.att.authz.facade.AuthzFacade#updAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
737 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
738 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
740 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
743 setContentType(resp, keysDF.getOutType());
744 resp.getOutputStream().println();
747 return Result.err(rp);
749 } catch (Exception e) {
750 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
751 return Result.err(e);
759 * @see com.att.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
762 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
763 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
765 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
768 setContentType(resp, keysDF.getOutType());
769 resp.getOutputStream().println();
772 return Result.err(rp);
774 } catch (Exception e) {
775 trans.error().log(e,IN,NS_DELETE_ATTRIB);
776 return Result.err(e);
785 public static final String CREATE_PERMISSION = "createPermission";
786 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
787 public static final String GET_PERMS_BY_NAME = "getPermsByName";
788 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
789 public static final String GET_PERMISSIONS_BY_USER_SCOPE = "getPermissionsByUserScope";
790 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
791 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
792 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
793 public static final String UPDATE_PERMISSION = "updatePermission";
794 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
795 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
796 public static final String DELETE_PERMISSION = "deletePermission";
800 * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
803 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
804 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
808 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
809 if (Question.willSpecialLog(trans, trans.user())) {
810 Question.logEncryptTrace(trans,data.asString());
812 rreq = data.asObject();
813 } catch (APIException e) {
814 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
815 return Result.err(Status.ERR_BadData,"Invalid Input");
818 Result<Void> rp = service.createPerm(trans,rreq);
821 setContentType(resp,permsDF.getOutType());
824 return Result.err(rp);
826 } catch (Exception e) {
827 trans.error().log(e,IN,CREATE_PERMISSION);
828 return Result.err(e);
835 * @see com.att.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
838 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
839 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
842 Result<PERMS> rp = service.getPermsByType(trans, perm);
845 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
846 if (Question.willSpecialLog(trans, trans.user())) {
847 Question.logEncryptTrace(trans,data.asString());
849 data.to(resp.getOutputStream());
850 setContentType(resp,permsDF.getOutType());
851 setCacheControlOff(resp);
854 return Result.err(rp);
856 } catch (Exception e) {
857 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
858 return Result.err(e);
865 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
866 String type, String instance, String action) {
868 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
869 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
872 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
875 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
876 if (Question.willSpecialLog(trans, trans.user())) {
877 Question.logEncryptTrace(trans,data.asString());
879 data.to(resp.getOutputStream());
880 setContentType(resp,permsDF.getOutType());
881 setCacheControlOff(resp);
884 return Result.err(rp);
886 } catch (Exception e) {
887 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
888 return Result.err(e);
895 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
898 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
899 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
901 Result<PERMS> rp = service.getPermsByUser(trans, user);
904 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
905 if (Question.willSpecialLog(trans, trans.user())) {
906 Question.logEncryptTrace(trans,data.asString());
908 data.to(resp.getOutputStream());
909 setContentType(resp,permsDF.getOutType());
910 setCacheControlOff(resp);
913 return Result.err(rp);
915 } catch (Exception e) {
916 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
917 return Result.err(e);
924 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
927 public Result<Void> getPermsByUserScope(AuthzTrans trans, HttpServletResponse resp, String user, String[] scopes) {
928 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_SCOPE + ' ' + user, Env.SUB|Env.ALWAYS);
930 Result<PERMS> rp = service.getPermsByUserScope(trans, user, scopes);
933 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
934 if (Question.willSpecialLog(trans, trans.user())) {
935 Question.logEncryptTrace(trans,data.asString());
937 data.to(resp.getOutputStream());
938 setContentType(resp,permsDF.getOutType());
939 setCacheControlOff(resp);
942 return Result.err(rp);
944 } catch (Exception e) {
945 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_SCOPE, user);
946 return Result.err(e);
955 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
958 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
959 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
963 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
964 if (Question.willSpecialLog(trans, trans.user())) {
965 Question.logEncryptTrace(trans,data.asString());
967 perms = data.asObject();
968 } catch (APIException e) {
969 trans.error().log("Invalid Input",IN,GET_PERMISSIONS_BY_USER_WITH_QUERY);
970 return Result.err(Status.ERR_BadData,"Invalid Input");
973 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
976 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
977 if (Question.willSpecialLog(trans, trans.user())) {
978 Question.logEncryptTrace(trans,data.asString());
980 data.to(resp.getOutputStream());
981 setContentType(resp,permsDF.getOutType());
982 setCacheControlOff(resp);
985 return Result.err(rp);
987 } catch (Exception e) {
988 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
989 return Result.err(e);
997 * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1000 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
1001 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
1003 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
1006 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1007 if (Question.willSpecialLog(trans, trans.user())) {
1008 Question.logEncryptTrace(trans,data.asString());
1010 data.to(resp.getOutputStream());
1011 setContentType(resp,permsDF.getOutType());
1012 setCacheControlOff(resp);
1015 return Result.err(rp);
1017 } catch (Exception e) {
1018 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
1019 return Result.err(e);
1026 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
1027 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1029 Result<PERMS> rp = service.getPermsByNS(trans, ns);
1032 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1033 if (Question.willSpecialLog(trans, trans.user())) {
1034 Question.logEncryptTrace(trans,data.asString());
1036 data.to(resp.getOutputStream());
1037 setContentType(resp,permsDF.getOutType());
1038 setCacheControlOff(resp);
1041 return Result.err(rp);
1043 } catch (Exception e) {
1044 trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);
1045 return Result.err(e);
1053 * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
1056 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
1057 String origType, String origInstance, String origAction) {
1058 String cmdDescription = UPDATE_PERMISSION;
1059 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
1063 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1064 if (Question.willSpecialLog(trans, trans.user())) {
1065 Question.logEncryptTrace(trans,data.asString());
1067 rreq = data.asObject();
1068 } catch (APIException e) {
1069 trans.error().log("Invalid Input",IN,cmdDescription);
1070 return Result.err(Status.ERR_BadData,"Invalid Input");
1073 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
1076 setContentType(resp,permsDF.getOutType());
1079 return Result.err(rp);
1081 } catch (Exception e) {
1082 trans.error().log(e,IN,cmdDescription);
1083 return Result.err(e);
1090 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1091 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
1095 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1096 if (Question.willSpecialLog(trans, trans.user())) {
1097 Question.logEncryptTrace(trans,data.asString());
1099 rreq = data.asObject();
1100 } catch (APIException e) {
1101 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);
1102 return Result.err(Status.ERR_BadData,"Invalid Input");
1105 Result<Void> rp = service.updatePermDescription(trans, rreq);
1108 setContentType(resp,permRequestDF.getOutType());
1111 return Result.err(rp);
1113 } catch (Exception e) {
1114 trans.error().log(e,IN,UPDATE_PERM_DESC);
1115 return Result.err(e);
1123 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1124 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
1128 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1129 if (Question.willSpecialLog(trans, trans.user())) {
1130 Question.logEncryptTrace(trans,data.asString());
1132 rreq = data.asObject();
1133 } catch (APIException e) {
1134 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);
1135 return Result.err(Status.ERR_BadData,"Invalid Input");
1138 Result<Void> rp = service.resetPermRoles(trans, rreq);
1142 setContentType(resp,permsDF.getOutType());
1145 return Result.err(rp);
1147 } catch (Exception e) {
1148 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
1149 return Result.err(e);
1156 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1157 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
1161 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1162 if (Question.willSpecialLog(trans, trans.user())) {
1163 Question.logEncryptTrace(trans,data.asString());
1165 rreq = data.asObject();
1166 } catch (APIException e) {
1167 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);
1168 return Result.err(Status.ERR_BadData,"Invalid Input");
1172 Result<Void> rp = service.deletePerm(trans,rreq);
1175 setContentType(resp,permsDF.getOutType());
1178 return Result.err(rp);
1180 } catch (Exception e) {
1181 trans.error().log(e,IN,DELETE_PERMISSION);
1182 return Result.err(e);
1189 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
1190 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
1192 Result<Void> rp = service.deletePerm(trans,type,instance,action);
1195 setContentType(resp,permsDF.getOutType());
1198 return Result.err(rp);
1200 } catch (Exception e) {
1201 trans.error().log(e,IN,DELETE_PERMISSION);
1202 return Result.err(e);
1208 public static final String CREATE_ROLE = "createRole";
1209 public static final String GET_ROLES_BY_USER = "getRolesByUser";
1210 public static final String GET_ROLES_BY_NS = "getRolesByNS";
1211 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
1212 public static final String GET_ROLES_BY_NAME = "getRolesByName";
1213 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
1214 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
1215 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
1216 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
1217 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
1218 public static final String DELETE_ROLE = "deleteRole";
1219 public static final String GET_CERT_BY_ID = "getCertByID";
1222 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1223 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
1227 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1228 if (Question.willSpecialLog(trans, trans.user())) {
1229 Question.logEncryptTrace(trans,data.asString());
1231 rreq = data.asObject();
1232 } catch (APIException e) {
1233 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1234 return Result.err(Status.ERR_BadData,"Invalid Input");
1237 Result<Void> rp = service.createRole(trans, rreq);
1240 setContentType(resp,roleRequestDF.getOutType());
1243 return Result.err(rp);
1245 } catch (Exception e) {
1246 trans.error().log(e,IN,CREATE_ROLE);
1247 return Result.err(e);
1254 * @see com.att.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1257 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
1258 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
1260 Result<ROLES> rp = service.getRolesByName(trans, role);
1263 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1264 if (Question.willSpecialLog(trans, trans.user())) {
1265 Question.logEncryptTrace(trans,data.asString());
1267 data.to(resp.getOutputStream());
1268 setContentType(resp,roleDF.getOutType());
1269 setCacheControlOff(resp);
1272 return Result.err(rp);
1274 } catch (Exception e) {
1275 trans.error().log(e,IN,GET_ROLES_BY_NAME);
1276 return Result.err(e);
1283 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1286 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
1287 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1289 Result<ROLES> rp = service.getRolesByUser(trans, user);
1292 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1293 if (Question.willSpecialLog(trans, trans.user())) {
1294 Question.logEncryptTrace(trans,data.asString());
1296 data.to(resp.getOutputStream());
1297 setContentType(resp,roleDF.getOutType());
1298 setCacheControlOff(resp);
1301 return Result.err(rp);
1303 } catch (Exception e) {
1304 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
1305 return Result.err(e);
1312 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1315 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
1316 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1318 Result<ROLES> rp = service.getRolesByNS(trans, ns);
1321 if (!rp.isEmpty()) {
1322 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1323 if (Question.willSpecialLog(trans, trans.user())) {
1324 Question.logEncryptTrace(trans,data.asString());
1326 data.to(resp.getOutputStream());
1328 Question.logEncryptTrace(trans, NO_DATA);
1330 setContentType(resp,roleDF.getOutType());
1331 setCacheControlOff(resp);
1334 return Result.err(rp);
1336 } catch (Exception e) {
1337 trans.error().log(e,IN,GET_ROLES_BY_NS);
1338 return Result.err(e);
1346 * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1349 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
1350 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
1352 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
1355 if (!rp.isEmpty()) {
1356 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1357 if (Question.willSpecialLog(trans, trans.user())) {
1358 Question.logEncryptTrace(trans,data.asString());
1360 data.to(resp.getOutputStream());
1362 Question.logEncryptTrace(trans, NO_DATA);
1364 setContentType(resp,roleDF.getOutType());
1365 setCacheControlOff(resp);
1368 return Result.err(rp);
1370 } catch (Exception e) {
1371 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
1372 return Result.err(e);
1379 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1382 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
1383 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
1385 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
1388 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1389 if (Question.willSpecialLog(trans, trans.user())) {
1390 Question.logEncryptTrace(trans,data.asString());
1392 data.to(resp.getOutputStream());
1393 setContentType(resp,roleDF.getOutType());
1394 setCacheControlOff(resp);
1397 return Result.err(rp);
1399 } catch (Exception e) {
1400 trans.error().log(e,IN,GET_ROLES_BY_PERM);
1401 return Result.err(e);
1409 * @see com.att.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
1412 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1413 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
1417 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1418 if (Question.willSpecialLog(trans, trans.user())) {
1419 Question.logEncryptTrace(trans,data.asString());
1421 rreq = data.asObject();
1422 } catch (APIException e) {
1423 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);
1424 return Result.err(Status.ERR_BadData,"Invalid Input");
1427 Result<Void> rp = service.updateRoleDescription(trans, rreq);
1430 setContentType(resp,roleRequestDF.getOutType());
1435 } catch (Exception e) {
1436 trans.error().log(e,IN,UPDATE_ROLE_DESC);
1437 return Result.err(e);
1444 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1445 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
1449 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1450 if (Question.willSpecialLog(trans, trans.user())) {
1451 Question.logEncryptTrace(trans,data.asString());
1453 rreq = data.asObject();
1454 } catch (APIException e) {
1455 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);
1456 return Result.err(Status.ERR_BadData,"Invalid Input");
1459 Result<Void> rp = service.addPermToRole(trans, rreq);
1462 setContentType(resp,permsDF.getOutType());
1463 resp.getOutputStream().println();
1466 return Result.err(rp);
1468 } catch (Exception e) {
1469 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
1470 return Result.err(e);
1477 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1478 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1482 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1483 if (Question.willSpecialLog(trans, trans.user())) {
1484 Question.logEncryptTrace(trans,data.asString());
1486 rreq = data.asObject();
1487 } catch (APIException e) {
1488 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);
1489 return Result.err(Status.ERR_BadData,"Invalid Input");
1492 Result<Void> rp = service.delPermFromRole(trans, rreq);
1495 setContentType(resp,permsDF.getOutType());
1496 resp.getOutputStream().println();
1499 return Result.err(rp);
1501 } catch (Exception e) {
1502 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1503 return Result.err(e);
1510 * @see com.att.authz.facade.AuthzFacade#delPermFromRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String, java.lang.String)
1513 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletResponse resp, String role, String type,
1514 String instance, String action) {
1515 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1517 Result<Void> rp = service.delPermFromRole(trans, role, type, instance, action);
1520 setContentType(resp,permsDF.getOutType());
1521 resp.getOutputStream().println();
1524 return Result.err(rp);
1526 } catch (Exception e) {
1527 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1528 return Result.err(e);
1535 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1536 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1538 Result<Void> rp = service.deleteRole(trans, role);
1541 setContentType(resp,permsDF.getOutType());
1544 return Result.err(rp);
1546 } catch (Exception e) {
1547 trans.error().log(e,IN,DELETE_ROLE);
1548 return Result.err(e);
1555 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1556 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
1560 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1561 if (Question.willSpecialLog(trans, trans.user())) {
1562 Question.logEncryptTrace(trans,data.asString());
1564 rreq = data.asObject();
1565 } catch (APIException e) {
1566 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1567 return Result.err(Status.ERR_BadData,"Invalid Input");
1570 Result<Void> rp = service.deleteRole(trans, rreq);
1573 setContentType(resp,permsDF.getOutType());
1576 return Result.err(rp);
1578 } catch (Exception e) {
1579 trans.error().log(e,IN,DELETE_ROLE);
1580 return Result.err(e);
1586 public static final String CREATE_CRED = "createUserCred";
1587 private static final String GET_CREDS_BY_NS = "getCredsByNS";
1588 private static final String GET_CREDS_BY_ID = "getCredsByID";
1589 public static final String UPDATE_CRED = "updateUserCred";
1590 public static final String EXTEND_CRED = "extendUserCred";
1591 public static final String DELETE_CRED = "deleteUserCred";
1592 public static final String DOES_CRED_MATCH = "doesCredMatch";
1593 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
1602 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
1603 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
1605 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1606 if (Question.willSpecialLog(trans, trans.user())) {
1607 Question.logEncryptTrace(trans,data.asString());
1609 return service.createUserCred(trans, data.asObject());
1610 } catch (APIException e) {
1611 trans.error().log(e,"Bad Input data");
1612 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1613 } catch (Exception e) {
1614 trans.error().log(e,IN,CREATE_CRED);
1615 return Result.err(e);
1622 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
1623 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
1625 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1626 if (Question.willSpecialLog(trans, trans.user())) {
1627 Question.logEncryptTrace(trans,data.asString());
1630 return service.resetUserCred(trans, data.asObject());
1631 } catch (APIException e) {
1632 trans.error().log(e,"Bad Input data");
1633 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1634 } catch (Exception e) {
1635 trans.error().log(e,IN,UPDATE_CRED);
1636 return Result.err(e);
1643 * @see com.att.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
1646 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
1647 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
1649 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1650 if (Question.willSpecialLog(trans, trans.user())) {
1651 Question.logEncryptTrace(trans,data.asString());
1654 return service.extendUserCred(trans, data.asObject(), days);
1655 } catch (APIException e) {
1656 trans.error().log(e,"Bad Input data");
1657 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1658 } catch (Exception e) {
1659 trans.error().log(e,IN,EXTEND_CRED);
1660 return Result.err(e);
1667 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
1668 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1671 Result<USERS> ru = service.getCredsByNS(trans,ns);
1674 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1675 if (Question.willSpecialLog(trans,trans.user())) {
1676 Question.logEncryptTrace(trans,data.asString());
1678 data.to(resp.getOutputStream());
1679 setContentType(resp,usersDF.getOutType());
1682 return Result.err(ru);
1684 } catch (Exception e) {
1685 trans.error().log(e,IN,GET_CREDS_BY_NS);
1686 return Result.err(e);
1695 * @see com.att.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1698 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
1699 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
1702 Result<USERS> ru = service.getCredsByID(trans,id);
1705 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1706 if (Question.willSpecialLog(trans, trans.user())) {
1707 Question.logEncryptTrace(trans,data.asString());
1709 data.to(resp.getOutputStream());
1710 setContentType(resp,usersDF.getOutType());
1713 return Result.err(ru);
1715 } catch (Exception e) {
1716 trans.error().log(e,IN,GET_CREDS_BY_ID);
1717 return Result.err(e);
1725 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
1726 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
1728 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1729 if (Question.willSpecialLog(trans, trans.user())) {
1730 Question.logEncryptTrace(trans,data.asString());
1733 return service.deleteUserCred(trans, data.asObject());
1734 } catch (APIException e) {
1735 trans.error().log(e,"Bad Input data");
1736 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1737 } catch (Exception e) {
1738 trans.error().log(e,IN,DELETE_CRED);
1739 return Result.err(e);
1747 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1748 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
1750 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1751 if (Question.willSpecialLog(trans, trans.user())) {
1752 Question.logEncryptTrace(trans,data.asString());
1755 return service.doesCredentialMatch(trans, data.asObject());
1756 } catch (APIException e) {
1757 trans.error().log(e,"Bad Input data");
1758 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1759 } catch (IOException e) {
1760 trans.error().log(e,IN,DOES_CRED_MATCH);
1761 return Result.err(e);
1769 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
1770 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
1772 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
1773 switch(result.status){
1775 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
1778 return Result.err(result);
1779 } catch (Exception e) {
1780 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
1781 return Result.err(e);
1788 * @see com.att.authz.facade.AuthzFacade#getCertInfoByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
1791 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
1792 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
1794 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
1796 switch(rci.status) {
1798 if (Question.willSpecialLog(trans, trans.user())) {
1799 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
1800 Question.logEncryptTrace(trans,data.asString());
1801 data.to(resp.getOutputStream());
1803 certsDF.direct(trans, rci.value, resp.getOutputStream());
1805 setContentType(resp,certsDF.getOutType());
1808 return Result.err(rci);
1810 } catch (Exception e) {
1811 trans.error().log(e,IN,GET_CERT_BY_ID);
1812 return Result.err(e);
1818 public static final String CREATE_DELEGATE = "createDelegate";
1819 public static final String UPDATE_DELEGATE = "updateDelegate";
1820 public static final String DELETE_DELEGATE = "deleteDelegate";
1821 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
1822 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
1825 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1826 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
1828 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1829 if (Question.willSpecialLog(trans, trans.user())) {
1830 Question.logEncryptTrace(trans,data.asString());
1833 return service.createDelegate(trans, data.asObject());
1834 } catch (Exception e) {
1835 trans.error().log(e,IN,CREATE_DELEGATE);
1836 return Result.err(e);
1843 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1844 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
1846 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1847 if (Question.willSpecialLog(trans, trans.user())) {
1848 Question.logEncryptTrace(trans,data.asString());
1851 return service.updateDelegate(trans, data.asObject());
1852 } catch (Exception e) {
1853 trans.error().log(e,IN,UPDATE_DELEGATE);
1854 return Result.err(e);
1861 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1862 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
1864 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1865 if (Question.willSpecialLog(trans, trans.user())) {
1866 Question.logEncryptTrace(trans,data.asString());
1869 return service.deleteDelegate(trans, data.asObject());
1870 } catch (Exception e) {
1871 trans.error().log(e,IN,DELETE_DELEGATE);
1872 return Result.err(e);
1879 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
1880 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
1882 return service.deleteDelegate(trans, userName);
1883 } catch (Exception e) {
1884 trans.error().log(e,IN,DELETE_DELEGATE);
1885 return Result.err(e);
1892 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
1893 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
1895 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
1899 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1900 if (Question.willSpecialLog(trans, trans.user())) {
1901 Question.logEncryptTrace(trans,data.asString());
1903 data.to(resp.getOutputStream());
1904 setContentType(resp,delgDF.getOutType());
1907 return Result.err(rd);
1909 } catch (Exception e) {
1910 trans.error().log(e,IN,GET_DELEGATE_USER);
1911 return Result.err(e);
1918 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
1919 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
1921 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
1924 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1925 if (Question.willSpecialLog(trans, trans.user())) {
1926 Question.logEncryptTrace(trans,data.asString());
1928 data.to(resp.getOutputStream());
1929 setContentType(resp,delgDF.getOutType());
1932 return Result.err(rd);
1934 } catch (Exception e) {
1935 trans.error().log(e,IN,GET_DELEGATE_DELG);
1936 return Result.err(e);
1942 private static final String REQUEST_USER_ROLE = "createUserRole";
1943 private static final String GET_USERROLES = "getUserRoles";
1944 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
1945 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
1946 // private static final String SET_ROLES_FOR_USER = "setRolesForUser";
1947 // private static final String SET_USERS_FOR_ROLE = "setUsersForRole";
1948 private static final String EXTEND_USER_ROLE = "extendUserRole";
1949 private static final String DELETE_USER_ROLE = "deleteUserRole";
1951 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1952 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
1956 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
1957 if (Question.willSpecialLog(trans, trans.user())) {
1958 Question.logEncryptTrace(trans,data.asString());
1961 request = data.asObject();
1962 } catch (APIException e) {
1963 return Result.err(Status.ERR_BadData,"Invalid Input");
1966 Result<Void> rp = service.createUserRole(trans,request);
1969 setContentType(resp,permsDF.getOutType());
1972 return Result.err(rp);
1974 } catch (Exception e) {
1975 trans.error().log(e,IN,REQUEST_USER_ROLE);
1976 return Result.err(e);
1983 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
1984 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
1986 Result<USERS> ru = service.getUserInRole(trans,user,role);
1989 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1990 if (Question.willSpecialLog(trans, trans.user())) {
1991 Question.logEncryptTrace(trans,data.asString());
1994 data.to(resp.getOutputStream());
1995 setContentType(resp,usersDF.getOutType());
1996 setCacheControlOff(resp);
1999 return Result.err(ru);
2001 } catch (Exception e) {
2002 trans.error().log(e,IN,GET_USERROLES);
2003 return Result.err(e);
2011 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2012 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2014 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
2017 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2018 if (Question.willSpecialLog(trans, trans.user())) {
2019 Question.logEncryptTrace(trans,data.asString());
2022 data.to(resp.getOutputStream());
2023 setContentType(resp,usersDF.getOutType());
2024 setCacheControlOff(resp);
2027 return Result.err(ru);
2029 } catch (Exception e) {
2030 trans.error().log(e,IN,GET_USERROLES_BY_USER);
2031 return Result.err(e);
2039 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2040 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2042 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
2045 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2046 if (Question.willSpecialLog(trans, trans.user())) {
2047 Question.logEncryptTrace(trans,data.asString());
2050 data.to(resp.getOutputStream());
2051 setContentType(resp,usersDF.getOutType());
2052 setCacheControlOff(resp);
2055 return Result.err(ru);
2057 } catch (Exception e) {
2058 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
2059 return Result.err(e);
2068 * @see com.att.authz.facade.AuthzFacade#extendUserRoleExpiration(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
2071 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2072 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2074 return service.extendUserRole(trans,user,role);
2075 } catch (Exception e) {
2076 trans.error().log(e,IN,EXTEND_USER_ROLE);
2077 return Result.err(e);
2084 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2085 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2087 Result<Void> rp = service.deleteUserRole(trans,user,role);
2090 setContentType(resp,permsDF.getOutType());
2093 return Result.err(rp);
2095 } catch (Exception e) {
2096 trans.error().log(e,IN,DELETE_USER_ROLE);
2097 return Result.err(e);
2103 private static final String UPDATE_APPROVAL = "updateApproval";
2104 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
2105 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
2106 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
2109 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
2110 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
2112 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
2113 if (Question.willSpecialLog(trans, trans.user())) {
2114 Question.logEncryptTrace(trans,data.asString());
2117 Result<Void> rp = service.updateApproval(trans, data.asObject());
2121 setContentType(resp,approvalDF.getOutType());
2124 return Result.err(rp);
2126 } catch (Exception e) {
2127 trans.error().log(e,IN,UPDATE_APPROVAL);
2128 return Result.err(e);
2135 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2136 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2138 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
2141 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2142 if (Question.willSpecialLog(trans, trans.user())) {
2143 Question.logEncryptTrace(trans,data.asString());
2145 data.to(resp.getOutputStream());
2147 setContentType(resp,permsDF.getOutType());
2150 return Result.err(rp);
2152 } catch (Exception e) {
2153 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
2154 return Result.err(e);
2161 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
2162 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
2164 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
2167 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2168 if (Question.willSpecialLog(trans, trans.user())) {
2169 Question.logEncryptTrace(trans,data.asString());
2172 data.to(resp.getOutputStream());
2173 setContentType(resp,permsDF.getOutType());
2176 return Result.err(rp);
2178 } catch (Exception e) {
2179 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
2180 return Result.err(e);
2187 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
2188 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
2190 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
2193 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2194 if (Question.willSpecialLog(trans, trans.user())) {
2195 Question.logEncryptTrace(trans,data.asString());
2198 data.to(resp.getOutputStream());
2199 setContentType(resp,permsDF.getOutType());
2202 return Result.err(rp);
2204 } catch (Exception e) {
2205 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
2206 return Result.err(e);
2214 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
2215 public static final String GET_USERS_ROLE = "getUsersByRole";
2218 * @see com.att.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2221 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2222 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2224 Result<USERS> ru = service.getUsersByRole(trans,role);
2227 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2228 if (Question.willSpecialLog(trans, trans.user())) {
2229 Question.logEncryptTrace(trans,data.asString());
2232 data.to(resp.getOutputStream());
2233 setContentType(resp,usersDF.getOutType());
2236 return Result.err(ru);
2238 } catch (Exception e) {
2239 trans.error().log(e,IN,GET_USERS_ROLE);
2240 return Result.err(e);
2247 * @see com.att.authz.facade.AuthzFacade#getUsersByPermission(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
2250 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
2251 String type, String instance, String action) {
2252 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
2254 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
2257 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2258 if (Question.willSpecialLog(trans, trans.user())) {
2259 Question.logEncryptTrace(trans,data.asString());
2262 data.to(resp.getOutputStream());
2263 setContentType(resp,usersDF.getOutType());
2266 return Result.err(ru);
2268 } catch (Exception e) {
2269 trans.error().log(e,IN,GET_USERS_PERMISSION);
2270 return Result.err(e);
2277 public static final String GET_HISTORY_USER = "getHistoryByUser";
2278 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
2279 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
2280 public static final String GET_HISTORY_NS = "getHistoryByNS";
2281 public static final String GET_HISTORY_SUBJECT = "getHistoryBySubject";
2283 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2286 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
2287 StringBuilder sb = new StringBuilder();
2288 sb.append(GET_HISTORY_USER);
2292 boolean first = true;
2293 for (int i : yyyymm) {
2301 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2304 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
2307 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2308 if (Question.willSpecialLog(trans, trans.user())) {
2309 Question.logEncryptTrace(trans,data.asString());
2312 data.to(resp.getOutputStream());
2313 setContentType(resp,historyDF.getOutType());
2316 return Result.err(rh);
2318 } catch (Exception e) {
2319 trans.error().log(e,IN,GET_HISTORY_USER);
2320 return Result.err(e);
2327 * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2330 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
2331 StringBuilder sb = new StringBuilder();
2332 sb.append(GET_HISTORY_ROLE);
2336 boolean first = true;
2337 for (int i : yyyymm) {
2345 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2347 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
2350 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2351 if (Question.willSpecialLog(trans, trans.user())) {
2352 Question.logEncryptTrace(trans,data.asString());
2355 data.to(resp.getOutputStream());
2356 setContentType(resp,historyDF.getOutType());
2359 return Result.err(rh);
2361 } catch (Exception e) {
2362 trans.error().log(e,IN,GET_HISTORY_ROLE);
2363 return Result.err(e);
2370 * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2373 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
2374 StringBuilder sb = new StringBuilder();
2375 sb.append(GET_HISTORY_NS);
2379 boolean first = true;
2380 for (int i : yyyymm) {
2388 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2390 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
2393 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2394 if (Question.willSpecialLog(trans, trans.user())) {
2395 Question.logEncryptTrace(trans,data.asString());
2398 data.to(resp.getOutputStream());
2399 setContentType(resp,historyDF.getOutType());
2402 return Result.err(rh);
2404 } catch (Exception e) {
2405 trans.error().log(e,IN,GET_HISTORY_NS);
2406 return Result.err(e);
2413 * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2416 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
2417 StringBuilder sb = new StringBuilder();
2418 sb.append(GET_HISTORY_PERM);
2422 boolean first = true;
2423 for (int i : yyyymm) {
2431 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2433 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
2436 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2437 if (Question.willSpecialLog(trans, trans.user())) {
2438 Question.logEncryptTrace(trans,data.asString());
2441 data.to(resp.getOutputStream());
2442 setContentType(resp,historyDF.getOutType());
2445 return Result.err(rh);
2447 } catch (Exception e) {
2448 trans.error().log(e,IN,GET_HISTORY_PERM);
2449 return Result.err(e);
2456 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2459 public Result<Void> getHistoryBySubject(AuthzTrans trans, HttpServletResponse resp, String subject, String target, int[] yyyymm, final int sort) {
2460 StringBuilder sb = new StringBuilder();
2461 sb.append(GET_HISTORY_SUBJECT);
2465 boolean first = true;
2466 for (int i : yyyymm) {
2474 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2477 Result<HISTORY> rh = service.getHistoryBySubject(trans,subject,target,yyyymm,sort);
2480 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2481 if (Question.willSpecialLog(trans, trans.user())) {
2482 Question.logEncryptTrace(trans,data.asString());
2485 data.to(resp.getOutputStream());
2486 setContentType(resp,historyDF.getOutType());
2489 return Result.err(rh);
2491 } catch (Exception e) {
2492 trans.error().log(e,IN,GET_HISTORY_USER);
2493 return Result.err(e);
2499 public final static String CACHE_CLEAR = "cacheClear ";
2500 // public final static String CACHE_VALIDATE = "validateCache";
2503 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String)
2506 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
2507 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
2509 return service.cacheClear(trans,cname);
2510 } catch (Exception e) {
2511 trans.error().log(e,IN,CACHE_CLEAR);
2512 return Result.err(e);
2519 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.Integer)
2522 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
2523 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
2525 String[] segs = segments.split("\\s*,\\s*");
2526 int isegs[] = new int[segs.length];
2527 for (int i=0;i<segs.length;++i) {
2529 isegs[i] = Integer.parseInt(segs[i]);
2530 } catch (NumberFormatException nfe) {
2534 return service.cacheClear(trans,cname, isegs);
2535 } catch (Exception e) {
2536 trans.error().log(e,IN,CACHE_CLEAR);
2537 return Result.err(e);
2544 * @see com.att.authz.facade.AuthzFacade#dbReset(org.onap.aaf.auth.env.test.AuthzTrans)
2547 public void dbReset(AuthzTrans trans) {
2548 service.dbReset(trans);
2552 * @see com.att.authz.facade.AuthzFacade#getAPI(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse)
2554 public final static String API_REPORT = "apiReport";
2556 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
2557 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
2559 Api api = new Api();
2561 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
2562 for (RouteReport rr : rservlet.routeReport()) {
2563 api.getRoute().add(ar = new Api.Route());
2564 ar.setMeth(rr.meth.name());
2565 ar.setPath(rr.path);
2566 ar.setDesc(rr.desc);
2567 ar.getContentType().addAll(rr.contextTypes);
2568 for (Method m : meths) {
2570 if ((ad = m.getAnnotation(ApiDoc.class))!=null &&
2571 rr.meth.equals(ad.method()) &&
2572 rr.path.equals(ad.path())) {
2573 for (String param : ad.params()) {
2574 ar.getParam().add(param);
2576 for (String text : ad.text()) {
2577 ar.getComments().add(text);
2579 ar.setExpected(ad.expectedCode());
2580 for (int ec : ad.errorCodes()) {
2581 ar.getExplicitErr().add(ec);
2586 RosettaData<Api> data = apiDF.newData(trans).load(api);
2587 if (Question.willSpecialLog(trans, trans.user())) {
2588 Question.logEncryptTrace(trans,data.asString());
2591 data.to(resp.getOutputStream());
2592 setContentType(resp,apiDF.getOutType());
2595 } catch (Exception e) {
2596 trans.error().log(e,IN,API_REPORT);
2597 return Result.err(e);
2604 public final static String API_EXAMPLE = "apiExample";
2607 * @see com.att.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2610 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
2611 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
2613 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
2614 resp.getOutputStream().print(content);
2615 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
2617 } catch (Exception e) {
2618 trans.error().log(e,IN,API_EXAMPLE);
2619 return Result.err(Status.ERR_NotImplemented,e.getMessage());