authz-service/src/main/java/com/att/authz/service/mapper/Mapper_2_0.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.service.mapper;\r
  24 \r
  25 import java.nio.ByteBuffer;\r
  26 import java.util.ArrayList;\r
  27 import java.util.Collection;\r
  28 import java.util.Collections;\r
  29 import java.util.Comparator;\r
  30 import java.util.Date;\r
  31 import java.util.GregorianCalendar;\r
  32 import java.util.List;\r
  33 import java.util.UUID;\r
  34 \r
  35 import javax.xml.datatype.XMLGregorianCalendar;\r
  36 \r
  37 import com.att.authz.env.AuthzTrans;\r
  38 import com.att.authz.layer.Result;\r
  39 import com.att.authz.org.Organization;\r
  40 import com.att.authz.org.Organization.Expiration;\r
  41 import com.att.authz.service.MayChange;\r
  42 import com.att.cadi.aaf.marshal.CertsMarshal;\r
  43 import com.att.cadi.util.Vars;\r
  44 import com.att.cssa.rserv.Pair;\r
  45 import com.att.dao.Bytification;\r
  46 import com.att.dao.aaf.cass.ApprovalDAO;\r
  47 import com.att.dao.aaf.cass.CertDAO;\r
  48 import com.att.dao.aaf.cass.CredDAO;\r
  49 import com.att.dao.aaf.cass.DelegateDAO;\r
  50 import com.att.dao.aaf.cass.DelegateDAO.Data;\r
  51 import com.att.dao.aaf.cass.FutureDAO;\r
  52 import com.att.dao.aaf.cass.HistoryDAO;\r
  53 import com.att.dao.aaf.cass.Namespace;\r
  54 import com.att.dao.aaf.cass.NsSplit;\r
  55 import com.att.dao.aaf.cass.NsType;\r
  56 import com.att.dao.aaf.cass.PermDAO;\r
  57 import com.att.dao.aaf.cass.RoleDAO;\r
  58 import com.att.dao.aaf.cass.Status;\r
  59 import com.att.dao.aaf.cass.UserRoleDAO;\r
  60 import com.att.dao.aaf.hl.Question;\r
  61 import com.att.dao.aaf.hl.Question.Access;\r
  62 import com.att.inno.env.Env;\r
  63 import com.att.inno.env.TimeTaken;\r
  64 import com.att.inno.env.util.Chrono;\r
  65 import com.att.rosetta.Marshal;\r
  66 \r
  67 import aaf.v2_0.Api;\r
  68 import aaf.v2_0.Approval;\r
  69 import aaf.v2_0.Approvals;\r
  70 import aaf.v2_0.Certs;\r
  71 import aaf.v2_0.Certs.Cert;\r
  72 import aaf.v2_0.CredRequest;\r
  73 import aaf.v2_0.Delg;\r
  74 import aaf.v2_0.DelgRequest;\r
  75 import aaf.v2_0.Delgs;\r
  76 import aaf.v2_0.Error;\r
  77 import aaf.v2_0.History;\r
  78 import aaf.v2_0.History.Item;\r
  79 import aaf.v2_0.Keys;\r
  80 import aaf.v2_0.NsRequest;\r
  81 import aaf.v2_0.Nss;\r
  82 import aaf.v2_0.Nss.Ns;\r
  83 import aaf.v2_0.Nss.Ns.Attrib;\r
  84 import aaf.v2_0.Perm;\r
  85 import aaf.v2_0.PermKey;\r
  86 import aaf.v2_0.PermRequest;\r
  87 import aaf.v2_0.Perms;\r
  88 import aaf.v2_0.Pkey;\r
  89 import aaf.v2_0.Request;\r
  90 import aaf.v2_0.Role;\r
  91 import aaf.v2_0.RolePermRequest;\r
  92 import aaf.v2_0.RoleRequest;\r
  93 import aaf.v2_0.Roles;\r
  94 import aaf.v2_0.UserRole;\r
  95 import aaf.v2_0.UserRoleRequest;\r
  96 import aaf.v2_0.UserRoles;\r
  97 import aaf.v2_0.Users;\r
  98 import aaf.v2_0.Users.User;\r
  99 \r
 100 public class Mapper_2_0 implements Mapper<Nss, Perms, Pkey, Roles, Users, UserRoles, Delgs, Certs, Keys, Request, History, Error, Approvals> {\r
 101         private Question q;\r
 102 \r
 103         public Mapper_2_0(Question q) {\r
 104                 this.q = q;\r
 105         }\r
 106         \r
 107         /* (non-Javadoc)\r
 108          * @see com.att.authz.service.mapper.Mapper#ns(java.lang.Object, com.att.authz.service.mapper.Mapper.Holder)\r
 109          */\r
 110         @Override\r
 111         public Result<Namespace> ns(AuthzTrans trans, Request base) {\r
 112                 NsRequest from = (NsRequest)base;\r
 113                 Namespace namespace = new Namespace();\r
 114                 namespace.name = from.getName();\r
 115                 namespace.admin = from.getAdmin();\r
 116                 namespace.owner = from.getResponsible();\r
 117                 namespace.description = from.getDescription();\r
 118                 trans.checkpoint(namespace.name, Env.ALWAYS);\r
 119                 \r
 120                 NsType nt = NsType.fromString(from.getType());\r
 121                 if(nt.equals(NsType.UNKNOWN)) {\r
 122                         String ns = namespace.name;\r
 123                         int count = 0;\r
 124                         for(int i=ns.indexOf('.');\r
 125                                         i>=0;\r
 126                                         i=ns.indexOf('.',i+1)) {\r
 127                                 ++count;\r
 128                         }\r
 129                         switch(count) {\r
 130                                 case 0: nt = NsType.ROOT;break;\r
 131                                 case 1: nt = NsType.COMPANY;break;\r
 132                                 default: nt = NsType.APP;\r
 133                         }\r
 134                 }\r
 135                 namespace.type = nt.type;\r
 136                 \r
 137                 return Result.ok(namespace);\r
 138         }\r
 139 \r
 140         @Override\r
 141         public Result<Nss> nss(AuthzTrans trans, Namespace from, Nss to) {\r
 142                 List<Ns> nss = to.getNs();\r
 143                 Ns ns = new Ns();\r
 144                 ns.setName(from.name);\r
 145                 if(from.admin!=null)ns.getAdmin().addAll(from.admin);\r
 146                 if(from.owner!=null)ns.getResponsible().addAll(from.owner);\r
 147                 if(from.attrib!=null) {\r
 148                         for(Pair<String,String> attrib : from.attrib) {\r
 149                                 Attrib toAttrib = new Attrib();\r
 150                                 toAttrib.setKey(attrib.x);\r
 151                                 toAttrib.setValue(attrib.y);\r
 152                                 ns.getAttrib().add(toAttrib);\r
 153                         }\r
 154                 }\r
 155 \r
 156                 ns.setDescription(from.description);\r
 157                 nss.add(ns);\r
 158                 return Result.ok(to);\r
 159         }\r
 160 \r
 161         /**\r
 162          * Note: Prevalidate if NS given is allowed to be seen before calling\r
 163          */\r
 164         @Override\r
 165         public Result<Nss> nss(AuthzTrans trans, Collection<Namespace> from, Nss to) {\r
 166                 List<Ns> nss = to.getNs();\r
 167                 for(Namespace nd : from) {\r
 168                         Ns ns = new Ns();\r
 169                         ns.setName(nd.name);\r
 170                         ns.getAdmin().addAll(nd.admin);\r
 171                         ns.getResponsible().addAll(nd.owner);\r
 172                         ns.setDescription(nd.description);\r
 173                         if(nd.attrib!=null) {\r
 174                                 for(Pair<String,String> attrib : nd.attrib) {\r
 175                                         Attrib toAttrib = new Attrib();\r
 176                                         toAttrib.setKey(attrib.x);\r
 177                                         toAttrib.setValue(attrib.y);\r
 178                                         ns.getAttrib().add(toAttrib);\r
 179                                 }\r
 180                         }\r
 181 \r
 182                         nss.add(ns);\r
 183                 }\r
 184                 return Result.ok(to);\r
 185         }\r
 186 \r
 187         @Override\r
 188         public Result<Perms> perms(AuthzTrans trans, List<PermDAO.Data> from, Perms to, boolean filter) {\r
 189                 List<Perm> perms = to.getPerm();\r
 190                 TimeTaken tt = trans.start("Filter Perms before return", Env.SUB);\r
 191                 try {\r
 192                         if(from!=null) {\r
 193                                 for (PermDAO.Data data : from) {\r
 194                                         if(!filter || q.mayUser(trans, trans.user(), data, Access.read).isOK()) {\r
 195                                                 Perm perm = new Perm();\r
 196                                                 perm.setType(data.fullType());\r
 197                                                 perm.setInstance(data.instance);\r
 198                                                 perm.setAction(data.action);\r
 199                                                 for(String role : data.roles(false)) {\r
 200                                                         perm.getRoles().add(role);\r
 201                                                 }\r
 202                                                 perm.setDescription(data.description);\r
 203                                                 perms.add(perm);\r
 204                                         }\r
 205                                 }\r
 206                         }\r
 207                 } finally {\r
 208                         tt.done();\r
 209                 }\r
 210                  \r
 211                 tt = trans.start("Sort Perms", Env.SUB);\r
 212                 try {\r
 213                         Collections.sort(perms, new Comparator<Perm>() {\r
 214                                 @Override\r
 215                                 public int compare(Perm perm1, Perm perm2) {\r
 216                                         int typeCompare = perm1.getType().compareToIgnoreCase(perm2.getType());\r
 217                                         if (typeCompare == 0) {\r
 218                                                 int instanceCompare = perm1.getInstance().compareToIgnoreCase(perm2.getInstance());\r
 219                                                 if (instanceCompare == 0) {\r
 220                                                         return perm1.getAction().compareToIgnoreCase(perm2.getAction());\r
 221                                                 }\r
 222                                                 return instanceCompare;\r
 223                                         }\r
 224                                         return typeCompare;\r
 225                                 }       \r
 226                         });\r
 227                 } finally {\r
 228                         tt.done();\r
 229                 }\r
 230                 return Result.ok(to);\r
 231         }\r
 232         \r
 233         @Override\r
 234         public Result<List<PermDAO.Data>> perms(AuthzTrans trans, Perms perms) {\r
 235                 List<PermDAO.Data> lpd = new ArrayList<PermDAO.Data>();\r
 236                 for (Perm p : perms.getPerm()) {\r
 237                         Result<NsSplit> nss = q.deriveNsSplit(trans, p.getType());\r
 238                         PermDAO.Data pd = new PermDAO.Data();\r
 239                         if(nss.isOK()) { \r
 240                                 pd.ns=nss.value.ns;\r
 241                                 pd.type = nss.value.name;\r
 242                                 pd.instance = p.getInstance();\r
 243                                 pd.action = p.getAction();\r
 244                                 for (String role : p.getRoles())\r
 245                                         pd.roles(true).add(role);\r
 246                                 lpd.add(pd);\r
 247                         } else {\r
 248                                 return Result.err(nss);\r
 249                         }\r
 250                 }\r
 251                 return Result.ok(lpd);\r
 252         }\r
 253 \r
 254         @Override\r
 255         public Result<PermDAO.Data> permkey(AuthzTrans trans, Pkey from) {\r
 256                 return q.permFrom(trans, from.getType(),from.getInstance(),from.getAction());\r
 257         }\r
 258         \r
 259         @Override\r
 260         public Result<PermDAO.Data> permFromRPRequest(AuthzTrans trans, Request req) {\r
 261                 RolePermRequest from = (RolePermRequest)req;\r
 262                 Pkey perm = from.getPerm();\r
 263                 if(perm==null)return Result.err(Status.ERR_NotFound, "Permission not found");\r
 264                 Result<NsSplit> nss = q.deriveNsSplit(trans, perm.getType());\r
 265                 PermDAO.Data pd = new PermDAO.Data();\r
 266                 if(nss.isOK()) { \r
 267                         pd.ns=nss.value.ns;\r
 268                         pd.type = nss.value.name;\r
 269                         pd.instance = from.getPerm().getInstance();\r
 270                         pd.action = from.getPerm().getAction();\r
 271                         trans.checkpoint(pd.fullPerm(), Env.ALWAYS);\r
 272                         \r
 273                         String[] roles = {};\r
 274                         \r
 275                         if (from.getRole() != null) {\r
 276                                 roles = from.getRole().split(",");\r
 277                         }\r
 278                         for (String role : roles) { \r
 279                                 pd.roles(true).add(role);\r
 280                         }\r
 281                         return Result.ok(pd);\r
 282                 } else {\r
 283                         return Result.err(nss);\r
 284                 }\r
 285         }\r
 286         \r
 287         @Override\r
 288         public Result<RoleDAO.Data> roleFromRPRequest(AuthzTrans trans, Request req) {\r
 289                 RolePermRequest from = (RolePermRequest)req;\r
 290                 Result<NsSplit> nss = q.deriveNsSplit(trans, from.getRole());\r
 291                 RoleDAO.Data rd = new RoleDAO.Data();\r
 292                 if(nss.isOK()) { \r
 293                         rd.ns = nss.value.ns;\r
 294                         rd.name = nss.value.name;\r
 295                         trans.checkpoint(rd.fullName(), Env.ALWAYS);\r
 296                         return Result.ok(rd);\r
 297                 } else {\r
 298                         return Result.err(nss);\r
 299                 }\r
 300         }\r
 301         \r
 302         @Override\r
 303         public Result<PermDAO.Data> perm(AuthzTrans trans, Request req) {\r
 304                 PermRequest from = (PermRequest)req;\r
 305                 Result<NsSplit> nss = q.deriveNsSplit(trans, from.getType());\r
 306                 PermDAO.Data pd = new PermDAO.Data();\r
 307                 if(nss.isOK()) { \r
 308                         pd.ns=nss.value.ns;\r
 309                         pd.type = nss.value.name;\r
 310                         pd.instance = from.getInstance();\r
 311                         pd.action = from.getAction();\r
 312                         pd.description = from.getDescription();\r
 313                         trans.checkpoint(pd.fullPerm(), Env.ALWAYS);\r
 314                         return Result.ok(pd);\r
 315                 } else {\r
 316                         return Result.err(nss);\r
 317                 }\r
 318         }\r
 319 \r
 320         @Override\r
 321         public Result<RoleDAO.Data> role(AuthzTrans trans, Request base) {\r
 322                 RoleRequest from = (RoleRequest)base;\r
 323                 Result<NsSplit> nss = q.deriveNsSplit(trans, from.getName());\r
 324                 if(nss.isOK()) {\r
 325                         RoleDAO.Data to = new RoleDAO.Data();\r
 326                         to.ns = nss.value.ns;\r
 327                         to.name = nss.value.name;\r
 328                         to.description = from.getDescription();\r
 329                         trans.checkpoint(to.fullName(), Env.ALWAYS);\r
 330 \r
 331                         return Result.ok(to);\r
 332                 } else {\r
 333                         return Result.err(nss);\r
 334                 }\r
 335         }\r
 336 \r
 337         /* (non-Javadoc)\r
 338          * @see com.att.authz.service.mapper.Mapper#roles(java.util.List)\r
 339          */\r
 340         @Override\r
 341         public Result<Roles> roles(AuthzTrans trans, List<RoleDAO.Data> from, Roles to, boolean filter) {\r
 342                 for(RoleDAO.Data frole : from) {\r
 343                         // Only Add Data to view if User is allowed to see this Role \r
 344                         //if(!filter || q.mayUserViewRole(trans, trans.user(), frole).isOK()) {\r
 345                         if(!filter || q.mayUser(trans, trans.user(), frole,Access.read).isOK()) {\r
 346                                 Role role = new Role();\r
 347                                 role.setName(frole.ns + '.' + frole.name);\r
 348                                 role.setDescription(frole.description);\r
 349                                 for(String p : frole.perms(false)) { // can see any Perms in the Role he has permission for\r
 350                                         Result<String[]> rpa = PermDAO.Data.decodeToArray(trans,q,p);\r
 351                                         if(rpa.notOK()) return Result.err(rpa);\r
 352                                         \r
 353                                         String[] pa = rpa.value;\r
 354                                         Pkey pKey = new Pkey();\r
 355                                         pKey.setType(pa[0]+'.'+pa[1]);\r
 356                                         pKey.setInstance(pa[2]);\r
 357                                         pKey.setAction(pa[3]);\r
 358                                         role.getPerms().add(pKey);\r
 359                                 }\r
 360                                 to.getRole().add(role);\r
 361                         }\r
 362                 }\r
 363                 return Result.ok(to);\r
 364         }\r
 365 \r
 366         /*\r
 367          * (non-Javadoc)\r
 368          * @see com.att.authz.service.mapper.Mapper#users(java.util.Collection, java.lang.Object)\r
 369          * \r
 370          * Note: Prevalidate all data for permission to view\r
 371          */\r
 372         @Override\r
 373         public Result<Users> users(AuthzTrans trans, Collection<UserRoleDAO.Data> from, Users to) {\r
 374                 List<User> cu = to.getUser();\r
 375                 for(UserRoleDAO.Data urd : from) {\r
 376                         User user = new User();\r
 377                         user.setId(urd.user);\r
 378                         user.setExpires(Chrono.timeStamp(urd.expires));\r
 379                         cu.add(user);\r
 380                 }\r
 381                 return Result.ok(to);\r
 382         }\r
 383 \r
 384         /*\r
 385          * (non-Javadoc)\r
 386          * @see com.att.authz.service.mapper.Mapper#users(java.util.Collection, java.lang.Object)\r
 387          * \r
 388          * Note: Prevalidate all data for permission to view\r
 389          */\r
 390         @Override\r
 391         public Result<UserRoles> userRoles(AuthzTrans trans, Collection<UserRoleDAO.Data> from, UserRoles to) {\r
 392                 List<UserRole> cu = to.getUserRole();\r
 393                 for(UserRoleDAO.Data urd : from) {\r
 394                         UserRole ur = new UserRole();\r
 395                         ur.setUser(urd.user);\r
 396                         ur.setRole(urd.role);\r
 397                         ur.setExpires(Chrono.timeStamp(urd.expires));\r
 398                         cu.add(ur);\r
 399                 }\r
 400                 return Result.ok(to);\r
 401         }\r
 402 \r
 403         /**\r
 404          * \r
 405          * @param base\r
 406          * @param start\r
 407          * @return\r
 408          */\r
 409         @Override\r
 410         public Result<UserRoleDAO.Data> userRole(AuthzTrans trans, Request base) {\r
 411                 try {\r
 412                         UserRoleRequest from = (UserRoleRequest)base;\r
 413 \r
 414                         // Setup UserRoleData, either for immediate placement, or for future\r
 415                         UserRoleDAO.Data to = new UserRoleDAO.Data();\r
 416                         if (from.getUser() != null) {\r
 417                                 String user = from.getUser();\r
 418                                 to.user = user;\r
 419                         }\r
 420                         if (from.getRole() != null) {\r
 421                                 to.role(trans,q,from.getRole());\r
 422                         }\r
 423                         to.expires = getExpires(trans.org(),Expiration.UserInRole,base,from.getUser());\r
 424                         trans.checkpoint(to.toString(), Env.ALWAYS);\r
 425 \r
 426                         return Result.ok(to);\r
 427                 } catch (Exception t) {\r
 428                         return Result.err(Status.ERR_BadData,t.getMessage());\r
 429                 }\r
 430         }\r
 431 \r
 432         @Override\r
 433         public Result<CredDAO.Data> cred(AuthzTrans trans, Request base, boolean requiresPass) {\r
 434                 CredRequest from = (CredRequest)base;\r
 435                 CredDAO.Data to = new CredDAO.Data();\r
 436                 to.id=from.getId();\r
 437                 to.ns = Question.domain2ns(to.id);\r
 438                 String passwd = from.getPassword();\r
 439                 if(requiresPass) {\r
 440                         String ok = trans.org().isValidPassword(to.id,passwd);\r
 441                         if(ok.length()>0) {\r
 442                                 return Result.err(Status.ERR_BadData,ok);\r
 443                         }\r
 444 \r
 445                 } else {\r
 446                         to.type=0;\r
 447                 }\r
 448                 if(passwd != null) {\r
 449                         to.cred = ByteBuffer.wrap(passwd.getBytes());\r
 450                         to.type = CredDAO.RAW; \r
 451                 } else {\r
 452                         to.type = 0;\r
 453                 }\r
 454                 \r
 455                 // Note: Ensure requested EndDate created will match Organization Password Rules\r
 456                 //  P.S. Do not apply TempPassword rule here. Do that when you know you are doing a Create/Reset (see Service)\r
 457                 to.expires = getExpires(trans.org(),Expiration.Password,base,from.getId());\r
 458                 trans.checkpoint(to.id, Env.ALWAYS);\r
 459 \r
 460                 return Result.ok(to);\r
 461         }\r
 462         \r
 463         @Override\r
 464         public Result<Users> cred(List<CredDAO.Data> from, Users to) {\r
 465                 List<User> cu = to.getUser();\r
 466                 for(CredDAO.Data cred : from) {\r
 467                         User user = new User();\r
 468                         user.setId(cred.id);\r
 469                         user.setExpires(Chrono.timeStamp(cred.expires));\r
 470                         user.setType(cred.type);\r
 471                         cu.add(user);\r
 472                 }\r
 473                 return Result.ok(to);\r
 474         }\r
 475         \r
 476 @Override\r
 477         public Result<Certs> cert(List<CertDAO.Data> from, Certs to) {\r
 478                 List<Cert> lc = to.getCert();\r
 479                 for(CertDAO.Data fcred : from) {\r
 480                         Cert cert = new Cert();\r
 481                         cert.setId(fcred.id);\r
 482                         cert.setX500(fcred.x500);\r
 483                         /**TODO - change Interface \r
 484                          * @deprecated */\r
 485                         cert.setFingerprint(fcred.serial.toByteArray());\r
 486                         lc.add(cert);\r
 487                 }\r
 488                 return Result.ok(to);\r
 489         }\r
 490 \r
 491         /**\r
 492          * Analyze whether Requests should be acted on now, or in the future, based on Start Date, and whether the requester\r
 493          * is allowed to change this value directly\r
 494          * \r
 495          * Returning Result.OK means it should be done in the future.\r
 496          * Returning Result.ACC_Now means to act on table change now.\r
 497          */\r
 498         @Override\r
 499         public Result<FutureDAO.Data> future(AuthzTrans trans, String table, Request from, \r
 500                                 Bytification content, boolean enableApproval,  Memo memo, MayChange mc) {\r
 501                 Result<?> rMayChange = mc.mayChange();\r
 502                 boolean needsAppr;\r
 503                 if(needsAppr = rMayChange.notOK()) {\r
 504                         if(enableApproval) {\r
 505                                 if(!trans.futureRequested()) {\r
 506                                         return Result.err(rMayChange);\r
 507                                 }\r
 508                         } else {\r
 509                                 return Result.err(rMayChange);\r
 510                         }\r
 511                 }\r
 512                 GregorianCalendar now = new GregorianCalendar(); \r
 513                 GregorianCalendar start = from.getStart()==null?now:from.getStart().toGregorianCalendar();\r
 514                 \r
 515                 GregorianCalendar expires = trans.org().expiration(start, Expiration.Future);\r
 516                 XMLGregorianCalendar xgc;\r
 517                 if((xgc=from.getEnd())!=null) {\r
 518                         GregorianCalendar fgc = xgc.toGregorianCalendar();\r
 519                         expires = expires.before(fgc)?expires:fgc; // Min of desired expiration, and Org expiration\r
 520                 }\r
 521                 \r
 522                 //TODO needs two answers from this.  What's the NSS, and may Change.\r
 523                 FutureDAO.Data fto;\r
 524                 if(start.after(now) || needsAppr ) {\r
 525                         //String user = trans.user();\r
 526                         fto = new FutureDAO.Data();\r
 527                         fto.target=table;\r
 528                         fto.memo = memo.get();\r
 529                         fto.start = start.getTime();\r
 530                         fto.expires = expires.getTime();\r
 531                         if(needsAppr) { // Need to add Approvers...\r
 532                                 /*\r
 533                                 Result<Data> rslt = mc.getNsd();\r
 534                                 if(rslt.notOKorIsEmpty())return Result.err(rslt);\r
 535                                 appr.addAll(mc.getNsd().value.responsible);\r
 536                                 try {\r
 537                                         //Note from 2013 Is this getting Approvers for user only?  What about Delegates?\r
 538                                         // 3/25/2014.  Approvers are set by Corporate policy.  We don't have to worry here about what that means.\r
 539                                         // It is important to get Delegates, if necessary, at notification time\r
 540                                         // If we add delegates now, it will get all confused as to who is actually responsible.\r
 541                                         for(Organization.User ou : org.getApprovers(trans, user)) {\r
 542                                                 appr.add(ou.email);\r
 543                                         }\r
 544                                 } catch (Exception e) {\r
 545                                         return Result.err(Status.ERR_Policy,org.getName() + " did not respond with Approvers: " + e.getLocalizedMessage());\r
 546                                 }\r
 547                                 */\r
 548                         }\r
 549                         try {\r
 550                                 fto.construct = content.bytify();\r
 551                         } catch (Exception e) {\r
 552                                 return Result.err(Status.ERR_BadData,"Data cannot be saved for Future.");\r
 553                         }\r
 554                 } else {\r
 555                         return Result.err(Status.ACC_Now, "Make Data changes now.");\r
 556                 }\r
 557                 return Result.ok(fto);\r
 558         }\r
 559 \r
 560 \r
 561         /* (non-Javadoc)\r
 562          * @see com.att.authz.service.mapper.Mapper#history(java.util.List)\r
 563          */\r
 564         @Override\r
 565         public Result<History> history(AuthzTrans trans, List<HistoryDAO.Data> history, final int sort) {\r
 566                 History hist = new History();\r
 567                 List<Item> items = hist.getItem();\r
 568                 for(HistoryDAO.Data data : history) {\r
 569                         History.Item item = new History.Item();\r
 570                         item.setYYYYMM(Integer.toString(data.yr_mon));\r
 571                         Date date = Chrono.uuidToDate(data.id);\r
 572                         item.setTimestamp(Chrono.timeStamp(date));\r
 573                         item.setAction(data.action);\r
 574                         item.setMemo(data.memo);\r
 575                         item.setSubject(data.subject);\r
 576                         item.setTarget(data.target);\r
 577                         item.setUser(data.user);\r
 578                         items.add(item);\r
 579                 }\r
 580                 \r
 581                 if(sort != 0) {\r
 582                         TimeTaken tt = trans.start("Sort ", Env.SUB);\r
 583                         try {\r
 584                                 java.util.Collections.sort(items, new Comparator<Item>() {\r
 585                                         @Override\r
 586                                         public int compare(Item o1, Item o2) {\r
 587                                                 return sort*(o1.getTimestamp().compare(o2.getTimestamp()));\r
 588                                         }\r
 589                                 });\r
 590                         } finally {\r
 591                                 tt.done();\r
 592                         }\r
 593                 }\r
 594                 return Result.ok(hist);\r
 595         }\r
 596 \r
 597         @Override\r
 598         public Error errorFromMessage(StringBuilder holder, String msgID, String text, String... var) {\r
 599                 Error err = new Error();\r
 600                 err.setMessageId(msgID);\r
 601                 // AT&T Restful Error Format requires numbers "%" placements\r
 602                 err.setText(Vars.convert(holder, text, var));\r
 603                 for(String s : var) {\r
 604                         err.getVariables().add(s);\r
 605                 }\r
 606                 return err;\r
 607         }\r
 608         \r
 609         @Override\r
 610         public Class<?> getClass(API api) {\r
 611                 switch(api) {\r
 612                         case NSS:  return Nss.class;\r
 613                         case NS_REQ: return NsRequest.class;\r
 614                         case PERMS: return Perms.class;\r
 615                         case PERM_KEY: return PermKey.class;\r
 616                         case ROLES: return Roles.class;\r
 617                         case ROLE: return Role.class;\r
 618                         case USERS: return Users.class;\r
 619                         case DELGS: return Delgs.class;\r
 620                         case CERTS: return Certs.class;\r
 621                         case DELG_REQ: return DelgRequest.class;\r
 622                         case PERM_REQ: return PermRequest.class;\r
 623                         case ROLE_REQ:  return RoleRequest.class;\r
 624                         case CRED_REQ:  return CredRequest.class;\r
 625                         case USER_ROLE_REQ:  return UserRoleRequest.class;\r
 626                         case USER_ROLES: return UserRoles.class;\r
 627                         case ROLE_PERM_REQ:  return RolePermRequest.class;\r
 628                         case APPROVALS: return Approvals.class;\r
 629                         case KEYS: return Keys.class;\r
 630                         case HISTORY: return History.class;\r
 631 //                      case MODEL: return Model.class;\r
 632                         case ERROR: return Error.class;\r
 633                         case API: return Api.class;\r
 634                         case VOID: return Void.class;\r
 635                 }\r
 636                 return null;\r
 637         }\r
 638 \r
 639         @SuppressWarnings("unchecked")\r
 640         @Override\r
 641         public <A> A newInstance(API api) {\r
 642                 switch(api) {\r
 643                         case NS_REQ: return (A) new NsRequest();\r
 644                         case NSS: return (A) new Nss();\r
 645                         case PERMS: return (A)new Perms();\r
 646                         case PERM_KEY: return (A)new PermKey();\r
 647                         case ROLES: return (A)new Roles();\r
 648                         case ROLE: return (A)new Role();\r
 649                         case USERS: return (A)new Users();\r
 650                         case DELGS: return (A)new Delgs();\r
 651                         case CERTS: return (A)new Certs();\r
 652                         case PERM_REQ: return (A)new PermRequest();\r
 653                         case CRED_REQ: return (A)new CredRequest();\r
 654                         case ROLE_REQ:  return (A)new RoleRequest();\r
 655                         case USER_ROLE_REQ:  return (A)new UserRoleRequest();\r
 656                         case USER_ROLES:  return (A)new UserRoles();\r
 657                         case ROLE_PERM_REQ:  return (A)new RolePermRequest();\r
 658                         case HISTORY: return (A)new History();\r
 659                         case KEYS: return (A)new Keys();\r
 660                         //case MODEL: return (A)new Model();\r
 661                         case ERROR: return (A)new Error();\r
 662                         case API: return (A)new Api();\r
 663                         case VOID: return null;\r
 664                         \r
 665                         case APPROVALS: return (A) new Approvals();\r
 666                         case DELG_REQ: return (A) new DelgRequest();\r
 667                 }\r
 668                 return null;\r
 669         }\r
 670         \r
 671         @SuppressWarnings("unchecked")\r
 672         /**\r
 673          * Get Typed Marshaler as they are defined\r
 674          * \r
 675          * @param api\r
 676          * @return\r
 677          */\r
 678         public <A> Marshal<A> getMarshal(API api) {\r
 679                 switch(api) {\r
 680                         case CERTS: return (Marshal<A>) new CertsMarshal();\r
 681                         default:\r
 682                                 return null;\r
 683                 }\r
 684         }\r
 685 \r
 686         @Override\r
 687         public Result<Approvals> approvals(List<ApprovalDAO.Data> lAppr) {\r
 688                 Approvals apprs = new Approvals();\r
 689                 List<Approval> lappr = apprs.getApprovals();\r
 690                 Approval a;\r
 691                 for(ApprovalDAO.Data appr : lAppr) {\r
 692                         a = new Approval();\r
 693                         a.setId(appr.id.toString());\r
 694                         a.setTicket(appr.ticket.toString());\r
 695                         a.setUser(appr.user);\r
 696                         a.setApprover(appr.approver);\r
 697                         a.setType(appr.type);\r
 698                         a.setStatus(appr.status);\r
 699                         a.setMemo(appr.memo);\r
 700                         a.setOperation(appr.operation);\r
 701                         a.setUpdated(Chrono.timeStamp(appr.updated));\r
 702                         lappr.add(a);\r
 703                 }\r
 704                 return Result.ok(apprs);\r
 705         }\r
 706         \r
 707         @Override\r
 708         public Result<List<ApprovalDAO.Data>> approvals(Approvals apprs) {\r
 709                 List<ApprovalDAO.Data>  lappr = new ArrayList<ApprovalDAO.Data>();\r
 710                 for(Approval a : apprs.getApprovals()) {\r
 711                         ApprovalDAO.Data ad = new ApprovalDAO.Data();\r
 712                         String str = a.getId();\r
 713                         if(str!=null)ad.id=UUID.fromString(str);\r
 714                         str = a.getTicket();\r
 715                         if(str!=null)ad.ticket=UUID.fromString(str);\r
 716                         ad.user=a.getUser();\r
 717                         ad.approver=a.getApprover();\r
 718                         ad.type=a.getType();\r
 719                         ad.status=a.getStatus();\r
 720                         ad.operation=a.getOperation();\r
 721                         ad.memo=a.getMemo();\r
 722                         \r
 723                         XMLGregorianCalendar xgc = a.getUpdated();\r
 724                         if(xgc!=null)ad.updated=xgc.toGregorianCalendar().getTime();\r
 725                         lappr.add(ad);\r
 726                 }\r
 727                 return Result.ok(lappr);\r
 728         }\r
 729 \r
 730         @Override\r
 731         public Result<Delgs> delegate(List<DelegateDAO.Data> lDelg) {\r
 732                 Delgs delgs = new Delgs();\r
 733                 List<Delg> ldelg = delgs.getDelgs();\r
 734                 Delg d;\r
 735                 for(DelegateDAO.Data del: lDelg) {\r
 736                         d = new Delg();\r
 737                         d.setUser(del.user);\r
 738                         d.setDelegate(del.delegate);\r
 739                         if(del.expires!=null)d.setExpires(Chrono.timeStamp(del.expires));\r
 740                         ldelg.add(d);\r
 741                 }\r
 742                 return Result.ok(delgs);\r
 743         }\r
 744 \r
 745         @Override\r
 746         public Result<Data> delegate(AuthzTrans trans, Request base) {\r
 747                 try {\r
 748                         DelgRequest from = (DelgRequest)base;\r
 749                         DelegateDAO.Data to = new DelegateDAO.Data();\r
 750                         String user = from.getUser();\r
 751                         to.user = user;\r
 752                         String delegate = from.getDelegate();\r
 753                         to.delegate = delegate;\r
 754                         to.expires = getExpires(trans.org(),Expiration.UserDelegate,base,from.getUser());\r
 755                         trans.checkpoint(to.user+"=>"+to.delegate, Env.ALWAYS);\r
 756 \r
 757                         return Result.ok(to);\r
 758                 } catch (Exception t) {\r
 759                         return Result.err(Status.ERR_BadData,t.getMessage());\r
 760                 }\r
 761         }\r
 762 \r
 763         /*\r
 764          * We want "Expired" dates to start at a specified time set by the Organization, and consistent wherever\r
 765          * the date is created from.\r
 766          */ \r
 767         private Date getExpires(Organization org, Expiration exp, Request base, String id) {\r
 768                 XMLGregorianCalendar end = base.getEnd();\r
 769                 GregorianCalendar gc = end==null?new GregorianCalendar():end.toGregorianCalendar();\r
 770                 GregorianCalendar orggc;\r
 771                 orggc = org.expiration(gc,exp,id); \r
 772 \r
 773                 // We'll choose the lesser of dates to ensure Policy Compliance...\r
 774         \r
 775                 GregorianCalendar endgc = end==null||gc.after(orggc)?orggc:gc;\r
 776                 // Allow the Organization to determine when official "day Start" begins, Specifically when to consider something Expired.\r
 777                 endgc = Chrono.firstMomentOfDay(endgc);\r
 778                 endgc.set(GregorianCalendar.HOUR_OF_DAY, org.startOfDay());\r
 779                 return endgc.getTime();\r
 780         }\r
 781 \r
 782 \r
 783         @Override\r
 784         public Result<Keys> keys(Collection<String> from) {\r
 785                 Keys keys = new Keys();\r
 786                 keys.getKey().addAll(from);\r
 787                 return Result.ok(keys).emptyList(from.isEmpty());\r
 788         }\r
 789 \r
 790 }\r