authz-service/src/main/java/com/att/authz/facade/AuthzFacadeImpl.java

   1 /*******************************************************************************\r
   2  * ============LICENSE_START====================================================\r
   3  * * org.onap.aaf\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
  10  * * \r
  11  *  *      http://www.apache.org/licenses/LICENSE-2.0\r
  12  * * \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
  19  * *\r
  20  * * ECOMP is a trademark and service mark of AT&T Intellectual Property.\r
  21  * *\r
  22  ******************************************************************************/\r
  23 package com.att.authz.facade;\r
  24 \r
  25 import static com.att.authz.layer.Result.ERR_ActionNotCompleted;\r
  26 import static com.att.authz.layer.Result.ERR_Backend;\r
  27 import static com.att.authz.layer.Result.ERR_BadData;\r
  28 import static com.att.authz.layer.Result.ERR_ConflictAlreadyExists;\r
  29 import static com.att.authz.layer.Result.ERR_Denied;\r
  30 import static com.att.authz.layer.Result.ERR_NotFound;\r
  31 import static com.att.authz.layer.Result.ERR_NotImplemented;\r
  32 import static com.att.authz.layer.Result.ERR_Policy;\r
  33 import static com.att.authz.layer.Result.ERR_Security;\r
  34 import static com.att.authz.layer.Result.OK;\r
  35 import static com.att.dao.aaf.cass.Status.ERR_ChoiceNeeded;\r
  36 import static com.att.dao.aaf.cass.Status.ERR_DelegateNotFound;\r
  37 import static com.att.dao.aaf.cass.Status.ERR_DependencyExists;\r
  38 import static com.att.dao.aaf.cass.Status.ERR_FutureNotRequested;\r
  39 import static com.att.dao.aaf.cass.Status.ERR_InvalidDelegate;\r
  40 import static com.att.dao.aaf.cass.Status.ERR_NsNotFound;\r
  41 import static com.att.dao.aaf.cass.Status.ERR_PermissionNotFound;\r
  42 import static com.att.dao.aaf.cass.Status.ERR_RoleNotFound;\r
  43 import static com.att.dao.aaf.cass.Status.ERR_UserNotFound;\r
  44 import static com.att.dao.aaf.cass.Status.ERR_UserRoleNotFound;\r
  45 \r
  46 import java.io.IOException;\r
  47 import java.lang.reflect.Method;\r
  48 import java.util.Date;\r
  49 \r
  50 import javax.servlet.http.HttpServletRequest;\r
  51 import javax.servlet.http.HttpServletResponse;\r
  52 \r
  53 import com.att.authz.env.AuthzEnv;\r
  54 import com.att.authz.env.AuthzTrans;\r
  55 import com.att.authz.layer.FacadeImpl;\r
  56 import com.att.authz.layer.Result;\r
  57 import com.att.authz.service.AuthzCassServiceImpl;\r
  58 import com.att.authz.service.AuthzService;\r
  59 import com.att.authz.service.mapper.Mapper;\r
  60 import com.att.authz.service.mapper.Mapper.API;\r
  61 import com.att.cadi.aaf.client.Examples;\r
  62 import com.att.cssa.rserv.RServlet;\r
  63 import com.att.cssa.rserv.RouteReport;\r
  64 import com.att.cssa.rserv.doc.ApiDoc;\r
  65 import com.att.dao.aaf.cass.NsType;\r
  66 import com.att.dao.aaf.cass.Status;\r
  67 import com.att.dao.aaf.hl.Question;\r
  68 import com.att.inno.env.APIException;\r
  69 import com.att.inno.env.Data;\r
  70 import com.att.inno.env.Data.TYPE;\r
  71 import com.att.inno.env.Env;\r
  72 import com.att.inno.env.TimeTaken;\r
  73 import com.att.inno.env.util.Chrono;\r
  74 import com.att.rosetta.Marshal;\r
  75 import com.att.rosetta.env.RosettaDF;\r
  76 import com.att.rosetta.env.RosettaData;\r
  77 \r
  78 import aaf.v2_0.Api;\r
  79 \r
  80 /**\r
  81  * AuthzFacade\r
  82  * \r
  83  * This Service Facade encapsulates the essence of the API Service can do, and provides\r
  84  * a single created object for elements such as RosettaDF.\r
  85  *\r
  86  * The Responsibilities of this class are to:\r
  87  * 1) Interact with the Service Implementation (which might be supported by various kinds of Backend Storage)\r
  88  * 2) Validate incoming data (if applicable)\r
  89  * 3) Convert the Service response into the right Format, and mark the Content Type\r
  90  *              a) In the future, we may support multiple Response Formats, aka JSON or XML, based on User Request.\r
  91  * 4) Log Service info, warnings and exceptions as necessary\r
  92  * 5) When asked by the API layer, this will create and write Error content to the OutputStream\r
  93  * \r
  94  * Note: This Class does NOT set the HTTP Status Code.  That is up to the API layer, so that it can be \r
  95  * clearly coordinated with the API Documentation\r
  96  * \r
  97  *\r
  98  */\r
  99 public abstract class AuthzFacadeImpl<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> extends FacadeImpl implements AuthzFacade \r
 100         {\r
 101         private static final String FORBIDDEN = "Forbidden";\r
 102         private static final String NOT_FOUND = "Not Found";\r
 103         private static final String NOT_ACCEPTABLE = "Not Acceptable";\r
 104         private static final String GENERAL_SERVICE_ERROR = "General Service Error";\r
 105         private static final String NO_DATA = "***No Data***";\r
 106         private AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service = null;\r
 107         private final RosettaDF<NSS> nssDF;\r
 108         private final RosettaDF<PERMS> permsDF;\r
 109         private final RosettaDF<ROLES> roleDF;\r
 110         private final RosettaDF<USERS> usersDF;\r
 111         private final RosettaDF<USERROLES> userrolesDF;\r
 112         private final RosettaDF<CERTS> certsDF;\r
 113         private final RosettaDF<DELGS> delgDF;\r
 114         private final RosettaDF<REQUEST> permRequestDF;\r
 115         private final RosettaDF<REQUEST> roleRequestDF;\r
 116         private final RosettaDF<REQUEST> userRoleRequestDF;\r
 117         private final RosettaDF<REQUEST> rolePermRequestDF;\r
 118         private final RosettaDF<REQUEST> nsRequestDF;\r
 119         private final RosettaDF<REQUEST> credRequestDF;\r
 120         private final RosettaDF<REQUEST> delgRequestDF;\r
 121         private final RosettaDF<HISTORY> historyDF;\r
 122         private final RosettaDF<KEYS>    keysDF;\r
 123 \r
 124         private final RosettaDF<ERR>            errDF;\r
 125         private final RosettaDF<APPROVALS>  approvalDF;\r
 126         // Note: Api is not different per Version\r
 127         private final RosettaDF<Api>            apiDF;\r
 128 \r
 129 \r
 130         @SuppressWarnings("unchecked")\r
 131         public AuthzFacadeImpl(AuthzEnv env, AuthzService<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> service, Data.TYPE dataType) throws APIException {\r
 132                 this.service = service;\r
 133                 (nssDF                          = env.newDataFactory(service.mapper().getClass(API.NSS))).in(dataType).out(dataType);\r
 134                 (permRequestDF          = env.newDataFactory(service.mapper().getClass(API.PERM_REQ))).in(dataType).out(dataType);\r
 135                 (permsDF                        = env.newDataFactory(service.mapper().getClass(API.PERMS))).in(dataType).out(dataType);\r
 136 //              (permKeyDF                      = env.newDataFactory(service.mapper().getClass(API.PERM_KEY))).in(dataType).out(dataType);\r
 137                 (roleDF                         = env.newDataFactory(service.mapper().getClass(API.ROLES))).in(dataType).out(dataType);\r
 138                 (roleRequestDF          = env.newDataFactory(service.mapper().getClass(API.ROLE_REQ))).in(dataType).out(dataType);\r
 139                 (usersDF                        = env.newDataFactory(service.mapper().getClass(API.USERS))).in(dataType).out(dataType);\r
 140                 (userrolesDF                    = env.newDataFactory(service.mapper().getClass(API.USER_ROLES))).in(dataType).out(dataType);\r
 141                 (certsDF                        = env.newDataFactory(service.mapper().getClass(API.CERTS))).in(dataType).out(dataType)\r
 142                         .rootMarshal((Marshal<CERTS>) service.mapper().getMarshal(API.CERTS));\r
 143                 ;\r
 144                 (userRoleRequestDF      = env.newDataFactory(service.mapper().getClass(API.USER_ROLE_REQ))).in(dataType).out(dataType);\r
 145                 (rolePermRequestDF      = env.newDataFactory(service.mapper().getClass(API.ROLE_PERM_REQ))).in(dataType).out(dataType);\r
 146                 (nsRequestDF            = env.newDataFactory(service.mapper().getClass(API.NS_REQ))).in(dataType).out(dataType);\r
 147                 (credRequestDF          = env.newDataFactory(service.mapper().getClass(API.CRED_REQ))).in(dataType).out(dataType);\r
 148                 (delgRequestDF          = env.newDataFactory(service.mapper().getClass(API.DELG_REQ))).in(dataType).out(dataType);\r
 149                 (historyDF                      = env.newDataFactory(service.mapper().getClass(API.HISTORY))).in(dataType).out(dataType);\r
 150                 ( keysDF                        = env.newDataFactory(service.mapper().getClass(API.KEYS))).in(dataType).out(dataType);\r
 151                 (delgDF                         = env.newDataFactory(service.mapper().getClass(API.DELGS))).in(dataType).out(dataType);\r
 152                 (approvalDF             = env.newDataFactory(service.mapper().getClass(API.APPROVALS))).in(dataType).out(dataType);\r
 153                 (errDF                          = env.newDataFactory(service.mapper().getClass(API.ERROR))).in(dataType).out(dataType);\r
 154                 (apiDF                          = env.newDataFactory(Api.class)).in(dataType).out(dataType);\r
 155         }\r
 156         \r
 157         public Mapper<NSS,PERMS,PERMKEY,ROLES,USERS,USERROLES,DELGS,CERTS,KEYS,REQUEST,HISTORY,ERR,APPROVALS> mapper() {\r
 158                 return service.mapper();\r
 159         }\r
 160         \r
 161         /* (non-Javadoc)\r
 162          * @see com.att.authz.facade.AuthzFacade#error(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, int)\r
 163          * \r
 164          * Note: Conforms to AT&T TSS RESTful Error Structure\r
 165          */\r
 166         @Override\r
 167         public void error(AuthzTrans trans, HttpServletResponse response, Result<?> result) {\r
 168                 String msg = result.details==null?"%s":"%s - " + result.details.trim();\r
 169                 String msgId;\r
 170                 String[] detail;\r
 171                 if(result.variables==null) {\r
 172                         detail = new String[1];\r
 173                 } else {\r
 174                         int l = result.variables.length;\r
 175                         detail=new String[l+1];\r
 176                         System.arraycopy(result.variables, 0, detail, 1, l);\r
 177                 }\r
 178                 //int httpstatus;\r
 179                 \r
 180                 switch(result.status) {\r
 181                         case ERR_ActionNotCompleted:\r
 182                                 msgId = "SVC1202";\r
 183                                 detail[0] = "Accepted, Action not complete";\r
 184                                 response.setStatus(/*httpstatus=*/202);\r
 185                                 break;\r
 186 \r
 187                         case ERR_Policy:\r
 188                                 msgId = "SVC3403";\r
 189                                 detail[0] = FORBIDDEN;\r
 190                                 response.setStatus(/*httpstatus=*/403);\r
 191                                 break;\r
 192                         case ERR_Security:\r
 193                                 msgId = "SVC2403";\r
 194                                 detail[0] = FORBIDDEN;\r
 195                                 response.setStatus(/*httpstatus=*/403);\r
 196                                 break;\r
 197                         case ERR_Denied:\r
 198                                 msgId = "SVC1403";\r
 199                                 detail[0] = FORBIDDEN;\r
 200                                 response.setStatus(/*httpstatus=*/403);\r
 201                                 break;\r
 202                         // This is still forbidden to directly impact, but can be Requested when passed\r
 203                         // with "request=true" query Param\r
 204                         case ERR_FutureNotRequested:\r
 205                                 msgId = "SVC2403";\r
 206                                 detail[0] = msg;\r
 207                                 response.setStatus(/*httpstatus=*/403);\r
 208                                 break;\r
 209                                 \r
 210                         case ERR_NsNotFound:\r
 211                                 msgId = "SVC2404";\r
 212                                 detail[0] = NOT_FOUND;\r
 213                                 response.setStatus(/*httpstatus=*/404);\r
 214                                 break;\r
 215                         case ERR_RoleNotFound:\r
 216                                 msgId = "SVC3404";\r
 217                                 detail[0] = NOT_FOUND;\r
 218                                 response.setStatus(/*httpstatus=*/404);\r
 219                                 break;\r
 220                         case ERR_PermissionNotFound:\r
 221                                 msgId = "SVC4404";\r
 222                                 detail[0] = NOT_FOUND;\r
 223                                 response.setStatus(/*httpstatus=*/404);\r
 224                                 break;\r
 225                         case ERR_UserNotFound:\r
 226                                 msgId = "SVC5404";\r
 227                                 detail[0] = NOT_FOUND;\r
 228                                 response.setStatus(/*httpstatus=*/404);\r
 229                                 break;\r
 230                         case ERR_UserRoleNotFound:\r
 231                                 msgId = "SVC6404";\r
 232                                 detail[0] = NOT_FOUND;\r
 233                                 response.setStatus(/*httpstatus=*/404);\r
 234                                 break;\r
 235                         case ERR_DelegateNotFound:\r
 236                                 msgId = "SVC7404";\r
 237                                 detail[0] = NOT_FOUND;\r
 238                                 response.setStatus(/*httpstatus=*/404);\r
 239                                 break;\r
 240                         case ERR_NotFound:\r
 241                                 msgId = "SVC1404";\r
 242                                 detail[0] = NOT_FOUND;\r
 243                                 response.setStatus(/*httpstatus=*/404);\r
 244                                 break;\r
 245 \r
 246                         case ERR_InvalidDelegate:\r
 247                                 msgId="SVC2406";\r
 248                                 detail[0] = NOT_ACCEPTABLE;\r
 249                                 response.setStatus(/*httpstatus=*/406);\r
 250                                 break;\r
 251                         case ERR_BadData:\r
 252                                 msgId="SVC1406";\r
 253                                 detail[0] = NOT_ACCEPTABLE;\r
 254                                 response.setStatus(/*httpstatus=*/406);\r
 255                                 break;\r
 256                                 \r
 257                         case ERR_ConflictAlreadyExists:\r
 258                                 msgId = "SVC1409";\r
 259                                 detail[0] = "Conflict Already Exists";\r
 260                                 response.setStatus(/*httpstatus=*/409);\r
 261                                 break;\r
 262                         \r
 263                         case ERR_DependencyExists:\r
 264                                 msgId = "SVC1424";\r
 265                                 detail[0] = "Failed Dependency";\r
 266                                 response.setStatus(/*httpstatus=*/424);\r
 267                                 break;\r
 268                         \r
 269                         case ERR_NotImplemented:\r
 270                                 msgId = "SVC1501";\r
 271                                 detail[0] = "Not Implemented"; \r
 272                                 response.setStatus(/*httpstatus=*/501);\r
 273                                 break;\r
 274                                 \r
 275                         case Status.ACC_Future:\r
 276                                 msgId = "SVC1202";\r
 277                                 detail[0] = "Accepted for Future, pending Approvals";\r
 278                                 response.setStatus(/*httpstatus=*/202);\r
 279                                 break;\r
 280                         case ERR_ChoiceNeeded:\r
 281                                 msgId = "SVC1300";\r
 282                                 detail = result.variables;\r
 283                                 response.setStatus(/*httpstatus=*/300);\r
 284                                 break;\r
 285                         case ERR_Backend: \r
 286                                 msgId = "SVC2500";\r
 287                                 detail[0] = GENERAL_SERVICE_ERROR;\r
 288                                 response.setStatus(/*httpstatus=*/500);\r
 289                                 break;\r
 290 \r
 291                         default: \r
 292                                 msgId = "SVC1500";\r
 293                                 detail[0] = GENERAL_SERVICE_ERROR;\r
 294                                 response.setStatus(/*httpstatus=*/500);\r
 295                                 break;\r
 296                 }\r
 297 \r
 298                 try {\r
 299                         StringBuilder holder = new StringBuilder();\r
 300                         errDF.newData(trans).load(\r
 301                                 service.mapper()\r
 302                                         .errorFromMessage(holder,msgId,msg,detail))\r
 303                                                 .to(response.getOutputStream());\r
 304                         trans.checkpoint(\r
 305                                         holder.toString(),\r
 306 //                                      String.format("ErrResp [" +     msgId + "] " + msg,(Object[])detail),\r
 307                                         Env.ALWAYS);\r
 308                 } catch (Exception e) {\r
 309                         trans.error().log(e,"unable to send response for",msg);\r
 310                 }\r
 311         }\r
 312         \r
 313         ///////////////////////////\r
 314         // Namespace\r
 315         ///////////////////////////\r
 316         public static final String CREATE_NS = "createNamespace";\r
 317         public static final String ADD_NS_ADMIN = "addNamespaceAdmin";\r
 318         public static final String DELETE_NS_ADMIN = "delNamespaceAdmin";\r
 319         public static final String ADD_NS_RESPONSIBLE = "addNamespaceResponsible";\r
 320         public static final String DELETE_NS_RESPONSIBLE = "delNamespaceResponsible";\r
 321         public static final String GET_NS_BY_NAME = "getNamespaceByName";\r
 322         public static final String GET_NS_BY_ADMIN = "getNamespaceByAdmin";\r
 323         public static final String GET_NS_BY_RESPONSIBLE = "getNamespaceByResponsible";\r
 324         public static final String GET_NS_BY_EITHER = "getNamespaceByEither";\r
 325         public static final String GET_NS_CHILDREN = "getNamespaceChildren";\r
 326         public static final String UPDATE_NS_DESC = "updateNamespaceDescription";\r
 327         public static final String DELETE_NS = "deleteNamespace";\r
 328         \r
 329 \r
 330         /* (non-Javadoc)\r
 331          * @see com.att.authz.facade.AuthzFacade#createNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
 332          */\r
 333         @Override\r
 334         public Result<Void> requestNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, NsType type) {\r
 335                 TimeTaken tt = trans.start(CREATE_NS, Env.SUB|Env.ALWAYS);\r
 336                 try {\r
 337                         REQUEST request;\r
 338                         try {\r
 339                                 Data<REQUEST> rd = nsRequestDF.newData().load(req.getInputStream());\r
 340                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 341                                         Question.logEncryptTrace(trans,rd.asString());\r
 342                                 }\r
 343                                 request = rd.asObject();\r
 344                         } catch(APIException e) {\r
 345                                 trans.error().log("Invalid Input",IN,CREATE_NS);\r
 346                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 347                         }\r
 348                         \r
 349                         Result<Void> rp = service.createNS(trans,request,type);\r
 350                         switch(rp.status) {\r
 351                                 case OK: \r
 352                                         setContentType(resp,nsRequestDF.getOutType());\r
 353                                         return Result.ok();\r
 354                                 default:\r
 355                                         return Result.err(rp);\r
 356                         }\r
 357                 } catch (Exception e) {\r
 358                         trans.error().log(e,IN,CREATE_NS);\r
 359                         return Result.err(e);\r
 360                 } finally {\r
 361                         tt.done();\r
 362                 }\r
 363         }\r
 364 \r
 365         /* (non-Javadoc)\r
 366          * @see com.att.authz.facade.AuthzFacade#addAdminToNS(com.att.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 367          */\r
 368         @Override\r
 369         public Result<Void> addAdminToNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 370                 TimeTaken tt = trans.start(ADD_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 371                 try {\r
 372                         Result<Void> rp = service.addAdminNS(trans,ns,id);\r
 373                         switch(rp.status) {\r
 374                                 case OK: \r
 375                                         //TODO Perms??\r
 376                                         setContentType(resp,nsRequestDF.getOutType());\r
 377                                         resp.getOutputStream().println();\r
 378                                         return Result.ok();\r
 379                                 default:\r
 380                                         return Result.err(rp);\r
 381                         }\r
 382                 } catch (Exception e) {\r
 383                         trans.error().log(e,IN,ADD_NS_ADMIN);\r
 384                         return Result.err(e);\r
 385                 } finally {\r
 386                         tt.done();\r
 387                 }\r
 388         }\r
 389 \r
 390         /* (non-Javadoc)\r
 391          * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(com.att.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 392          */\r
 393         @Override\r
 394         public Result<Void> delAdminFromNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 395                 TimeTaken tt = trans.start(DELETE_NS_ADMIN + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 396                 try {\r
 397                         Result<Void> rp = service.delAdminNS(trans, ns, id);\r
 398                         switch(rp.status) {\r
 399                                 case OK: \r
 400                                         setContentType(resp,nsRequestDF.getOutType());\r
 401                                         return Result.ok();\r
 402                                 default:\r
 403                                         return Result.err(rp);\r
 404                         }\r
 405                 } catch (Exception e) {\r
 406                         trans.error().log(e,IN,DELETE_NS_ADMIN);\r
 407                         return Result.err(e);\r
 408                 } finally {\r
 409                         tt.done();\r
 410                 }\r
 411         }\r
 412 \r
 413         /* (non-Javadoc)\r
 414          * @see com.att.authz.facade.AuthzFacade#addAdminToNS(com.att.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 415          */\r
 416         @Override\r
 417         public Result<Void> addResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 418                 TimeTaken tt = trans.start(ADD_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 419                 try {\r
 420                         Result<Void> rp = service.addResponsibleNS(trans,ns,id);\r
 421                         switch(rp.status) {\r
 422                                 case OK: \r
 423                                         setContentType(resp,nsRequestDF.getOutType());\r
 424                                         resp.getOutputStream().println();\r
 425                                         return Result.ok();\r
 426                                 default:\r
 427                                         return Result.err(rp);\r
 428                         }\r
 429                 } catch (Exception e) {\r
 430                         trans.error().log(e,IN,ADD_NS_RESPONSIBLE);\r
 431                         return Result.err(e);\r
 432                 } finally {\r
 433                         tt.done();\r
 434                 }\r
 435         }\r
 436 \r
 437         /* (non-Javadoc)\r
 438          * @see com.att.authz.facade.AuthzFacade#delAdminFromNS(com.att.authz.env.AuthzTrans, java.lang.String, java.lang.String)\r
 439          */\r
 440         @Override\r
 441         public Result<Void> delResponsibilityForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String id) {\r
 442                 TimeTaken tt = trans.start(DELETE_NS_RESPONSIBLE + ' ' + ns + ' ' + id, Env.SUB|Env.ALWAYS);\r
 443                 try {\r
 444                         Result<Void> rp = service.delResponsibleNS(trans, ns, id);\r
 445                         switch(rp.status) {\r
 446                                 case OK: \r
 447                                         setContentType(resp,nsRequestDF.getOutType());\r
 448                                         resp.getOutputStream().println();\r
 449                                         return Result.ok();\r
 450                                 default:\r
 451                                         return Result.err(rp);\r
 452                         }\r
 453                 } catch (Exception e) {\r
 454                         trans.error().log(e,IN,DELETE_NS_RESPONSIBLE);\r
 455                         return Result.err(e);\r
 456                 } finally {\r
 457                         tt.done();\r
 458                 }\r
 459         }\r
 460 \r
 461         /* (non-Javadoc)\r
 462          * @see com.att.authz.facade.AuthzFacade#getNSsByName(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 463          */\r
 464         @Override\r
 465         public Result<Void> getNSsByName(AuthzTrans trans, HttpServletResponse resp, String ns) {\r
 466                 TimeTaken tt = trans.start(GET_NS_BY_NAME + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 467                 try {\r
 468                         Result<NSS> rp = service.getNSbyName(trans, ns);\r
 469                         switch(rp.status) {\r
 470                                 case OK: \r
 471                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 472                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 473                                                 Question.logEncryptTrace(trans,data.asString());\r
 474                                         }\r
 475                                         data.to(resp.getOutputStream());\r
 476                                         setContentType(resp,nssDF.getOutType());\r
 477                                         return Result.ok();\r
 478                                 default:\r
 479                                         return Result.err(rp);\r
 480                         }\r
 481                 } catch (Exception e) {\r
 482                         trans.error().log(e,IN,GET_NS_BY_NAME);\r
 483                         return Result.err(e);\r
 484                 } finally {\r
 485                         tt.done();\r
 486                 }\r
 487         }\r
 488         \r
 489 //      TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page\r
 490         /* (non-Javadoc)\r
 491          * @see com.att.authz.facade.AuthzFacade#getNSsByAdmin(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 492          */\r
 493         @Override\r
 494         public Result<Void> getNSsByAdmin(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 495                 TimeTaken tt = trans.start(GET_NS_BY_ADMIN + ' ' + user, Env.SUB|Env.ALWAYS);\r
 496                 try {\r
 497                         Result<NSS> rp = service.getNSbyAdmin(trans, user, full);\r
 498                         switch(rp.status) {\r
 499                                 case OK: \r
 500                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 501                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 502                                                 Question.logEncryptTrace(trans,data.asString());\r
 503                                         }\r
 504                                         data.to(resp.getOutputStream());\r
 505                                         setContentType(resp,nssDF.getOutType());\r
 506                                         return Result.ok();\r
 507                                 default:\r
 508                                         return Result.err(rp);\r
 509                         }\r
 510                 } catch (Exception e) {\r
 511                         trans.error().log(e,IN,GET_NS_BY_ADMIN);\r
 512                         return Result.err(e);\r
 513                 } finally {\r
 514                         tt.done();\r
 515                 }\r
 516         }\r
 517         \r
 518 //      TODO: uncomment when on cassandra 2.1.2 for MyNamespace GUI page\r
 519         /* (non-Javadoc)\r
 520          * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 521          */\r
 522         @Override\r
 523         public Result<Void> getNSsByResponsible(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 524                 TimeTaken tt = trans.start(GET_NS_BY_RESPONSIBLE + ' ' + user, Env.SUB|Env.ALWAYS);\r
 525                 try {\r
 526                         Result<NSS> rp = service.getNSbyResponsible(trans, user, full);\r
 527                         switch(rp.status) {\r
 528                                 case OK: \r
 529                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 530                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 531                                                 Question.logEncryptTrace(trans,data.asString());\r
 532                                         }\r
 533                                         data.to(resp.getOutputStream());\r
 534 \r
 535                                         setContentType(resp,nssDF.getOutType());\r
 536                                         return Result.ok();\r
 537                                 default:\r
 538                                         return Result.err(rp);\r
 539                         }\r
 540                 } catch (Exception e) {\r
 541                         trans.error().log(e,IN,GET_NS_BY_RESPONSIBLE);\r
 542                         return Result.err(e);\r
 543                 } finally {\r
 544                         tt.done();\r
 545                 }\r
 546         }\r
 547 \r
 548         /* (non-Javadoc)\r
 549          * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 550          */\r
 551         @Override\r
 552         public Result<Void> getNSsByEither(AuthzTrans trans, HttpServletResponse resp, String user, boolean full){\r
 553                 TimeTaken tt = trans.start(GET_NS_BY_EITHER + ' ' + user, Env.SUB|Env.ALWAYS);\r
 554                 try {\r
 555                         Result<NSS> rp = service.getNSbyEither(trans, user, full);\r
 556                         \r
 557                         switch(rp.status) {\r
 558                                 case OK: \r
 559                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 560                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 561                                                 Question.logEncryptTrace(trans,data.asString());\r
 562                                         }\r
 563                                         data.to(resp.getOutputStream());\r
 564 \r
 565                                         setContentType(resp,nssDF.getOutType());\r
 566                                         return Result.ok();\r
 567                                 default:\r
 568                                         return Result.err(rp);\r
 569                         }\r
 570                 } catch (Exception e) {\r
 571                         trans.error().log(e,IN,GET_NS_BY_EITHER);\r
 572                         return Result.err(e);\r
 573                 } finally {\r
 574                         tt.done();\r
 575                 }\r
 576         }\r
 577 \r
 578         /* (non-Javadoc)\r
 579          * @see com.att.authz.facade.AuthzFacade#getNSsByResponsible(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 580          */\r
 581         @Override\r
 582         public Result<Void> getNSsChildren(AuthzTrans trans, HttpServletResponse resp, String parent){\r
 583                 TimeTaken tt = trans.start(GET_NS_CHILDREN + ' ' + parent, Env.SUB|Env.ALWAYS);\r
 584                 try {\r
 585                         Result<NSS> rp = service.getNSsChildren(trans, parent);\r
 586                         switch(rp.status) {\r
 587                                 case OK: \r
 588                                         RosettaData<NSS> data = nssDF.newData(trans).load(rp.value);\r
 589                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 590                                                 Question.logEncryptTrace(trans,data.asString());\r
 591                                         }\r
 592                                         data.to(resp.getOutputStream());\r
 593                                         setContentType(resp,nssDF.getOutType());\r
 594                                         return Result.ok();\r
 595                                 default:\r
 596                                         return Result.err(rp);\r
 597                         }\r
 598                 } catch (Exception e) {\r
 599                         trans.error().log(e,IN,GET_NS_CHILDREN);\r
 600                         return Result.err(e);\r
 601                 } finally {\r
 602                         tt.done();\r
 603                 }\r
 604         }\r
 605 \r
 606         @Override\r
 607         public Result<Void> updateNsDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
 608                 TimeTaken tt = trans.start(UPDATE_NS_DESC, Env.SUB|Env.ALWAYS);\r
 609                 try {\r
 610                         REQUEST rreq;\r
 611                         try {\r
 612                                 RosettaData<REQUEST> data = nsRequestDF.newData().load(req.getInputStream());\r
 613                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 614                                         Question.logEncryptTrace(trans,data.asString());\r
 615                                 }\r
 616                                 rreq = data.asObject();\r
 617                         } catch(APIException e) {\r
 618                                 trans.error().log("Invalid Input",IN,UPDATE_NS_DESC);\r
 619                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 620 \r
 621                         }\r
 622                         Result<Void> rp = service.updateNsDescription(trans, rreq);\r
 623                         switch(rp.status) {\r
 624                                 case OK: \r
 625                                         setContentType(resp,nsRequestDF.getOutType());\r
 626                                         return Result.ok();\r
 627                                 default:\r
 628                                         return Result.err(rp);\r
 629                         }\r
 630                 } catch (Exception e) {\r
 631                         trans.error().log(e,IN,UPDATE_NS_DESC);\r
 632                         return Result.err(e);\r
 633                 } finally {\r
 634                         tt.done();\r
 635                 }\r
 636         }\r
 637         \r
 638         /*\r
 639          * (non-Javadoc)\r
 640          * @see com.att.authz.facade.AuthzFacade#requestNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
 641          */\r
 642         @Override\r
 643         public Result<Void> deleteNS(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String ns) {\r
 644                 TimeTaken tt = trans.start(DELETE_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 645                 try {\r
 646                         Result<Void> rp = service.deleteNS(trans,ns);\r
 647                         switch(rp.status) {\r
 648                                 case OK: \r
 649                                         setContentType(resp,nsRequestDF.getOutType());\r
 650                                         return Result.ok();\r
 651                                 default:\r
 652                                         return Result.err(rp);\r
 653                         }\r
 654                 } catch (Exception e) {\r
 655                         trans.error().log(e,IN,DELETE_NS);\r
 656                         return Result.err(e);\r
 657                 } finally {\r
 658                         tt.done();\r
 659                 }\r
 660         }\r
 661 \r
 662         private final static String NS_CREATE_ATTRIB = "nsCreateAttrib";\r
 663         private final static String NS_UPDATE_ATTRIB = "nsUpdateAttrib";\r
 664         private final static String READ_NS_BY_ATTRIB = "readNsByAttrib";\r
 665         private final static String NS_DELETE_ATTRIB = "nsDeleteAttrib";\r
 666         \r
 667         /* (non-Javadoc)\r
 668          * @see com.att.authz.facade.AuthzFacade#createAttribForNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
 669          */\r
 670         @Override\r
 671         public Result<Void> createAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {\r
 672                 TimeTaken tt = trans.start(NS_CREATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);\r
 673                 try {\r
 674                         Result<?> rp = service.createNsAttrib(trans,ns,key,value);\r
 675                         switch(rp.status) {\r
 676                                 case OK: \r
 677                                         setContentType(resp, keysDF.getOutType());\r
 678                                         resp.getOutputStream().println();\r
 679                                         return Result.ok();\r
 680                                 default:\r
 681                                         return Result.err(rp);\r
 682                         }\r
 683                 } catch (Exception e) {\r
 684                         trans.error().log(e,IN,NS_CREATE_ATTRIB);\r
 685                         return Result.err(e);\r
 686                 } finally {\r
 687                         tt.done();\r
 688                 }\r
 689         }\r
 690 \r
 691         /* (non-Javadoc)\r
 692          * @see com.att.authz.facade.AuthzFacade#readAttribForNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 693          */\r
 694         @Override\r
 695         public Result<Void> readNsByAttrib(AuthzTrans trans, HttpServletResponse resp, String key) {\r
 696                 TimeTaken tt = trans.start(READ_NS_BY_ATTRIB + ' ' + key, Env.SUB|Env.ALWAYS);\r
 697                 try {\r
 698                         Result<KEYS> rp = service.readNsByAttrib(trans, key);\r
 699                         switch(rp.status) {\r
 700                                 case OK: \r
 701                                         RosettaData<KEYS> data = keysDF.newData(trans).load(rp.value);\r
 702                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 703                                                 Question.logEncryptTrace(trans,data.asString());\r
 704                                         }\r
 705                                         data.to(resp.getOutputStream());\r
 706                                         setContentType(resp,keysDF.getOutType());\r
 707                                         return Result.ok();\r
 708                                 default:\r
 709                                         return Result.err(rp);\r
 710                         }\r
 711                 } catch (Exception e) {\r
 712                         trans.error().log(e,IN,READ_NS_BY_ATTRIB);\r
 713                         return Result.err(e);\r
 714                 } finally {\r
 715                         tt.done();\r
 716                 }\r
 717         }\r
 718 \r
 719         /* (non-Javadoc)\r
 720          * @see com.att.authz.facade.AuthzFacade#updAttribForNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
 721          */\r
 722         @Override\r
 723         public Result<Void> updAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key, String value) {\r
 724                 TimeTaken tt = trans.start(NS_UPDATE_ATTRIB + ' ' + ns + ':'+key+':'+value, Env.SUB|Env.ALWAYS);\r
 725                 try {\r
 726                         Result<?> rp = service.updateNsAttrib(trans,ns,key,value);\r
 727                         switch(rp.status) {\r
 728                                 case OK: \r
 729                                         setContentType(resp, keysDF.getOutType());\r
 730                                         resp.getOutputStream().println();\r
 731                                         return Result.ok();\r
 732                                 default:\r
 733                                         return Result.err(rp);\r
 734                         }\r
 735                 } catch (Exception e) {\r
 736                         trans.error().log(e,IN,NS_UPDATE_ATTRIB);\r
 737                         return Result.err(e);\r
 738                 } finally {\r
 739                         tt.done();\r
 740                 }\r
 741 \r
 742         }\r
 743 \r
 744         /* (non-Javadoc)\r
 745          * @see com.att.authz.facade.AuthzFacade#delAttribForNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)\r
 746          */\r
 747         @Override\r
 748         public Result<Void> delAttribForNS(AuthzTrans trans, HttpServletResponse resp, String ns, String key) {\r
 749                 TimeTaken tt = trans.start(NS_DELETE_ATTRIB + ' ' + ns + ':'+key, Env.SUB|Env.ALWAYS);\r
 750                 try {\r
 751                         Result<?> rp = service.deleteNsAttrib(trans,ns,key);\r
 752                         switch(rp.status) {\r
 753                                 case OK: \r
 754                                         setContentType(resp, keysDF.getOutType());\r
 755                                         resp.getOutputStream().println();\r
 756                                         return Result.ok();\r
 757                                 default:\r
 758                                         return Result.err(rp);\r
 759                         }\r
 760                 } catch (Exception e) {\r
 761                         trans.error().log(e,IN,NS_DELETE_ATTRIB);\r
 762                         return Result.err(e);\r
 763                 } finally {\r
 764                         tt.done();\r
 765                 }\r
 766         }\r
 767 \r
 768 //\r
 769 // PERMISSION\r
 770 //\r
 771         public static final String CREATE_PERMISSION = "createPermission";\r
 772         public static final String GET_PERMS_BY_TYPE = "getPermsByType";\r
 773         public static final String GET_PERMS_BY_NAME = "getPermsByName";\r
 774         public static final String GET_PERMISSIONS_BY_USER = "getPermissionsByUser";\r
 775         public static final String GET_PERMISSIONS_BY_USER_WITH_QUERY = "getPermissionsByUserWithQuery";\r
 776         public static final String GET_PERMISSIONS_BY_ROLE = "getPermissionsByRole";\r
 777         public static final String GET_PERMISSIONS_BY_NS = "getPermissionsByNS";\r
 778         public static final String UPDATE_PERMISSION = "updatePermission";\r
 779         public static final String UPDATE_PERM_DESC = "updatePermissionDescription";\r
 780         public static final String SET_PERMISSION_ROLES_TO = "setPermissionRolesTo";\r
 781         public static final String DELETE_PERMISSION = "deletePermission";\r
 782         \r
 783         /*\r
 784          * (non-Javadoc)\r
 785          * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)\r
 786          */\r
 787         @Override\r
 788         public Result<Void> createPerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
 789                 TimeTaken tt = trans.start( CREATE_PERMISSION, Env.SUB|Env.ALWAYS);     \r
 790                 try {\r
 791                         REQUEST rreq;\r
 792                         try {\r
 793                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
 794                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 795                                         Question.logEncryptTrace(trans,data.asString());\r
 796                                 }\r
 797                                 rreq = data.asObject();                 \r
 798                         } catch(APIException e) {\r
 799                                 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);\r
 800                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 801                         }\r
 802                         \r
 803                         Result<Void> rp = service.createPerm(trans,rreq);\r
 804                         switch(rp.status) {\r
 805                                 case OK: \r
 806                                         setContentType(resp,permsDF.getOutType());\r
 807                                         return Result.ok();\r
 808                                 default:\r
 809                                         return Result.err(rp);\r
 810                         }\r
 811                 } catch (Exception e) {\r
 812                         trans.error().log(e,IN,CREATE_PERMISSION);\r
 813                         return Result.err(e);\r
 814                 } finally {\r
 815                         tt.done();\r
 816                 }\r
 817         }\r
 818         \r
 819         /* (non-Javadoc)\r
 820          * @see com.att.authz.facade.AuthzFacade#getChildPerms(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 821          */\r
 822         @Override\r
 823         public Result<Void> getPermsByType(AuthzTrans trans, HttpServletResponse resp, String perm) {\r
 824                 TimeTaken tt = trans.start(GET_PERMS_BY_TYPE + ' ' + perm, Env.SUB|Env.ALWAYS);\r
 825                 try {\r
 826                         \r
 827                         Result<PERMS> rp = service.getPermsByType(trans, perm);\r
 828                         switch(rp.status) {\r
 829                                 case OK:\r
 830                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 831                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 832                                                 Question.logEncryptTrace(trans,data.asString());\r
 833                                         }\r
 834                                         data.to(resp.getOutputStream());\r
 835                                         setContentType(resp,permsDF.getOutType());\r
 836                                         return Result.ok();\r
 837                                 default:\r
 838                                         return Result.err(rp);\r
 839                         }\r
 840                 } catch (Exception e) {\r
 841                         trans.error().log(e,IN,GET_PERMS_BY_TYPE);\r
 842                         return Result.err(e);\r
 843                 } finally {\r
 844                         tt.done();\r
 845                 }\r
 846         }\r
 847         \r
 848         @Override\r
 849         public Result<Void> getPermsByName(AuthzTrans trans, HttpServletResponse resp, \r
 850                         String type, String instance, String action) {\r
 851                 \r
 852                 TimeTaken tt = trans.start(GET_PERMS_BY_NAME + ' ' + type\r
 853                                 + '|' + instance + '|' + action, Env.SUB|Env.ALWAYS);\r
 854                 try {\r
 855                         \r
 856                         Result<PERMS> rp = service.getPermsByName(trans, type, instance, action);\r
 857                         switch(rp.status) {\r
 858                                 case OK:\r
 859                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 860                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 861                                                 Question.logEncryptTrace(trans,data.asString());\r
 862                                         }\r
 863                                         data.to(resp.getOutputStream());\r
 864                                         setContentType(resp,permsDF.getOutType());\r
 865                                         return Result.ok();\r
 866                                 default:\r
 867                                         return Result.err(rp);\r
 868                         }\r
 869                 } catch (Exception e) {\r
 870                         trans.error().log(e,IN,GET_PERMS_BY_TYPE);\r
 871                         return Result.err(e);\r
 872                 } finally {\r
 873                         tt.done();\r
 874                 }\r
 875         }\r
 876 \r
 877         /* (non-Javadoc)\r
 878          * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 879          */\r
 880         @Override\r
 881         public Result<Void> getPermsByUser(AuthzTrans trans, HttpServletResponse resp,  String user) {\r
 882                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
 883                 try {\r
 884                         Result<PERMS> rp = service.getPermsByUser(trans, user);\r
 885                         switch(rp.status) {\r
 886                                 case OK: \r
 887                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 888                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 889                                                 Question.logEncryptTrace(trans,data.asString());\r
 890                                         }\r
 891                                         data.to(resp.getOutputStream());\r
 892                                         setContentType(resp,permsDF.getOutType());\r
 893                                         return Result.ok();\r
 894                                 default:\r
 895                                         return Result.err(rp);\r
 896                         }\r
 897                 } catch (Exception e) {\r
 898                         trans.error().log(e,IN,GET_PERMISSIONS_BY_USER, user);\r
 899                         return Result.err(e);\r
 900                 } finally {\r
 901                         tt.done();\r
 902                 }\r
 903         }\r
 904         \r
 905         /* (non-Javadoc)\r
 906          * @see com.att.authz.facade.AuthzFacade#getPermissionByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 907          */\r
 908         @Override\r
 909         public Result<Void> getPermsByUserWithAAFQuery(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String user) {\r
 910                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_USER_WITH_QUERY + ' ' + user, Env.SUB|Env.ALWAYS);\r
 911                 try {\r
 912                         PERMS perms;\r
 913                         try {\r
 914                                 RosettaData<PERMS> data = permsDF.newData().load(req.getInputStream());\r
 915                                 if(Question.willSpecialLog(trans, trans.user())) {\r
 916                                         Question.logEncryptTrace(trans,data.asString());\r
 917                                 }\r
 918                                 perms = data.asObject();                        \r
 919                         } catch(APIException e) {\r
 920                                 trans.error().log("Invalid Input",IN,CREATE_PERMISSION);\r
 921                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
 922                         }\r
 923 \r
 924                         Result<PERMS> rp = service.getPermsByUser(trans, perms, user);\r
 925                         switch(rp.status) {\r
 926                                 case OK: \r
 927                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 928                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 929                                                 Question.logEncryptTrace(trans,data.asString());\r
 930                                         }\r
 931                                         data.to(resp.getOutputStream());\r
 932                                         setContentType(resp,permsDF.getOutType());\r
 933                                         return Result.ok();\r
 934                                 default:\r
 935                                         return Result.err(rp);\r
 936                         }\r
 937                 } catch (Exception e) {\r
 938                         trans.error().log(e,IN,GET_PERMISSIONS_BY_USER_WITH_QUERY , user);\r
 939                         return Result.err(e);\r
 940                 } finally {\r
 941                         tt.done();\r
 942                 }\r
 943         }\r
 944 \r
 945 \r
 946         /* (non-Javadoc)\r
 947          * @see com.att.authz.facade.AuthzFacade#getPermissionsForRole(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
 948          */\r
 949         @Override\r
 950         public Result<Void> getPermsForRole(AuthzTrans trans, HttpServletResponse resp, String roleName) {\r
 951                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_ROLE + ' ' + roleName, Env.SUB|Env.ALWAYS);\r
 952                 try {\r
 953                         Result<PERMS> rp = service.getPermsByRole(trans, roleName);\r
 954                         switch(rp.status) {\r
 955                                 case OK:\r
 956                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 957                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 958                                                 Question.logEncryptTrace(trans,data.asString());\r
 959                                         }\r
 960                                         data.to(resp.getOutputStream());\r
 961                                         setContentType(resp,permsDF.getOutType());\r
 962                                         return Result.ok();\r
 963                                 default:\r
 964                                         return Result.err(rp);\r
 965                         }\r
 966                 } catch (Exception e) {\r
 967                         trans.error().log(e,IN,GET_PERMISSIONS_BY_ROLE);\r
 968                         return Result.err(e);\r
 969                 } finally {\r
 970                         tt.done();\r
 971                 }\r
 972         }\r
 973         \r
 974         @Override\r
 975         public Result<Void> getPermsByNS(AuthzTrans trans,HttpServletResponse resp,String ns) {\r
 976                 TimeTaken tt = trans.start(GET_PERMISSIONS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
 977                 try {\r
 978                         Result<PERMS> rp = service.getPermsByNS(trans, ns);\r
 979                         switch(rp.status) {\r
 980                                 case OK:\r
 981                                         RosettaData<PERMS> data = permsDF.newData(trans).load(rp.value);\r
 982                                         if(Question.willSpecialLog(trans, trans.user())) {\r
 983                                                 Question.logEncryptTrace(trans,data.asString());\r
 984                                         }\r
 985                                         data.to(resp.getOutputStream());\r
 986                                         setContentType(resp,permsDF.getOutType());\r
 987                                         return Result.ok();\r
 988                                 default:\r
 989                                         return Result.err(rp);\r
 990                         }\r
 991                 } catch (Exception e) {\r
 992                         trans.error().log(e,IN,GET_PERMISSIONS_BY_NS);\r
 993                         return Result.err(e);\r
 994                 } finally {\r
 995                         tt.done();\r
 996                 }\r
 997         }\r
 998 \r
 999         /*\r
1000          * (non-Javadoc)\r
1001          * @see com.att.authz.facade.AuthzFacade#createOrUpdatePerm(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, boolean, java.lang.String, java.lang.String, java.lang.String)\r
1002          */\r
1003         @Override\r
1004         public Result<Void> renamePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp,\r
1005                         String origType, String origInstance, String origAction) {\r
1006                 String cmdDescription = UPDATE_PERMISSION;\r
1007                 TimeTaken tt = trans.start( cmdDescription      + ' ' + origType + ' ' + origInstance + ' ' + origAction, Env.SUB|Env.ALWAYS);  \r
1008                 try {\r
1009                         REQUEST rreq;\r
1010                         try {\r
1011                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1012                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1013                                         Question.logEncryptTrace(trans,data.asString());\r
1014                                 }\r
1015                                 rreq = data.asObject();                 \r
1016                         } catch(APIException e) {\r
1017                                 trans.error().log("Invalid Input",IN,cmdDescription);\r
1018                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1019                         }\r
1020                         \r
1021                         Result<Void> rp = service.renamePerm(trans,rreq, origType, origInstance, origAction);\r
1022                         switch(rp.status) {\r
1023                                 case OK: \r
1024                                         setContentType(resp,permsDF.getOutType());\r
1025                                         return Result.ok();\r
1026                                 default:\r
1027                                         return Result.err(rp);\r
1028                         }\r
1029                 } catch (Exception e) {\r
1030                         trans.error().log(e,IN,cmdDescription);\r
1031                         return Result.err(e);\r
1032                 } finally {\r
1033                         tt.done();\r
1034                 }\r
1035         }\r
1036         \r
1037         @Override\r
1038         public Result<Void> updatePermDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1039                 TimeTaken tt = trans.start(UPDATE_PERM_DESC, Env.SUB|Env.ALWAYS);\r
1040                 try {\r
1041                         REQUEST rreq;\r
1042                         try {\r
1043                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1044                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1045                                         Question.logEncryptTrace(trans,data.asString());\r
1046                                 }\r
1047                                 rreq = data.asObject();\r
1048                         } catch(APIException e) {\r
1049                                 trans.error().log("Invalid Input",IN,UPDATE_PERM_DESC);\r
1050                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1051 \r
1052                         }\r
1053                         Result<Void> rp = service.updatePermDescription(trans, rreq);\r
1054                         switch(rp.status) {\r
1055                                 case OK: \r
1056                                         setContentType(resp,permRequestDF.getOutType());\r
1057                                         return Result.ok();\r
1058                                 default:\r
1059                                         return Result.err(rp);\r
1060                         }\r
1061                 } catch (Exception e) {\r
1062                         trans.error().log(e,IN,UPDATE_PERM_DESC);\r
1063                         return Result.err(e);\r
1064                 } finally {\r
1065                         tt.done();\r
1066                 }\r
1067         }\r
1068         \r
1069         \r
1070         @Override\r
1071         public Result<Void> resetPermRoles(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1072                 TimeTaken tt = trans.start(SET_PERMISSION_ROLES_TO, Env.SUB|Env.ALWAYS);\r
1073                 try {\r
1074                         REQUEST rreq;\r
1075                         try {\r
1076                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1077                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1078                                         Question.logEncryptTrace(trans,data.asString());\r
1079                                 }\r
1080                                 rreq = data.asObject();\r
1081                         } catch(APIException e) {\r
1082                                 trans.error().log("Invalid Input",IN, SET_PERMISSION_ROLES_TO);\r
1083                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1084                         }\r
1085                         \r
1086                         Result<Void> rp = service.resetPermRoles(trans, rreq);\r
1087                         \r
1088                         switch(rp.status) {\r
1089                                 case OK: \r
1090                                         setContentType(resp,permsDF.getOutType());\r
1091                                         return Result.ok();\r
1092                                 default:\r
1093                                         return Result.err(rp);\r
1094                         }\r
1095                 } catch (Exception e) {\r
1096                         trans.error().log(e,IN,SET_PERMISSION_ROLES_TO);\r
1097                         return Result.err(e);\r
1098                 } finally {\r
1099                         tt.done();\r
1100                 }\r
1101         }\r
1102         \r
1103         @Override\r
1104         public Result<Void> deletePerm(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1105                 TimeTaken tt = trans.start(DELETE_PERMISSION, Env.SUB|Env.ALWAYS);\r
1106                 try {\r
1107                         REQUEST rreq;\r
1108                         try {\r
1109                                 RosettaData<REQUEST> data = permRequestDF.newData().load(req.getInputStream());\r
1110                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1111                                         Question.logEncryptTrace(trans,data.asString());\r
1112                                 }\r
1113                                 rreq = data.asObject();\r
1114                         } catch(APIException e) {\r
1115                                 trans.error().log("Invalid Input",IN,DELETE_PERMISSION);\r
1116                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1117 \r
1118                         }\r
1119 \r
1120                         Result<Void> rp = service.deletePerm(trans,rreq);\r
1121                         switch(rp.status) {\r
1122                                 case OK: \r
1123                                         setContentType(resp,permsDF.getOutType());\r
1124                                         return Result.ok();\r
1125                                 default:\r
1126                                         return Result.err(rp);\r
1127                         }\r
1128                 } catch (Exception e) {\r
1129                         trans.error().log(e,IN,DELETE_PERMISSION);\r
1130                         return Result.err(e);\r
1131                 } finally {\r
1132                         tt.done();\r
1133                 }\r
1134         }\r
1135 \r
1136         @Override\r
1137         public Result<Void> deletePerm(AuthzTrans trans, HttpServletResponse resp, String type, String instance, String action) {\r
1138                 TimeTaken tt = trans.start(DELETE_PERMISSION + type + ' ' + instance + ' ' + action, Env.SUB|Env.ALWAYS);\r
1139                 try {\r
1140                         Result<Void> rp = service.deletePerm(trans,type,instance,action);\r
1141                         switch(rp.status) {\r
1142                                 case OK: \r
1143                                         setContentType(resp,permsDF.getOutType());\r
1144                                         return Result.ok();\r
1145                                 default:\r
1146                                         return Result.err(rp);\r
1147                         }\r
1148                 } catch (Exception e) {\r
1149                         trans.error().log(e,IN,DELETE_PERMISSION);\r
1150                         return Result.err(e);\r
1151                 } finally {\r
1152                         tt.done();\r
1153                 }\r
1154         }\r
1155 \r
1156         public static final String CREATE_ROLE = "createRole";\r
1157         public static final String GET_ROLES_BY_USER = "getRolesByUser";\r
1158         public static final String GET_ROLES_BY_NS = "getRolesByNS";\r
1159         public static final String GET_ROLES_BY_NAME_ONLY = "getRolesByNameOnly";\r
1160         public static final String GET_ROLES_BY_NAME = "getRolesByName";\r
1161         public static final String GET_ROLES_BY_PERM = "getRolesByPerm";\r
1162         public static final String UPDATE_ROLE_DESC = "updateRoleDescription"; \r
1163         public static final String ADD_PERM_TO_ROLE = "addPermissionToRole";\r
1164         public static final String DELETE_PERM_FROM_ROLE = "deletePermissionFromRole";\r
1165         public static final String UPDATE_MGTPERM_ROLE = "updateMgtPermRole";\r
1166         public static final String DELETE_ROLE = "deleteRole";\r
1167         public static final String GET_CERT_BY_ID = "getCertByID";\r
1168 \r
1169         @Override\r
1170         public Result<Void> createRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1171                 TimeTaken tt = trans.start(CREATE_ROLE, Env.SUB|Env.ALWAYS);\r
1172                 try {\r
1173                         REQUEST rreq;\r
1174                         try {\r
1175                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1176                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1177                                         Question.logEncryptTrace(trans,data.asString());\r
1178                                 }\r
1179                                 rreq = data.asObject();\r
1180                         } catch(APIException e) {\r
1181                                 trans.error().log("Invalid Input",IN,CREATE_ROLE);\r
1182                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1183 \r
1184                         }\r
1185                         Result<Void> rp = service.createRole(trans, rreq);\r
1186                         switch(rp.status) {\r
1187                                 case OK: \r
1188                                         setContentType(resp,roleRequestDF.getOutType());\r
1189                                         return Result.ok();\r
1190                                 default:\r
1191                                         return Result.err(rp);\r
1192                         }\r
1193                 } catch (Exception e) {\r
1194                         trans.error().log(e,IN,CREATE_ROLE);\r
1195                         return Result.err(e);\r
1196                 } finally {\r
1197                         tt.done();\r
1198                 }\r
1199         }\r
1200 \r
1201         /* (non-Javadoc)\r
1202          * @see com.att.authz.facade.AuthzFacade#getRolesByName(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1203          */\r
1204         @Override\r
1205         public Result<Void> getRolesByName(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1206                 TimeTaken tt = trans.start(GET_ROLES_BY_NAME + ' ' + role, Env.SUB|Env.ALWAYS);\r
1207                 try {\r
1208                         Result<ROLES> rp = service.getRolesByName(trans, role);\r
1209                         switch(rp.status) {\r
1210                                 case OK: \r
1211                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1212                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1213                                                 Question.logEncryptTrace(trans,data.asString());\r
1214                                         }\r
1215                                         data.to(resp.getOutputStream());\r
1216                                         setContentType(resp,roleDF.getOutType());\r
1217                                         return Result.ok();\r
1218                                 default:\r
1219                                         return Result.err(rp);\r
1220                         }\r
1221                 } catch (Exception e) {\r
1222                         trans.error().log(e,IN,GET_ROLES_BY_NAME);\r
1223                         return Result.err(e);\r
1224                 } finally {\r
1225                         tt.done();\r
1226                 }\r
1227         }\r
1228 \r
1229         /* (non-Javadoc)\r
1230          * @see com.att.authz.facade.AuthzFacade#getRolesByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1231          */\r
1232         @Override\r
1233         public Result<Void> getRolesByUser(AuthzTrans trans,HttpServletResponse resp, String user) {\r
1234                 TimeTaken tt = trans.start(GET_ROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
1235                 try {\r
1236                         Result<ROLES> rp = service.getRolesByUser(trans, user);\r
1237                         switch(rp.status) {\r
1238                                 case OK: \r
1239                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1240                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1241                                                 Question.logEncryptTrace(trans,data.asString());\r
1242                                         }\r
1243                                         data.to(resp.getOutputStream());\r
1244                                         setContentType(resp,roleDF.getOutType());\r
1245                                         return Result.ok();\r
1246                                 default:\r
1247                                         return Result.err(rp);\r
1248                         }\r
1249                 } catch (Exception e) {\r
1250                         trans.error().log(e,IN,GET_ROLES_BY_USER, user);\r
1251                         return Result.err(e);\r
1252                 } finally {\r
1253                         tt.done();\r
1254                 }\r
1255         }\r
1256 \r
1257         /* (non-Javadoc)\r
1258          * @see com.att.authz.facade.AuthzFacade#getRolesByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1259          */\r
1260         @Override\r
1261         public Result<Void> getRolesByNS(AuthzTrans trans,HttpServletResponse resp, String ns) {\r
1262                 TimeTaken tt = trans.start(GET_ROLES_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
1263                 try {\r
1264                         Result<ROLES> rp = service.getRolesByNS(trans, ns);\r
1265                         switch(rp.status) {\r
1266                                 case OK: \r
1267                                         if(!rp.isEmpty()) {\r
1268                                                 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1269                                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1270                                                         Question.logEncryptTrace(trans,data.asString());\r
1271                                                 }\r
1272                                                 data.to(resp.getOutputStream());\r
1273                                         } else {\r
1274                                                 Question.logEncryptTrace(trans, NO_DATA);\r
1275                                         }\r
1276                                         setContentType(resp,roleDF.getOutType());\r
1277                                         return Result.ok();\r
1278                                 default:\r
1279                                         return Result.err(rp);\r
1280                         }\r
1281                 } catch (Exception e) {\r
1282                         trans.error().log(e,IN,GET_ROLES_BY_NS);\r
1283                         return Result.err(e);\r
1284                 } finally {\r
1285                         tt.done();\r
1286                 }\r
1287         }\r
1288 \r
1289 \r
1290         /* (non-Javadoc)\r
1291          * @see com.att.authz.facade.AuthzFacade#getRolesByNameOnly(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1292          */\r
1293         @Override\r
1294         public Result<Void> getRolesByNameOnly(AuthzTrans trans,HttpServletResponse resp, String nameOnly) {\r
1295                 TimeTaken tt = trans.start(GET_ROLES_BY_NAME_ONLY + ' ' + nameOnly, Env.SUB|Env.ALWAYS);\r
1296                 try {\r
1297                         Result<ROLES> rp = service.getRolesByNameOnly(trans, nameOnly);\r
1298                         switch(rp.status) {\r
1299                                 case OK: \r
1300                                         if(!rp.isEmpty()) {\r
1301                                                 RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1302                                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1303                                                         Question.logEncryptTrace(trans,data.asString());\r
1304                                                 }\r
1305                                                 data.to(resp.getOutputStream());\r
1306                                         } else {\r
1307                                                 Question.logEncryptTrace(trans, NO_DATA);\r
1308                                         }\r
1309                                         setContentType(resp,roleDF.getOutType());\r
1310                                         return Result.ok();\r
1311                                 default:\r
1312                                         return Result.err(rp);\r
1313                         }\r
1314                 } catch (Exception e) {\r
1315                         trans.error().log(e,IN,GET_ROLES_BY_NAME_ONLY);\r
1316                         return Result.err(e);\r
1317                 } finally {\r
1318                         tt.done();\r
1319                 }\r
1320         }\r
1321 \r
1322         /* (non-Javadoc)\r
1323          * @see com.att.authz.facade.AuthzFacade#getRolesByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1324          */\r
1325         @Override\r
1326         public Result<Void> getRolesByPerm(AuthzTrans trans,HttpServletResponse resp, String type, String instance, String action) {\r
1327                 TimeTaken tt = trans.start(GET_ROLES_BY_PERM + type +' '+instance+' '+action, Env.SUB|Env.ALWAYS);\r
1328                 try {\r
1329                         Result<ROLES> rp = service.getRolesByPerm(trans, type,instance,action);\r
1330                         switch(rp.status) {\r
1331                                 case OK: \r
1332                                         RosettaData<ROLES> data = roleDF.newData(trans).load(rp.value);\r
1333                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1334                                                 Question.logEncryptTrace(trans,data.asString());\r
1335                                         }\r
1336                                         data.to(resp.getOutputStream());\r
1337                                         setContentType(resp,roleDF.getOutType());\r
1338                                         return Result.ok();\r
1339                                 default:\r
1340                                         return Result.err(rp);\r
1341                         }\r
1342                 } catch (Exception e) {\r
1343                         trans.error().log(e,IN,GET_ROLES_BY_PERM);\r
1344                         return Result.err(e);\r
1345                 } finally {\r
1346                         tt.done();\r
1347                 }\r
1348         }\r
1349 \r
1350         /*\r
1351          * (non-Javadoc)\r
1352          * @see com.att.authz.facade.AuthzFacade#updateDescription(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
1353          */\r
1354         @Override\r
1355         public Result<Void> updateRoleDescription(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1356                 TimeTaken tt = trans.start(UPDATE_ROLE_DESC, Env.SUB|Env.ALWAYS);\r
1357                 try {\r
1358                         REQUEST rreq;\r
1359                         try {\r
1360                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1361                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1362                                         Question.logEncryptTrace(trans,data.asString());\r
1363                                 }\r
1364                                 rreq = data.asObject();\r
1365                         } catch(APIException e) {\r
1366                                 trans.error().log("Invalid Input",IN,UPDATE_ROLE_DESC);\r
1367                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1368 \r
1369                         }\r
1370                         Result<Void> rp = service.updateRoleDescription(trans, rreq);\r
1371                         switch(rp.status) {\r
1372                                 case OK: \r
1373                                         setContentType(resp,roleRequestDF.getOutType());\r
1374                                         return Result.ok();\r
1375                                 default:\r
1376                                         return rp;\r
1377                         }\r
1378                 } catch (Exception e) {\r
1379                         trans.error().log(e,IN,UPDATE_ROLE_DESC);\r
1380                         return Result.err(e);\r
1381                 } finally {\r
1382                         tt.done();\r
1383                 }\r
1384         }\r
1385 \r
1386         @Override\r
1387         public Result<Void> addPermToRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1388                 TimeTaken tt = trans.start(ADD_PERM_TO_ROLE, Env.SUB|Env.ALWAYS);\r
1389                 try {\r
1390                         REQUEST rreq;\r
1391                         try {\r
1392                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1393                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1394                                         Question.logEncryptTrace(trans,data.asString());\r
1395                                 }\r
1396                                 rreq = data.asObject();\r
1397                         } catch(APIException e) {\r
1398                                 trans.error().log("Invalid Input",IN,ADD_PERM_TO_ROLE);\r
1399                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1400 \r
1401                         }\r
1402                         Result<Void> rp = service.addPermToRole(trans, rreq);\r
1403                         switch(rp.status) {\r
1404                                 case OK: \r
1405                                         setContentType(resp,permsDF.getOutType());\r
1406                                         resp.getOutputStream().println();\r
1407                                         return Result.ok();\r
1408                                 default:\r
1409                                         return Result.err(rp);\r
1410                         }\r
1411                 } catch (Exception e) {\r
1412                         trans.error().log(e,IN,ADD_PERM_TO_ROLE);\r
1413                         return Result.err(e);\r
1414                 } finally {\r
1415                         tt.done();\r
1416                 }\r
1417         }\r
1418 \r
1419         @Override\r
1420         public Result<Void> delPermFromRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1421                 TimeTaken tt = trans.start(DELETE_PERM_FROM_ROLE, Env.SUB|Env.ALWAYS);\r
1422                 try {\r
1423                         REQUEST rreq;\r
1424                         try {\r
1425                                 RosettaData<REQUEST> data = rolePermRequestDF.newData().load(req.getInputStream());\r
1426                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1427                                         Question.logEncryptTrace(trans,data.asString());\r
1428                                 }\r
1429                                 rreq = data.asObject();\r
1430                         } catch(APIException e) {\r
1431                                 trans.error().log("Invalid Input",IN,DELETE_PERM_FROM_ROLE);\r
1432                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1433 \r
1434                         }\r
1435                         Result<Void> rp = service.delPermFromRole(trans, rreq);\r
1436                         switch(rp.status) {\r
1437                                 case OK: \r
1438                                         setContentType(resp,permsDF.getOutType());\r
1439                                         resp.getOutputStream().println();\r
1440                                         return Result.ok();\r
1441                                 default:\r
1442                                         return Result.err(rp);\r
1443                         }\r
1444                 } catch (Exception e) {\r
1445                         trans.error().log(e,IN,DELETE_PERM_FROM_ROLE);\r
1446                         return Result.err(e);\r
1447                 } finally {\r
1448                         tt.done();\r
1449                 }\r
1450         }\r
1451 \r
1452         @Override\r
1453         public Result<Void> deleteRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1454                 TimeTaken tt = trans.start(DELETE_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
1455                 try {\r
1456                         Result<Void> rp = service.deleteRole(trans, role);\r
1457                         switch(rp.status) {\r
1458                                 case OK: \r
1459                                         setContentType(resp,permsDF.getOutType());\r
1460                                         return Result.ok();\r
1461                                 default:\r
1462                                         return Result.err(rp);\r
1463                         }\r
1464                 } catch (Exception e) {\r
1465                         trans.error().log(e,IN,DELETE_ROLE);\r
1466                         return Result.err(e);\r
1467                 } finally {\r
1468                         tt.done();\r
1469                 }\r
1470         }\r
1471 \r
1472         @Override\r
1473         public Result<Void> deleteRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1474                 TimeTaken tt = trans.start(DELETE_ROLE, Env.SUB|Env.ALWAYS);\r
1475                 try {\r
1476                         REQUEST rreq;\r
1477                         try {\r
1478                                 RosettaData<REQUEST> data = roleRequestDF.newData().load(req.getInputStream());\r
1479                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1480                                         Question.logEncryptTrace(trans,data.asString());\r
1481                                 }\r
1482                                 rreq = data.asObject();\r
1483                         } catch(APIException e) {\r
1484                                 trans.error().log("Invalid Input",IN,CREATE_ROLE);\r
1485                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1486                         }\r
1487 \r
1488                         Result<Void> rp = service.deleteRole(trans, rreq);\r
1489                         switch(rp.status) {\r
1490                                 case OK: \r
1491                                         setContentType(resp,permsDF.getOutType());\r
1492                                         return Result.ok();\r
1493                                 default:\r
1494                                         return Result.err(rp);\r
1495                         }\r
1496                 } catch (Exception e) {\r
1497                         trans.error().log(e,IN,DELETE_ROLE);\r
1498                         return Result.err(e);\r
1499                 } finally {\r
1500                         tt.done();\r
1501                 }\r
1502         }\r
1503 \r
1504         public static final String CREATE_CRED = "createUserCred";\r
1505         private static final String GET_CREDS_BY_NS = "getCredsByNS";\r
1506         private static final String GET_CREDS_BY_ID = "getCredsByID";\r
1507         public static final String UPDATE_CRED = "updateUserCred";\r
1508         public static final String EXTEND_CRED = "extendUserCred";\r
1509         public static final String DELETE_CRED = "deleteUserCred";\r
1510         public static final String DOES_CRED_MATCH = "doesCredMatch";\r
1511         public static final String VALIDATE_BASIC_AUTH = "validateBasicAuth";\r
1512 \r
1513 \r
1514 \r
1515         @Override\r
1516         /**\r
1517          * Create Credential\r
1518          * \r
1519          */\r
1520         public Result<Void> createUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1521                 TimeTaken tt = trans.start(CREATE_CRED, Env.SUB|Env.ALWAYS);\r
1522                 try {\r
1523                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1524                         if(Question.willSpecialLog(trans, trans.user())) {\r
1525                                 Question.logEncryptTrace(trans,data.asString());\r
1526                         }\r
1527                         return service.createUserCred(trans, data.asObject());\r
1528                 } catch(APIException e) {\r
1529                         trans.error().log(e,"Bad Input data");\r
1530                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1531                 } catch (Exception e) {\r
1532                         trans.error().log(e,IN,CREATE_CRED);\r
1533                         return Result.err(e);\r
1534                 } finally {\r
1535                         tt.done();\r
1536                 }\r
1537         }\r
1538 \r
1539         @Override\r
1540         public Result<Void> changeUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1541                 TimeTaken tt = trans.start(UPDATE_CRED, Env.SUB|Env.ALWAYS);\r
1542                 try {\r
1543                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1544                         if(Question.willSpecialLog(trans, trans.user())) {\r
1545                                 Question.logEncryptTrace(trans,data.asString());\r
1546                         }\r
1547 \r
1548                         return service.changeUserCred(trans, data.asObject());\r
1549                 } catch(APIException e) {\r
1550                         trans.error().log(e,"Bad Input data");\r
1551                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1552                 } catch (Exception e) {\r
1553                         trans.error().log(e,IN,UPDATE_CRED);\r
1554                         return Result.err(e);\r
1555                 } finally {\r
1556                         tt.done();\r
1557                 }\r
1558         }\r
1559 \r
1560         /* (non-Javadoc)\r
1561          * @see com.att.authz.facade.AuthzFacade#extendUserCred(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, int)\r
1562          */\r
1563         @Override\r
1564         public Result<Void> extendUserCred(AuthzTrans trans, HttpServletRequest req, String days) {\r
1565                 TimeTaken tt = trans.start(EXTEND_CRED, Env.SUB|Env.ALWAYS);\r
1566                 try {\r
1567                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1568                         if(Question.willSpecialLog(trans, trans.user())) {\r
1569                                 Question.logEncryptTrace(trans,data.asString());\r
1570                         }\r
1571 \r
1572                         return service.extendUserCred(trans, data.asObject(), days);\r
1573                 } catch(APIException e) {\r
1574                         trans.error().log(e,"Bad Input data");\r
1575                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1576                 } catch (Exception e) {\r
1577                         trans.error().log(e,IN,EXTEND_CRED);\r
1578                         return Result.err(e);\r
1579                 } finally {\r
1580                         tt.done();\r
1581                 }\r
1582         }\r
1583 \r
1584         @Override\r
1585         public Result<Void> getCredsByNS(AuthzTrans trans, HttpServletResponse resp, String ns) {\r
1586                 TimeTaken tt = trans.start(GET_CREDS_BY_NS + ' ' + ns, Env.SUB|Env.ALWAYS);\r
1587                 \r
1588                 try {\r
1589                         Result<USERS> ru = service.getCredsByNS(trans,ns);\r
1590                         switch(ru.status) {\r
1591                                 case OK: \r
1592                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1593                                         if(Question.willSpecialLog(trans,trans.user())) {\r
1594                                                 Question.logEncryptTrace(trans,data.asString());\r
1595                                         }\r
1596                                         data.to(resp.getOutputStream());\r
1597                                         setContentType(resp,usersDF.getOutType());\r
1598                                         return Result.ok();\r
1599                                 default:\r
1600                                         return Result.err(ru);\r
1601                         }\r
1602                 } catch (Exception e) {\r
1603                         trans.error().log(e,IN,GET_CREDS_BY_NS);\r
1604                         return Result.err(e);\r
1605                 } finally {\r
1606                         tt.done();\r
1607                 }\r
1608                 \r
1609         }\r
1610         \r
1611         \r
1612         /* (non-Javadoc)\r
1613          * @see com.att.authz.facade.AuthzFacade#getCredsByID(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1614          */\r
1615         @Override\r
1616         public Result<Void> getCredsByID(AuthzTrans trans, HttpServletResponse resp, String id) {\r
1617                 TimeTaken tt = trans.start(GET_CREDS_BY_ID + ' ' + id, Env.SUB|Env.ALWAYS);\r
1618                 \r
1619                 try {\r
1620                         Result<USERS> ru = service.getCredsByID(trans,id);\r
1621                         switch(ru.status) {\r
1622                                 case OK: \r
1623                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1624                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1625                                                 Question.logEncryptTrace(trans,data.asString());\r
1626                                         }\r
1627                                         data.to(resp.getOutputStream());\r
1628                                         setContentType(resp,usersDF.getOutType());\r
1629                                         return Result.ok();\r
1630                                 default:\r
1631                                         return Result.err(ru);\r
1632                         }\r
1633                 } catch (Exception e) {\r
1634                         trans.error().log(e,IN,GET_CREDS_BY_ID);\r
1635                         return Result.err(e);\r
1636                 } finally {\r
1637                         tt.done();\r
1638                 }\r
1639                 \r
1640         }\r
1641 \r
1642         @Override\r
1643         public Result<Void> deleteUserCred(AuthzTrans trans, HttpServletRequest req) {\r
1644                 TimeTaken tt = trans.start(DELETE_CRED, Env.SUB|Env.ALWAYS);\r
1645                 try {\r
1646                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1647                         if(Question.willSpecialLog(trans, trans.user())) {\r
1648                                 Question.logEncryptTrace(trans,data.asString());\r
1649                         }\r
1650 \r
1651                         return service.deleteUserCred(trans, data.asObject());\r
1652                 } catch(APIException e) {\r
1653                         trans.error().log(e,"Bad Input data");\r
1654                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1655                 } catch (Exception e) {\r
1656                         trans.error().log(e,IN,DELETE_CRED);\r
1657                         return Result.err(e);\r
1658                 } finally {\r
1659                         tt.done();\r
1660                 }       \r
1661         }\r
1662         \r
1663         \r
1664         @Override\r
1665         public Result<Date> doesCredentialMatch(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1666                 TimeTaken tt = trans.start(DOES_CRED_MATCH, Env.SUB|Env.ALWAYS);\r
1667                 try {\r
1668                         RosettaData<REQUEST> data = credRequestDF.newData().load(req.getInputStream());\r
1669                         if(Question.willSpecialLog(trans, trans.user())) {\r
1670                                 Question.logEncryptTrace(trans,data.asString());\r
1671                         }\r
1672 \r
1673                         return service.doesCredentialMatch(trans, data.asObject());\r
1674                 } catch(APIException e) {\r
1675                         trans.error().log(e,"Bad Input data");\r
1676                         return Result.err(Status.ERR_BadData, e.getLocalizedMessage());\r
1677                 } catch (IOException e) {\r
1678                         trans.error().log(e,IN,DOES_CRED_MATCH);\r
1679                         return Result.err(e);\r
1680                 } finally {\r
1681                         tt.done();\r
1682                 }       \r
1683         }\r
1684 \r
1685 \r
1686         @Override\r
1687         public Result<Void> validBasicAuth(AuthzTrans trans, HttpServletResponse resp, String basicAuth) {\r
1688                 TimeTaken tt = trans.start(VALIDATE_BASIC_AUTH, Env.SUB|Env.ALWAYS);\r
1689                 try {\r
1690                         Result<Date> result = service.validateBasicAuth(trans,basicAuth);\r
1691                         switch(result.status){\r
1692                                 case OK:\r
1693                                         resp.getOutputStream().write(Chrono.utcStamp(result.value).getBytes());\r
1694                                         return Result.ok();\r
1695                         }\r
1696                         return Result.err(result);\r
1697                 } catch (Exception e) {\r
1698                         trans.error().log(e,IN,VALIDATE_BASIC_AUTH);\r
1699                         return Result.err(e);\r
1700                 } finally {\r
1701                         tt.done();\r
1702                 }\r
1703         }\r
1704 \r
1705         /* (non-Javadoc)\r
1706          * @see com.att.authz.facade.AuthzFacade#getCertInfoByID(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String)\r
1707          */\r
1708         @Override\r
1709         public Result<Void> getCertInfoByID(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp, String id) {\r
1710                 TimeTaken tt = trans.start(GET_CERT_BY_ID, Env.SUB|Env.ALWAYS);\r
1711                 try {   \r
1712                         Result<CERTS> rci = service.getCertInfoByID(trans,req,id);\r
1713                         \r
1714                         switch(rci.status) {\r
1715                                 case OK: \r
1716                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1717                                                 RosettaData<CERTS> data = certsDF.newData(trans).load(rci.value);\r
1718                                                 Question.logEncryptTrace(trans,data.asString());\r
1719                                                 data.to(resp.getOutputStream());\r
1720                                         } else {\r
1721                                                 certsDF.direct(trans, rci.value, resp.getOutputStream());\r
1722                                         }\r
1723                                         setContentType(resp,certsDF.getOutType());\r
1724                                         return Result.ok();\r
1725                                 default:\r
1726                                         return Result.err(rci);\r
1727                         }\r
1728                 } catch (Exception e) {\r
1729                         trans.error().log(e,IN,GET_CERT_BY_ID);\r
1730                         return Result.err(e);\r
1731                 } finally {\r
1732                         tt.done();\r
1733                 }\r
1734         }\r
1735 \r
1736         public static final String CREATE_DELEGATE = "createDelegate";\r
1737         public static final String UPDATE_DELEGATE = "updateDelegate";\r
1738         public static final String DELETE_DELEGATE = "deleteDelegate";\r
1739         public static final String GET_DELEGATE_USER = "getDelegatesByUser";\r
1740         public static final String GET_DELEGATE_DELG = "getDelegatesByDelegate";\r
1741         \r
1742         @Override\r
1743         public Result<Void> createDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1744                 TimeTaken tt = trans.start(CREATE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1745                 try {   \r
1746                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1747                         if(Question.willSpecialLog(trans, trans.user())) {\r
1748                                 Question.logEncryptTrace(trans,data.asString());\r
1749                         }\r
1750 \r
1751                         return service.createDelegate(trans, data.asObject());\r
1752                 } catch (Exception e) {\r
1753                         trans.error().log(e,IN,CREATE_DELEGATE);\r
1754                         return Result.err(e);\r
1755                 } finally {\r
1756                         tt.done();\r
1757                 }\r
1758         }\r
1759         \r
1760         @Override\r
1761         public Result<Void> updateDelegate(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1762                 TimeTaken tt = trans.start(UPDATE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1763                 try {   \r
1764                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1765                         if(Question.willSpecialLog(trans, trans.user())) {\r
1766                                 Question.logEncryptTrace(trans,data.asString());\r
1767                         }\r
1768 \r
1769                         return service.updateDelegate(trans, data.asObject());\r
1770                 } catch (Exception e) {\r
1771                         trans.error().log(e,IN,UPDATE_DELEGATE);\r
1772                         return Result.err(e);\r
1773                 } finally {\r
1774                         tt.done();\r
1775                 }\r
1776         }\r
1777         \r
1778         @Override\r
1779         public Result<Void> deleteDelegate(AuthzTrans trans,  HttpServletRequest req, HttpServletResponse resp) {\r
1780                 TimeTaken tt = trans.start(DELETE_DELEGATE, Env.SUB|Env.ALWAYS);\r
1781                 try {\r
1782                         Data<REQUEST> data = delgRequestDF.newData().load(req.getInputStream());\r
1783                         if(Question.willSpecialLog(trans, trans.user())) {\r
1784                                 Question.logEncryptTrace(trans,data.asString());\r
1785                         }\r
1786 \r
1787                         return service.deleteDelegate(trans, data.asObject());\r
1788                 } catch (Exception e) {\r
1789                         trans.error().log(e,IN,DELETE_DELEGATE);\r
1790                         return Result.err(e);\r
1791                 } finally {\r
1792                         tt.done();\r
1793                 }\r
1794         }\r
1795         \r
1796         @Override\r
1797         public Result<Void> deleteDelegate(AuthzTrans trans, String userName) {\r
1798                 TimeTaken tt = trans.start(DELETE_DELEGATE + ' ' + userName, Env.SUB|Env.ALWAYS);\r
1799                 try {\r
1800                         return service.deleteDelegate(trans, userName);\r
1801                 } catch (Exception e) {\r
1802                         trans.error().log(e,IN,DELETE_DELEGATE);\r
1803                         return Result.err(e);\r
1804                 } finally {\r
1805                         tt.done();\r
1806                 }\r
1807         }\r
1808         \r
1809         @Override\r
1810         public Result<Void> getDelegatesByUser(AuthzTrans trans, String user, HttpServletResponse resp) {\r
1811                 TimeTaken tt = trans.start(GET_DELEGATE_USER, Env.SUB|Env.ALWAYS);\r
1812                 try {\r
1813                         Result<DELGS> rd = service.getDelegatesByUser(trans, user);\r
1814                         \r
1815                         switch(rd.status) {\r
1816                                 case OK: \r
1817                                         RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);\r
1818                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1819                                                 Question.logEncryptTrace(trans,data.asString());\r
1820                                         }\r
1821                                         data.to(resp.getOutputStream());\r
1822                                         setContentType(resp,delgDF.getOutType());\r
1823                                         return Result.ok();\r
1824                                 default:\r
1825                                         return Result.err(rd);\r
1826                         }\r
1827                 } catch (Exception e) {\r
1828                         trans.error().log(e,IN,GET_DELEGATE_USER);\r
1829                         return Result.err(e);\r
1830                 } finally {\r
1831                         tt.done();\r
1832                 }\r
1833         }\r
1834 \r
1835         @Override\r
1836         public Result<Void> getDelegatesByDelegate(AuthzTrans trans, String delegate, HttpServletResponse resp) {\r
1837                 TimeTaken tt = trans.start(GET_DELEGATE_DELG, Env.SUB|Env.ALWAYS);\r
1838                 try {\r
1839                         Result<DELGS> rd = service.getDelegatesByDelegate(trans, delegate);\r
1840                         switch(rd.status) {\r
1841                                 case OK: \r
1842                                         RosettaData<DELGS> data = delgDF.newData(trans).load(rd.value);\r
1843                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1844                                                 Question.logEncryptTrace(trans,data.asString());\r
1845                                         }\r
1846                                         data.to(resp.getOutputStream());\r
1847                                         setContentType(resp,delgDF.getOutType());\r
1848                                         return Result.ok();\r
1849                                 default:\r
1850                                         return Result.err(rd);\r
1851                         }\r
1852                 } catch (Exception e) {\r
1853                         trans.error().log(e,IN,GET_DELEGATE_DELG);\r
1854                         return Result.err(e);\r
1855                 } finally {\r
1856                         tt.done();\r
1857                 }\r
1858         }\r
1859 \r
1860         private static final String REQUEST_USER_ROLE = "createUserRole";\r
1861         private static final String GET_USERROLES = "getUserRoles";\r
1862         private static final String GET_USERROLES_BY_ROLE = "getUserRolesByRole";\r
1863         private static final String GET_USERROLES_BY_USER = "getUserRolesByUser";\r
1864         private static final String SET_ROLES_FOR_USER = "setRolesForUser";\r
1865         private static final String SET_USERS_FOR_ROLE = "setUsersForRole";\r
1866         private static final String EXTEND_USER_ROLE = "extendUserRole";\r
1867         private static final String DELETE_USER_ROLE = "deleteUserRole";\r
1868         @Override\r
1869         public Result<Void> requestUserRole(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
1870                 TimeTaken tt = trans.start(REQUEST_USER_ROLE, Env.SUB|Env.ALWAYS);\r
1871                 try {\r
1872                         REQUEST request;\r
1873                         try {\r
1874                                 Data<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
1875                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1876                                         Question.logEncryptTrace(trans,data.asString());\r
1877                                 }\r
1878 \r
1879                                 request = data.asObject();\r
1880                         } catch(APIException e) {\r
1881                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1882                         }\r
1883                         \r
1884                         Result<Void> rp = service.createUserRole(trans,request);\r
1885                         switch(rp.status) {\r
1886                                 case OK: \r
1887                                         setContentType(resp,permsDF.getOutType());\r
1888                                         return Result.ok();\r
1889                                 default:\r
1890                                         return Result.err(rp);\r
1891                         }\r
1892                 } catch (Exception e) {\r
1893                         trans.error().log(e,IN,REQUEST_USER_ROLE);\r
1894                         return Result.err(e);\r
1895                 } finally {\r
1896                         tt.done();\r
1897                 }\r
1898         }\r
1899         \r
1900         @Override\r
1901         public Result<Void> getUserInRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
1902                 TimeTaken tt = trans.start(GET_USERROLES + ' ' + user + '|' + role, Env.SUB|Env.ALWAYS);\r
1903                 try {\r
1904                         Result<USERS> ru = service.getUserInRole(trans,user,role);\r
1905                         switch(ru.status) {\r
1906                                 case OK: \r
1907                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
1908                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1909                                                 Question.logEncryptTrace(trans,data.asString());\r
1910                                         }\r
1911 \r
1912                                         data.to(resp.getOutputStream());\r
1913                                         setContentType(resp,usersDF.getOutType());\r
1914                                         return Result.ok();\r
1915                                 default:\r
1916                                         return Result.err(ru);\r
1917                         }\r
1918                 } catch (Exception e) {\r
1919                         trans.error().log(e,IN,GET_USERROLES);\r
1920                         return Result.err(e);\r
1921                 } finally {\r
1922                         tt.done();\r
1923                 }\r
1924 \r
1925         }\r
1926 \r
1927         @Override\r
1928         public Result<Void> getUserRolesByUser(AuthzTrans trans, HttpServletResponse resp, String user) {\r
1929                 TimeTaken tt = trans.start(GET_USERROLES_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
1930                 try {\r
1931                         Result<USERROLES> ru = service.getUserRolesByUser(trans,user);\r
1932                         switch(ru.status) {\r
1933                                 case OK: \r
1934                                         RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);\r
1935                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1936                                                 Question.logEncryptTrace(trans,data.asString());\r
1937                                         }\r
1938 \r
1939                                         data.to(resp.getOutputStream());\r
1940                                         setContentType(resp,usersDF.getOutType());\r
1941                                         return Result.ok();\r
1942                                 default:\r
1943                                         return Result.err(ru);\r
1944                         }\r
1945                 } catch (Exception e) {\r
1946                         trans.error().log(e,IN,GET_USERROLES_BY_USER);\r
1947                         return Result.err(e);\r
1948                 } finally {\r
1949                         tt.done();\r
1950                 }\r
1951 \r
1952         }\r
1953         \r
1954         @Override\r
1955         public Result<Void> getUserRolesByRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
1956                 TimeTaken tt = trans.start(GET_USERROLES_BY_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
1957                 try {\r
1958                         Result<USERROLES> ru = service.getUserRolesByRole(trans,role);\r
1959                         switch(ru.status) {\r
1960                                 case OK: \r
1961                                         RosettaData<USERROLES> data = userrolesDF.newData(trans).load(ru.value);\r
1962                                         if(Question.willSpecialLog(trans, trans.user())) {\r
1963                                                 Question.logEncryptTrace(trans,data.asString());\r
1964                                         }\r
1965 \r
1966                                         data.to(resp.getOutputStream());\r
1967                                         setContentType(resp,usersDF.getOutType());\r
1968                                         return Result.ok();\r
1969                                 default:\r
1970                                         return Result.err(ru);\r
1971                         }\r
1972                 } catch (Exception e) {\r
1973                         trans.error().log(e,IN,GET_USERROLES_BY_ROLE);\r
1974                         return Result.err(e);\r
1975                 } finally {\r
1976                         tt.done();\r
1977                 }\r
1978 \r
1979         }\r
1980         \r
1981 \r
1982         @Override\r
1983         public Result<Void> resetUsersForRole(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {\r
1984                 TimeTaken tt = trans.start(SET_USERS_FOR_ROLE, Env.SUB|Env.ALWAYS);\r
1985                 try {\r
1986                         REQUEST rreq;\r
1987                         try {\r
1988                                 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
1989                                 if(Question.willSpecialLog(trans, trans.user())) {\r
1990                                         Question.logEncryptTrace(trans,data.asString());\r
1991                                 }\r
1992                                 rreq = data.asObject();\r
1993                         } catch(APIException e) {\r
1994                                 trans.error().log("Invalid Input",IN, SET_USERS_FOR_ROLE);\r
1995                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
1996                         }\r
1997                         \r
1998                         Result<Void> rp = service.resetUsersForRole(trans, rreq);\r
1999                         \r
2000                         switch(rp.status) {\r
2001                                 case OK: \r
2002                                         setContentType(resp,permsDF.getOutType());\r
2003                                         return Result.ok();\r
2004                                 default:\r
2005                                         return Result.err(rp);\r
2006                         }\r
2007                 } catch (Exception e) {\r
2008                         trans.error().log(e,IN,SET_USERS_FOR_ROLE);\r
2009                         return Result.err(e);\r
2010                 } finally {\r
2011                         tt.done();\r
2012                 }\r
2013                 \r
2014         }\r
2015 \r
2016         @Override\r
2017         public Result<Void> resetRolesForUser(AuthzTrans trans, HttpServletResponse resp, HttpServletRequest req) {\r
2018                 TimeTaken tt = trans.start(SET_ROLES_FOR_USER, Env.SUB|Env.ALWAYS);\r
2019                 try {\r
2020                         REQUEST rreq;\r
2021                         try {\r
2022                                 RosettaData<REQUEST> data = userRoleRequestDF.newData().load(req.getInputStream());\r
2023                                 if(Question.willSpecialLog(trans, trans.user())) {\r
2024                                         Question.logEncryptTrace(trans,data.asString());\r
2025                                 }\r
2026 \r
2027                                 rreq = data.asObject();\r
2028                         } catch(APIException e) {\r
2029                                 trans.error().log("Invalid Input",IN, SET_ROLES_FOR_USER);\r
2030                                 return Result.err(Status.ERR_BadData,"Invalid Input");\r
2031                         }\r
2032                         \r
2033                         Result<Void> rp = service.resetRolesForUser(trans, rreq);\r
2034                         \r
2035                         switch(rp.status) {\r
2036                                 case OK: \r
2037                                         setContentType(resp,permsDF.getOutType());\r
2038                                         return Result.ok();\r
2039                                 default:\r
2040                                         return Result.err(rp);\r
2041                         }\r
2042                 } catch (Exception e) {\r
2043                         trans.error().log(e,IN,SET_ROLES_FOR_USER);\r
2044                         return Result.err(e);\r
2045                 } finally {\r
2046                         tt.done();\r
2047                 }\r
2048                 \r
2049         }\r
2050 \r
2051         /* (non-Javadoc)\r
2052          * @see com.att.authz.facade.AuthzFacade#extendUserRoleExpiration(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String)\r
2053          */\r
2054         @Override\r
2055         public Result<Void> extendUserRoleExpiration(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
2056                 TimeTaken tt = trans.start(EXTEND_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);\r
2057                 try {\r
2058                         return service.extendUserRole(trans,user,role);\r
2059                 } catch (Exception e) {\r
2060                         trans.error().log(e,IN,EXTEND_USER_ROLE);\r
2061                         return Result.err(e);\r
2062                 } finally {\r
2063                         tt.done();\r
2064                 }\r
2065         }\r
2066 \r
2067         @Override\r
2068         public Result<Void> deleteUserRole(AuthzTrans trans, HttpServletResponse resp, String user, String role) {\r
2069                 TimeTaken tt = trans.start(DELETE_USER_ROLE + ' ' + user + ' ' + role, Env.SUB|Env.ALWAYS);\r
2070                 try {\r
2071                         Result<Void> rp = service.deleteUserRole(trans,user,role);\r
2072                         switch(rp.status) {\r
2073                                 case OK: \r
2074                                         setContentType(resp,permsDF.getOutType());\r
2075                                         return Result.ok();\r
2076                                 default:\r
2077                                         return Result.err(rp);\r
2078                         }\r
2079                 } catch (Exception e) {\r
2080                         trans.error().log(e,IN,DELETE_USER_ROLE);\r
2081                         return Result.err(e);\r
2082                 } finally {\r
2083                         tt.done();\r
2084                 }\r
2085         }\r
2086 \r
2087         private static final String UPDATE_APPROVAL = "updateApproval";\r
2088         private static final String GET_APPROVALS_BY_USER = "getApprovalsByUser.";\r
2089         private static final String GET_APPROVALS_BY_TICKET = "getApprovalsByTicket.";\r
2090         private static final String GET_APPROVALS_BY_APPROVER = "getApprovalsByApprover.";\r
2091         \r
2092         @Override\r
2093         public Result<Void> updateApproval(AuthzTrans trans, HttpServletRequest req, HttpServletResponse resp) {\r
2094                 TimeTaken tt = trans.start(UPDATE_APPROVAL, Env.SUB|Env.ALWAYS);\r
2095                 try {\r
2096                         Data<APPROVALS> data = approvalDF.newData().load(req.getInputStream());\r
2097                         if(Question.willSpecialLog(trans, trans.user())) {\r
2098                                 Question.logEncryptTrace(trans,data.asString());\r
2099                         }\r
2100 \r
2101                         Result<Void> rp = service.updateApproval(trans, data.asObject());\r
2102                         \r
2103                         switch(rp.status) {\r
2104                                 case OK: \r
2105                                         setContentType(resp,approvalDF.getOutType());\r
2106                                         return Result.ok();\r
2107                                 default:\r
2108                                         return Result.err(rp);\r
2109                         }\r
2110                 } catch (Exception e) {\r
2111                         trans.error().log(e,IN,UPDATE_APPROVAL);\r
2112                         return Result.err(e);\r
2113                 } finally {\r
2114                         tt.done();\r
2115                 }\r
2116         }\r
2117         \r
2118         @Override\r
2119         public Result<Void> getApprovalsByUser(AuthzTrans trans, HttpServletResponse resp, String user) {\r
2120                 TimeTaken tt = trans.start(GET_APPROVALS_BY_USER + ' ' + user, Env.SUB|Env.ALWAYS);\r
2121                 try {\r
2122                         Result<APPROVALS> rp = service.getApprovalsByUser(trans, user);\r
2123                         switch(rp.status) {\r
2124                                 case OK: \r
2125                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2126                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2127                                                 Question.logEncryptTrace(trans,data.asString());\r
2128                                         }\r
2129                                         data.to(resp.getOutputStream());\r
2130                                         \r
2131                                         setContentType(resp,permsDF.getOutType());\r
2132                                         return Result.ok();\r
2133                                 default:\r
2134                                         return Result.err(rp);\r
2135                         }\r
2136                 } catch (Exception e) {\r
2137                         trans.error().log(e,IN,GET_APPROVALS_BY_USER, user);\r
2138                         return Result.err(e);\r
2139                 } finally {\r
2140                         tt.done();\r
2141                 }\r
2142         }\r
2143 \r
2144         @Override\r
2145         public Result<Void> getApprovalsByApprover(AuthzTrans trans, HttpServletResponse resp, String approver) {\r
2146                 TimeTaken tt = trans.start(GET_APPROVALS_BY_APPROVER + ' ' + approver, Env.SUB|Env.ALWAYS);\r
2147                 try {\r
2148                         Result<APPROVALS> rp = service.getApprovalsByApprover(trans, approver);\r
2149                         switch(rp.status) {\r
2150                                 case OK: \r
2151                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2152                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2153                                                 Question.logEncryptTrace(trans,data.asString());\r
2154                                         }\r
2155 \r
2156                                         data.to(resp.getOutputStream());\r
2157                                         setContentType(resp,permsDF.getOutType());\r
2158                                         return Result.ok();\r
2159                                 default:\r
2160                                         return Result.err(rp);\r
2161                         }\r
2162                 } catch (Exception e) {\r
2163                         trans.error().log(e,IN,GET_APPROVALS_BY_APPROVER,approver);\r
2164                         return Result.err(e);\r
2165                 } finally {\r
2166                         tt.done();\r
2167                 }\r
2168         }\r
2169 \r
2170         @Override\r
2171         public Result<Void> getApprovalsByTicket(AuthzTrans trans, HttpServletResponse resp, String ticket) {\r
2172                 TimeTaken tt = trans.start(GET_APPROVALS_BY_TICKET, Env.SUB|Env.ALWAYS);\r
2173                 try {\r
2174                         Result<APPROVALS> rp = service.getApprovalsByTicket(trans, ticket);\r
2175                         switch(rp.status) {\r
2176                                 case OK: \r
2177                                         RosettaData<APPROVALS> data = approvalDF.newData(trans).load(rp.value);\r
2178                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2179                                                 Question.logEncryptTrace(trans,data.asString());\r
2180                                         }\r
2181 \r
2182                                         data.to(resp.getOutputStream());\r
2183                                         setContentType(resp,permsDF.getOutType());\r
2184                                         return Result.ok();\r
2185                                 default:\r
2186                                         return Result.err(rp);\r
2187                         }\r
2188                 } catch (Exception e) {\r
2189                         trans.error().log(e,IN,GET_APPROVALS_BY_TICKET);\r
2190                         return Result.err(e);\r
2191                 } finally {\r
2192                         tt.done();\r
2193                 }\r
2194         }\r
2195 \r
2196 \r
2197         \r
2198         public static final String GET_USERS_PERMISSION = "getUsersByPermission";\r
2199         public static final String GET_USERS_ROLE = "getUsersByRole";\r
2200 \r
2201         /* (non-Javadoc)\r
2202          * @see com.att.authz.facade.AuthzFacade#getUsersByRole(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
2203          */\r
2204         @Override\r
2205         public Result<Void> getUsersByRole(AuthzTrans trans, HttpServletResponse resp, String role) {\r
2206                 TimeTaken tt = trans.start(GET_USERS_ROLE + ' ' + role, Env.SUB|Env.ALWAYS);\r
2207                 try {\r
2208                         Result<USERS> ru = service.getUsersByRole(trans,role);\r
2209                         switch(ru.status) {\r
2210                                 case OK: \r
2211                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
2212                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2213                                                 Question.logEncryptTrace(trans,data.asString());\r
2214                                         }\r
2215 \r
2216                                         data.to(resp.getOutputStream());\r
2217                                         setContentType(resp,usersDF.getOutType());\r
2218                                         return Result.ok();\r
2219                                 default:\r
2220                                         return Result.err(ru);\r
2221                         }\r
2222                 } catch (Exception e) {\r
2223                         trans.error().log(e,IN,GET_USERS_ROLE);\r
2224                         return Result.err(e);\r
2225                 } finally {\r
2226                         tt.done();\r
2227                 }\r
2228         }\r
2229 \r
2230         /* (non-Javadoc)\r
2231          * @see com.att.authz.facade.AuthzFacade#getUsersByPermission(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, java.lang.String, java.lang.String)\r
2232          */\r
2233         @Override\r
2234         public Result<Void> getUsersByPermission(AuthzTrans trans, HttpServletResponse resp, \r
2235                         String type, String instance, String action) {\r
2236                 TimeTaken tt = trans.start(GET_USERS_PERMISSION + ' ' + type + ' ' + instance + ' ' +action, Env.SUB|Env.ALWAYS);\r
2237                 try {\r
2238                         Result<USERS> ru = service.getUsersByPermission(trans,type,instance,action);\r
2239                         switch(ru.status) {\r
2240                                 case OK: \r
2241                                         RosettaData<USERS> data = usersDF.newData(trans).load(ru.value);\r
2242                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2243                                                 Question.logEncryptTrace(trans,data.asString());\r
2244                                         }\r
2245 \r
2246                                         data.to(resp.getOutputStream());\r
2247                                         setContentType(resp,usersDF.getOutType());\r
2248                                         return Result.ok();\r
2249                                 default:\r
2250                                         return Result.err(ru);\r
2251                         }\r
2252                 } catch (Exception e) {\r
2253                         trans.error().log(e,IN,GET_USERS_PERMISSION);\r
2254                         return Result.err(e);\r
2255                 } finally {\r
2256                         tt.done();\r
2257                 }\r
2258         }\r
2259 \r
2260         \r
2261         public static final String GET_HISTORY_USER = "getHistoryByUser";\r
2262         public static final String GET_HISTORY_ROLE = "getHistoryByRole";\r
2263         public static final String GET_HISTORY_PERM = "getHistoryByPerm";\r
2264         public static final String GET_HISTORY_NS = "getHistoryByNS";\r
2265         /* (non-Javadoc)\r
2266          * @see com.att.authz.facade.AuthzFacade#getHistoryByUser(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)\r
2267          */\r
2268         @Override\r
2269         public Result<Void> getHistoryByUser(AuthzTrans trans, HttpServletResponse resp, String user, int[] yyyymm, final int sort) {\r
2270                 StringBuilder sb = new StringBuilder();\r
2271                 sb.append(GET_HISTORY_USER);\r
2272                 sb.append(' ');\r
2273                 sb.append(user);\r
2274                 sb.append(" for ");\r
2275                 boolean first = true;\r
2276                 for(int i : yyyymm) {\r
2277                         if(first) {\r
2278                             first = false;\r
2279                         } else {\r
2280                             sb.append(',');\r
2281                         }\r
2282                         sb.append(i);\r
2283                 }\r
2284                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2285 \r
2286                 try {\r
2287                         Result<HISTORY> rh = service.getHistoryByUser(trans,user,yyyymm,sort);\r
2288                         switch(rh.status) {\r
2289                                 case OK: \r
2290                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2291                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2292                                                 Question.logEncryptTrace(trans,data.asString());\r
2293                                         }\r
2294 \r
2295                                         data.to(resp.getOutputStream());\r
2296                                         setContentType(resp,historyDF.getOutType());\r
2297                                         return Result.ok();\r
2298                                 default:\r
2299                                         return Result.err(rh);\r
2300                         }\r
2301                 } catch (Exception e) {\r
2302                         trans.error().log(e,IN,GET_HISTORY_USER);\r
2303                         return Result.err(e);\r
2304                 } finally {\r
2305                         tt.done();\r
2306                 }\r
2307         }\r
2308 \r
2309         /* (non-Javadoc)\r
2310          * @see com.att.authz.facade.AuthzFacade#getHistoryByRole(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2311          */\r
2312         @Override\r
2313         public Result<Void> getHistoryByRole(AuthzTrans trans, HttpServletResponse resp, String role, int[] yyyymm, final int sort) {\r
2314                 StringBuilder sb = new StringBuilder();\r
2315                 sb.append(GET_HISTORY_ROLE);\r
2316                 sb.append(' ');\r
2317                 sb.append(role);\r
2318                 sb.append(" for ");\r
2319                 boolean first = true;\r
2320                 for(int i : yyyymm) {\r
2321                         if(first) {\r
2322                             first = false;\r
2323                         } else {\r
2324                             sb.append(',');\r
2325                         }\r
2326                         sb.append(i);\r
2327                 }\r
2328                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2329                 try {\r
2330                         Result<HISTORY> rh = service.getHistoryByRole(trans,role,yyyymm,sort);\r
2331                         switch(rh.status) {\r
2332                                 case OK: \r
2333                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2334                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2335                                                 Question.logEncryptTrace(trans,data.asString());\r
2336                                         }\r
2337 \r
2338                                         data.to(resp.getOutputStream());\r
2339                                         setContentType(resp,historyDF.getOutType());\r
2340                                         return Result.ok();\r
2341                                 default:\r
2342                                         return Result.err(rh);\r
2343                         }\r
2344                 } catch (Exception e) {\r
2345                         trans.error().log(e,IN,GET_HISTORY_ROLE);\r
2346                         return Result.err(e);\r
2347                 } finally {\r
2348                         tt.done();\r
2349                 }\r
2350         }\r
2351 \r
2352         /* (non-Javadoc)\r
2353          * @see com.att.authz.facade.AuthzFacade#getHistoryByNS(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2354          */\r
2355         @Override\r
2356         public Result<Void> getHistoryByNS(AuthzTrans trans, HttpServletResponse resp, String ns, int[] yyyymm, final int sort) {\r
2357                 StringBuilder sb = new StringBuilder();\r
2358                 sb.append(GET_HISTORY_NS);\r
2359                 sb.append(' ');\r
2360                 sb.append(ns);\r
2361                 sb.append(" for ");\r
2362                 boolean first = true;\r
2363                 for(int i : yyyymm) {\r
2364                         if(first) {\r
2365                             first = false;\r
2366                         } else {\r
2367                             sb.append(',');\r
2368                         }\r
2369                         sb.append(i);\r
2370                 }\r
2371                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2372                 try {\r
2373                         Result<HISTORY> rh = service.getHistoryByNS(trans,ns,yyyymm,sort);\r
2374                         switch(rh.status) {\r
2375                                 case OK: \r
2376                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2377                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2378                                                 Question.logEncryptTrace(trans,data.asString());\r
2379                                         }\r
2380 \r
2381                                         data.to(resp.getOutputStream());\r
2382                                         setContentType(resp,historyDF.getOutType());\r
2383                                         return Result.ok();\r
2384                                 default:\r
2385                                         return Result.err(rh);\r
2386                         }\r
2387                 } catch (Exception e) {\r
2388                         trans.error().log(e,IN,GET_HISTORY_NS);\r
2389                         return Result.err(e);\r
2390                 } finally {\r
2391                         tt.done();\r
2392                 }\r
2393         }\r
2394 \r
2395         /* (non-Javadoc)\r
2396          * @see com.att.authz.facade.AuthzFacade#getHistoryByPerm(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String, int[])\r
2397          */\r
2398         @Override\r
2399         public Result<Void> getHistoryByPerm(AuthzTrans trans, HttpServletResponse resp, String perm, int[] yyyymm, final int sort) {\r
2400                 StringBuilder sb = new StringBuilder();\r
2401                 sb.append(GET_HISTORY_PERM);\r
2402                 sb.append(' ');\r
2403                 sb.append(perm);\r
2404                 sb.append(" for ");\r
2405                 boolean first = true;\r
2406                 for(int i : yyyymm) {\r
2407                         if(first) {\r
2408                             first = false;\r
2409                         } else {\r
2410                             sb.append(',');\r
2411                         }\r
2412                         sb.append(i);\r
2413                 }\r
2414                 TimeTaken tt = trans.start(sb.toString(), Env.SUB|Env.ALWAYS);\r
2415                 try {\r
2416                         Result<HISTORY> rh = service.getHistoryByPerm(trans,perm,yyyymm,sort);\r
2417                         switch(rh.status) {\r
2418                                 case OK: \r
2419                                         RosettaData<HISTORY> data = historyDF.newData(trans).load(rh.value);\r
2420                                         if(Question.willSpecialLog(trans, trans.user())) {\r
2421                                                 Question.logEncryptTrace(trans,data.asString());\r
2422                                         }\r
2423 \r
2424                                         data.to(resp.getOutputStream());\r
2425                                         setContentType(resp,historyDF.getOutType());\r
2426                                         return Result.ok();\r
2427                                 default:\r
2428                                         return Result.err(rh);\r
2429                         }\r
2430                 } catch (Exception e) {\r
2431                         trans.error().log(e,IN,GET_HISTORY_PERM);\r
2432                         return Result.err(e);\r
2433                 } finally {\r
2434                         tt.done();\r
2435                 }\r
2436         }\r
2437 \r
2438         public final static String CACHE_CLEAR = "cacheClear "; \r
2439 //      public final static String CACHE_VALIDATE = "validateCache";\r
2440         \r
2441         /* (non-Javadoc)\r
2442          * @see com.att.authz.facade.AuthzFacade#cacheClear(com.att.authz.env.AuthzTrans, java.lang.String)\r
2443          */\r
2444         @Override\r
2445         public Result<Void> cacheClear(AuthzTrans trans, String cname) {\r
2446                 TimeTaken tt = trans.start(CACHE_CLEAR + cname, Env.SUB|Env.ALWAYS);\r
2447                 try {\r
2448                         return service.cacheClear(trans,cname);\r
2449                 } catch (Exception e) {\r
2450                         trans.error().log(e,IN,CACHE_CLEAR);\r
2451                         return Result.err(e);\r
2452                 } finally {\r
2453                         tt.done();\r
2454                 }\r
2455         }\r
2456 \r
2457         /* (non-Javadoc)\r
2458  * @see com.att.authz.facade.AuthzFacade#cacheClear(com.att.authz.env.AuthzTrans, java.lang.String, java.lang.Integer)\r
2459  */\r
2460         @Override\r
2461         public Result<Void> cacheClear(AuthzTrans trans, String cname,  String segments) {\r
2462                 TimeTaken tt = trans.start(CACHE_CLEAR + cname + ", segments[" + segments + ']', Env.SUB|Env.ALWAYS);\r
2463                 try {\r
2464                         String[] segs = segments.split("\\s*,\\s*");\r
2465                         int isegs[] = new int[segs.length];\r
2466                         for(int i=0;i<segs.length;++i) {\r
2467                                 try {\r
2468                                         isegs[i] = Integer.parseInt(segs[i]);\r
2469                                 } catch(NumberFormatException nfe) {\r
2470                                         isegs[i] = -1;\r
2471                                 }\r
2472                         }\r
2473                         return service.cacheClear(trans,cname, isegs);\r
2474                 } catch (Exception e) {\r
2475                         trans.error().log(e,IN,CACHE_CLEAR);\r
2476                         return Result.err(e);\r
2477                 } finally {\r
2478                         tt.done();\r
2479                 }\r
2480         }\r
2481 \r
2482         /* (non-Javadoc)\r
2483          * @see com.att.authz.facade.AuthzFacade#dbReset(com.att.authz.env.AuthzTrans)\r
2484          */\r
2485         @Override\r
2486         public void dbReset(AuthzTrans trans) {\r
2487                 service.dbReset(trans);\r
2488         }\r
2489 \r
2490         /* (non-Javadoc)\r
2491          * @see com.att.authz.facade.AuthzFacade#getAPI(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse)\r
2492          */\r
2493         public final static String API_REPORT = "apiReport";\r
2494         @Override\r
2495         public Result<Void> getAPI(AuthzTrans trans, HttpServletResponse resp, RServlet<AuthzTrans> rservlet) {\r
2496                 TimeTaken tt = trans.start(API_REPORT, Env.SUB);\r
2497                 try {\r
2498                         Api api = new Api();\r
2499                         Api.Route ar;\r
2500                         Method[] meths = AuthzCassServiceImpl.class.getDeclaredMethods();\r
2501                         for(RouteReport rr : rservlet.routeReport()) {\r
2502                                 api.getRoute().add(ar = new Api.Route());\r
2503                                 ar.setMeth(rr.meth.name());\r
2504                                 ar.setPath(rr.path);\r
2505                                 ar.setDesc(rr.desc);\r
2506                                 ar.getContentType().addAll(rr.contextTypes);\r
2507                                 for(Method m : meths) {\r
2508                                         ApiDoc ad;\r
2509                                         if((ad = m.getAnnotation(ApiDoc.class))!=null &&\r
2510                                                         rr.meth.equals(ad.method()) &&\r
2511                                                     rr.path.equals(ad.path())) {\r
2512                                                 for(String param : ad.params()) {\r
2513                                                         ar.getParam().add(param);\r
2514                                                 }\r
2515                                                 for(String text : ad.text()) {\r
2516                                                         ar.getComments().add(text);\r
2517                                                 }\r
2518                                                 ar.setExpected(ad.expectedCode());\r
2519                                                 for(int ec : ad.errorCodes()) {\r
2520                                                         ar.getExplicitErr().add(ec);\r
2521                                                 }\r
2522                                         }\r
2523                                 }\r
2524                         }\r
2525                         RosettaData<Api> data = apiDF.newData(trans).load(api);\r
2526                         if(Question.willSpecialLog(trans, trans.user())) {\r
2527                                 Question.logEncryptTrace(trans,data.asString());\r
2528                         }\r
2529 \r
2530                         data.to(resp.getOutputStream());\r
2531                         setContentType(resp,apiDF.getOutType());\r
2532                         return Result.ok();\r
2533 \r
2534                 } catch (Exception e) {\r
2535                         trans.error().log(e,IN,API_REPORT);\r
2536                         return Result.err(e);\r
2537                 } finally {\r
2538                         tt.done();\r
2539                 }\r
2540         }\r
2541         \r
2542 \r
2543         public final static String API_EXAMPLE = "apiExample";\r
2544 \r
2545         /* (non-Javadoc)\r
2546          * @see com.att.authz.facade.AuthzFacade#getAPIExample(com.att.authz.env.AuthzTrans, javax.servlet.http.HttpServletResponse, java.lang.String)\r
2547          */\r
2548         @Override\r
2549         public Result<Void> getAPIExample(AuthzTrans trans, HttpServletResponse resp, String nameOrContentType, boolean optional) {\r
2550                 TimeTaken tt = trans.start(API_EXAMPLE, Env.SUB);\r
2551                 try {\r
2552                         String content =Examples.print(apiDF.getEnv(), nameOrContentType, optional); \r
2553                         resp.getOutputStream().print(content);\r
2554                         setContentType(resp,content.contains("<?xml")?TYPE.XML:TYPE.JSON);\r
2555                         return Result.ok();\r
2556                 } catch (Exception e) {\r
2557                         trans.error().log(e,IN,API_EXAMPLE);\r
2558                         return Result.err(Status.ERR_NotImplemented,e.getMessage());\r
2559                 } finally {\r
2560                         tt.done();\r
2561                 }\r
2562         }\r
2563 \r
2564 }\r