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);
139 (roleDF = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);
140 (roleRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);
141 (usersDF = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);
142 (userrolesDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);
143 (certsDF = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)
144 .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));
145 (userRoleRequestDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);
146 (rolePermRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);
147 (nsRequestDF = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);
148 (credRequestDF = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);
149 (delgRequestDF = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);
150 (historyDF = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);
151 ( keysDF = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);
152 (delgDF = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);
153 (approvalDF = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);
154 (errDF = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);
155 (apiDF = env.newDataFactory(Api.class)).in(dataType).out(dataType);
158 public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {
159 return service.mapper();
163 * @see com.att.authz.facade.AuthzFacade#error(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
165 * Note: Conforms to AT&T TSS RESTful Error Structure
168 public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
169 String msg = result.details==null?"%s":"%s - " + result.details.trim();
172 boolean hidemsg = false;
173 if (result.variables==null || result.variables.length<1) {
174 detail = new String[1];
176 List<String> dlist = new ArrayList<>();
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);
187 switch(result.status) {
188 case ERR_ActionNotCompleted:
190 detail[0] = "Accepted, Action not complete";
191 response.setStatus(/*httpstatus=*/202);
196 detail[0] = FORBIDDEN;
197 response.setStatus(/*httpstatus=*/403);
201 detail[0] = FORBIDDEN;
202 response.setStatus(/*httpstatus=*/403);
206 detail[0] = FORBIDDEN;
207 response.setStatus(/*httpstatus=*/403);
209 // This is still forbidden to directly impact, but can be Requested when passed
210 // with "request=true" query Param
211 case ERR_FutureNotRequested:
214 response.setStatus(/*httpstatus=*/403);
219 detail[0] = NOT_FOUND;
220 response.setStatus(/*httpstatus=*/404);
222 case ERR_RoleNotFound:
224 detail[0] = NOT_FOUND;
225 response.setStatus(/*httpstatus=*/404);
227 case ERR_PermissionNotFound:
229 detail[0] = NOT_FOUND;
230 response.setStatus(/*httpstatus=*/404);
232 case ERR_UserNotFound:
234 detail[0] = NOT_FOUND;
235 response.setStatus(/*httpstatus=*/404);
237 case ERR_UserRoleNotFound:
239 detail[0] = NOT_FOUND;
240 response.setStatus(/*httpstatus=*/404);
242 case ERR_DelegateNotFound:
244 detail[0] = NOT_FOUND;
245 response.setStatus(/*httpstatus=*/404);
249 detail[0] = NOT_FOUND;
250 response.setStatus(/*httpstatus=*/404);
253 case ERR_InvalidDelegate:
255 detail[0] = NOT_ACCEPTABLE;
256 response.setStatus(/*httpstatus=*/406);
260 detail[0] = NOT_ACCEPTABLE;
261 response.setStatus(/*httpstatus=*/406);
264 case ERR_ConflictAlreadyExists:
266 detail[0] = "Conflict Already Exists";
267 response.setStatus(/*httpstatus=*/409);
270 case ERR_DependencyExists:
272 detail[0] = "Failed Dependency";
273 response.setStatus(/*httpstatus=*/424);
276 case ERR_NotImplemented:
278 detail[0] = "Not Implemented";
279 response.setStatus(/*httpstatus=*/501);
282 case Status.ACC_Future:
284 detail[0] = "Accepted for Future, pending Approvals";
285 response.setStatus(/*httpstatus=*/202);
287 case ERR_ChoiceNeeded:
289 detail[0] = "Choice Needed";
290 response.setStatus(/*httpstatus=*/300);
294 detail[0] = GENERAL_SERVICE_ERROR;
295 response.setStatus(/*httpstatus=*/500);
301 detail[0] = GENERAL_SERVICE_ERROR;
302 response.setStatus(/*httpstatus=*/500);
308 StringBuilder holder = new StringBuilder();
309 ERR em = service.mapper().errorFromMessage(holder,msgId,msg,detail);
318 em = mapper().errorFromMessage(holder, msgId, "Server had an issue processing this request");
320 errDF.newData(trans).load(em).to(response.getOutputStream());
321 } catch (Exception e) {
322 trans.error().log(e,"unable to send response for",msg);
326 ///////////////////////////
328 ///////////////////////////
329 public static final String CREATE_NS = "createNamespace";
330 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
331 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
332 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
333 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
334 public static final String GET_NS_BY_NAME = "getNamespaceByName";
335 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
336 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
337 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
338 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
339 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
340 public static final String DELETE_NS = "deleteNamespace";
341 public static final String INVALID_INPUT = "Invalid Input";
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(Result.ERR_BadData,INVALID_INPUT);
363 Result<Void> rp = service.createNS(trans,request,type);
365 if(rp.status == OK) {
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);
387 if(rp.status == OK) {
389 setContentType(resp,nsRequestDF.getOutType());
390 resp.getOutputStream().println();
393 return Result.err(rp);
395 } catch (Exception e) {
396 trans.error().log(e,IN,ADD_NS_ADMIN);
397 return Result.err(e);
404 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
407 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
408 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
410 Result<Void> rp = service.delAdminNS(trans, ns, id);
411 if(rp.status == OK) {
412 setContentType(resp,nsRequestDF.getOutType());
415 return Result.err(rp);
417 } catch (Exception e) {
418 trans.error().log(e,IN,DELETE_NS_ADMIN);
419 return Result.err(e);
426 * @see com.att.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
429 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
430 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
432 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
433 if(rp.status == OK) {
434 setContentType(resp,nsRequestDF.getOutType());
435 resp.getOutputStream().println();
438 return Result.err(rp);
440 } catch (Exception e) {
441 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
442 return Result.err(e);
449 * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.String)
452 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
453 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
455 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
456 if(rp.status == OK) {
457 setContentType(resp,nsRequestDF.getOutType());
458 resp.getOutputStream().println();
461 return Result.err(rp);
463 } catch (Exception e) {
464 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
465 return Result.err(e);
472 * @see com.att.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
475 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns, boolean full) {
476 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
478 Result<NSS> rp = service.getNSbyName(trans, ns, full );
479 if(rp.status == OK) {
480 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
481 if (Question.willSpecialLog(trans, trans.user())) {
482 Question.logEncryptTrace(trans,data.asString());
484 data.to(resp.getOutputStream());
485 setContentType(resp,nssDF.getOutType());
488 return Result.err(rp);
490 } catch (Exception e) {
491 trans.error().log(e,IN,GET_NS_BY_NAME);
492 return Result.err(e);
498 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
500 * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
503 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
504 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
506 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
507 if(rp.status == OK) {
508 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
509 if (Question.willSpecialLog(trans, trans.user())) {
510 Question.logEncryptTrace(trans,data.asString());
512 data.to(resp.getOutputStream());
513 setContentType(resp,nssDF.getOutType());
516 return Result.err(rp);
518 } catch (Exception e) {
519 trans.error().log(e,IN,GET_NS_BY_ADMIN);
520 return Result.err(e);
526 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
528 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
531 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
532 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
534 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
536 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
537 if (Question.willSpecialLog(trans, trans.user())) {
538 Question.logEncryptTrace(trans,data.asString());
540 data.to(resp.getOutputStream());
542 setContentType(resp,nssDF.getOutType());
545 return Result.err(rp);
547 } catch (Exception e) {
548 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
549 return Result.err(e);
556 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
559 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
560 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
562 Result<NSS> rp = service.getNSbyEither(trans, user, full);
563 if(rp.status == OK) {
564 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
565 if (Question.willSpecialLog(trans, trans.user())) {
566 Question.logEncryptTrace(trans,data.asString());
568 data.to(resp.getOutputStream());
570 setContentType(resp,nssDF.getOutType());
573 return Result.err(rp);
575 } catch (Exception e) {
576 trans.error().log(e,IN,GET_NS_BY_EITHER);
577 return Result.err(e);
584 * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
587 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
588 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
590 Result<NSS> rp = service.getNSsChildren(trans, parent);
591 if(rp.status == OK) {
592 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
593 if (Question.willSpecialLog(trans, trans.user())) {
594 Question.logEncryptTrace(trans,data.asString());
596 data.to(resp.getOutputStream());
597 setContentType(resp,nssDF.getOutType());
600 return Result.err(rp);
602 } catch (Exception e) {
603 trans.error().log(e,IN,GET_NS_CHILDREN);
604 return Result.err(e);
611 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
612 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
616 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
617 if (Question.willSpecialLog(trans, trans.user())) {
618 Question.logEncryptTrace(trans,data.asString());
620 rreq = data.asObject();
621 } catch (APIException e) {
622 trans.error().log(INVALID_INPUT,IN,UPDATE_NS_DESC);
623 return Result.err(Result.ERR_BadData,INVALID_INPUT);
626 Result<Void> rp = service.updateNsDescription(trans, rreq);
627 if(rp.status == OK) {
628 setContentType(resp,nsRequestDF.getOutType());
631 return Result.err(rp);
633 } catch (Exception e) {
634 trans.error().log(e,IN,UPDATE_NS_DESC);
635 return Result.err(e);
643 * @see com.att.authz.facade.AuthzFacade#requestNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
646 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
647 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
649 Result<Void> rp = service.deleteNS(trans,ns);
650 if(rp.status == OK) {
651 setContentType(resp,nsRequestDF.getOutType());
654 return Result.err(rp);
656 } catch (Exception e) {
657 trans.error().log(e,IN,DELETE_NS);
658 return Result.err(e);
664 private static final String NS_CREATE_ATTRIB = "nsCreateAttrib";
665 private static final String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
666 private static final String READ_NS_BY_ATTRIB = "readNsByAttrib";
667 private static final String NS_DELETE_ATTRIB = "nsDeleteAttrib";
670 * @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)
673 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
674 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
676 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
677 if(rp.status == OK) {
678 setContentType(resp, keysDF.getOutType());
679 resp.getOutputStream().println();
682 return Result.err(rp);
684 } catch (Exception e) {
685 trans.error().log(e,IN,NS_CREATE_ATTRIB);
686 return Result.err(e);
693 * @see com.att.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
696 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
697 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
699 Result<KEYS> rp = service.readNsByAttrib(trans, key);
700 if(rp.status == OK) {
701 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
702 if (Question.willSpecialLog(trans, trans.user())) {
703 Question.logEncryptTrace(trans,data.asString());
705 data.to(resp.getOutputStream());
706 setContentType(resp,keysDF.getOutType());
709 return Result.err(rp);
711 } catch (Exception e) {
712 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
713 return Result.err(e);
720 * @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)
723 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
724 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
726 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
727 if(rp.status == OK) {
728 setContentType(resp, keysDF.getOutType());
729 resp.getOutputStream().println();
732 return Result.err(rp);
734 } catch (Exception e) {
735 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
736 return Result.err(e);
744 * @see com.att.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
747 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
748 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
750 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
751 if(rp.status == OK) {
752 setContentType(resp, keysDF.getOutType());
753 resp.getOutputStream().println();
756 return Result.err(rp);
758 } catch (Exception e) {
759 trans.error().log(e,IN,NS_DELETE_ATTRIB);
760 return Result.err(e);
769 public static final String CREATE_PERMISSION = "createPermission";
770 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
771 public static final String GET_PERMS_BY_NAME = "getPermsByName";
772 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
773 public static final String GET_PERMISSIONS_BY_USER_SCOPE = "getPermissionsByUserScope";
774 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
775 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
776 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
777 public static final String UPDATE_PERMISSION = "updatePermission";
778 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
779 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
780 public static final String DELETE_PERMISSION = "deletePermission";
784 * @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)
787 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
788 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
792 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
793 if (Question.willSpecialLog(trans, trans.user())) {
794 Question.logEncryptTrace(trans,data.asString());
796 rreq = data.asObject();
797 } catch (APIException e) {
798 trans.error().log(INVALID_INPUT,IN,CREATE_PERMISSION);
799 return Result.err(Result.ERR_BadData,INVALID_INPUT);
802 Result<Void> rp = service.createPerm(trans,rreq);
803 if(rp.status == OK) {
804 setContentType(resp,permsDF.getOutType());
807 return Result.err(rp);
809 } catch (Exception e) {
810 trans.error().log(e,IN,CREATE_PERMISSION);
811 return Result.err(e);
818 * @see com.att.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
821 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
822 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
825 Result<PERMS> rp = service.getPermsByType(trans, perm);
826 if(rp.status == OK) {
827 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
828 if (Question.willSpecialLog(trans, trans.user())) {
829 Question.logEncryptTrace(trans,data.asString());
831 data.to(resp.getOutputStream());
832 setContentType(resp,permsDF.getOutType());
833 setCacheControlOff(resp);
836 return Result.err(rp);
838 } catch (Exception e) {
839 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
840 return Result.err(e);
847 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
848 String type, String instance, String action) {
850 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
851 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
854 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
855 if(rp.status == OK) {
856 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
857 if (Question.willSpecialLog(trans, trans.user())) {
858 Question.logEncryptTrace(trans,data.asString());
860 data.to(resp.getOutputStream());
861 setContentType(resp,permsDF.getOutType());
862 setCacheControlOff(resp);
865 return Result.err(rp);
867 } catch (Exception e) {
868 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
869 return Result.err(e);
876 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
879 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
880 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
882 Result<PERMS> rp = service.getPermsByUser(trans, user);
883 if(rp.status == OK) {
884 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
885 if (Question.willSpecialLog(trans, trans.user())) {
886 Question.logEncryptTrace(trans,data.asString());
888 data.to(resp.getOutputStream());
889 setContentType(resp,permsDF.getOutType());
890 setCacheControlOff(resp);
893 return Result.err(rp);
895 } catch (Exception e) {
896 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
897 return Result.err(e);
904 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
907 public Result<Void> getPermsByUserScope(AuthzTrans trans, HttpServletResponse resp, String user, String[] scopes) {
908 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_SCOPE + ' ' + user, Env.SUB|Env.ALWAYS);
910 Result<PERMS> rp = service.getPermsByUserScope(trans, user, scopes);
911 if(rp.status == OK) {
912 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
913 if (Question.willSpecialLog(trans, trans.user())) {
914 Question.logEncryptTrace(trans,data.asString());
916 data.to(resp.getOutputStream());
917 setContentType(resp,permsDF.getOutType());
918 setCacheControlOff(resp);
921 return Result.err(rp);
923 } catch (Exception e) {
924 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_SCOPE, user);
925 return Result.err(e);
934 * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
937 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
938 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
942 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
943 if (Question.willSpecialLog(trans, trans.user())) {
944 Question.logEncryptTrace(trans,data.asString());
946 perms = data.asObject();
947 } catch (APIException e) {
948 trans.error().log(INVALID_INPUT,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY);
949 return Result.err(Result.ERR_BadData,INVALID_INPUT);
952 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
953 if(rp.status == OK) {
954 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
955 if (Question.willSpecialLog(trans, trans.user())) {
956 Question.logEncryptTrace(trans,data.asString());
958 data.to(resp.getOutputStream());
959 setContentType(resp,permsDF.getOutType());
960 setCacheControlOff(resp);
963 return Result.err(rp);
965 } catch (Exception e) {
966 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
967 return Result.err(e);
975 * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
978 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
979 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
981 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
982 if(rp.status == OK) {
983 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
984 if (Question.willSpecialLog(trans, trans.user())) {
985 Question.logEncryptTrace(trans,data.asString());
987 data.to(resp.getOutputStream());
988 setContentType(resp,permsDF.getOutType());
989 setCacheControlOff(resp);
992 return Result.err(rp);
994 } catch (Exception e) {
995 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
996 return Result.err(e);
1003 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
1004 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1006 Result<PERMS> rp = service.getPermsByNS(trans, ns);
1007 if(rp.status == OK) {
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_NS);
1021 return Result.err(e);
1029 * @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)
1032 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
1033 String origType, String origInstance, String origAction) {
1034 String cmdDescription = UPDATE_PERMISSION;
1035 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
1039 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1040 if (Question.willSpecialLog(trans, trans.user())) {
1041 Question.logEncryptTrace(trans,data.asString());
1043 rreq = data.asObject();
1044 } catch (APIException e) {
1045 trans.error().log(INVALID_INPUT,IN,cmdDescription);
1046 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1049 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
1050 if(rp.status == OK) {
1051 setContentType(resp,permsDF.getOutType());
1054 return Result.err(rp);
1056 } catch (Exception e) {
1057 trans.error().log(e,IN,cmdDescription);
1058 return Result.err(e);
1065 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1066 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
1070 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1071 if (Question.willSpecialLog(trans, trans.user())) {
1072 Question.logEncryptTrace(trans,data.asString());
1074 rreq = data.asObject();
1075 } catch (APIException e) {
1076 trans.error().log(INVALID_INPUT,IN,UPDATE_PERM_DESC);
1077 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1080 Result<Void> rp = service.updatePermDescription(trans, rreq);
1081 if(rp.status == OK) {
1082 setContentType(resp,permRequestDF.getOutType());
1085 return Result.err(rp);
1087 } catch (Exception e) {
1088 trans.error().log(e,IN,UPDATE_PERM_DESC);
1089 return Result.err(e);
1097 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1098 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
1102 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1103 if (Question.willSpecialLog(trans, trans.user())) {
1104 Question.logEncryptTrace(trans,data.asString());
1106 rreq = data.asObject();
1107 } catch (APIException e) {
1108 trans.error().log(INVALID_INPUT,IN, SET_PERMISSION_ROLES_TO);
1109 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1112 Result<Void> rp = service.resetPermRoles(trans, rreq);
1113 if(rp.status == OK) {
1114 setContentType(resp,permsDF.getOutType());
1117 return Result.err(rp);
1119 } catch (Exception e) {
1120 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
1121 return Result.err(e);
1128 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1129 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
1133 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
1134 if (Question.willSpecialLog(trans, trans.user())) {
1135 Question.logEncryptTrace(trans,data.asString());
1137 rreq = data.asObject();
1138 } catch (APIException e) {
1139 trans.error().log(INVALID_INPUT,IN,DELETE_PERMISSION);
1140 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1144 Result<Void> rp = service.deletePerm(trans,rreq);
1145 if(rp.status == OK) {
1146 setContentType(resp,permsDF.getOutType());
1149 return Result.err(rp);
1151 } catch (Exception e) {
1152 trans.error().log(e,IN,DELETE_PERMISSION);
1153 return Result.err(e);
1160 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
1161 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
1163 Result<Void> rp = service.deletePerm(trans,type,instance,action);
1164 if(rp.status == OK) {
1165 setContentType(resp,permsDF.getOutType());
1168 return Result.err(rp);
1170 } catch (Exception e) {
1171 trans.error().log(e,IN,DELETE_PERMISSION);
1172 return Result.err(e);
1178 public static final String CREATE_ROLE = "createRole";
1179 public static final String GET_ROLES_BY_USER = "getRolesByUser";
1180 public static final String GET_ROLES_BY_NS = "getRolesByNS";
1181 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
1182 public static final String GET_ROLES_BY_NAME = "getRolesByName";
1183 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
1184 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
1185 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
1186 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
1187 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
1188 public static final String DELETE_ROLE = "deleteRole";
1189 public static final String GET_CERT_BY_ID = "getCertByID";
1192 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1193 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
1197 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1198 if (Question.willSpecialLog(trans, trans.user())) {
1199 Question.logEncryptTrace(trans,data.asString());
1201 rreq = data.asObject();
1202 } catch (APIException e) {
1203 trans.error().log(INVALID_INPUT,IN,CREATE_ROLE);
1204 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1207 Result<Void> rp = service.createRole(trans, rreq);
1208 if(rp.status == OK) {
1209 setContentType(resp,roleRequestDF.getOutType());
1212 return Result.err(rp);
1214 } catch (Exception e) {
1215 trans.error().log(e,IN,CREATE_ROLE);
1216 return Result.err(e);
1223 * @see com.att.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1226 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
1227 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
1229 Result<ROLES> rp = service.getRolesByName(trans, role);
1230 if(rp.status == OK) {
1231 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1232 if (Question.willSpecialLog(trans, trans.user())) {
1233 Question.logEncryptTrace(trans,data.asString());
1235 data.to(resp.getOutputStream());
1236 setContentType(resp,roleDF.getOutType());
1237 setCacheControlOff(resp);
1240 return Result.err(rp);
1242 } catch (Exception e) {
1243 trans.error().log(e,IN,GET_ROLES_BY_NAME);
1244 return Result.err(e);
1251 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1254 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
1255 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1257 Result<ROLES> rp = service.getRolesByUser(trans, user);
1258 if(rp.status == OK) {
1259 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1260 if (Question.willSpecialLog(trans, trans.user())) {
1261 Question.logEncryptTrace(trans,data.asString());
1263 data.to(resp.getOutputStream());
1264 setContentType(resp,roleDF.getOutType());
1265 setCacheControlOff(resp);
1268 return Result.err(rp);
1270 } catch (Exception e) {
1271 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
1272 return Result.err(e);
1279 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1282 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
1283 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1285 Result<ROLES> rp = service.getRolesByNS(trans, ns);
1286 if(rp.status == OK) {
1287 if (!rp.isEmpty()) {
1288 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1289 if (Question.willSpecialLog(trans, trans.user())) {
1290 Question.logEncryptTrace(trans,data.asString());
1292 data.to(resp.getOutputStream());
1294 Question.logEncryptTrace(trans, NO_DATA);
1296 setContentType(resp,roleDF.getOutType());
1297 setCacheControlOff(resp);
1300 return Result.err(rp);
1302 } catch (Exception e) {
1303 trans.error().log(e,IN,GET_ROLES_BY_NS);
1304 return Result.err(e);
1312 * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1315 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
1316 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
1318 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
1319 if(rp.status == OK) {
1320 if (!rp.isEmpty()) {
1321 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1322 if (Question.willSpecialLog(trans, trans.user())) {
1323 Question.logEncryptTrace(trans,data.asString());
1325 data.to(resp.getOutputStream());
1327 Question.logEncryptTrace(trans, NO_DATA);
1329 setContentType(resp,roleDF.getOutType());
1330 setCacheControlOff(resp);
1333 return Result.err(rp);
1336 } catch (Exception e) {
1337 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
1338 return Result.err(e);
1345 * @see com.att.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1348 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
1349 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
1351 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
1352 if(rp.status == OK) {
1353 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
1354 if (Question.willSpecialLog(trans, trans.user())) {
1355 Question.logEncryptTrace(trans,data.asString());
1357 data.to(resp.getOutputStream());
1358 setContentType(resp,roleDF.getOutType());
1359 setCacheControlOff(resp);
1362 return Result.err(rp);
1364 } catch (Exception e) {
1365 trans.error().log(e,IN,GET_ROLES_BY_PERM);
1366 return Result.err(e);
1374 * @see com.att.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
1377 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1378 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
1382 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1383 if (Question.willSpecialLog(trans, trans.user())) {
1384 Question.logEncryptTrace(trans,data.asString());
1386 rreq = data.asObject();
1387 } catch (APIException e) {
1388 trans.error().log(INVALID_INPUT,IN,UPDATE_ROLE_DESC);
1389 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1392 Result<Void> rp = service.updateRoleDescription(trans, rreq);
1393 if(rp.status == OK) {
1394 setContentType(resp,roleRequestDF.getOutType());
1399 } catch (Exception e) {
1400 trans.error().log(e,IN,UPDATE_ROLE_DESC);
1401 return Result.err(e);
1408 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1409 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
1413 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1414 if (Question.willSpecialLog(trans, trans.user())) {
1415 Question.logEncryptTrace(trans,data.asString());
1417 rreq = data.asObject();
1418 } catch (APIException e) {
1419 trans.error().log(INVALID_INPUT,IN,ADD_PERM_TO_ROLE);
1420 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1423 Result<Void> rp = service.addPermToRole(trans, rreq);
1424 if(rp.status == OK) {
1425 setContentType(resp,permsDF.getOutType());
1426 resp.getOutputStream().println();
1429 return Result.err(rp);
1431 } catch (Exception e) {
1432 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
1433 return Result.err(e);
1440 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1441 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1445 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
1446 if (Question.willSpecialLog(trans, trans.user())) {
1447 Question.logEncryptTrace(trans,data.asString());
1449 rreq = data.asObject();
1450 } catch (APIException e) {
1451 trans.error().log(INVALID_INPUT,IN,DELETE_PERM_FROM_ROLE);
1452 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1455 Result<Void> rp = service.delPermFromRole(trans, rreq);
1456 if(rp.status == OK) {
1457 setContentType(resp,permsDF.getOutType());
1458 resp.getOutputStream().println();
1461 return Result.err(rp);
1463 } catch (Exception e) {
1464 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1465 return Result.err(e);
1472 * @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)
1475 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletResponse resp, String role, String type,
1476 String instance, String action) {
1477 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
1479 Result<Void> rp = service.delPermFromRole(trans, role, type, instance, action);
1480 if(rp.status == OK) {
1481 setContentType(resp,permsDF.getOutType());
1482 resp.getOutputStream().println();
1485 return Result.err(rp);
1487 } catch (Exception e) {
1488 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
1489 return Result.err(e);
1496 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1497 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1499 Result<Void> rp = service.deleteRole(trans, role);
1500 if(rp.status == OK) {
1501 setContentType(resp,permsDF.getOutType());
1504 return Result.err(rp);
1506 } catch (Exception e) {
1507 trans.error().log(e,IN,DELETE_ROLE);
1508 return Result.err(e);
1515 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1516 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
1520 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
1521 if (Question.willSpecialLog(trans, trans.user())) {
1522 Question.logEncryptTrace(trans,data.asString());
1524 rreq = data.asObject();
1525 } catch (APIException e) {
1526 trans.error().log(INVALID_INPUT,IN,CREATE_ROLE);
1527 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1530 Result<Void> rp = service.deleteRole(trans, rreq);
1531 if(rp.status == OK) {
1532 setContentType(resp,permsDF.getOutType());
1535 return Result.err(rp);
1537 } catch (Exception e) {
1538 trans.error().log(e,IN,DELETE_ROLE);
1539 return Result.err(e);
1545 public static final String CREATE_CRED = "createUserCred";
1546 private static final String GET_CREDS_BY_NS = "getCredsByNS";
1547 private static final String GET_CREDS_BY_ID = "getCredsByID";
1548 public static final String UPDATE_CRED = "updateUserCred";
1549 public static final String EXTEND_CRED = "extendUserCred";
1550 public static final String DELETE_CRED = "deleteUserCred";
1551 public static final String DOES_CRED_MATCH = "doesCredMatch";
1552 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
1553 public static final String BAD_INPUT_DATA = "Bad Input data";
1562 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
1563 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
1565 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1566 if (Question.willSpecialLog(trans, trans.user())) {
1567 Question.logEncryptTrace(trans,data.asString());
1569 return service.createUserCred(trans, data.asObject());
1570 } catch (APIException e) {
1571 trans.error().log(e,BAD_INPUT_DATA);
1572 return Result.err(Result.ERR_BadData, e.getLocalizedMessage());
1573 } catch (Exception e) {
1574 trans.error().log(e,IN,CREATE_CRED);
1575 return Result.err(e);
1582 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
1583 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
1585 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1586 if (Question.willSpecialLog(trans, trans.user())) {
1587 Question.logEncryptTrace(trans,data.asString());
1590 return service.resetUserCred(trans, data.asObject());
1591 } catch (APIException e) {
1592 trans.error().log(e,BAD_INPUT_DATA);
1593 return Result.err(Result.ERR_BadData, e.getLocalizedMessage());
1594 } catch (Exception e) {
1595 trans.error().log(e,IN,UPDATE_CRED);
1596 return Result.err(e);
1603 * @see com.att.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
1606 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
1607 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
1609 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1610 if (Question.willSpecialLog(trans, trans.user())) {
1611 Question.logEncryptTrace(trans,data.asString());
1614 return service.extendUserCred(trans, data.asObject(), days);
1615 } catch (APIException e) {
1616 trans.error().log(e,BAD_INPUT_DATA);
1617 return Result.err(Result.ERR_BadData, e.getLocalizedMessage());
1618 } catch (Exception e) {
1619 trans.error().log(e,IN,EXTEND_CRED);
1620 return Result.err(e);
1627 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
1628 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
1631 Result<USERS> ru = service.getCredsByNS(trans,ns);
1632 if(ru.status == OK) {
1633 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1634 if (Question.willSpecialLog(trans,trans.user())) {
1635 Question.logEncryptTrace(trans,data.asString());
1637 data.to(resp.getOutputStream());
1638 setContentType(resp,usersDF.getOutType());
1641 return Result.err(ru);
1643 } catch (Exception e) {
1644 trans.error().log(e,IN,GET_CREDS_BY_NS);
1645 return Result.err(e);
1654 * @see com.att.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
1657 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
1658 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
1661 Result<USERS> ru = service.getCredsByID(trans,id);
1662 if(ru.status == OK) {
1663 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1664 if (Question.willSpecialLog(trans, trans.user())) {
1665 Question.logEncryptTrace(trans,data.asString());
1667 data.to(resp.getOutputStream());
1668 setContentType(resp,usersDF.getOutType());
1671 return Result.err(ru);
1673 } catch (Exception e) {
1674 trans.error().log(e,IN,GET_CREDS_BY_ID);
1675 return Result.err(e);
1683 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
1684 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
1686 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1687 if (Question.willSpecialLog(trans, trans.user())) {
1688 Question.logEncryptTrace(trans,data.asString());
1691 return service.deleteUserCred(trans, data.asObject());
1692 } catch (APIException e) {
1693 trans.error().log(e,BAD_INPUT_DATA);
1694 return Result.err(Result.ERR_BadData, e.getLocalizedMessage());
1695 } catch (Exception e) {
1696 trans.error().log(e,IN,DELETE_CRED);
1697 return Result.err(e);
1705 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1706 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
1708 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
1709 if (Question.willSpecialLog(trans, trans.user())) {
1710 Question.logEncryptTrace(trans,data.asString());
1713 return service.doesCredentialMatch(trans, data.asObject());
1714 } catch (APIException e) {
1715 trans.error().log(e,BAD_INPUT_DATA);
1716 return Result.err(Result.ERR_BadData, e.getLocalizedMessage());
1717 } catch (IOException e) {
1718 trans.error().log(e,IN,DOES_CRED_MATCH);
1719 return Result.err(e);
1727 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
1728 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
1730 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
1731 if(result.status == OK) {
1732 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
1735 return Result.err(result);
1736 } catch (Exception e) {
1737 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
1738 return Result.err(e);
1745 * @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)
1748 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
1749 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
1751 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
1753 if(rci.status == OK) {
1754 if (Question.willSpecialLog(trans, trans.user())) {
1755 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
1756 Question.logEncryptTrace(trans,data.asString());
1757 data.to(resp.getOutputStream());
1759 certsDF.direct(trans, rci.value, resp.getOutputStream());
1761 setContentType(resp,certsDF.getOutType());
1764 return Result.err(rci);
1766 } catch (Exception e) {
1767 trans.error().log(e,IN,GET_CERT_BY_ID);
1768 return Result.err(e);
1774 public static final String CREATE_DELEGATE = "createDelegate";
1775 public static final String UPDATE_DELEGATE = "updateDelegate";
1776 public static final String DELETE_DELEGATE = "deleteDelegate";
1777 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
1778 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
1781 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1782 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
1784 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1785 if (Question.willSpecialLog(trans, trans.user())) {
1786 Question.logEncryptTrace(trans,data.asString());
1789 return service.createDelegate(trans, data.asObject());
1790 } catch (Exception e) {
1791 trans.error().log(e,IN,CREATE_DELEGATE);
1792 return Result.err(e);
1799 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1800 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
1802 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1803 if (Question.willSpecialLog(trans, trans.user())) {
1804 Question.logEncryptTrace(trans,data.asString());
1807 return service.updateDelegate(trans, data.asObject());
1808 } catch (Exception e) {
1809 trans.error().log(e,IN,UPDATE_DELEGATE);
1810 return Result.err(e);
1817 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1818 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
1820 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
1821 if (Question.willSpecialLog(trans, trans.user())) {
1822 Question.logEncryptTrace(trans,data.asString());
1825 return service.deleteDelegate(trans, data.asObject());
1826 } catch (Exception e) {
1827 trans.error().log(e,IN,DELETE_DELEGATE);
1828 return Result.err(e);
1835 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
1836 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
1838 return service.deleteDelegate(trans, userName);
1839 } catch (Exception e) {
1840 trans.error().log(e,IN,DELETE_DELEGATE);
1841 return Result.err(e);
1848 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
1849 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
1851 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
1853 if(rd.status == OK) {
1854 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1855 if (Question.willSpecialLog(trans, trans.user())) {
1856 Question.logEncryptTrace(trans,data.asString());
1858 data.to(resp.getOutputStream());
1859 setContentType(resp,delgDF.getOutType());
1862 return Result.err(rd);
1864 } catch (Exception e) {
1865 trans.error().log(e,IN,GET_DELEGATE_USER);
1866 return Result.err(e);
1873 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
1874 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
1876 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
1877 if(rd.status == OK) {
1878 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
1879 if (Question.willSpecialLog(trans, trans.user())) {
1880 Question.logEncryptTrace(trans,data.asString());
1882 data.to(resp.getOutputStream());
1883 setContentType(resp,delgDF.getOutType());
1886 return Result.err(rd);
1888 } catch (Exception e) {
1889 trans.error().log(e,IN,GET_DELEGATE_DELG);
1890 return Result.err(e);
1896 private static final String REQUEST_USER_ROLE = "createUserRole";
1897 private static final String GET_USERROLES = "getUserRoles";
1898 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
1899 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
1900 private static final String EXTEND_USER_ROLE = "extendUserRole";
1901 private static final String DELETE_USER_ROLE = "deleteUserRole";
1903 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
1904 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
1908 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
1909 if (Question.willSpecialLog(trans, trans.user())) {
1910 Question.logEncryptTrace(trans,data.asString());
1913 request = data.asObject();
1914 } catch (APIException e) {
1915 return Result.err(Result.ERR_BadData,INVALID_INPUT);
1918 Result<Void> rp = service.createUserRole(trans,request);
1919 if(rp.status == OK) {
1920 setContentType(resp,permsDF.getOutType());
1923 return Result.err(rp);
1925 } catch (Exception e) {
1926 trans.error().log(e,IN,REQUEST_USER_ROLE);
1927 return Result.err(e);
1934 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
1935 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
1937 Result<USERS> ru = service.getUserInRole(trans,user,role);
1938 if(ru.status == OK) {
1939 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
1940 if (Question.willSpecialLog(trans, trans.user())) {
1941 Question.logEncryptTrace(trans,data.asString());
1944 data.to(resp.getOutputStream());
1945 setContentType(resp,usersDF.getOutType());
1946 setCacheControlOff(resp);
1949 return Result.err(ru);
1951 } catch (Exception e) {
1952 trans.error().log(e,IN,GET_USERROLES);
1953 return Result.err(e);
1961 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
1962 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
1964 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
1965 if(ru.status == OK) {
1966 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
1967 if (Question.willSpecialLog(trans, trans.user())) {
1968 Question.logEncryptTrace(trans,data.asString());
1971 data.to(resp.getOutputStream());
1972 setContentType(resp,usersDF.getOutType());
1973 setCacheControlOff(resp);
1976 return Result.err(ru);
1978 } catch (Exception e) {
1979 trans.error().log(e,IN,GET_USERROLES_BY_USER);
1980 return Result.err(e);
1988 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
1989 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
1991 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
1992 if(ru.status == OK) {
1993 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
1994 if (Question.willSpecialLog(trans, trans.user())) {
1995 Question.logEncryptTrace(trans,data.asString());
1998 data.to(resp.getOutputStream());
1999 setContentType(resp,usersDF.getOutType());
2000 setCacheControlOff(resp);
2003 return Result.err(ru);
2005 } catch (Exception e) {
2006 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
2007 return Result.err(e);
2016 * @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)
2019 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2020 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2022 return service.extendUserRole(trans,user,role);
2023 } catch (Exception e) {
2024 trans.error().log(e,IN,EXTEND_USER_ROLE);
2025 return Result.err(e);
2032 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
2033 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
2035 Result<Void> rp = service.deleteUserRole(trans,user,role);
2036 if(rp.status == OK) {
2037 setContentType(resp,permsDF.getOutType());
2040 return Result.err(rp);
2042 } catch (Exception e) {
2043 trans.error().log(e,IN,DELETE_USER_ROLE);
2044 return Result.err(e);
2050 private static final String UPDATE_APPROVAL = "updateApproval";
2051 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
2052 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
2053 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
2056 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
2057 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
2059 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
2060 if (Question.willSpecialLog(trans, trans.user())) {
2061 Question.logEncryptTrace(trans,data.asString());
2064 Result<Void> rp = service.updateApproval(trans, data.asObject());
2066 if(rp.status == OK) {
2067 setContentType(resp,approvalDF.getOutType());
2070 return Result.err(rp);
2072 } catch (Exception e) {
2073 trans.error().log(e,IN,UPDATE_APPROVAL);
2074 return Result.err(e);
2081 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
2082 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
2084 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
2085 if(rp.status == OK) {
2086 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2087 if (Question.willSpecialLog(trans, trans.user())) {
2088 Question.logEncryptTrace(trans,data.asString());
2090 data.to(resp.getOutputStream());
2092 setContentType(resp,permsDF.getOutType());
2095 return Result.err(rp);
2097 } catch (Exception e) {
2098 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
2099 return Result.err(e);
2106 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
2107 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
2109 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
2110 if(rp.status == OK) {
2111 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2112 if (Question.willSpecialLog(trans, trans.user())) {
2113 Question.logEncryptTrace(trans,data.asString());
2116 data.to(resp.getOutputStream());
2117 setContentType(resp,permsDF.getOutType());
2120 return Result.err(rp);
2122 } catch (Exception e) {
2123 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
2124 return Result.err(e);
2131 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
2132 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
2134 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
2135 if(rp.status == OK) {
2136 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
2137 if (Question.willSpecialLog(trans, trans.user())) {
2138 Question.logEncryptTrace(trans,data.asString());
2141 data.to(resp.getOutputStream());
2142 setContentType(resp,permsDF.getOutType());
2145 return Result.err(rp);
2147 } catch (Exception e) {
2148 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
2149 return Result.err(e);
2157 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
2158 public static final String GET_USERS_ROLE = "getUsersByRole";
2161 * @see com.att.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2164 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
2165 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
2167 Result<USERS> ru = service.getUsersByRole(trans,role);
2168 if(ru.status == OK) {
2169 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2170 if (Question.willSpecialLog(trans, trans.user())) {
2171 Question.logEncryptTrace(trans,data.asString());
2174 data.to(resp.getOutputStream());
2175 setContentType(resp,usersDF.getOutType());
2178 return Result.err(ru);
2180 } catch (Exception e) {
2181 trans.error().log(e,IN,GET_USERS_ROLE);
2182 return Result.err(e);
2189 * @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)
2192 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
2193 String type, String instance, String action) {
2194 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
2196 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
2197 if(ru.status == OK) {
2198 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
2199 if (Question.willSpecialLog(trans, trans.user())) {
2200 Question.logEncryptTrace(trans,data.asString());
2203 data.to(resp.getOutputStream());
2204 setContentType(resp,usersDF.getOutType());
2207 return Result.err(ru);
2209 } catch (Exception e) {
2210 trans.error().log(e,IN,GET_USERS_PERMISSION);
2211 return Result.err(e);
2218 public static final String GET_HISTORY_USER = "getHistoryByUser";
2219 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
2220 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
2221 public static final String GET_HISTORY_NS = "getHistoryByNS";
2222 public static final String GET_HISTORY_SUBJECT = "getHistoryBySubject";
2224 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2227 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
2228 StringBuilder sb = new StringBuilder();
2229 sb.append(GET_HISTORY_USER);
2233 boolean first = true;
2234 for (int i : yyyymm) {
2242 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2245 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
2246 if(rh.status == OK) {
2247 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2248 if (Question.willSpecialLog(trans, trans.user())) {
2249 Question.logEncryptTrace(trans,data.asString());
2252 data.to(resp.getOutputStream());
2253 setContentType(resp,historyDF.getOutType());
2256 return Result.err(rh);
2258 } catch (Exception e) {
2259 trans.error().log(e,IN,GET_HISTORY_USER);
2260 return Result.err(e);
2267 * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2270 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
2271 StringBuilder sb = new StringBuilder();
2272 sb.append(GET_HISTORY_ROLE);
2276 boolean first = true;
2277 for (int i : yyyymm) {
2285 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2287 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
2288 if(rh.status == OK) {
2289 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2290 if (Question.willSpecialLog(trans, trans.user())) {
2291 Question.logEncryptTrace(trans,data.asString());
2294 data.to(resp.getOutputStream());
2295 setContentType(resp,historyDF.getOutType());
2298 return Result.err(rh);
2300 } catch (Exception e) {
2301 trans.error().log(e,IN,GET_HISTORY_ROLE);
2302 return Result.err(e);
2309 * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2312 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
2313 StringBuilder sb = new StringBuilder();
2314 sb.append(GET_HISTORY_NS);
2318 boolean first = true;
2319 for (int i : yyyymm) {
2327 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2329 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
2330 if(rh.status == OK) {
2331 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2332 if (Question.willSpecialLog(trans, trans.user())) {
2333 Question.logEncryptTrace(trans,data.asString());
2336 data.to(resp.getOutputStream());
2337 setContentType(resp,historyDF.getOutType());
2340 return Result.err(rh);
2342 } catch (Exception e) {
2343 trans.error().log(e,IN,GET_HISTORY_NS);
2344 return Result.err(e);
2351 * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
2354 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
2355 StringBuilder sb = new StringBuilder();
2356 sb.append(GET_HISTORY_PERM);
2360 boolean first = true;
2361 for (int i : yyyymm) {
2369 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2371 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
2372 if(rh.status == OK) {
2373 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2374 if (Question.willSpecialLog(trans, trans.user())) {
2375 Question.logEncryptTrace(trans,data.asString());
2378 data.to(resp.getOutputStream());
2379 setContentType(resp,historyDF.getOutType());
2382 return Result.err(rh);
2384 } catch (Exception e) {
2385 trans.error().log(e,IN,GET_HISTORY_PERM);
2386 return Result.err(e);
2393 * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
2396 public Result<Void> getHistoryBySubject(AuthzTrans trans, HttpServletResponse resp, String subject, String target, int[] yyyymm, final int sort) {
2397 StringBuilder sb = new StringBuilder();
2398 sb.append(GET_HISTORY_SUBJECT);
2402 boolean first = true;
2403 for (int i : yyyymm) {
2411 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
2414 Result<HISTORY> rh = service.getHistoryBySubject(trans,subject,target,yyyymm,sort);
2415 if(rh.status == OK) {
2416 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
2417 if (Question.willSpecialLog(trans, trans.user())) {
2418 Question.logEncryptTrace(trans,data.asString());
2421 data.to(resp.getOutputStream());
2422 setContentType(resp,historyDF.getOutType());
2425 return Result.err(rh);
2427 } catch (Exception e) {
2428 trans.error().log(e,IN,GET_HISTORY_USER);
2429 return Result.err(e);
2435 public static final String CACHE_CLEAR = "cacheClear ";
2439 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String)
2442 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
2443 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
2445 return service.cacheClear(trans,cname);
2446 } catch (Exception e) {
2447 trans.error().log(e,IN,CACHE_CLEAR);
2448 return Result.err(e);
2455 * @see com.att.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.auth.env.test.AuthzTrans, java.lang.String, java.lang.Integer)
2458 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
2459 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
2461 String[] segs = segments.split("\\s*,\\s*");
2462 int[] isegs = new int[segs.length];
2463 for (int i=0;i<segs.length;++i) {
2465 isegs[i] = Integer.parseInt(segs[i]);
2466 } catch (NumberFormatException nfe) {
2470 return service.cacheClear(trans,cname, isegs);
2471 } catch (Exception e) {
2472 trans.error().log(e,IN,CACHE_CLEAR);
2473 return Result.err(e);
2480 * @see com.att.authz.facade.AuthzFacade#dbReset(org.onap.aaf.auth.env.test.AuthzTrans)
2483 public void dbReset(AuthzTrans trans) {
2484 service.dbReset(trans);
2488 * @see com.att.authz.facade.AuthzFacade#getAPI(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse)
2490 public static final String API_REPORT = "apiReport";
2492 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
2493 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
2495 Api api = new Api();
2497 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
2498 for (RouteReport rr : rservlet.routeReport()) {
2499 api.getRoute().add(ar = new Api.Route());
2500 ar.setMeth(rr.meth.name());
2501 ar.setPath(rr.path);
2502 ar.setDesc(rr.desc);
2503 ar.getContentType().addAll(rr.contextTypes);
2504 for (Method m : meths) {
2506 if ((ad = m.getAnnotation(ApiDoc.class))!=null &&
2507 rr.meth.equals(ad.method()) &&
2508 rr.path.equals(ad.path())) {
2509 for (String param : ad.params()) {
2510 ar.getParam().add(param);
2512 for (String text : ad.text()) {
2513 ar.getComments().add(text);
2515 ar.setExpected(ad.expectedCode());
2516 for (int ec : ad.errorCodes()) {
2517 ar.getExplicitErr().add(ec);
2522 RosettaData<Api> data = apiDF.newData(trans).load(api);
2523 if (Question.willSpecialLog(trans, trans.user())) {
2524 Question.logEncryptTrace(trans,data.asString());
2527 data.to(resp.getOutputStream());
2528 setContentType(resp,apiDF.getOutType());
2531 } catch (Exception e) {
2532 trans.error().log(e,IN,API_REPORT);
2533 return Result.err(e);
2540 public static final String API_EXAMPLE = "apiExample";
2543 * @see com.att.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.auth.env.test.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
2546 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
2547 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
2549 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
2550 resp.getOutputStream().print(content);
2551 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
2553 } catch (Exception e) {
2554 trans.error().log(e,IN,API_EXAMPLE);
2555 return Result.err(Result.ERR_NotImplemented,e.getMessage());