1 /*******************************************************************************
\r
2 * ============LICENSE_START====================================================
\r
4 * * ===========================================================================
\r
5 * * Copyright © 2017 AT&T Intellectual Property. All rights reserved.
\r
6 * * ===========================================================================
\r
7 * * Licensed under the Apache License, Version 2.0 (the "License");
\r
8 * * you may not use this file except in compliance with the License.
\r
9 * * You may obtain a copy of the License at
\r
11 * * http://www.apache.org/licenses/LICENSE-2.0
\r
13 * * Unless required by applicable law or agreed to in writing, software
\r
14 * * distributed under the License is distributed on an "AS IS" BASIS,
\r
15 * * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
16 * * See the License for the specific language governing permissions and
\r
17 * * limitations under the License.
\r
18 * * ============LICENSE_END====================================================
\r
20 * * ECOMP is a trademark and service mark of AT&T Intellectual Property.
\r
22 ******************************************************************************/
\r
23 package org.onap.aaf.authz.facade;
\r
25 import static org.onap.aaf.authz.layer.Result.ERR_ActionNotCompleted;
\r
26 import static org.onap.aaf.authz.layer.Result.ERR_Backend;
\r
27 import static org.onap.aaf.authz.layer.Result.ERR_BadData;
\r
28 import static org.onap.aaf.authz.layer.Result.ERR_ConflictAlreadyExists;
\r
29 import static org.onap.aaf.authz.layer.Result.ERR_Denied;
\r
30 import static org.onap.aaf.authz.layer.Result.ERR_NotFound;
\r
31 import static org.onap.aaf.authz.layer.Result.ERR_NotImplemented;
\r
32 import static org.onap.aaf.authz.layer.Result.ERR_Policy;
\r
33 import static org.onap.aaf.authz.layer.Result.ERR_Security;
\r
34 import static org.onap.aaf.authz.layer.Result.OK;
\r
35 import static org.onap.aaf.dao.aaf.cass.Status.ERR_ChoiceNeeded;
\r
36 import static org.onap.aaf.dao.aaf.cass.Status.ERR_DelegateNotFound;
\r
37 import static org.onap.aaf.dao.aaf.cass.Status.ERR_DependencyExists;
\r
38 import static org.onap.aaf.dao.aaf.cass.Status.ERR_FutureNotRequested;
\r
39 import static org.onap.aaf.dao.aaf.cass.Status.ERR_InvalidDelegate;
\r
40 import static org.onap.aaf.dao.aaf.cass.Status.ERR_NsNotFound;
\r
41 import static org.onap.aaf.dao.aaf.cass.Status.ERR_PermissionNotFound;
\r
42 import static org.onap.aaf.dao.aaf.cass.Status.ERR_RoleNotFound;
\r
43 import static org.onap.aaf.dao.aaf.cass.Status.ERR_UserNotFound;
\r
44 import static org.onap.aaf.dao.aaf.cass.Status.ERR_UserRoleNotFound;
\r
46 import java.io.IOException;
\r
47 import java.lang.reflect.Method;
\r
48 import java.util.Date;
\r
50 import javax.servlet.http.HttpServletRequest;
\r
51 import javax.servlet.http.HttpServletResponse;
\r
53 import org.onap.aaf.authz.env.AuthzEnv;
\r
54 import org.onap.aaf.authz.env.AuthzTrans;
\r
55 import org.onap.aaf.authz.layer.FacadeImpl;
\r
56 import org.onap.aaf.authz.layer.Result;
\r
57 import org.onap.aaf.authz.service.AuthzCassServiceImpl;
\r
58 import org.onap.aaf.authz.service.AuthzService;
\r
59 import org.onap.aaf.authz.service.mapper.Mapper;
\r
60 import org.onap.aaf.authz.service.mapper.Mapper.API;
\r
61 import org.onap.aaf.cssa.rserv.RServlet;
\r
62 import org.onap.aaf.cssa.rserv.RouteReport;
\r
63 import org.onap.aaf.cssa.rserv.doc.ApiDoc;
\r
64 import org.onap.aaf.dao.aaf.cass.NsType;
\r
65 import org.onap.aaf.dao.aaf.cass.Status;
\r
66 import org.onap.aaf.dao.aaf.hl.Question;
\r
68 import org.onap.aaf.cadi.aaf.client.Examples;
\r
69 import org.onap.aaf.inno.env.APIException;
\r
70 import org.onap.aaf.inno.env.Data;
\r
71 import org.onap.aaf.inno.env.Data.TYPE;
\r
72 import org.onap.aaf.inno.env.Env;
\r
73 import org.onap.aaf.inno.env.TimeTaken;
\r
74 import org.onap.aaf.inno.env.util.Chrono;
\r
75 import org.onap.aaf.rosetta.Marshal;
\r
76 import org.onap.aaf.rosetta.env.RosettaDF;
\r
77 import org.onap.aaf.rosetta.env.RosettaData;
\r
79 import aaf.v2_0.Api;
\r
84 * This Service Facade encapsulates the essence of the API Service can do, and provides
\r
85 * a single created object for elements such as RosettaDF.
\r
87 * The Responsibilities of this class are to:
\r
88 * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)
\r
89 * 2) Validate incoming data (if applicable)
\r
90 * 3) Convert the Service response into the right Format, and mark the Content Type
\r
91 * a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.
\r
92 * 4) Log Service info, warnings and exceptions as necessary
\r
93 * 5) When asked by the API layer, this will create and write Error content to the OutputStream
\r
95 * Note: This Class does NOT set the HTTP Status Code. That is up to the API layer, so that it can be
\r
96 * clearly coordinated with the API Documentation
\r
100 public abstract class AuthzFacadeImpl<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> extends FacadeImpl implements AuthzFacade
\r
102 private static final String FORBIDDEN = "Forbidden";
\r
103 private static final String NOT_FOUND = "Not Found";
\r
104 private static final String NOT_ACCEPTABLE = "Not Acceptable";
\r
105 private static final String GENERAL_SERVICE_ERROR = "General Service Error";
\r
106 private static final String NO_DATA = "***No Data***";
\r
107 private AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service = null;
\r
108 private final RosettaDF<NSS> nssDF;
\r
109 private final RosettaDF<PERMS> permsDF;
\r
110 private final RosettaDF<ROLES> roleDF;
\r
111 private final RosettaDF<USERS> usersDF;
\r
112 private final RosettaDF<USERROLES> userrolesDF;
\r
113 private final RosettaDF<CERTS> certsDF;
\r
114 private final RosettaDF<DELGS> delgDF;
\r
115 private final RosettaDF<REQUEST> permRequestDF;
\r
116 private final RosettaDF<REQUEST> roleRequestDF;
\r
117 private final RosettaDF<REQUEST> userRoleRequestDF;
\r
118 private final RosettaDF<REQUEST> rolePermRequestDF;
\r
119 private final RosettaDF<REQUEST> nsRequestDF;
\r
120 private final RosettaDF<REQUEST> credRequestDF;
\r
121 private final RosettaDF<REQUEST> delgRequestDF;
\r
122 private final RosettaDF<HISTORY> historyDF;
\r
123 private final RosettaDF<KEYS> keysDF;
\r
125 private final RosettaDF<ERR> errDF;
\r
126 private final RosettaDF<APPROVALS> approvalDF;
\r
127 // Note: Api is not different per Version
\r
128 private final RosettaDF<Api> apiDF;
\r
131 @SuppressWarnings("unchecked")
\r
132 public AuthzFacadeImpl(AuthzEnv env, AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service, Data.TYPE dataType) throws APIException {
\r
133 this.service = service;
\r
134 (nssDF = env.newDataFactory(service.mapper().getClass(API.NSS))).in(dataType).out(dataType);
\r
135 (permRequestDF = env.newDataFactory(service.mapper().getClass(API.PERM_REQ))).in(dataType).out(dataType);
\r
136 (permsDF = env.newDataFactory(service.mapper().getClass(API.PERMS))).in(dataType).out(dataType);
\r
137 // (permKeyDF = env.newDataFactory(service.mapper().getClass(API.PERM_KEY))).in(dataType).out(dataType);
\r
138 (roleDF = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);
\r
139 (roleRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);
\r
140 (usersDF = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);
\r
141 (userrolesDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);
\r
142 (certsDF = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)
\r
143 .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));
\r
145 (userRoleRequestDF = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);
\r
146 (rolePermRequestDF = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);
\r
147 (nsRequestDF = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);
\r
148 (credRequestDF = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);
\r
149 (delgRequestDF = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);
\r
150 (historyDF = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);
\r
151 ( keysDF = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);
\r
152 (delgDF = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);
\r
153 (approvalDF = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);
\r
154 (errDF = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);
\r
155 (apiDF = env.newDataFactory(Api.class)).in(dataType).out(dataType);
\r
158 public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {
\r
159 return service.mapper();
\r
163 * @see org.onap.aaf.authz.facade.AuthzFacade#error(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, int)
\r
165 * Note: Conforms to AT&T TSS RESTful Error Structure
\r
168 public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {
\r
169 String msg = result.details==null?"%s":"%s - " + result.details.trim();
\r
172 if(result.variables==null) {
\r
173 detail = new String[1];
\r
175 int l = result.variables.length;
\r
176 detail=new String[l+1];
\r
177 System.arraycopy(result.variables, 0, detail, 1, l);
\r
181 switch(result.status) {
\r
182 case ERR_ActionNotCompleted:
\r
184 detail[0] = "Accepted, Action not complete";
\r
185 response.setStatus(/*httpstatus=*/202);
\r
190 detail[0] = FORBIDDEN;
\r
191 response.setStatus(/*httpstatus=*/403);
\r
195 detail[0] = FORBIDDEN;
\r
196 response.setStatus(/*httpstatus=*/403);
\r
200 detail[0] = FORBIDDEN;
\r
201 response.setStatus(/*httpstatus=*/403);
\r
203 // This is still forbidden to directly impact, but can be Requested when passed
\r
204 // with "request=true" query Param
\r
205 case ERR_FutureNotRequested:
\r
208 response.setStatus(/*httpstatus=*/403);
\r
211 case ERR_NsNotFound:
\r
213 detail[0] = NOT_FOUND;
\r
214 response.setStatus(/*httpstatus=*/404);
\r
216 case ERR_RoleNotFound:
\r
218 detail[0] = NOT_FOUND;
\r
219 response.setStatus(/*httpstatus=*/404);
\r
221 case ERR_PermissionNotFound:
\r
223 detail[0] = NOT_FOUND;
\r
224 response.setStatus(/*httpstatus=*/404);
\r
226 case ERR_UserNotFound:
\r
228 detail[0] = NOT_FOUND;
\r
229 response.setStatus(/*httpstatus=*/404);
\r
231 case ERR_UserRoleNotFound:
\r
233 detail[0] = NOT_FOUND;
\r
234 response.setStatus(/*httpstatus=*/404);
\r
236 case ERR_DelegateNotFound:
\r
238 detail[0] = NOT_FOUND;
\r
239 response.setStatus(/*httpstatus=*/404);
\r
243 detail[0] = NOT_FOUND;
\r
244 response.setStatus(/*httpstatus=*/404);
\r
247 case ERR_InvalidDelegate:
\r
249 detail[0] = NOT_ACCEPTABLE;
\r
250 response.setStatus(/*httpstatus=*/406);
\r
254 detail[0] = NOT_ACCEPTABLE;
\r
255 response.setStatus(/*httpstatus=*/406);
\r
258 case ERR_ConflictAlreadyExists:
\r
260 detail[0] = "Conflict Already Exists";
\r
261 response.setStatus(/*httpstatus=*/409);
\r
264 case ERR_DependencyExists:
\r
266 detail[0] = "Failed Dependency";
\r
267 response.setStatus(/*httpstatus=*/424);
\r
270 case ERR_NotImplemented:
\r
272 detail[0] = "Not Implemented";
\r
273 response.setStatus(/*httpstatus=*/501);
\r
276 case Status.ACC_Future:
\r
278 detail[0] = "Accepted for Future, pending Approvals";
\r
279 response.setStatus(/*httpstatus=*/202);
\r
281 case ERR_ChoiceNeeded:
\r
283 detail = result.variables;
\r
284 response.setStatus(/*httpstatus=*/300);
\r
288 detail[0] = GENERAL_SERVICE_ERROR;
\r
289 response.setStatus(/*httpstatus=*/500);
\r
294 detail[0] = GENERAL_SERVICE_ERROR;
\r
295 response.setStatus(/*httpstatus=*/500);
\r
300 StringBuilder holder = new StringBuilder();
\r
301 errDF.newData(trans).load(
\r
303 .errorFromMessage(holder,msgId,msg,detail))
\r
304 .to(response.getOutputStream());
\r
307 // String.format("ErrResp [" + msgId + "] " + msg,(Object[])detail),
\r
309 } catch (Exception e) {
\r
310 trans.error().log(e,"unable to send response for",msg);
\r
314 ///////////////////////////
\r
316 ///////////////////////////
\r
317 public static final String CREATE_NS = "createNamespace";
\r
318 public static final String ADD_NS_ADMIN = "addNamespaceAdmin";
\r
319 public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";
\r
320 public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";
\r
321 public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";
\r
322 public static final String GET_NS_BY_NAME = "getNamespaceByName";
\r
323 public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";
\r
324 public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";
\r
325 public static final String GET_NS_BY_EITHER = "getNamespaceByEither";
\r
326 public static final String GET_NS_CHILDREN = "getNamespaceChildren";
\r
327 public static final String UPDATE_NS_DESC = "updateNamespaceDescription";
\r
328 public static final String DELETE_NS = "deleteNamespace";
\r
332 * @see org.onap.aaf.authz.facade.AuthzFacade#createNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
\r
335 public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {
\r
336 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);
\r
340 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());
\r
341 if(Question.willSpecialLog(trans, trans.user())) {
\r
342 Question.logEncryptTrace(trans,rd.asString());
\r
344 request = rd.asObject();
\r
345 } catch(APIException e) {
\r
346 trans.error().log("Invalid Input",IN,CREATE_NS);
\r
347 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
350 Result<Void> rp = service.createNS(trans,request,type);
\r
351 switch(rp.status) {
\r
353 setContentType(resp,nsRequestDF.getOutType());
\r
354 return Result.ok();
\r
356 return Result.err(rp);
\r
358 } catch (Exception e) {
\r
359 trans.error().log(e,IN,CREATE_NS);
\r
360 return Result.err(e);
\r
367 * @see org.onap.aaf.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)
\r
370 public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
\r
371 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
\r
373 Result<Void> rp = service.addAdminNS(trans,ns,id);
\r
374 switch(rp.status) {
\r
377 setContentType(resp,nsRequestDF.getOutType());
\r
378 resp.getOutputStream().println();
\r
379 return Result.ok();
\r
381 return Result.err(rp);
\r
383 } catch (Exception e) {
\r
384 trans.error().log(e,IN,ADD_NS_ADMIN);
\r
385 return Result.err(e);
\r
392 * @see org.onap.aaf.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)
\r
395 public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
\r
396 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
\r
398 Result<Void> rp = service.delAdminNS(trans, ns, id);
\r
399 switch(rp.status) {
\r
401 setContentType(resp,nsRequestDF.getOutType());
\r
402 return Result.ok();
\r
404 return Result.err(rp);
\r
406 } catch (Exception e) {
\r
407 trans.error().log(e,IN,DELETE_NS_ADMIN);
\r
408 return Result.err(e);
\r
415 * @see org.onap.aaf.authz.facade.AuthzFacade#addAdminToNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)
\r
418 public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
\r
419 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
\r
421 Result<Void> rp = service.addResponsibleNS(trans,ns,id);
\r
422 switch(rp.status) {
\r
424 setContentType(resp,nsRequestDF.getOutType());
\r
425 resp.getOutputStream().println();
\r
426 return Result.ok();
\r
428 return Result.err(rp);
\r
430 } catch (Exception e) {
\r
431 trans.error().log(e,IN,ADD_NS_RESPONSIBLE);
\r
432 return Result.err(e);
\r
439 * @see org.onap.aaf.authz.facade.AuthzFacade#delAdminFromNS(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.String)
\r
442 public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {
\r
443 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);
\r
445 Result<Void> rp = service.delResponsibleNS(trans, ns, id);
\r
446 switch(rp.status) {
\r
448 setContentType(resp,nsRequestDF.getOutType());
\r
449 resp.getOutputStream().println();
\r
450 return Result.ok();
\r
452 return Result.err(rp);
\r
454 } catch (Exception e) {
\r
455 trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);
\r
456 return Result.err(e);
\r
463 * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByName(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
466 public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns) {
\r
467 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);
\r
469 Result<NSS> rp = service.getNSbyName(trans, ns);
\r
470 switch(rp.status) {
\r
472 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
\r
473 if(Question.willSpecialLog(trans, trans.user())) {
\r
474 Question.logEncryptTrace(trans,data.asString());
\r
476 data.to(resp.getOutputStream());
\r
477 setContentType(resp,nssDF.getOutType());
\r
478 return Result.ok();
\r
480 return Result.err(rp);
\r
482 } catch (Exception e) {
\r
483 trans.error().log(e,IN,GET_NS_BY_NAME);
\r
484 return Result.err(e);
\r
490 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
\r
492 * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByAdmin(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
495 public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
\r
496 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);
\r
498 Result<NSS> rp = service.getNSbyAdmin(trans, user, full);
\r
499 switch(rp.status) {
\r
501 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
\r
502 if(Question.willSpecialLog(trans, trans.user())) {
\r
503 Question.logEncryptTrace(trans,data.asString());
\r
505 data.to(resp.getOutputStream());
\r
506 setContentType(resp,nssDF.getOutType());
\r
507 return Result.ok();
\r
509 return Result.err(rp);
\r
511 } catch (Exception e) {
\r
512 trans.error().log(e,IN,GET_NS_BY_ADMIN);
\r
513 return Result.err(e);
\r
519 // TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page
\r
521 * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
524 public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
\r
525 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);
\r
527 Result<NSS> rp = service.getNSbyResponsible(trans, user, full);
\r
528 switch(rp.status) {
\r
530 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
\r
531 if(Question.willSpecialLog(trans, trans.user())) {
\r
532 Question.logEncryptTrace(trans,data.asString());
\r
534 data.to(resp.getOutputStream());
\r
536 setContentType(resp,nssDF.getOutType());
\r
537 return Result.ok();
\r
539 return Result.err(rp);
\r
541 } catch (Exception e) {
\r
542 trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);
\r
543 return Result.err(e);
\r
550 * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
553 public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){
\r
554 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);
\r
556 Result<NSS> rp = service.getNSbyEither(trans, user, full);
\r
558 switch(rp.status) {
\r
560 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
\r
561 if(Question.willSpecialLog(trans, trans.user())) {
\r
562 Question.logEncryptTrace(trans,data.asString());
\r
564 data.to(resp.getOutputStream());
\r
566 setContentType(resp,nssDF.getOutType());
\r
567 return Result.ok();
\r
569 return Result.err(rp);
\r
571 } catch (Exception e) {
\r
572 trans.error().log(e,IN,GET_NS_BY_EITHER);
\r
573 return Result.err(e);
\r
580 * @see org.onap.aaf.authz.facade.AuthzFacade#getNSsByResponsible(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
583 public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){
\r
584 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);
\r
586 Result<NSS> rp = service.getNSsChildren(trans, parent);
\r
587 switch(rp.status) {
\r
589 RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);
\r
590 if(Question.willSpecialLog(trans, trans.user())) {
\r
591 Question.logEncryptTrace(trans,data.asString());
\r
593 data.to(resp.getOutputStream());
\r
594 setContentType(resp,nssDF.getOutType());
\r
595 return Result.ok();
\r
597 return Result.err(rp);
\r
599 } catch (Exception e) {
\r
600 trans.error().log(e,IN,GET_NS_CHILDREN);
\r
601 return Result.err(e);
\r
608 public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
609 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);
\r
613 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());
\r
614 if(Question.willSpecialLog(trans, trans.user())) {
\r
615 Question.logEncryptTrace(trans,data.asString());
\r
617 rreq = data.asObject();
\r
618 } catch(APIException e) {
\r
619 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);
\r
620 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
623 Result<Void> rp = service.updateNsDescription(trans, rreq);
\r
624 switch(rp.status) {
\r
626 setContentType(resp,nsRequestDF.getOutType());
\r
627 return Result.ok();
\r
629 return Result.err(rp);
\r
631 } catch (Exception e) {
\r
632 trans.error().log(e,IN,UPDATE_NS_DESC);
\r
633 return Result.err(e);
\r
641 * @see org.onap.aaf.authz.facade.AuthzFacade#requestNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
\r
644 public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {
\r
645 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
\r
647 Result<Void> rp = service.deleteNS(trans,ns);
\r
648 switch(rp.status) {
\r
650 setContentType(resp,nsRequestDF.getOutType());
\r
651 return Result.ok();
\r
653 return Result.err(rp);
\r
655 } catch (Exception e) {
\r
656 trans.error().log(e,IN,DELETE_NS);
\r
657 return Result.err(e);
\r
663 private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";
\r
664 private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";
\r
665 private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";
\r
666 private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";
\r
669 * @see org.onap.aaf.authz.facade.AuthzFacade#createAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
\r
672 public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
\r
673 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
\r
675 Result<?> rp = service.createNsAttrib(trans,ns,key,value);
\r
676 switch(rp.status) {
\r
678 setContentType(resp, keysDF.getOutType());
\r
679 resp.getOutputStream().println();
\r
680 return Result.ok();
\r
682 return Result.err(rp);
\r
684 } catch (Exception e) {
\r
685 trans.error().log(e,IN,NS_CREATE_ATTRIB);
\r
686 return Result.err(e);
\r
693 * @see org.onap.aaf.authz.facade.AuthzFacade#readAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
696 public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {
\r
697 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);
\r
699 Result<KEYS> rp = service.readNsByAttrib(trans, key);
\r
700 switch(rp.status) {
\r
702 RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);
\r
703 if(Question.willSpecialLog(trans, trans.user())) {
\r
704 Question.logEncryptTrace(trans,data.asString());
\r
706 data.to(resp.getOutputStream());
\r
707 setContentType(resp,keysDF.getOutType());
\r
708 return Result.ok();
\r
710 return Result.err(rp);
\r
712 } catch (Exception e) {
\r
713 trans.error().log(e,IN,READ_NS_BY_ATTRIB);
\r
714 return Result.err(e);
\r
721 * @see org.onap.aaf.authz.facade.AuthzFacade#updAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
\r
724 public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {
\r
725 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);
\r
727 Result<?> rp = service.updateNsAttrib(trans,ns,key,value);
\r
728 switch(rp.status) {
\r
730 setContentType(resp, keysDF.getOutType());
\r
731 resp.getOutputStream().println();
\r
732 return Result.ok();
\r
734 return Result.err(rp);
\r
736 } catch (Exception e) {
\r
737 trans.error().log(e,IN,NS_UPDATE_ATTRIB);
\r
738 return Result.err(e);
\r
746 * @see org.onap.aaf.authz.facade.AuthzFacade#delAttribForNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
\r
749 public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {
\r
750 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);
\r
752 Result<?> rp = service.deleteNsAttrib(trans,ns,key);
\r
753 switch(rp.status) {
\r
755 setContentType(resp, keysDF.getOutType());
\r
756 resp.getOutputStream().println();
\r
757 return Result.ok();
\r
759 return Result.err(rp);
\r
761 } catch (Exception e) {
\r
762 trans.error().log(e,IN,NS_DELETE_ATTRIB);
\r
763 return Result.err(e);
\r
772 public static final String CREATE_PERMISSION = "createPermission";
\r
773 public static final String GET_PERMS_BY_TYPE = "getPermsByType";
\r
774 public static final String GET_PERMS_BY_NAME = "getPermsByName";
\r
775 public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";
\r
776 public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";
\r
777 public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";
\r
778 public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";
\r
779 public static final String UPDATE_PERMISSION = "updatePermission";
\r
780 public static final String UPDATE_PERM_DESC = "updatePermissionDescription";
\r
781 public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";
\r
782 public static final String DELETE_PERMISSION = "deletePermission";
\r
786 * @see org.onap.aaf.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
\r
789 public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
790 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);
\r
794 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
\r
795 if(Question.willSpecialLog(trans, trans.user())) {
\r
796 Question.logEncryptTrace(trans,data.asString());
\r
798 rreq = data.asObject();
\r
799 } catch(APIException e) {
\r
800 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
\r
801 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
804 Result<Void> rp = service.createPerm(trans,rreq);
\r
805 switch(rp.status) {
\r
807 setContentType(resp,permsDF.getOutType());
\r
808 return Result.ok();
\r
810 return Result.err(rp);
\r
812 } catch (Exception e) {
\r
813 trans.error().log(e,IN,CREATE_PERMISSION);
\r
814 return Result.err(e);
\r
821 * @see org.onap.aaf.authz.facade.AuthzFacade#getChildPerms(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
824 public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {
\r
825 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);
\r
828 Result<PERMS> rp = service.getPermsByType(trans, perm);
\r
829 switch(rp.status) {
\r
831 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
832 if(Question.willSpecialLog(trans, trans.user())) {
\r
833 Question.logEncryptTrace(trans,data.asString());
\r
835 data.to(resp.getOutputStream());
\r
836 setContentType(resp,permsDF.getOutType());
\r
837 return Result.ok();
\r
839 return Result.err(rp);
\r
841 } catch (Exception e) {
\r
842 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
\r
843 return Result.err(e);
\r
850 public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp,
\r
851 String type, String instance, String action) {
\r
853 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type
\r
854 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);
\r
857 Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);
\r
858 switch(rp.status) {
\r
860 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
861 if(Question.willSpecialLog(trans, trans.user())) {
\r
862 Question.logEncryptTrace(trans,data.asString());
\r
864 data.to(resp.getOutputStream());
\r
865 setContentType(resp,permsDF.getOutType());
\r
866 return Result.ok();
\r
868 return Result.err(rp);
\r
870 } catch (Exception e) {
\r
871 trans.error().log(e,IN,GET_PERMS_BY_TYPE);
\r
872 return Result.err(e);
\r
879 * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
882 public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
\r
883 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
\r
885 Result<PERMS> rp = service.getPermsByUser(trans, user);
\r
886 switch(rp.status) {
\r
888 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
889 if(Question.willSpecialLog(trans, trans.user())) {
\r
890 Question.logEncryptTrace(trans,data.asString());
\r
892 data.to(resp.getOutputStream());
\r
893 setContentType(resp,permsDF.getOutType());
\r
894 return Result.ok();
\r
896 return Result.err(rp);
\r
898 } catch (Exception e) {
\r
899 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);
\r
900 return Result.err(e);
\r
907 * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
910 public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {
\r
911 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);
\r
915 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());
\r
916 if(Question.willSpecialLog(trans, trans.user())) {
\r
917 Question.logEncryptTrace(trans,data.asString());
\r
919 perms = data.asObject();
\r
920 } catch(APIException e) {
\r
921 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);
\r
922 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
925 Result<PERMS> rp = service.getPermsByUser(trans, perms, user);
\r
926 switch(rp.status) {
\r
928 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
929 if(Question.willSpecialLog(trans, trans.user())) {
\r
930 Question.logEncryptTrace(trans,data.asString());
\r
932 data.to(resp.getOutputStream());
\r
933 setContentType(resp,permsDF.getOutType());
\r
934 return Result.ok();
\r
936 return Result.err(rp);
\r
938 } catch (Exception e) {
\r
939 trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);
\r
940 return Result.err(e);
\r
948 * @see org.onap.aaf.authz.facade.AuthzFacade#getPermissionsForRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
951 public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {
\r
952 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);
\r
954 Result<PERMS> rp = service.getPermsByRole(trans, roleName);
\r
955 switch(rp.status) {
\r
957 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
958 if(Question.willSpecialLog(trans, trans.user())) {
\r
959 Question.logEncryptTrace(trans,data.asString());
\r
961 data.to(resp.getOutputStream());
\r
962 setContentType(resp,permsDF.getOutType());
\r
963 return Result.ok();
\r
965 return Result.err(rp);
\r
967 } catch (Exception e) {
\r
968 trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);
\r
969 return Result.err(e);
\r
976 public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {
\r
977 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
\r
979 Result<PERMS> rp = service.getPermsByNS(trans, ns);
\r
980 switch(rp.status) {
\r
982 RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);
\r
983 if(Question.willSpecialLog(trans, trans.user())) {
\r
984 Question.logEncryptTrace(trans,data.asString());
\r
986 data.to(resp.getOutputStream());
\r
987 setContentType(resp,permsDF.getOutType());
\r
988 return Result.ok();
\r
990 return Result.err(rp);
\r
992 } catch (Exception e) {
\r
993 trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);
\r
994 return Result.err(e);
\r
1002 * @see org.onap.aaf.authz.facade.AuthzFacade#createOrUpdatePerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)
\r
1005 public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,
\r
1006 String origType, String origInstance, String origAction) {
\r
1007 String cmdDescription = UPDATE_PERMISSION;
\r
1008 TimeTaken tt = trans.start( cmdDescription + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);
\r
1012 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
\r
1013 if(Question.willSpecialLog(trans, trans.user())) {
\r
1014 Question.logEncryptTrace(trans,data.asString());
\r
1016 rreq = data.asObject();
\r
1017 } catch(APIException e) {
\r
1018 trans.error().log("Invalid Input",IN,cmdDescription);
\r
1019 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1022 Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);
\r
1023 switch(rp.status) {
\r
1025 setContentType(resp,permsDF.getOutType());
\r
1026 return Result.ok();
\r
1028 return Result.err(rp);
\r
1030 } catch (Exception e) {
\r
1031 trans.error().log(e,IN,cmdDescription);
\r
1032 return Result.err(e);
\r
1039 public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1040 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);
\r
1044 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
\r
1045 if(Question.willSpecialLog(trans, trans.user())) {
\r
1046 Question.logEncryptTrace(trans,data.asString());
\r
1048 rreq = data.asObject();
\r
1049 } catch(APIException e) {
\r
1050 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);
\r
1051 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1054 Result<Void> rp = service.updatePermDescription(trans, rreq);
\r
1055 switch(rp.status) {
\r
1057 setContentType(resp,permRequestDF.getOutType());
\r
1058 return Result.ok();
\r
1060 return Result.err(rp);
\r
1062 } catch (Exception e) {
\r
1063 trans.error().log(e,IN,UPDATE_PERM_DESC);
\r
1064 return Result.err(e);
\r
1072 public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1073 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);
\r
1077 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
\r
1078 if(Question.willSpecialLog(trans, trans.user())) {
\r
1079 Question.logEncryptTrace(trans,data.asString());
\r
1081 rreq = data.asObject();
\r
1082 } catch(APIException e) {
\r
1083 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);
\r
1084 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1087 Result<Void> rp = service.resetPermRoles(trans, rreq);
\r
1089 switch(rp.status) {
\r
1091 setContentType(resp,permsDF.getOutType());
\r
1092 return Result.ok();
\r
1094 return Result.err(rp);
\r
1096 } catch (Exception e) {
\r
1097 trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);
\r
1098 return Result.err(e);
\r
1105 public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1106 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);
\r
1110 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());
\r
1111 if(Question.willSpecialLog(trans, trans.user())) {
\r
1112 Question.logEncryptTrace(trans,data.asString());
\r
1114 rreq = data.asObject();
\r
1115 } catch(APIException e) {
\r
1116 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);
\r
1117 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1121 Result<Void> rp = service.deletePerm(trans,rreq);
\r
1122 switch(rp.status) {
\r
1124 setContentType(resp,permsDF.getOutType());
\r
1125 return Result.ok();
\r
1127 return Result.err(rp);
\r
1129 } catch (Exception e) {
\r
1130 trans.error().log(e,IN,DELETE_PERMISSION);
\r
1131 return Result.err(e);
\r
1138 public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {
\r
1139 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);
\r
1141 Result<Void> rp = service.deletePerm(trans,type,instance,action);
\r
1142 switch(rp.status) {
\r
1144 setContentType(resp,permsDF.getOutType());
\r
1145 return Result.ok();
\r
1147 return Result.err(rp);
\r
1149 } catch (Exception e) {
\r
1150 trans.error().log(e,IN,DELETE_PERMISSION);
\r
1151 return Result.err(e);
\r
1157 public static final String CREATE_ROLE = "createRole";
\r
1158 public static final String GET_ROLES_BY_USER = "getRolesByUser";
\r
1159 public static final String GET_ROLES_BY_NS = "getRolesByNS";
\r
1160 public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";
\r
1161 public static final String GET_ROLES_BY_NAME = "getRolesByName";
\r
1162 public static final String GET_ROLES_BY_PERM = "getRolesByPerm";
\r
1163 public static final String UPDATE_ROLE_DESC = "updateRoleDescription";
\r
1164 public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";
\r
1165 public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";
\r
1166 public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";
\r
1167 public static final String DELETE_ROLE = "deleteRole";
\r
1168 public static final String GET_CERT_BY_ID = "getCertByID";
\r
1171 public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1172 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);
\r
1176 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
\r
1177 if(Question.willSpecialLog(trans, trans.user())) {
\r
1178 Question.logEncryptTrace(trans,data.asString());
\r
1180 rreq = data.asObject();
\r
1181 } catch(APIException e) {
\r
1182 trans.error().log("Invalid Input",IN,CREATE_ROLE);
\r
1183 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1186 Result<Void> rp = service.createRole(trans, rreq);
\r
1187 switch(rp.status) {
\r
1189 setContentType(resp,roleRequestDF.getOutType());
\r
1190 return Result.ok();
\r
1192 return Result.err(rp);
\r
1194 } catch (Exception e) {
\r
1195 trans.error().log(e,IN,CREATE_ROLE);
\r
1196 return Result.err(e);
\r
1203 * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByName(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1206 public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {
\r
1207 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);
\r
1209 Result<ROLES> rp = service.getRolesByName(trans, role);
\r
1210 switch(rp.status) {
\r
1212 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
\r
1213 if(Question.willSpecialLog(trans, trans.user())) {
\r
1214 Question.logEncryptTrace(trans,data.asString());
\r
1216 data.to(resp.getOutputStream());
\r
1217 setContentType(resp,roleDF.getOutType());
\r
1218 return Result.ok();
\r
1220 return Result.err(rp);
\r
1222 } catch (Exception e) {
\r
1223 trans.error().log(e,IN,GET_ROLES_BY_NAME);
\r
1224 return Result.err(e);
\r
1231 * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1234 public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {
\r
1235 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
\r
1237 Result<ROLES> rp = service.getRolesByUser(trans, user);
\r
1238 switch(rp.status) {
\r
1240 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
\r
1241 if(Question.willSpecialLog(trans, trans.user())) {
\r
1242 Question.logEncryptTrace(trans,data.asString());
\r
1244 data.to(resp.getOutputStream());
\r
1245 setContentType(resp,roleDF.getOutType());
\r
1246 return Result.ok();
\r
1248 return Result.err(rp);
\r
1250 } catch (Exception e) {
\r
1251 trans.error().log(e,IN,GET_ROLES_BY_USER, user);
\r
1252 return Result.err(e);
\r
1259 * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1262 public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {
\r
1263 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
\r
1265 Result<ROLES> rp = service.getRolesByNS(trans, ns);
\r
1266 switch(rp.status) {
\r
1268 if(!rp.isEmpty()) {
\r
1269 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
\r
1270 if(Question.willSpecialLog(trans, trans.user())) {
\r
1271 Question.logEncryptTrace(trans,data.asString());
\r
1273 data.to(resp.getOutputStream());
\r
1275 Question.logEncryptTrace(trans, NO_DATA);
\r
1277 setContentType(resp,roleDF.getOutType());
\r
1278 return Result.ok();
\r
1280 return Result.err(rp);
\r
1282 } catch (Exception e) {
\r
1283 trans.error().log(e,IN,GET_ROLES_BY_NS);
\r
1284 return Result.err(e);
\r
1292 * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByNameOnly(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1295 public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {
\r
1296 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);
\r
1298 Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);
\r
1299 switch(rp.status) {
\r
1301 if(!rp.isEmpty()) {
\r
1302 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
\r
1303 if(Question.willSpecialLog(trans, trans.user())) {
\r
1304 Question.logEncryptTrace(trans,data.asString());
\r
1306 data.to(resp.getOutputStream());
\r
1308 Question.logEncryptTrace(trans, NO_DATA);
\r
1310 setContentType(resp,roleDF.getOutType());
\r
1311 return Result.ok();
\r
1313 return Result.err(rp);
\r
1315 } catch (Exception e) {
\r
1316 trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);
\r
1317 return Result.err(e);
\r
1324 * @see org.onap.aaf.authz.facade.AuthzFacade#getRolesByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1327 public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {
\r
1328 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);
\r
1330 Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);
\r
1331 switch(rp.status) {
\r
1333 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);
\r
1334 if(Question.willSpecialLog(trans, trans.user())) {
\r
1335 Question.logEncryptTrace(trans,data.asString());
\r
1337 data.to(resp.getOutputStream());
\r
1338 setContentType(resp,roleDF.getOutType());
\r
1339 return Result.ok();
\r
1341 return Result.err(rp);
\r
1343 } catch (Exception e) {
\r
1344 trans.error().log(e,IN,GET_ROLES_BY_PERM);
\r
1345 return Result.err(e);
\r
1353 * @see org.onap.aaf.authz.facade.AuthzFacade#updateDescription(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
\r
1356 public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1357 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);
\r
1361 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
\r
1362 if(Question.willSpecialLog(trans, trans.user())) {
\r
1363 Question.logEncryptTrace(trans,data.asString());
\r
1365 rreq = data.asObject();
\r
1366 } catch(APIException e) {
\r
1367 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);
\r
1368 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1371 Result<Void> rp = service.updateRoleDescription(trans, rreq);
\r
1372 switch(rp.status) {
\r
1374 setContentType(resp,roleRequestDF.getOutType());
\r
1375 return Result.ok();
\r
1379 } catch (Exception e) {
\r
1380 trans.error().log(e,IN,UPDATE_ROLE_DESC);
\r
1381 return Result.err(e);
\r
1388 public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1389 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);
\r
1393 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
\r
1394 if(Question.willSpecialLog(trans, trans.user())) {
\r
1395 Question.logEncryptTrace(trans,data.asString());
\r
1397 rreq = data.asObject();
\r
1398 } catch(APIException e) {
\r
1399 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);
\r
1400 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1403 Result<Void> rp = service.addPermToRole(trans, rreq);
\r
1404 switch(rp.status) {
\r
1406 setContentType(resp,permsDF.getOutType());
\r
1407 resp.getOutputStream().println();
\r
1408 return Result.ok();
\r
1410 return Result.err(rp);
\r
1412 } catch (Exception e) {
\r
1413 trans.error().log(e,IN,ADD_PERM_TO_ROLE);
\r
1414 return Result.err(e);
\r
1421 public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1422 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);
\r
1426 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());
\r
1427 if(Question.willSpecialLog(trans, trans.user())) {
\r
1428 Question.logEncryptTrace(trans,data.asString());
\r
1430 rreq = data.asObject();
\r
1431 } catch(APIException e) {
\r
1432 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);
\r
1433 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1436 Result<Void> rp = service.delPermFromRole(trans, rreq);
\r
1437 switch(rp.status) {
\r
1439 setContentType(resp,permsDF.getOutType());
\r
1440 resp.getOutputStream().println();
\r
1441 return Result.ok();
\r
1443 return Result.err(rp);
\r
1445 } catch (Exception e) {
\r
1446 trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);
\r
1447 return Result.err(e);
\r
1454 public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {
\r
1455 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
\r
1457 Result<Void> rp = service.deleteRole(trans, role);
\r
1458 switch(rp.status) {
\r
1460 setContentType(resp,permsDF.getOutType());
\r
1461 return Result.ok();
\r
1463 return Result.err(rp);
\r
1465 } catch (Exception e) {
\r
1466 trans.error().log(e,IN,DELETE_ROLE);
\r
1467 return Result.err(e);
\r
1474 public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1475 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);
\r
1479 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());
\r
1480 if(Question.willSpecialLog(trans, trans.user())) {
\r
1481 Question.logEncryptTrace(trans,data.asString());
\r
1483 rreq = data.asObject();
\r
1484 } catch(APIException e) {
\r
1485 trans.error().log("Invalid Input",IN,CREATE_ROLE);
\r
1486 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1489 Result<Void> rp = service.deleteRole(trans, rreq);
\r
1490 switch(rp.status) {
\r
1492 setContentType(resp,permsDF.getOutType());
\r
1493 return Result.ok();
\r
1495 return Result.err(rp);
\r
1497 } catch (Exception e) {
\r
1498 trans.error().log(e,IN,DELETE_ROLE);
\r
1499 return Result.err(e);
\r
1505 public static final String CREATE_CRED = "createUserCred";
\r
1506 private static final String GET_CREDS_BY_NS = "getCredsByNS";
\r
1507 private static final String GET_CREDS_BY_ID = "getCredsByID";
\r
1508 public static final String UPDATE_CRED = "updateUserCred";
\r
1509 public static final String EXTEND_CRED = "extendUserCred";
\r
1510 public static final String DELETE_CRED = "deleteUserCred";
\r
1511 public static final String DOES_CRED_MATCH = "doesCredMatch";
\r
1512 public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";
\r
1518 * Create Credential
\r
1521 public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {
\r
1522 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);
\r
1524 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
\r
1525 if(Question.willSpecialLog(trans, trans.user())) {
\r
1526 Question.logEncryptTrace(trans,data.asString());
\r
1528 return service.createUserCred(trans, data.asObject());
\r
1529 } catch(APIException e) {
\r
1530 trans.error().log(e,"Bad Input data");
\r
1531 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
\r
1532 } catch (Exception e) {
\r
1533 trans.error().log(e,IN,CREATE_CRED);
\r
1534 return Result.err(e);
\r
1541 public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {
\r
1542 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);
\r
1544 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
\r
1545 if(Question.willSpecialLog(trans, trans.user())) {
\r
1546 Question.logEncryptTrace(trans,data.asString());
\r
1549 return service.changeUserCred(trans, data.asObject());
\r
1550 } catch(APIException e) {
\r
1551 trans.error().log(e,"Bad Input data");
\r
1552 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
\r
1553 } catch (Exception e) {
\r
1554 trans.error().log(e,IN,UPDATE_CRED);
\r
1555 return Result.err(e);
\r
1562 * @see org.onap.aaf.authz.facade.AuthzFacade#extendUserCred(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, int)
\r
1565 public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {
\r
1566 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);
\r
1568 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
\r
1569 if(Question.willSpecialLog(trans, trans.user())) {
\r
1570 Question.logEncryptTrace(trans,data.asString());
\r
1573 return service.extendUserCred(trans, data.asObject(), days);
\r
1574 } catch(APIException e) {
\r
1575 trans.error().log(e,"Bad Input data");
\r
1576 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
\r
1577 } catch (Exception e) {
\r
1578 trans.error().log(e,IN,EXTEND_CRED);
\r
1579 return Result.err(e);
\r
1586 public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {
\r
1587 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);
\r
1590 Result<USERS> ru = service.getCredsByNS(trans,ns);
\r
1591 switch(ru.status) {
\r
1593 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
\r
1594 if(Question.willSpecialLog(trans,trans.user())) {
\r
1595 Question.logEncryptTrace(trans,data.asString());
\r
1597 data.to(resp.getOutputStream());
\r
1598 setContentType(resp,usersDF.getOutType());
\r
1599 return Result.ok();
\r
1601 return Result.err(ru);
\r
1603 } catch (Exception e) {
\r
1604 trans.error().log(e,IN,GET_CREDS_BY_NS);
\r
1605 return Result.err(e);
\r
1614 * @see org.onap.aaf.authz.facade.AuthzFacade#getCredsByID(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1617 public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {
\r
1618 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);
\r
1621 Result<USERS> ru = service.getCredsByID(trans,id);
\r
1622 switch(ru.status) {
\r
1624 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
\r
1625 if(Question.willSpecialLog(trans, trans.user())) {
\r
1626 Question.logEncryptTrace(trans,data.asString());
\r
1628 data.to(resp.getOutputStream());
\r
1629 setContentType(resp,usersDF.getOutType());
\r
1630 return Result.ok();
\r
1632 return Result.err(ru);
\r
1634 } catch (Exception e) {
\r
1635 trans.error().log(e,IN,GET_CREDS_BY_ID);
\r
1636 return Result.err(e);
\r
1644 public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {
\r
1645 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);
\r
1647 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
\r
1648 if(Question.willSpecialLog(trans, trans.user())) {
\r
1649 Question.logEncryptTrace(trans,data.asString());
\r
1652 return service.deleteUserCred(trans, data.asObject());
\r
1653 } catch(APIException e) {
\r
1654 trans.error().log(e,"Bad Input data");
\r
1655 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
\r
1656 } catch (Exception e) {
\r
1657 trans.error().log(e,IN,DELETE_CRED);
\r
1658 return Result.err(e);
\r
1666 public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1667 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);
\r
1669 RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());
\r
1670 if(Question.willSpecialLog(trans, trans.user())) {
\r
1671 Question.logEncryptTrace(trans,data.asString());
\r
1674 return service.doesCredentialMatch(trans, data.asObject());
\r
1675 } catch(APIException e) {
\r
1676 trans.error().log(e,"Bad Input data");
\r
1677 return Result.err(Status.ERR_BadData, e.getLocalizedMessage());
\r
1678 } catch (IOException e) {
\r
1679 trans.error().log(e,IN,DOES_CRED_MATCH);
\r
1680 return Result.err(e);
\r
1688 public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {
\r
1689 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);
\r
1691 Result<Date> result = service.validateBasicAuth(trans,basicAuth);
\r
1692 switch(result.status){
\r
1694 resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());
\r
1695 return Result.ok();
\r
1697 return Result.err(result);
\r
1698 } catch (Exception e) {
\r
1699 trans.error().log(e,IN,VALIDATE_BASIC_AUTH);
\r
1700 return Result.err(e);
\r
1707 * @see org.onap.aaf.authz.facade.AuthzFacade#getCertInfoByID(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
1710 public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {
\r
1711 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);
\r
1713 Result<CERTS> rci = service.getCertInfoByID(trans,req,id);
\r
1715 switch(rci.status) {
\r
1717 if(Question.willSpecialLog(trans, trans.user())) {
\r
1718 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);
\r
1719 Question.logEncryptTrace(trans,data.asString());
\r
1720 data.to(resp.getOutputStream());
\r
1722 certsDF.direct(trans, rci.value, resp.getOutputStream());
\r
1724 setContentType(resp,certsDF.getOutType());
\r
1725 return Result.ok();
\r
1727 return Result.err(rci);
\r
1729 } catch (Exception e) {
\r
1730 trans.error().log(e,IN,GET_CERT_BY_ID);
\r
1731 return Result.err(e);
\r
1737 public static final String CREATE_DELEGATE = "createDelegate";
\r
1738 public static final String UPDATE_DELEGATE = "updateDelegate";
\r
1739 public static final String DELETE_DELEGATE = "deleteDelegate";
\r
1740 public static final String GET_DELEGATE_USER = "getDelegatesByUser";
\r
1741 public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";
\r
1744 public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1745 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);
\r
1747 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
\r
1748 if(Question.willSpecialLog(trans, trans.user())) {
\r
1749 Question.logEncryptTrace(trans,data.asString());
\r
1752 return service.createDelegate(trans, data.asObject());
\r
1753 } catch (Exception e) {
\r
1754 trans.error().log(e,IN,CREATE_DELEGATE);
\r
1755 return Result.err(e);
\r
1762 public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1763 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);
\r
1765 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
\r
1766 if(Question.willSpecialLog(trans, trans.user())) {
\r
1767 Question.logEncryptTrace(trans,data.asString());
\r
1770 return service.updateDelegate(trans, data.asObject());
\r
1771 } catch (Exception e) {
\r
1772 trans.error().log(e,IN,UPDATE_DELEGATE);
\r
1773 return Result.err(e);
\r
1780 public Result<Void> deleteDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1781 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);
\r
1783 Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());
\r
1784 if(Question.willSpecialLog(trans, trans.user())) {
\r
1785 Question.logEncryptTrace(trans,data.asString());
\r
1788 return service.deleteDelegate(trans, data.asObject());
\r
1789 } catch (Exception e) {
\r
1790 trans.error().log(e,IN,DELETE_DELEGATE);
\r
1791 return Result.err(e);
\r
1798 public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {
\r
1799 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);
\r
1801 return service.deleteDelegate(trans, userName);
\r
1802 } catch (Exception e) {
\r
1803 trans.error().log(e,IN,DELETE_DELEGATE);
\r
1804 return Result.err(e);
\r
1811 public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {
\r
1812 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);
\r
1814 Result<DELGS> rd = service.getDelegatesByUser(trans, user);
\r
1816 switch(rd.status) {
\r
1818 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
\r
1819 if(Question.willSpecialLog(trans, trans.user())) {
\r
1820 Question.logEncryptTrace(trans,data.asString());
\r
1822 data.to(resp.getOutputStream());
\r
1823 setContentType(resp,delgDF.getOutType());
\r
1824 return Result.ok();
\r
1826 return Result.err(rd);
\r
1828 } catch (Exception e) {
\r
1829 trans.error().log(e,IN,GET_DELEGATE_USER);
\r
1830 return Result.err(e);
\r
1837 public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {
\r
1838 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);
\r
1840 Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);
\r
1841 switch(rd.status) {
\r
1843 RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);
\r
1844 if(Question.willSpecialLog(trans, trans.user())) {
\r
1845 Question.logEncryptTrace(trans,data.asString());
\r
1847 data.to(resp.getOutputStream());
\r
1848 setContentType(resp,delgDF.getOutType());
\r
1849 return Result.ok();
\r
1851 return Result.err(rd);
\r
1853 } catch (Exception e) {
\r
1854 trans.error().log(e,IN,GET_DELEGATE_DELG);
\r
1855 return Result.err(e);
\r
1861 private static final String REQUEST_USER_ROLE = "createUserRole";
\r
1862 private static final String GET_USERROLES = "getUserRoles";
\r
1863 private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";
\r
1864 private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";
\r
1865 private static final String SET_ROLES_FOR_USER = "setRolesForUser";
\r
1866 private static final String SET_USERS_FOR_ROLE = "setUsersForRole";
\r
1867 private static final String EXTEND_USER_ROLE = "extendUserRole";
\r
1868 private static final String DELETE_USER_ROLE = "deleteUserRole";
\r
1870 public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
1871 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);
\r
1875 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
\r
1876 if(Question.willSpecialLog(trans, trans.user())) {
\r
1877 Question.logEncryptTrace(trans,data.asString());
\r
1880 request = data.asObject();
\r
1881 } catch(APIException e) {
\r
1882 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1885 Result<Void> rp = service.createUserRole(trans,request);
\r
1886 switch(rp.status) {
\r
1888 setContentType(resp,permsDF.getOutType());
\r
1889 return Result.ok();
\r
1891 return Result.err(rp);
\r
1893 } catch (Exception e) {
\r
1894 trans.error().log(e,IN,REQUEST_USER_ROLE);
\r
1895 return Result.err(e);
\r
1902 public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
\r
1903 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);
\r
1905 Result<USERS> ru = service.getUserInRole(trans,user,role);
\r
1906 switch(ru.status) {
\r
1908 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
\r
1909 if(Question.willSpecialLog(trans, trans.user())) {
\r
1910 Question.logEncryptTrace(trans,data.asString());
\r
1913 data.to(resp.getOutputStream());
\r
1914 setContentType(resp,usersDF.getOutType());
\r
1915 return Result.ok();
\r
1917 return Result.err(ru);
\r
1919 } catch (Exception e) {
\r
1920 trans.error().log(e,IN,GET_USERROLES);
\r
1921 return Result.err(e);
\r
1929 public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
\r
1930 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
\r
1932 Result<USERROLES> ru = service.getUserRolesByUser(trans,user);
\r
1933 switch(ru.status) {
\r
1935 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
\r
1936 if(Question.willSpecialLog(trans, trans.user())) {
\r
1937 Question.logEncryptTrace(trans,data.asString());
\r
1940 data.to(resp.getOutputStream());
\r
1941 setContentType(resp,usersDF.getOutType());
\r
1942 return Result.ok();
\r
1944 return Result.err(ru);
\r
1946 } catch (Exception e) {
\r
1947 trans.error().log(e,IN,GET_USERROLES_BY_USER);
\r
1948 return Result.err(e);
\r
1956 public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
\r
1957 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
\r
1959 Result<USERROLES> ru = service.getUserRolesByRole(trans,role);
\r
1960 switch(ru.status) {
\r
1962 RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);
\r
1963 if(Question.willSpecialLog(trans, trans.user())) {
\r
1964 Question.logEncryptTrace(trans,data.asString());
\r
1967 data.to(resp.getOutputStream());
\r
1968 setContentType(resp,usersDF.getOutType());
\r
1969 return Result.ok();
\r
1971 return Result.err(ru);
\r
1973 } catch (Exception e) {
\r
1974 trans.error().log(e,IN,GET_USERROLES_BY_ROLE);
\r
1975 return Result.err(e);
\r
1984 public Result<Void> resetUsersForRole(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
\r
1985 TimeTaken tt = trans.start(SET_USERS_FOR_ROLE, Env.SUB|Env.ALWAYS);
\r
1989 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
\r
1990 if(Question.willSpecialLog(trans, trans.user())) {
\r
1991 Question.logEncryptTrace(trans,data.asString());
\r
1993 rreq = data.asObject();
\r
1994 } catch(APIException e) {
\r
1995 trans.error().log("Invalid Input",IN, SET_USERS_FOR_ROLE);
\r
1996 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
1999 Result<Void> rp = service.resetUsersForRole(trans, rreq);
\r
2001 switch(rp.status) {
\r
2003 setContentType(resp,permsDF.getOutType());
\r
2004 return Result.ok();
\r
2006 return Result.err(rp);
\r
2008 } catch (Exception e) {
\r
2009 trans.error().log(e,IN,SET_USERS_FOR_ROLE);
\r
2010 return Result.err(e);
\r
2018 public Result<Void> resetRolesForUser(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {
\r
2019 TimeTaken tt = trans.start(SET_ROLES_FOR_USER, Env.SUB|Env.ALWAYS);
\r
2023 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());
\r
2024 if(Question.willSpecialLog(trans, trans.user())) {
\r
2025 Question.logEncryptTrace(trans,data.asString());
\r
2028 rreq = data.asObject();
\r
2029 } catch(APIException e) {
\r
2030 trans.error().log("Invalid Input",IN, SET_ROLES_FOR_USER);
\r
2031 return Result.err(Status.ERR_BadData,"Invalid Input");
\r
2034 Result<Void> rp = service.resetRolesForUser(trans, rreq);
\r
2036 switch(rp.status) {
\r
2038 setContentType(resp,permsDF.getOutType());
\r
2039 return Result.ok();
\r
2041 return Result.err(rp);
\r
2043 } catch (Exception e) {
\r
2044 trans.error().log(e,IN,SET_ROLES_FOR_USER);
\r
2045 return Result.err(e);
\r
2053 * @see org.onap.aaf.authz.facade.AuthzFacade#extendUserRoleExpiration(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)
\r
2056 public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
\r
2057 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
\r
2059 return service.extendUserRole(trans,user,role);
\r
2060 } catch (Exception e) {
\r
2061 trans.error().log(e,IN,EXTEND_USER_ROLE);
\r
2062 return Result.err(e);
\r
2069 public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {
\r
2070 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);
\r
2072 Result<Void> rp = service.deleteUserRole(trans,user,role);
\r
2073 switch(rp.status) {
\r
2075 setContentType(resp,permsDF.getOutType());
\r
2076 return Result.ok();
\r
2078 return Result.err(rp);
\r
2080 } catch (Exception e) {
\r
2081 trans.error().log(e,IN,DELETE_USER_ROLE);
\r
2082 return Result.err(e);
\r
2088 private static final String UPDATE_APPROVAL = "updateApproval";
\r
2089 private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";
\r
2090 private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";
\r
2091 private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";
\r
2094 public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {
\r
2095 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);
\r
2097 Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());
\r
2098 if(Question.willSpecialLog(trans, trans.user())) {
\r
2099 Question.logEncryptTrace(trans,data.asString());
\r
2102 Result<Void> rp = service.updateApproval(trans, data.asObject());
\r
2104 switch(rp.status) {
\r
2106 setContentType(resp,approvalDF.getOutType());
\r
2107 return Result.ok();
\r
2109 return Result.err(rp);
\r
2111 } catch (Exception e) {
\r
2112 trans.error().log(e,IN,UPDATE_APPROVAL);
\r
2113 return Result.err(e);
\r
2120 public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {
\r
2121 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);
\r
2123 Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);
\r
2124 switch(rp.status) {
\r
2126 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
\r
2127 if(Question.willSpecialLog(trans, trans.user())) {
\r
2128 Question.logEncryptTrace(trans,data.asString());
\r
2130 data.to(resp.getOutputStream());
\r
2132 setContentType(resp,permsDF.getOutType());
\r
2133 return Result.ok();
\r
2135 return Result.err(rp);
\r
2137 } catch (Exception e) {
\r
2138 trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);
\r
2139 return Result.err(e);
\r
2146 public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {
\r
2147 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);
\r
2149 Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);
\r
2150 switch(rp.status) {
\r
2152 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
\r
2153 if(Question.willSpecialLog(trans, trans.user())) {
\r
2154 Question.logEncryptTrace(trans,data.asString());
\r
2157 data.to(resp.getOutputStream());
\r
2158 setContentType(resp,permsDF.getOutType());
\r
2159 return Result.ok();
\r
2161 return Result.err(rp);
\r
2163 } catch (Exception e) {
\r
2164 trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);
\r
2165 return Result.err(e);
\r
2172 public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {
\r
2173 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);
\r
2175 Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);
\r
2176 switch(rp.status) {
\r
2178 RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);
\r
2179 if(Question.willSpecialLog(trans, trans.user())) {
\r
2180 Question.logEncryptTrace(trans,data.asString());
\r
2183 data.to(resp.getOutputStream());
\r
2184 setContentType(resp,permsDF.getOutType());
\r
2185 return Result.ok();
\r
2187 return Result.err(rp);
\r
2189 } catch (Exception e) {
\r
2190 trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);
\r
2191 return Result.err(e);
\r
2199 public static final String GET_USERS_PERMISSION = "getUsersByPermission";
\r
2200 public static final String GET_USERS_ROLE = "getUsersByRole";
\r
2203 * @see org.onap.aaf.authz.facade.AuthzFacade#getUsersByRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
2206 public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {
\r
2207 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);
\r
2209 Result<USERS> ru = service.getUsersByRole(trans,role);
\r
2210 switch(ru.status) {
\r
2212 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
\r
2213 if(Question.willSpecialLog(trans, trans.user())) {
\r
2214 Question.logEncryptTrace(trans,data.asString());
\r
2217 data.to(resp.getOutputStream());
\r
2218 setContentType(resp,usersDF.getOutType());
\r
2219 return Result.ok();
\r
2221 return Result.err(ru);
\r
2223 } catch (Exception e) {
\r
2224 trans.error().log(e,IN,GET_USERS_ROLE);
\r
2225 return Result.err(e);
\r
2232 * @see org.onap.aaf.authz.facade.AuthzFacade#getUsersByPermission(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)
\r
2235 public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp,
\r
2236 String type, String instance, String action) {
\r
2237 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);
\r
2239 Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);
\r
2240 switch(ru.status) {
\r
2242 RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);
\r
2243 if(Question.willSpecialLog(trans, trans.user())) {
\r
2244 Question.logEncryptTrace(trans,data.asString());
\r
2247 data.to(resp.getOutputStream());
\r
2248 setContentType(resp,usersDF.getOutType());
\r
2249 return Result.ok();
\r
2251 return Result.err(ru);
\r
2253 } catch (Exception e) {
\r
2254 trans.error().log(e,IN,GET_USERS_PERMISSION);
\r
2255 return Result.err(e);
\r
2262 public static final String GET_HISTORY_USER = "getHistoryByUser";
\r
2263 public static final String GET_HISTORY_ROLE = "getHistoryByRole";
\r
2264 public static final String GET_HISTORY_PERM = "getHistoryByPerm";
\r
2265 public static final String GET_HISTORY_NS = "getHistoryByNS";
\r
2267 * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByUser(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
\r
2270 public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {
\r
2271 StringBuilder sb = new StringBuilder();
\r
2272 sb.append(GET_HISTORY_USER);
\r
2275 sb.append(" for ");
\r
2276 boolean first = true;
\r
2277 for(int i : yyyymm) {
\r
2285 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
\r
2288 Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);
\r
2289 switch(rh.status) {
\r
2291 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
\r
2292 if(Question.willSpecialLog(trans, trans.user())) {
\r
2293 Question.logEncryptTrace(trans,data.asString());
\r
2296 data.to(resp.getOutputStream());
\r
2297 setContentType(resp,historyDF.getOutType());
\r
2298 return Result.ok();
\r
2300 return Result.err(rh);
\r
2302 } catch (Exception e) {
\r
2303 trans.error().log(e,IN,GET_HISTORY_USER);
\r
2304 return Result.err(e);
\r
2311 * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByRole(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
\r
2314 public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {
\r
2315 StringBuilder sb = new StringBuilder();
\r
2316 sb.append(GET_HISTORY_ROLE);
\r
2319 sb.append(" for ");
\r
2320 boolean first = true;
\r
2321 for(int i : yyyymm) {
\r
2329 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
\r
2331 Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);
\r
2332 switch(rh.status) {
\r
2334 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
\r
2335 if(Question.willSpecialLog(trans, trans.user())) {
\r
2336 Question.logEncryptTrace(trans,data.asString());
\r
2339 data.to(resp.getOutputStream());
\r
2340 setContentType(resp,historyDF.getOutType());
\r
2341 return Result.ok();
\r
2343 return Result.err(rh);
\r
2345 } catch (Exception e) {
\r
2346 trans.error().log(e,IN,GET_HISTORY_ROLE);
\r
2347 return Result.err(e);
\r
2354 * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByNS(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
\r
2357 public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {
\r
2358 StringBuilder sb = new StringBuilder();
\r
2359 sb.append(GET_HISTORY_NS);
\r
2362 sb.append(" for ");
\r
2363 boolean first = true;
\r
2364 for(int i : yyyymm) {
\r
2372 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
\r
2374 Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);
\r
2375 switch(rh.status) {
\r
2377 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
\r
2378 if(Question.willSpecialLog(trans, trans.user())) {
\r
2379 Question.logEncryptTrace(trans,data.asString());
\r
2382 data.to(resp.getOutputStream());
\r
2383 setContentType(resp,historyDF.getOutType());
\r
2384 return Result.ok();
\r
2386 return Result.err(rh);
\r
2388 } catch (Exception e) {
\r
2389 trans.error().log(e,IN,GET_HISTORY_NS);
\r
2390 return Result.err(e);
\r
2397 * @see org.onap.aaf.authz.facade.AuthzFacade#getHistoryByPerm(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])
\r
2400 public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {
\r
2401 StringBuilder sb = new StringBuilder();
\r
2402 sb.append(GET_HISTORY_PERM);
\r
2405 sb.append(" for ");
\r
2406 boolean first = true;
\r
2407 for(int i : yyyymm) {
\r
2415 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);
\r
2417 Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);
\r
2418 switch(rh.status) {
\r
2420 RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);
\r
2421 if(Question.willSpecialLog(trans, trans.user())) {
\r
2422 Question.logEncryptTrace(trans,data.asString());
\r
2425 data.to(resp.getOutputStream());
\r
2426 setContentType(resp,historyDF.getOutType());
\r
2427 return Result.ok();
\r
2429 return Result.err(rh);
\r
2431 } catch (Exception e) {
\r
2432 trans.error().log(e,IN,GET_HISTORY_PERM);
\r
2433 return Result.err(e);
\r
2439 public final static String CACHE_CLEAR = "cacheClear ";
\r
2440 // public final static String CACHE_VALIDATE = "validateCache";
\r
2443 * @see org.onap.aaf.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.authz.env.AuthzTrans, java.lang.String)
\r
2446 public Result<Void> cacheClear(AuthzTrans trans, String cname) {
\r
2447 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);
\r
2449 return service.cacheClear(trans,cname);
\r
2450 } catch (Exception e) {
\r
2451 trans.error().log(e,IN,CACHE_CLEAR);
\r
2452 return Result.err(e);
\r
2459 * @see org.onap.aaf.authz.facade.AuthzFacade#cacheClear(org.onap.aaf.authz.env.AuthzTrans, java.lang.String, java.lang.Integer)
\r
2462 public Result<Void> cacheClear(AuthzTrans trans, String cname, String segments) {
\r
2463 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);
\r
2465 String[] segs = segments.split("\\s*,\\s*");
\r
2466 int isegs[] = new int[segs.length];
\r
2467 for(int i=0;i<segs.length;++i) {
\r
2469 isegs[i] = Integer.parseInt(segs[i]);
\r
2470 } catch(NumberFormatException nfe) {
\r
2474 return service.cacheClear(trans,cname, isegs);
\r
2475 } catch (Exception e) {
\r
2476 trans.error().log(e,IN,CACHE_CLEAR);
\r
2477 return Result.err(e);
\r
2484 * @see org.onap.aaf.authz.facade.AuthzFacade#dbReset(org.onap.aaf.authz.env.AuthzTrans)
\r
2487 public void dbReset(AuthzTrans trans) {
\r
2488 service.dbReset(trans);
\r
2492 * @see org.onap.aaf.authz.facade.AuthzFacade#getAPI(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse)
\r
2494 public final static String API_REPORT = "apiReport";
\r
2496 public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {
\r
2497 TimeTaken tt = trans.start(API_REPORT, Env.SUB);
\r
2499 Api api = new Api();
\r
2501 Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();
\r
2502 for(RouteReport rr : rservlet.routeReport()) {
\r
2503 api.getRoute().add(ar = new Api.Route());
\r
2504 ar.setMeth(rr.meth.name());
\r
2505 ar.setPath(rr.path);
\r
2506 ar.setDesc(rr.desc);
\r
2507 ar.getContentType().addAll(rr.contextTypes);
\r
2508 for(Method m : meths) {
\r
2510 if((ad = m.getAnnotation(ApiDoc.class))!=null &&
\r
2511 rr.meth.equals(ad.method()) &&
\r
2512 rr.path.equals(ad.path())) {
\r
2513 for(String param : ad.params()) {
\r
2514 ar.getParam().add(param);
\r
2516 for(String text : ad.text()) {
\r
2517 ar.getComments().add(text);
\r
2519 ar.setExpected(ad.expectedCode());
\r
2520 for(int ec : ad.errorCodes()) {
\r
2521 ar.getExplicitErr().add(ec);
\r
2526 RosettaData<Api> data = apiDF.newData(trans).load(api);
\r
2527 if(Question.willSpecialLog(trans, trans.user())) {
\r
2528 Question.logEncryptTrace(trans,data.asString());
\r
2531 data.to(resp.getOutputStream());
\r
2532 setContentType(resp,apiDF.getOutType());
\r
2533 return Result.ok();
\r
2535 } catch (Exception e) {
\r
2536 trans.error().log(e,IN,API_REPORT);
\r
2537 return Result.err(e);
\r
2544 public final static String API_EXAMPLE = "apiExample";
\r
2547 * @see org.onap.aaf.authz.facade.AuthzFacade#getAPIExample(org.onap.aaf.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)
\r
2550 public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {
\r
2551 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);
\r
2553 String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional);
\r
2554 resp.getOutputStream().print(content);
\r
2555 setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);
\r
2556 return Result.ok();
\r
2557 } catch (Exception e) {
\r
2558 trans.error().log(e,IN,API_EXAMPLE);
\r
2559 return Result.err(Status.ERR_NotImplemented,e.getMessage());
\r