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 || result.variables.length<1) {
175 detail = new String[1];
177 List<String> dlist = new ArrayList<String>();
180 for(Object s : result.variables) {
181 if(s!=null && (os=s.toString()).length()>0) {
185 detail = new String[dlist.size()];
186 dlist.toArray(detail);
190 switch(result.status) {
191 case ERR_ActionNotCompleted:
193 detail[0] = "Accepted, Action not complete";
194 response.setStatus(/*httpstatus=*/202);
199 detail[0] = FORBIDDEN;
200 response.setStatus(/*httpstatus=*/403);
204 detail[0] = FORBIDDEN;
205 response.setStatus(/*httpstatus=*/403);
209 detail[0] = FORBIDDEN;
210 response.setStatus(/*httpstatus=*/403);
212 // This is still forbidden to directly impact, but can be Requested when passed
213 // with "request=true" query Param
214 case ERR_FutureNotRequested:
217 response.setStatus(/*httpstatus=*/403);
222 detail[0] = NOT_FOUND;
223 response.setStatus(/*httpstatus=*/404);
225 case ERR_RoleNotFound:
227 detail[0] = NOT_FOUND;
228 response.setStatus(/*httpstatus=*/404);
230 case ERR_PermissionNotFound:
232 detail[0] = NOT_FOUND;
233 response.setStatus(/*httpstatus=*/404);
235 case ERR_UserNotFound:
237 detail[0] = NOT_FOUND;
238 response.setStatus(/*httpstatus=*/404);
240 case ERR_UserRoleNotFound:
242 detail[0] = NOT_FOUND;
243 response.setStatus(/*httpstatus=*/404);
245 case ERR_DelegateNotFound:
247 detail[0] = NOT_FOUND;
248 response.setStatus(/*httpstatus=*/404);
252 detail[0] = NOT_FOUND;
253 response.setStatus(/*httpstatus=*/404);
256 case ERR_InvalidDelegate:
258 detail[0] = NOT_ACCEPTABLE;
259 response.setStatus(/*httpstatus=*/406);
263 detail[0] = NOT_ACCEPTABLE;
264 response.setStatus(/*httpstatus=*/406);
267 case ERR_ConflictAlreadyExists:
269 detail[0] = "Conflict Already Exists";
270 response.setStatus(/*httpstatus=*/409);
273 case ERR_DependencyExists:
275 detail[0] = "Failed Dependency";
276 response.setStatus(/*httpstatus=*/424);
279 case ERR_NotImplemented:
281 detail[0] = "Not Implemented";
282 response.setStatus(/*httpstatus=*/501);
285 case Status.ACC_Future:
287 detail[0] = "Accepted for Future, pending Approvals";
288 response.setStatus(/*httpstatus=*/202);
290 case ERR_ChoiceNeeded:
292 detail[0] = "Choice Needed";
293 response.setStatus(/*httpstatus=*/300);
297 detail[0] = GENERAL_SERVICE_ERROR;
298 response.setStatus(/*httpstatus=*/500);
304 detail[0] = GENERAL_SERVICE_ERROR;
305 response.setStatus(/*httpstatus=*/500);
311 StringBuilder holder = new StringBuilder();
312 ERR em = service.mapper().errorFromMessage(holder,msgId,msg,detail);
321 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
323 errDF.newData(trans).load(em).to(response.getOutputStream());
324 } catch (Exception e) {
325 trans.error().log(e,"unable to send response for",msg);
329 ///////////////////////////
331 ///////////////////////////
332 public static final String CREATE_NS = "createNamespace";
333 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
334 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
335 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
336 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
337 public static final String GET_NS_BY_NAME = "getNamespaceByName";
338 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
339 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
340 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
341 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
342 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
343 public static final String DELETE_NS = "deleteNamespace";
347 * @see com.att.authz.facade.AuthzFacade#createNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
350 public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {
351 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);
355 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());
356 if (Question.willSpecialLog(trans, trans.user())) {
357 Question.logEncryptTrace(trans,rd.asString());
359 request = rd.asObject();
360 } catch (APIException e) {
361 trans.error().log("Invalid Input",IN,CREATE_NS);
362 return Result.err(Status.ERR_BadData,"Invalid Input");
365 Result<Void> rp = service.createNS(trans,request,type);
368 setContentType(resp,nsRequestDF.getOutType());
371 return Result.err(rp);
373 } catch (Exception e) {
374 trans.error().log(e,IN,CREATE_NS);
375 return Result.err(e);
382 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
385 public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
386 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
388 Result<Void> rp = service.addAdminNS(trans,ns,id);
392 setContentType(resp,nsRequestDF.getOutType());
393 resp.getOutputStream().println();
396 return Result.err(rp);
398 } catch (Exception e) {
399 trans.error().log(e,IN,ADD_NS_ADMIN);
400 return Result.err(e);
407 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
410 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
411 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
413 Result<Void> rp = service.delAdminNS(trans, ns, id);
416 setContentType(resp,nsRequestDF.getOutType());
419 return Result.err(rp);
421 } catch (Exception e) {
422 trans.error().log(e,IN,DELETE_NS_ADMIN);
423 return Result.err(e);
430 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
433 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
434 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
436 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
439 setContentType(resp,nsRequestDF.getOutType());
440 resp.getOutputStream().println();
443 return Result.err(rp);
445 } catch (Exception e) {
446 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
447 return Result.err(e);
454 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
457 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
458 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
460 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
463 setContentType(resp,nsRequestDF.getOutType());
464 resp.getOutputStream().println();
467 return Result.err(rp);
469 } catch (Exception e) {
470 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
471 return Result.err(e);
478 * @see com.att.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
481 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns, boolean full) {
482 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
484 Result<NSS> rp = service.getNSbyName(trans, ns, full );
487 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
488 if (Question.willSpecialLog(trans, trans.user())) {
489 Question.logEncryptTrace(trans,data.asString());
491 data.to(resp.getOutputStream());
492 setContentType(resp,nssDF.getOutType());
495 return Result.err(rp);
497 } catch (Exception e) {
498 trans.error().log(e,IN,GET_NS_BY_NAME);
499 return Result.err(e);
505 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
507 * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
510 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
511 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
513 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
516 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
517 if (Question.willSpecialLog(trans, trans.user())) {
518 Question.logEncryptTrace(trans,data.asString());
520 data.to(resp.getOutputStream());
521 setContentType(resp,nssDF.getOutType());
524 return Result.err(rp);
526 } catch (Exception e) {
527 trans.error().log(e,IN,GET_NS_BY_ADMIN);
528 return Result.err(e);
534 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
536 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
539 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
540 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
542 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
545 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
546 if (Question.willSpecialLog(trans, trans.user())) {
547 Question.logEncryptTrace(trans,data.asString());
549 data.to(resp.getOutputStream());
551 setContentType(resp,nssDF.getOutType());
554 return Result.err(rp);
556 } catch (Exception e) {
557 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
558 return Result.err(e);
565 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
568 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
569 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
571 Result<NSS> rp = service.getNSbyEither(trans, user, full);
575 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
576 if (Question.willSpecialLog(trans, trans.user())) {
577 Question.logEncryptTrace(trans,data.asString());
579 data.to(resp.getOutputStream());
581 setContentType(resp,nssDF.getOutType());
584 return Result.err(rp);
586 } catch (Exception e) {
587 trans.error().log(e,IN,GET_NS_BY_EITHER);
588 return Result.err(e);
595 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
598 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
599 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
601 Result<NSS> rp = service.getNSsChildren(trans, parent);
604 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
605 if (Question.willSpecialLog(trans, trans.user())) {
606 Question.logEncryptTrace(trans,data.asString());
608 data.to(resp.getOutputStream());
609 setContentType(resp,nssDF.getOutType());
612 return Result.err(rp);
614 } catch (Exception e) {
615 trans.error().log(e,IN,GET_NS_CHILDREN);
616 return Result.err(e);
623 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
624 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
628 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
629 if (Question.willSpecialLog(trans, trans.user())) {
630 Question.logEncryptTrace(trans,data.asString());
632 rreq = data.asObject();
633 } catch (APIException e) {
634 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);
635 return Result.err(Status.ERR_BadData,"Invalid Input");
638 Result<Void> rp = service.updateNsDescription(trans, rreq);
641 setContentType(resp,nsRequestDF.getOutType());
644 return Result.err(rp);
646 } catch (Exception e) {
647 trans.error().log(e,IN,UPDATE_NS_DESC);
648 return Result.err(e);
656 * @see com.att.authz.facade.AuthzFacade#requestNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
659 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
660 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
662 Result<Void> rp = service.deleteNS(trans,ns);
665 setContentType(resp,nsRequestDF.getOutType());
668 return Result.err(rp);
670 } catch (Exception e) {
671 trans.error().log(e,IN,DELETE_NS);
672 return Result.err(e);
678 private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";
679 private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
680 private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";
681 private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";
684 * @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)
687 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
688 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
690 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
693 setContentType(resp, keysDF.getOutType());
694 resp.getOutputStream().println();
697 return Result.err(rp);
699 } catch (Exception e) {
700 trans.error().log(e,IN,NS_CREATE_ATTRIB);
701 return Result.err(e);
708 * @see com.att.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
711 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
712 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
714 Result<KEYS> rp = service.readNsByAttrib(trans, key);
717 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
718 if (Question.willSpecialLog(trans, trans.user())) {
719 Question.logEncryptTrace(trans,data.asString());
721 data.to(resp.getOutputStream());
722 setContentType(resp,keysDF.getOutType());
725 return Result.err(rp);
727 } catch (Exception e) {
728 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
729 return Result.err(e);
736 * @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)
739 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
740 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
742 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
745 setContentType(resp, keysDF.getOutType());
746 resp.getOutputStream().println();
749 return Result.err(rp);
751 } catch (Exception e) {
752 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
753 return Result.err(e);
761 * @see com.att.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
764 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
765 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
767 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
770 setContentType(resp, keysDF.getOutType());
771 resp.getOutputStream().println();
774 return Result.err(rp);
776 } catch (Exception e) {
777 trans.error().log(e,IN,NS_DELETE_ATTRIB);
778 return Result.err(e);
787 public static final String CREATE_PERMISSION = "createPermission";
788 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
789 public static final String GET_PERMS_BY_NAME = "getPermsByName";
790 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
791 public static final String GET_PERMISSIONS_BY_USER_SCOPE = "getPermissionsByUserScope";
792 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
793 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
794 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
795 public static final String UPDATE_PERMISSION = "updatePermission";
796 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
797 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
798 public static final String DELETE_PERMISSION = "deletePermission";
802 * @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)
805 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
806 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
810 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
811 if (Question.willSpecialLog(trans, trans.user())) {
812 Question.logEncryptTrace(trans,data.asString());
814 rreq = data.asObject();
815 } catch (APIException e) {
816 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
817 return Result.err(Status.ERR_BadData,"Invalid Input");
820 Result<Void> rp = service.createPerm(trans,rreq);
823 setContentType(resp,permsDF.getOutType());
826 return Result.err(rp);
828 } catch (Exception e) {
829 trans.error().log(e,IN,CREATE_PERMISSION);
830 return Result.err(e);
837 * @see com.att.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
840 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
841 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
844 Result<PERMS> rp = service.getPermsByType(trans, perm);
847 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
848 if (Question.willSpecialLog(trans, trans.user())) {
849 Question.logEncryptTrace(trans,data.asString());
851 data.to(resp.getOutputStream());
852 setContentType(resp,permsDF.getOutType());
853 setCacheControlOff(resp);
856 return Result.err(rp);
858 } catch (Exception e) {
859 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
860 return Result.err(e);
867 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
868 String type, String instance, String action) {
870 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
871 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
874 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
877 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
878 if (Question.willSpecialLog(trans, trans.user())) {
879 Question.logEncryptTrace(trans,data.asString());
881 data.to(resp.getOutputStream());
882 setContentType(resp,permsDF.getOutType());
883 setCacheControlOff(resp);
886 return Result.err(rp);
888 } catch (Exception e) {
889 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
890 return Result.err(e);
897 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
900 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
901 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
903 Result<PERMS> rp = service.getPermsByUser(trans, user);
906 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
907 if (Question.willSpecialLog(trans, trans.user())) {
908 Question.logEncryptTrace(trans,data.asString());
910 data.to(resp.getOutputStream());
911 setContentType(resp,permsDF.getOutType());
912 setCacheControlOff(resp);
915 return Result.err(rp);
917 } catch (Exception e) {
918 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
919 return Result.err(e);
926 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
929 public Result<Void> getPermsByUserScope(AuthzTrans trans, HttpServletResponse resp, String user, String[] scopes) {
930 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_SCOPE + ' ' + user, Env.SUB|Env.ALWAYS);
932 Result<PERMS> rp = service.getPermsByUserScope(trans, user, scopes);
935 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
936 if (Question.willSpecialLog(trans, trans.user())) {
937 Question.logEncryptTrace(trans,data.asString());
939 data.to(resp.getOutputStream());
940 setContentType(resp,permsDF.getOutType());
941 setCacheControlOff(resp);
944 return Result.err(rp);
946 } catch (Exception e) {
947 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_SCOPE, user);
948 return Result.err(e);
957 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
960 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
961 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
965 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
966 if (Question.willSpecialLog(trans, trans.user())) {
967 Question.logEncryptTrace(trans,data.asString());
969 perms = data.asObject();
970 } catch (APIException e) {
971 trans.error().log("Invalid Input",IN,GET_PERMISSIONS_BY_USER_WITH_QUERY);
972 return Result.err(Status.ERR_BadData,"Invalid Input");
975 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
978 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
979 if (Question.willSpecialLog(trans, trans.user())) {
980 Question.logEncryptTrace(trans,data.asString());
982 data.to(resp.getOutputStream());
983 setContentType(resp,permsDF.getOutType());
984 setCacheControlOff(resp);
987 return Result.err(rp);
989 } catch (Exception e) {
990 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
991 return Result.err(e);
999 * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1002 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
1003 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
1005 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
1008 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1009 if (Question.willSpecialLog(trans, trans.user())) {
1010 Question.logEncryptTrace(trans,data.asString());
1012 data.to(resp.getOutputStream());
1013 setContentType(resp,permsDF.getOutType());
1014 setCacheControlOff(resp);
1017 return Result.err(rp);
1019 } catch (Exception e) {
1020 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
1021 return Result.err(e);
1028 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
1029 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1031 Result<PERMS> rp = service.getPermsByNS(trans, ns);
1034 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
1035 if (Question.willSpecialLog(trans, trans.user())) {
1036 Question.logEncryptTrace(trans,data.asString());
1038 data.to(resp.getOutputStream());
1039 setContentType(resp,permsDF.getOutType());
1040 setCacheControlOff(resp);
1043 return Result.err(rp);
1045 } catch (Exception e) {
1046 trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);
1047 return Result.err(e);
1055 * @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)
1058 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
1059 String origType, String origInstance, String origAction) {
1060 String cmdDescription = UPDATE_PERMISSION;
1061 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
1065 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1066 if (Question.willSpecialLog(trans, trans.user())) {
1067 Question.logEncryptTrace(trans,data.asString());
1069 rreq = data.asObject();
1070 } catch (APIException e) {
1071 trans.error().log("Invalid Input",IN,cmdDescription);
1072 return Result.err(Status.ERR_BadData,"Invalid Input");
1075 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
1078 setContentType(resp,permsDF.getOutType());
1081 return Result.err(rp);
1083 } catch (Exception e) {
1084 trans.error().log(e,IN,cmdDescription);
1085 return Result.err(e);
1092 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1093 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
1097 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1098 if (Question.willSpecialLog(trans, trans.user())) {
1099 Question.logEncryptTrace(trans,data.asString());
1101 rreq = data.asObject();
1102 } catch (APIException e) {
1103 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);
1104 return Result.err(Status.ERR_BadData,"Invalid Input");
1107 Result<Void> rp = service.updatePermDescription(trans, rreq);
1110 setContentType(resp,permRequestDF.getOutType());
1113 return Result.err(rp);
1115 } catch (Exception e) {
1116 trans.error().log(e,IN,UPDATE_PERM_DESC);
1117 return Result.err(e);
1125 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1126 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
1130 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1131 if (Question.willSpecialLog(trans, trans.user())) {
1132 Question.logEncryptTrace(trans,data.asString());
1134 rreq = data.asObject();
1135 } catch (APIException e) {
1136 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);
1137 return Result.err(Status.ERR_BadData,"Invalid Input");
1140 Result<Void> rp = service.resetPermRoles(trans, rreq);
1144 setContentType(resp,permsDF.getOutType());
1147 return Result.err(rp);
1149 } catch (Exception e) {
1150 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
1151 return Result.err(e);
1158 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1159 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
1163 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1164 if (Question.willSpecialLog(trans, trans.user())) {
1165 Question.logEncryptTrace(trans,data.asString());
1167 rreq = data.asObject();
1168 } catch (APIException e) {
1169 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);
1170 return Result.err(Status.ERR_BadData,"Invalid Input");
1174 Result<Void> rp = service.deletePerm(trans,rreq);
1177 setContentType(resp,permsDF.getOutType());
1180 return Result.err(rp);
1182 } catch (Exception e) {
1183 trans.error().log(e,IN,DELETE_PERMISSION);
1184 return Result.err(e);
1191 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
1192 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
1194 Result<Void> rp = service.deletePerm(trans,type,instance,action);
1197 setContentType(resp,permsDF.getOutType());
1200 return Result.err(rp);
1202 } catch (Exception e) {
1203 trans.error().log(e,IN,DELETE_PERMISSION);
1204 return Result.err(e);
1210 public static final String CREATE_ROLE = "createRole";
1211 public static final String GET_ROLES_BY_USER = "getRolesByUser";
1212 public static final String GET_ROLES_BY_NS = "getRolesByNS";
1213 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
1214 public static final String GET_ROLES_BY_NAME = "getRolesByName";
1215 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
1216 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
1217 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
1218 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
1219 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
1220 public static final String DELETE_ROLE = "deleteRole";
1221 public static final String GET_CERT_BY_ID = "getCertByID";
1224 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1225 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
1229 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1230 if (Question.willSpecialLog(trans, trans.user())) {
1231 Question.logEncryptTrace(trans,data.asString());
1233 rreq = data.asObject();
1234 } catch (APIException e) {
1235 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1236 return Result.err(Status.ERR_BadData,"Invalid Input");
1239 Result<Void> rp = service.createRole(trans, rreq);
1242 setContentType(resp,roleRequestDF.getOutType());
1245 return Result.err(rp);
1247 } catch (Exception e) {
1248 trans.error().log(e,IN,CREATE_ROLE);
1249 return Result.err(e);
1256 * @see com.att.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1259 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
1260 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
1262 Result<ROLES> rp = service.getRolesByName(trans, role);
1265 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1266 if (Question.willSpecialLog(trans, trans.user())) {
1267 Question.logEncryptTrace(trans,data.asString());
1269 data.to(resp.getOutputStream());
1270 setContentType(resp,roleDF.getOutType());
1271 setCacheControlOff(resp);
1274 return Result.err(rp);
1276 } catch (Exception e) {
1277 trans.error().log(e,IN,GET_ROLES_BY_NAME);
1278 return Result.err(e);
1285 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1288 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
1289 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1291 Result<ROLES> rp = service.getRolesByUser(trans, user);
1294 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1295 if (Question.willSpecialLog(trans, trans.user())) {
1296 Question.logEncryptTrace(trans,data.asString());
1298 data.to(resp.getOutputStream());
1299 setContentType(resp,roleDF.getOutType());
1300 setCacheControlOff(resp);
1303 return Result.err(rp);
1305 } catch (Exception e) {
1306 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
1307 return Result.err(e);
1314 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1317 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
1318 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1320 Result<ROLES> rp = service.getRolesByNS(trans, ns);
1323 if (!rp.isEmpty()) {
1324 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1325 if (Question.willSpecialLog(trans, trans.user())) {
1326 Question.logEncryptTrace(trans,data.asString());
1328 data.to(resp.getOutputStream());
1330 Question.logEncryptTrace(trans, NO_DATA);
1332 setContentType(resp,roleDF.getOutType());
1333 setCacheControlOff(resp);
1336 return Result.err(rp);
1338 } catch (Exception e) {
1339 trans.error().log(e,IN,GET_ROLES_BY_NS);
1340 return Result.err(e);
1348 * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1351 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
1352 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
1354 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
1357 if (!rp.isEmpty()) {
1358 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1359 if (Question.willSpecialLog(trans, trans.user())) {
1360 Question.logEncryptTrace(trans,data.asString());
1362 data.to(resp.getOutputStream());
1364 Question.logEncryptTrace(trans, NO_DATA);
1366 setContentType(resp,roleDF.getOutType());
1367 setCacheControlOff(resp);
1370 return Result.err(rp);
1372 } catch (Exception e) {
1373 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
1374 return Result.err(e);
1381 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1384 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
1385 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
1387 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
1390 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1391 if (Question.willSpecialLog(trans, trans.user())) {
1392 Question.logEncryptTrace(trans,data.asString());
1394 data.to(resp.getOutputStream());
1395 setContentType(resp,roleDF.getOutType());
1396 setCacheControlOff(resp);
1399 return Result.err(rp);
1401 } catch (Exception e) {
1402 trans.error().log(e,IN,GET_ROLES_BY_PERM);
1403 return Result.err(e);
1411 * @see com.att.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
1414 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1415 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
1419 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1420 if (Question.willSpecialLog(trans, trans.user())) {
1421 Question.logEncryptTrace(trans,data.asString());
1423 rreq = data.asObject();
1424 } catch (APIException e) {
1425 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);
1426 return Result.err(Status.ERR_BadData,"Invalid Input");
1429 Result<Void> rp = service.updateRoleDescription(trans, rreq);
1432 setContentType(resp,roleRequestDF.getOutType());
1437 } catch (Exception e) {
1438 trans.error().log(e,IN,UPDATE_ROLE_DESC);
1439 return Result.err(e);
1446 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1447 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
1451 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1452 if (Question.willSpecialLog(trans, trans.user())) {
1453 Question.logEncryptTrace(trans,data.asString());
1455 rreq = data.asObject();
1456 } catch (APIException e) {
1457 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);
1458 return Result.err(Status.ERR_BadData,"Invalid Input");
1461 Result<Void> rp = service.addPermToRole(trans, rreq);
1464 setContentType(resp,permsDF.getOutType());
1465 resp.getOutputStream().println();
1468 return Result.err(rp);
1470 } catch (Exception e) {
1471 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
1472 return Result.err(e);
1479 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1480 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1484 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1485 if (Question.willSpecialLog(trans, trans.user())) {
1486 Question.logEncryptTrace(trans,data.asString());
1488 rreq = data.asObject();
1489 } catch (APIException e) {
1490 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);
1491 return Result.err(Status.ERR_BadData,"Invalid Input");
1494 Result<Void> rp = service.delPermFromRole(trans, rreq);
1497 setContentType(resp,permsDF.getOutType());
1498 resp.getOutputStream().println();
1501 return Result.err(rp);
1503 } catch (Exception e) {
1504 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1505 return Result.err(e);
1512 * @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)
1515 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletResponse resp, String role, String type,
1516 String instance, String action) {
1517 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1519 Result<Void> rp = service.delPermFromRole(trans, role, type, instance, action);
1522 setContentType(resp,permsDF.getOutType());
1523 resp.getOutputStream().println();
1526 return Result.err(rp);
1528 } catch (Exception e) {
1529 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1530 return Result.err(e);
1537 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1538 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1540 Result<Void> rp = service.deleteRole(trans, role);
1543 setContentType(resp,permsDF.getOutType());
1546 return Result.err(rp);
1548 } catch (Exception e) {
1549 trans.error().log(e,IN,DELETE_ROLE);
1550 return Result.err(e);
1557 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1558 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
1562 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1563 if (Question.willSpecialLog(trans, trans.user())) {
1564 Question.logEncryptTrace(trans,data.asString());
1566 rreq = data.asObject();
1567 } catch (APIException e) {
1568 trans.error().log("Invalid Input",IN,CREATE_ROLE);
1569 return Result.err(Status.ERR_BadData,"Invalid Input");
1572 Result<Void> rp = service.deleteRole(trans, rreq);
1575 setContentType(resp,permsDF.getOutType());
1578 return Result.err(rp);
1580 } catch (Exception e) {
1581 trans.error().log(e,IN,DELETE_ROLE);
1582 return Result.err(e);
1588 public static final String CREATE_CRED = "createUserCred";
1589 private static final String GET_CREDS_BY_NS = "getCredsByNS";
1590 private static final String GET_CREDS_BY_ID = "getCredsByID";
1591 public static final String UPDATE_CRED = "updateUserCred";
1592 public static final String EXTEND_CRED = "extendUserCred";
1593 public static final String DELETE_CRED = "deleteUserCred";
1594 public static final String DOES_CRED_MATCH = "doesCredMatch";
1595 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
1604 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
1605 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
1607 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1608 if (Question.willSpecialLog(trans, trans.user())) {
1609 Question.logEncryptTrace(trans,data.asString());
1611 return service.createUserCred(trans, data.asObject());
1612 } catch (APIException e) {
1613 trans.error().log(e,"Bad Input data");
1614 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1615 } catch (Exception e) {
1616 trans.error().log(e,IN,CREATE_CRED);
1617 return Result.err(e);
1624 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
1625 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
1627 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1628 if (Question.willSpecialLog(trans, trans.user())) {
1629 Question.logEncryptTrace(trans,data.asString());
1632 return service.resetUserCred(trans, data.asObject());
1633 } catch (APIException e) {
1634 trans.error().log(e,"Bad Input data");
1635 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1636 } catch (Exception e) {
1637 trans.error().log(e,IN,UPDATE_CRED);
1638 return Result.err(e);
1645 * @see com.att.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
1648 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
1649 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
1651 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1652 if (Question.willSpecialLog(trans, trans.user())) {
1653 Question.logEncryptTrace(trans,data.asString());
1656 return service.extendUserCred(trans, data.asObject(), days);
1657 } catch (APIException e) {
1658 trans.error().log(e,"Bad Input data");
1659 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1660 } catch (Exception e) {
1661 trans.error().log(e,IN,EXTEND_CRED);
1662 return Result.err(e);
1669 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
1670 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1673 Result<USERS> ru = service.getCredsByNS(trans,ns);
1676 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1677 if (Question.willSpecialLog(trans,trans.user())) {
1678 Question.logEncryptTrace(trans,data.asString());
1680 data.to(resp.getOutputStream());
1681 setContentType(resp,usersDF.getOutType());
1684 return Result.err(ru);
1686 } catch (Exception e) {
1687 trans.error().log(e,IN,GET_CREDS_BY_NS);
1688 return Result.err(e);
1697 * @see com.att.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1700 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
1701 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
1704 Result<USERS> ru = service.getCredsByID(trans,id);
1707 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1708 if (Question.willSpecialLog(trans, trans.user())) {
1709 Question.logEncryptTrace(trans,data.asString());
1711 data.to(resp.getOutputStream());
1712 setContentType(resp,usersDF.getOutType());
1715 return Result.err(ru);
1717 } catch (Exception e) {
1718 trans.error().log(e,IN,GET_CREDS_BY_ID);
1719 return Result.err(e);
1727 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
1728 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
1730 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1731 if (Question.willSpecialLog(trans, trans.user())) {
1732 Question.logEncryptTrace(trans,data.asString());
1735 return service.deleteUserCred(trans, data.asObject());
1736 } catch (APIException e) {
1737 trans.error().log(e,"Bad Input data");
1738 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1739 } catch (Exception e) {
1740 trans.error().log(e,IN,DELETE_CRED);
1741 return Result.err(e);
1749 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1750 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
1752 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1753 if (Question.willSpecialLog(trans, trans.user())) {
1754 Question.logEncryptTrace(trans,data.asString());
1757 return service.doesCredentialMatch(trans, data.asObject());
1758 } catch (APIException e) {
1759 trans.error().log(e,"Bad Input data");
1760 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
1761 } catch (IOException e) {
1762 trans.error().log(e,IN,DOES_CRED_MATCH);
1763 return Result.err(e);
1771 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
1772 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
1774 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
1775 switch(result.status){
1777 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
1780 return Result.err(result);
1781 } catch (Exception e) {
1782 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
1783 return Result.err(e);
1790 * @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)
1793 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
1794 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
1796 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
1798 switch(rci.status) {
1800 if (Question.willSpecialLog(trans, trans.user())) {
1801 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
1802 Question.logEncryptTrace(trans,data.asString());
1803 data.to(resp.getOutputStream());
1805 certsDF.direct(trans, rci.value, resp.getOutputStream());
1807 setContentType(resp,certsDF.getOutType());
1810 return Result.err(rci);
1812 } catch (Exception e) {
1813 trans.error().log(e,IN,GET_CERT_BY_ID);
1814 return Result.err(e);
1820 public static final String CREATE_DELEGATE = "createDelegate";
1821 public static final String UPDATE_DELEGATE = "updateDelegate";
1822 public static final String DELETE_DELEGATE = "deleteDelegate";
1823 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
1824 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
1827 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1828 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
1830 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1831 if (Question.willSpecialLog(trans, trans.user())) {
1832 Question.logEncryptTrace(trans,data.asString());
1835 return service.createDelegate(trans, data.asObject());
1836 } catch (Exception e) {
1837 trans.error().log(e,IN,CREATE_DELEGATE);
1838 return Result.err(e);
1845 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1846 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
1848 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1849 if (Question.willSpecialLog(trans, trans.user())) {
1850 Question.logEncryptTrace(trans,data.asString());
1853 return service.updateDelegate(trans, data.asObject());
1854 } catch (Exception e) {
1855 trans.error().log(e,IN,UPDATE_DELEGATE);
1856 return Result.err(e);
1863 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1864 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
1866 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1867 if (Question.willSpecialLog(trans, trans.user())) {
1868 Question.logEncryptTrace(trans,data.asString());
1871 return service.deleteDelegate(trans, data.asObject());
1872 } catch (Exception e) {
1873 trans.error().log(e,IN,DELETE_DELEGATE);
1874 return Result.err(e);
1881 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
1882 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
1884 return service.deleteDelegate(trans, userName);
1885 } catch (Exception e) {
1886 trans.error().log(e,IN,DELETE_DELEGATE);
1887 return Result.err(e);
1894 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
1895 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
1897 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
1901 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1902 if (Question.willSpecialLog(trans, trans.user())) {
1903 Question.logEncryptTrace(trans,data.asString());
1905 data.to(resp.getOutputStream());
1906 setContentType(resp,delgDF.getOutType());
1909 return Result.err(rd);
1911 } catch (Exception e) {
1912 trans.error().log(e,IN,GET_DELEGATE_USER);
1913 return Result.err(e);
1920 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
1921 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
1923 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
1926 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1927 if (Question.willSpecialLog(trans, trans.user())) {
1928 Question.logEncryptTrace(trans,data.asString());
1930 data.to(resp.getOutputStream());
1931 setContentType(resp,delgDF.getOutType());
1934 return Result.err(rd);
1936 } catch (Exception e) {
1937 trans.error().log(e,IN,GET_DELEGATE_DELG);
1938 return Result.err(e);
1944 private static final String REQUEST_USER_ROLE = "createUserRole";
1945 private static final String GET_USERROLES = "getUserRoles";
1946 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
1947 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
1948 // private static final String SET_ROLES_FOR_USER = "setRolesForUser";
1949 // private static final String SET_USERS_FOR_ROLE = "setUsersForRole";
1950 private static final String EXTEND_USER_ROLE = "extendUserRole";
1951 private static final String DELETE_USER_ROLE = "deleteUserRole";
1953 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1954 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
1958 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
1959 if (Question.willSpecialLog(trans, trans.user())) {
1960 Question.logEncryptTrace(trans,data.asString());
1963 request = data.asObject();
1964 } catch (APIException e) {
1965 return Result.err(Status.ERR_BadData,"Invalid Input");
1968 Result<Void> rp = service.createUserRole(trans,request);
1971 setContentType(resp,permsDF.getOutType());
1974 return Result.err(rp);
1976 } catch (Exception e) {
1977 trans.error().log(e,IN,REQUEST_USER_ROLE);
1978 return Result.err(e);
1985 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
1986 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
1988 Result<USERS> ru = service.getUserInRole(trans,user,role);
1991 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1992 if (Question.willSpecialLog(trans, trans.user())) {
1993 Question.logEncryptTrace(trans,data.asString());
1996 data.to(resp.getOutputStream());
1997 setContentType(resp,usersDF.getOutType());
1998 setCacheControlOff(resp);
2001 return Result.err(ru);
2003 } catch (Exception e) {
2004 trans.error().log(e,IN,GET_USERROLES);
2005 return Result.err(e);
2013 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2014 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2016 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
2019 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2020 if (Question.willSpecialLog(trans, trans.user())) {
2021 Question.logEncryptTrace(trans,data.asString());
2024 data.to(resp.getOutputStream());
2025 setContentType(resp,usersDF.getOutType());
2026 setCacheControlOff(resp);
2029 return Result.err(ru);
2031 } catch (Exception e) {
2032 trans.error().log(e,IN,GET_USERROLES_BY_USER);
2033 return Result.err(e);
2041 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2042 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2044 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
2047 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
2048 if (Question.willSpecialLog(trans, trans.user())) {
2049 Question.logEncryptTrace(trans,data.asString());
2052 data.to(resp.getOutputStream());
2053 setContentType(resp,usersDF.getOutType());
2054 setCacheControlOff(resp);
2057 return Result.err(ru);
2059 } catch (Exception e) {
2060 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
2061 return Result.err(e);
2070 * @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)
2073 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2074 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2076 return service.extendUserRole(trans,user,role);
2077 } catch (Exception e) {
2078 trans.error().log(e,IN,EXTEND_USER_ROLE);
2079 return Result.err(e);
2086 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2087 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2089 Result<Void> rp = service.deleteUserRole(trans,user,role);
2092 setContentType(resp,permsDF.getOutType());
2095 return Result.err(rp);
2097 } catch (Exception e) {
2098 trans.error().log(e,IN,DELETE_USER_ROLE);
2099 return Result.err(e);
2105 private static final String UPDATE_APPROVAL = "updateApproval";
2106 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
2107 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
2108 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
2111 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
2112 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
2114 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
2115 if (Question.willSpecialLog(trans, trans.user())) {
2116 Question.logEncryptTrace(trans,data.asString());
2119 Result<Void> rp = service.updateApproval(trans, data.asObject());
2123 setContentType(resp,approvalDF.getOutType());
2126 return Result.err(rp);
2128 } catch (Exception e) {
2129 trans.error().log(e,IN,UPDATE_APPROVAL);
2130 return Result.err(e);
2137 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2138 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2140 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
2143 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2144 if (Question.willSpecialLog(trans, trans.user())) {
2145 Question.logEncryptTrace(trans,data.asString());
2147 data.to(resp.getOutputStream());
2149 setContentType(resp,permsDF.getOutType());
2152 return Result.err(rp);
2154 } catch (Exception e) {
2155 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
2156 return Result.err(e);
2163 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
2164 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
2166 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
2169 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2170 if (Question.willSpecialLog(trans, trans.user())) {
2171 Question.logEncryptTrace(trans,data.asString());
2174 data.to(resp.getOutputStream());
2175 setContentType(resp,permsDF.getOutType());
2178 return Result.err(rp);
2180 } catch (Exception e) {
2181 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
2182 return Result.err(e);
2189 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
2190 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
2192 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
2195 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2196 if (Question.willSpecialLog(trans, trans.user())) {
2197 Question.logEncryptTrace(trans,data.asString());
2200 data.to(resp.getOutputStream());
2201 setContentType(resp,permsDF.getOutType());
2204 return Result.err(rp);
2206 } catch (Exception e) {
2207 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
2208 return Result.err(e);
2216 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
2217 public static final String GET_USERS_ROLE = "getUsersByRole";
2220 * @see com.att.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2223 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2224 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2226 Result<USERS> ru = service.getUsersByRole(trans,role);
2229 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2230 if (Question.willSpecialLog(trans, trans.user())) {
2231 Question.logEncryptTrace(trans,data.asString());
2234 data.to(resp.getOutputStream());
2235 setContentType(resp,usersDF.getOutType());
2238 return Result.err(ru);
2240 } catch (Exception e) {
2241 trans.error().log(e,IN,GET_USERS_ROLE);
2242 return Result.err(e);
2249 * @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)
2252 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
2253 String type, String instance, String action) {
2254 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
2256 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
2259 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2260 if (Question.willSpecialLog(trans, trans.user())) {
2261 Question.logEncryptTrace(trans,data.asString());
2264 data.to(resp.getOutputStream());
2265 setContentType(resp,usersDF.getOutType());
2268 return Result.err(ru);
2270 } catch (Exception e) {
2271 trans.error().log(e,IN,GET_USERS_PERMISSION);
2272 return Result.err(e);
2279 public static final String GET_HISTORY_USER = "getHistoryByUser";
2280 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
2281 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
2282 public static final String GET_HISTORY_NS = "getHistoryByNS";
2283 public static final String GET_HISTORY_SUBJECT = "getHistoryBySubject";
2285 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2288 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
2289 StringBuilder sb = new StringBuilder();
2290 sb.append(GET_HISTORY_USER);
2294 boolean first = true;
2295 for (int i : yyyymm) {
2303 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2306 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
2309 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2310 if (Question.willSpecialLog(trans, trans.user())) {
2311 Question.logEncryptTrace(trans,data.asString());
2314 data.to(resp.getOutputStream());
2315 setContentType(resp,historyDF.getOutType());
2318 return Result.err(rh);
2320 } catch (Exception e) {
2321 trans.error().log(e,IN,GET_HISTORY_USER);
2322 return Result.err(e);
2329 * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2332 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
2333 StringBuilder sb = new StringBuilder();
2334 sb.append(GET_HISTORY_ROLE);
2338 boolean first = true;
2339 for (int i : yyyymm) {
2347 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2349 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
2352 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2353 if (Question.willSpecialLog(trans, trans.user())) {
2354 Question.logEncryptTrace(trans,data.asString());
2357 data.to(resp.getOutputStream());
2358 setContentType(resp,historyDF.getOutType());
2361 return Result.err(rh);
2363 } catch (Exception e) {
2364 trans.error().log(e,IN,GET_HISTORY_ROLE);
2365 return Result.err(e);
2372 * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2375 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
2376 StringBuilder sb = new StringBuilder();
2377 sb.append(GET_HISTORY_NS);
2381 boolean first = true;
2382 for (int i : yyyymm) {
2390 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2392 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
2395 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2396 if (Question.willSpecialLog(trans, trans.user())) {
2397 Question.logEncryptTrace(trans,data.asString());
2400 data.to(resp.getOutputStream());
2401 setContentType(resp,historyDF.getOutType());
2404 return Result.err(rh);
2406 } catch (Exception e) {
2407 trans.error().log(e,IN,GET_HISTORY_NS);
2408 return Result.err(e);
2415 * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2418 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
2419 StringBuilder sb = new StringBuilder();
2420 sb.append(GET_HISTORY_PERM);
2424 boolean first = true;
2425 for (int i : yyyymm) {
2433 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2435 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
2438 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2439 if (Question.willSpecialLog(trans, trans.user())) {
2440 Question.logEncryptTrace(trans,data.asString());
2443 data.to(resp.getOutputStream());
2444 setContentType(resp,historyDF.getOutType());
2447 return Result.err(rh);
2449 } catch (Exception e) {
2450 trans.error().log(e,IN,GET_HISTORY_PERM);
2451 return Result.err(e);
2458 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2461 public Result<Void> getHistoryBySubject(AuthzTrans trans, HttpServletResponse resp, String subject, String target, int[] yyyymm, final int sort) {
2462 StringBuilder sb = new StringBuilder();
2463 sb.append(GET_HISTORY_SUBJECT);
2467 boolean first = true;
2468 for (int i : yyyymm) {
2476 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2479 Result<HISTORY> rh = service.getHistoryBySubject(trans,subject,target,yyyymm,sort);
2482 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2483 if (Question.willSpecialLog(trans, trans.user())) {
2484 Question.logEncryptTrace(trans,data.asString());
2487 data.to(resp.getOutputStream());
2488 setContentType(resp,historyDF.getOutType());
2491 return Result.err(rh);
2493 } catch (Exception e) {
2494 trans.error().log(e,IN,GET_HISTORY_USER);
2495 return Result.err(e);
2501 public final static String CACHE_CLEAR = "cacheClear ";
2502 // public final static String CACHE_VALIDATE = "validateCache";
2505 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String)
2508 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
2509 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
2511 return service.cacheClear(trans,cname);
2512 } catch (Exception e) {
2513 trans.error().log(e,IN,CACHE_CLEAR);
2514 return Result.err(e);
2521 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.Integer)
2524 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
2525 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
2527 String[] segs = segments.split("\\s*,\\s*");
2528 int isegs[] = new int[segs.length];
2529 for (int i=0;i<segs.length;++i) {
2531 isegs[i] = Integer.parseInt(segs[i]);
2532 } catch (NumberFormatException nfe) {
2536 return service.cacheClear(trans,cname, isegs);
2537 } catch (Exception e) {
2538 trans.error().log(e,IN,CACHE_CLEAR);
2539 return Result.err(e);
2546 * @see com.att.authz.facade.AuthzFacade#dbReset(org.onap.aaf.auth.env.test.AuthzTrans)
2549 public void dbReset(AuthzTrans trans) {
2550 service.dbReset(trans);
2554 * @see com.att.authz.facade.AuthzFacade#getAPI(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse)
2556 public final static String API_REPORT = "apiReport";
2558 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
2559 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
2561 Api api = new Api();
2563 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
2564 for (RouteReport rr : rservlet.routeReport()) {
2565 api.getRoute().add(ar = new Api.Route());
2566 ar.setMeth(rr.meth.name());
2567 ar.setPath(rr.path);
2568 ar.setDesc(rr.desc);
2569 ar.getContentType().addAll(rr.contextTypes);
2570 for (Method m : meths) {
2572 if ((ad = m.getAnnotation(ApiDoc.class))!=null &&
2573 rr.meth.equals(ad.method()) &&
2574 rr.path.equals(ad.path())) {
2575 for (String param : ad.params()) {
2576 ar.getParam().add(param);
2578 for (String text : ad.text()) {
2579 ar.getComments().add(text);
2581 ar.setExpected(ad.expectedCode());
2582 for (int ec : ad.errorCodes()) {
2583 ar.getExplicitErr().add(ec);
2588 RosettaData<Api> data = apiDF.newData(trans).load(api);
2589 if (Question.willSpecialLog(trans, trans.user())) {
2590 Question.logEncryptTrace(trans,data.asString());
2593 data.to(resp.getOutputStream());
2594 setContentType(resp,apiDF.getOutType());
2597 } catch (Exception e) {
2598 trans.error().log(e,IN,API_REPORT);
2599 return Result.err(e);
2606 public final static String API_EXAMPLE = "apiExample";
2609 * @see com.att.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2612 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
2613 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
2615 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
2616 resp.getOutputStream().print(content);
2617 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
2619 } catch (Exception e) {
2620 trans.error().log(e,IN,API_EXAMPLE);
2621 return Result.err(Status.ERR_NotImplemented,e.getMessage());