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