war/src/main/java/pnews/servlet/Config.java

   1 package pnews.servlet;
   2
   3 import java.io.IOException;
   4 import java.io.InputStreamReader;
   5 import java.io.Reader;
   6 import java.io.UnsupportedEncodingException;
   7 import java.time.Instant;
   8 import java.time.temporal.ChronoUnit;
   9 import java.time.temporal.TemporalUnit;
  10 import java.util.ArrayList;
  11 import java.util.HashMap;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.logging.Level;
  17 import java.util.logging.Logger;
  18
  19 import javax.json.Json;
  20 import javax.json.JsonArray;
  21 import javax.json.JsonObject;
  22 import javax.json.JsonString;
  23 import javax.json.JsonValue;
  24
  25 import pnews.Article;
  26 import pnews.Category;
  27 import pnews.Feed;
  28 import pnews.Language;
  29
  30 public class Config {
  31         private Feed[] feeds;
  32         private Category[] categories;
  33         private Language[] languages;
  34         private final Set<String> blacklistedEntities = new HashSet<>();
  35         private final HashMap<String, String> entityAliases = new HashMap<>();
  36         private static final String CLASS_NAME = Config.class.getName();
  37
  38         /**
  39          * The key is the language, the value is the default category for this language.
  40          */
  41         private Map<String, Category> defaultCategories = new HashMap<>();
  42         private static final Logger LOG = Logger.getLogger(CLASS_NAME);
  43
  44         private void loadCategories(JsonArray jcats) {
  45                 List<Category> cats;
  46                 JsonObject jcat;
  47                 Category cat;
  48                 String id, label, title, language;
  49
  50                 cats = new ArrayList<>(jcats.size());
  51
  52                 for (JsonValue v: jcats) {
  53                         jcat = (JsonObject)v;
  54                         id = jcat.getString("id");
  55                         label = jcat.getString("label");
  56                         title = jcat.getString("title");
  57                         language = jcat.getString("language");
  58                         cat = new Category(id, label, title, language);
  59                         cats.add(cat);
  60                         if (defaultCategories.get(language) == null)
  61                                 defaultCategories.put(language, cat);
  62                 }
  63
  64                 categories = cats.toArray(new Category[0]);
  65         }
  66
  67         private void loadLanguages(JsonArray jlangs) {
  68                 List<Language> langs;
  69                 JsonObject jlang;
  70                 String id;
  71
  72                 langs = new ArrayList<>(jlangs.size());
  73
  74                 for (JsonValue v: jlangs) {
  75                         jlang = (JsonObject)v;
  76                         id = jlang.getString("id");
  77                         langs.add(new Language(id));
  78                 }
  79
  80                 languages = langs.toArray(new Language[0]);
  81         }
  82
  83         private Category getCategory(String id) {
  84                 for (Category c: categories)
  85                         if (c.getId().equals(id))
  86                                 return c;
  87                 return null;
  88         }
  89
  90         private void loadEntities(JsonObject jroot) {
  91                 JsonObject jentities, jaliases;
  92                 JsonArray jblacklist;
  93                 final String METHOD_NAME = "loadEntities";
  94
  95                 jentities = jroot.getJsonObject("entities");
  96
  97                 jblacklist = jentities.getJsonArray("blacklist");
  98                 jblacklist.forEach((jv)-> {
  99                         JsonString js;
 100
 101                         js = (JsonString)jv;
 102                         blacklistedEntities.add(js.getString());
 103                 });
 104
 105                 jaliases = jentities.getJsonObject("aliases");
 106                 jaliases.forEach((k, v)-> {
 107                         JsonArray jsources = (JsonArray)v;
 108
 109                         jsources.forEach((jsource)-> {
 110                                 entityAliases.put(((JsonString)jsource).getString(), k);
 111                         });
 112                 });
 113
 114                 LOG.logp(Level.FINEST, CLASS_NAME, METHOD_NAME, " blacklistedEntities=" + blacklistedEntities);
 115                 LOG.logp(Level.FINEST, CLASS_NAME, METHOD_NAME, " entityAliases=" + entityAliases);
 116         }
 117
 118         public String getEntityAlias(String entity) {
 119                 String result;
 120
 121                 result = entityAliases.get(entity);
 122
 123                 if (result == null)
 124                         return entity;
 125                 else
 126                         return result;
 127         }
 128
 129         public void loadConfig() throws UnsupportedEncodingException {
 130                 Reader r;
 131                 JsonObject jfeeds, jroot;
 132                 List<Feed> feedList;
 133
 134                 r = null;
 135                 try {
 136                         r = new InputStreamReader(Config.class.getClassLoader().getResourceAsStream("feeds.json"),
 137                                                   "UTF-8");
 138                         jroot = Json.createReader(r).readObject();
 139                 } finally {
 140                         if (r != null)
 141                                 try { r.close(); } catch (IOException e) { };
 142                 }
 143
 144                 loadLanguages(jroot.getJsonArray("languages"));
 145                 loadCategories(jroot.getJsonArray("categories"));
 146
 147                 jfeeds = jroot.getJsonObject("feeds");
 148
 149                 feedList = new ArrayList<Feed>(jfeeds.size());
 150
 151                 jfeeds.forEach((k, v)-> {
 152                         JsonObject jf;
 153                         String str;
 154                         Category cat;
 155                         JsonArray jcategories;
 156
 157                         jf = (JsonObject)v;
 158                         jcategories = jf.getJsonArray("categories");
 159                         str = jcategories.getString(0);
 160
 161                         cat = getCategory(str);
 162
 163                         if (cat != null)
 164                                 feedList.add(new Feed(k, cat));
 165                         else
 166                                 LOG.severe("Missing category: " + str);
 167                 });
 168
 169                 feeds = feedList.toArray(new Feed[0]);
 170
 171                 loadEntities(jroot);
 172         }
 173
 174         public boolean isBlacklistedEntity(String e) {
 175                 final String METHOD_NAME = "isBlacklistedEntity";
 176                 boolean result;
 177
 178                 LOG.entering(CLASS_NAME, METHOD_NAME, e);
 179
 180                 result = blacklistedEntities.contains(e);
 181
 182                 LOG.exiting(CLASS_NAME, METHOD_NAME, result);
 183
 184                 return result;
 185         }
 186
 187         public boolean isObsolete(Instant instant) {
 188                 Instant olderInstant;
 189
 190                 olderInstant = Instant.now().minus(60, ChronoUnit.DAYS);
 191
 192                 if (instant.isAfter(olderInstant))
 193                         return false;
 194                 else
 195                         return true;
 196         }
 197
 198         public Feed[] getFeeds() {
 199                 return feeds;
 200         }
 201
 202         public Map<Category, List<Feed>> getFeedsByCategory() {
 203                 Map<Category, List<Feed>> result;
 204                 Feed[] feeds;
 205                 List<Feed> catFeeds;
 206                 Category cat;
 207
 208                 result = new HashMap<>();
 209
 210                 feeds = getFeeds();
 211                 for (Feed f: feeds) {
 212                         cat = f.getCategory();
 213
 214                         catFeeds = result.get(cat);
 215                         if (catFeeds == null) {
 216                                 catFeeds = new ArrayList<Feed>();
 217                                 result.put(cat, catFeeds);
 218                         }
 219                         catFeeds.add(f);
 220                 }
 221
 222                 return result;
 223         }
 224
 225         public Category[] getCategories() {
 226                 return categories;
 227         }
 228
 229         public Category getDefaultCategory(Language lang) {
 230                 return defaultCategories.get(lang.getId());
 231         }
 232
 233         public Language[] getLanguages() {
 234                 return languages;
 235         }
 236
 237         public Language getDefaultLanguage() {
 238                 return languages[0];
 239         }
 240
 241         public static void main(String[] args) throws UnsupportedEncodingException {
 242                 Config cfg;
 243                 Feed[] feeds;
 244                 Category[] cats;
 245
 246                 cfg = new Config();
 247                 cfg.loadConfig();
 248
 249                 cats = cfg.getCategories();
 250                 for (Category cat: cats)
 251                         System.out.println(cat);
 252
 253                 feeds = cfg.getFeeds();
 254
 255                 System.out.println("Number of feeds: " + feeds.length);
 256                 for (Feed f: feeds)
 257                         System.out.println(f);
 258         }
 259 }