auth/auth-batch/src/main/java/org/onap/aaf/auth/batch/helpers/ExpireRange.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  *
   7  * Modifications Copyright © 2018 IBM.
   8  * ===========================================================================
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  * ============LICENSE_END====================================================
  21  */
  22
  23 package org.onap.aaf.auth.batch.helpers;
  24
  25 import java.util.ArrayList;
  26 import java.util.Date;
  27 import java.util.GregorianCalendar;
  28 import java.util.HashMap;
  29 import java.util.HashSet;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33
  34 import org.onap.aaf.auth.org.Organization.Identity;
  35 import org.onap.aaf.cadi.Access;
  36
  37 public class ExpireRange {
  38         private static final String DELETE = "Delete";
  39         public static final String ONE_MONTH = "OneMonth";
  40         public static final String TWO_MONTH = "TwoMonth";
  41         public static final String TWO_WEEK = "TwoWeek";
  42         public static final String ONE_WEEK = "OneWeek";
  43         private static final String AAF_BATCH_RANGE = "aaf_batch_range.";
  44         public final Map<String,List<Range>> ranges;
  45         private final Map<Integer,Date> intervalDates;
  46         private static final Date now = new Date();
  47         public final Range approveDelete ;
  48
  49         private Range delRange;
  50
  51         public ExpireRange(final Access access) {
  52                 ranges = new HashMap<>();
  53                 intervalDates = new HashMap<>();
  54                 int i=0;
  55                 approveDelete = new Range(DELETE,0,0,0,-1,0,GregorianCalendar.DAY_OF_YEAR,-100);
  56                 String prop = access.getProperty(AAF_BATCH_RANGE + i,null);
  57                 if(prop==null && i==0) {
  58                                 List<Range> lcred = getRangeList("cred");
  59                                 List<Range> lur = getRangeList("ur");
  60                                 List<Range> lx509 = getRangeList("x509");
  61
  62
  63                                 /*
  64                                    Range(Name, ReportingLevel, PeopleInterval, AppInterval, Start(Type,Qty) End(Type,Qty) )
  65                                    Interval of -1 Means "only once"
  66                                    Interval of 0 means none
  67                                    Interval > 0 means only X number of Days.
  68                                 */
  69                                 delRange = new Range(DELETE,0,0,0,-1,0,GregorianCalendar.WEEK_OF_MONTH,-2);
  70                                 lur.add(delRange);
  71                                 lcred.add(delRange);
  72                                 lx509.add(delRange);
  73
  74
  75                                 lcred.add(new Range(ONE_WEEK ,3,-1,1,0,0,GregorianCalendar.WEEK_OF_MONTH,1));
  76                                 lcred.add(new Range(TWO_WEEK ,2,-1,-1,GregorianCalendar.WEEK_OF_MONTH,1,GregorianCalendar.WEEK_OF_MONTH,2));
  77                                 lcred.add(new Range(ONE_MONTH,1,7,7,GregorianCalendar.WEEK_OF_MONTH,2,GregorianCalendar.MONTH,1));
  78                                 lcred.add(new Range(TWO_MONTH,1,-1,-1,GregorianCalendar.MONTH,1,GregorianCalendar.MONTH,2));
  79
  80                                 lur.add(  new Range(ONE_MONTH,1,-1,-1,GregorianCalendar.WEEK_OF_MONTH,2,GregorianCalendar.MONTH,1));
  81
  82                                 lx509.add(new Range(ONE_MONTH,1,-1,-1,GregorianCalendar.WEEK_OF_MONTH,2,GregorianCalendar.MONTH,1));
  83                         }
  84         }
  85
  86         public Range newFutureRange() {
  87                 return new Range("Approval",7,7,1,0,0,GregorianCalendar.MONTH,1);
  88         }
  89
  90         public Set<String> names() {
  91                 Set<String> names = new HashSet<>();
  92         for(List<Range> lr : ranges.values()) {
  93                 for(Range r : lr) {
  94                         names.add(r.name);
  95                 }
  96         }
  97
  98                 return names;
  99         }
 100
 101         private synchronized List<Range> getRangeList(final String key) {
 102                 List<Range> rv = ranges.get(key);
 103                 if(rv==null) {
 104                         rv = new ArrayList<>();
 105                         ranges.put(key, rv);
 106                 }
 107                 return rv;
 108         }
 109
 110         public class Range {
 111                 private final String name;
 112                 private final int reportingLevel;
 113                 private final int peopleInterval; // in Days
 114                 private final int appInterval; // in Days
 115                 private final Date start;
 116                 private final Date end;
 117                 private final Date lowerValid;
 118
 119                 public Range(
 120                                 final String name, final int reportingLevel,
 121                                 final int peopleInterval, final int appInterval,
 122                                 final int startGCType, final int startQty,
 123                                 final int endGCType,final int endQty) {
 124                         this.name = name;
 125                         this.reportingLevel = reportingLevel;
 126                         this.peopleInterval = peopleInterval;
 127                         this.appInterval = appInterval;
 128                         GregorianCalendar gc = new GregorianCalendar();
 129                         if(startGCType<0) {
 130                                 gc.set(GregorianCalendar.YEAR, 1);
 131                         } else {
 132                                 gc.setTime(now);
 133                                 gc.add(startGCType, startQty);
 134                         }
 135                         start = gc.getTime();
 136
 137                         if(endGCType<0) {
 138                                 gc.set(GregorianCalendar.YEAR, 1);
 139                         } else {
 140                                 gc.setTime(now);
 141                                 gc.add(endGCType, endQty);
 142                         }
 143                         end = gc.getTime();
 144
 145
 146                         if(endGCType<0) {
 147                                 gc.set(GregorianCalendar.YEAR, -1);
 148                         } else {
 149                                 gc.setTime(now);
 150                                 gc.add(endGCType, endQty * -1);
 151                         }
 152                         lowerValid = gc.getTime();
 153
 154                 }
 155
 156                 public String name() {
 157                         return name;
 158                 }
 159
 160                 public int reportingLevel() {
 161                         return reportingLevel;
 162                 }
 163
 164                 public boolean needsContact(Date lnd, Identity identity) {
 165                         final int interval;
 166                         if(identity==null || identity.isPerson()) {
 167                                 interval = peopleInterval;
 168                         } else {
 169                                 interval = appInterval;
 170                         }
 171                         if(interval == 0) {
 172                                 return false;
 173                         } else if(interval < 0) { // "-1 = only once "
 174                                 return (lnd==null || lnd.before(lowerValid));
 175                         } else {
 176                                 Date rv = intervalDates.get(interval);
 177                                 if(rv==null) {
 178                                         GregorianCalendar gc = new GregorianCalendar();
 179                                         gc.setTime(now);
 180                                         gc.add(GregorianCalendar.DAY_OF_YEAR, -1*interval);
 181                                         rv = gc.getTime();
 182                                         intervalDates.put(interval, rv);
 183                                 }
 184                                 return rv.after(lnd);
 185                         }
 186                 }
 187
 188                 public Date getStart() {
 189                         return start;
 190                 }
 191
 192                 public Date getEnd() {
 193                         return end;
 194                 }
 195
 196                 public boolean inRange(final Date date) {
 197                         if(date==null) {
 198                                 return false;
 199                         } else {
 200                                 return date.getTime()>=start.getTime() && date.before(end);
 201                         }
 202                 }
 203
 204         }
 205
 206         public Range getRange(final String key, final Date date) {
 207                 Range rv = null;
 208                 if(date!=null) {
 209                         List<Range> lr = ranges.get(key);
 210                         if(lr==null) {
 211                                 return null;
 212                         } else {
 213                                 for(Range r : lr) {
 214                                         if(r.inRange(date)) {
 215                                                 rv = r;
 216                                                 break;
 217                                         }
 218                                 }
 219                         }
 220                 }
 221                 return rv;
 222         }
 223
 224         public Date now() {
 225                 return now;
 226         }
 227
 228
 229 }