org.argeo.enterprise/src/org/argeo/naming/NamingUtils.java

   1 package org.argeo.naming;
   2
   3 import java.io.UnsupportedEncodingException;
   4 import java.net.URI;
   5 import java.net.URLDecoder;
   6 import java.nio.charset.StandardCharsets;
   7 import java.time.Instant;
   8 import java.time.OffsetDateTime;
   9 import java.time.ZoneOffset;
  10 import java.time.ZonedDateTime;
  11 import java.time.format.DateTimeFormatter;
  12 import java.time.format.DateTimeParseException;
  13 import java.time.temporal.ChronoField;
  14 import java.util.Calendar;
  15 import java.util.GregorianCalendar;
  16 import java.util.LinkedHashMap;
  17 import java.util.LinkedList;
  18 import java.util.List;
  19 import java.util.Map;
  20
  21 public class NamingUtils {
  22         private final static DateTimeFormatter utcLdapDate = DateTimeFormatter.ofPattern("uuuuMMddHHmmssX")
  23                         .withZone(ZoneOffset.UTC);
  24
  25         /** @return null if not parseable */
  26         public static Instant ldapDateToInstant(String ldapDate) {
  27                 try {
  28                         return OffsetDateTime.parse(ldapDate, utcLdapDate).toInstant();
  29                 } catch (DateTimeParseException e) {
  30                         return null;
  31                 }
  32         }
  33
  34         public static Calendar ldapDateToCalendar(String ldapDate) {
  35                 OffsetDateTime instant = OffsetDateTime.parse(ldapDate, utcLdapDate);
  36                 GregorianCalendar calendar = new GregorianCalendar();
  37                 calendar.set(Calendar.DAY_OF_MONTH, instant.get(ChronoField.DAY_OF_MONTH));
  38                 calendar.set(Calendar.MONTH, instant.get(ChronoField.MONTH_OF_YEAR));
  39                 calendar.set(Calendar.YEAR, instant.get(ChronoField.YEAR));
  40                 return calendar;
  41         }
  42
  43         public static String instantToLdapDate(ZonedDateTime instant) {
  44                 return utcLdapDate.format(instant.withZoneSameInstant(ZoneOffset.UTC));
  45         }
  46
  47         public static String getQueryValue(Map<String, List<String>> query, String key) {
  48                 if (!query.containsKey(key))
  49                         return null;
  50                 List<String> val = query.get(key);
  51                 if (val.size() == 1)
  52                         return val.get(0);
  53                 else
  54                         throw new IllegalArgumentException("There are " + val.size() + " value(s) for " + key);
  55         }
  56
  57         public static Map<String, List<String>> queryToMap(URI uri) {
  58                 return queryToMap(uri.getQuery());
  59         }
  60
  61         private static Map<String, List<String>> queryToMap(String queryPart) {
  62                 try {
  63                         final Map<String, List<String>> query_pairs = new LinkedHashMap<String, List<String>>();
  64                         if (queryPart == null)
  65                                 return query_pairs;
  66                         final String[] pairs = queryPart.split("&");
  67                         for (String pair : pairs) {
  68                                 final int idx = pair.indexOf("=");
  69                                 final String key = idx > 0 ? URLDecoder.decode(pair.substring(0, idx), StandardCharsets.UTF_8.name())
  70                                                 : pair;
  71                                 if (!query_pairs.containsKey(key)) {
  72                                         query_pairs.put(key, new LinkedList<String>());
  73                                 }
  74                                 final String value = idx > 0 && pair.length() > idx + 1
  75                                                 ? URLDecoder.decode(pair.substring(idx + 1), StandardCharsets.UTF_8.name())
  76                                                 : null;
  77                                 query_pairs.get(key).add(value);
  78                         }
  79                         return query_pairs;
  80                 } catch (UnsupportedEncodingException e) {
  81                         throw new IllegalArgumentException("Cannot convert " + queryPart + " to map", e);
  82                 }
  83         }
  84
  85         private NamingUtils() {
  86
  87         }
  88
  89         public static void main(String args[]) {
  90                 ZonedDateTime now = ZonedDateTime.now().withZoneSameInstant(ZoneOffset.UTC);
  91                 String str = utcLdapDate.format(now);
  92                 System.out.println(str);
  93                 utcLdapDate.parse(str);
  94                 utcLdapDate.parse("19520512000000Z");
  95         }
  96 }