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.List;
  10 import java.util.Map;
  11 import java.util.logging.Logger;
  12
  13 import javax.json.Json;
  14 import javax.json.JsonArray;
  15 import javax.json.JsonObject;
  16 import javax.json.JsonValue;
  17
  18 import pnews.Category;
  19 import pnews.Feed;
  20 import pnews.Language;
  21
  22 public class Config {
  23         private Feed[] feeds;
  24         private Category[] categories;
  25         private Language[] languages;
  26         /**
  27          * The key is the language, the value is the default category for this language.
  28          */
  29         private Map<String, Category> defaultCategories = new HashMap<>();
  30         private static final Logger LOG = Logger.getLogger(Config.class.getName());
  31
  32         private void loadCategories(JsonArray jcats) {
  33                 List<Category> cats;
  34                 JsonObject jcat;
  35                 Category cat;
  36                 String id, label, title, language;
  37
  38                 cats = new ArrayList<>(jcats.size());
  39
  40                 for (JsonValue v: jcats) {
  41                         jcat = (JsonObject)v;
  42                         id = jcat.getString("id");
  43                         label = jcat.getString("label");
  44                         title = jcat.getString("title");
  45                         language = jcat.getString("language");
  46                         cat = new Category(id, label, title, language);
  47                         cats.add(cat);
  48                         if (defaultCategories.get(language) == null)
  49                                 defaultCategories.put(language, cat);
  50                 }
  51
  52                 categories = cats.toArray(new Category[0]);
  53         }
  54
  55         private void loadLanguages(JsonArray jlangs) {
  56                 List<Language> langs;
  57                 JsonObject jlang;
  58                 String id;
  59
  60                 langs = new ArrayList<>(jlangs.size());
  61
  62                 for (JsonValue v: jlangs) {
  63                         jlang = (JsonObject)v;
  64                         id = jlang.getString("id");
  65                         langs.add(new Language(id));
  66                 }
  67
  68                 languages = langs.toArray(new Language[0]);
  69         }
  70
  71         private Category getCategory(String id) {
  72                 for (Category c: categories)
  73                         if (c.getId().equals(id))
  74                                 return c;
  75                 return null;
  76         }
  77
  78         public void loadConfig() throws UnsupportedEncodingException {
  79                 Reader r;
  80                 JsonObject jfeeds, jroot;
  81                 List<Feed> feedList;
  82
  83                 r = null;
  84                 try {
  85                         r = new InputStreamReader(Config.class.getClassLoader().getResourceAsStream("feeds.json"),
  86                                                   "UTF-8");
  87                         jroot = Json.createReader(r).readObject();
  88                 } finally {
  89                         if (r != null)
  90                                 try { r.close(); } catch (IOException e) { };
  91                 }
  92
  93                 loadLanguages(jroot.getJsonArray("languages"));
  94                 loadCategories(jroot.getJsonArray("categories"));
  95
  96                 jfeeds = jroot.getJsonObject("feeds");
  97
  98                 feedList = new ArrayList<Feed>(jfeeds.size());
  99
 100                 jfeeds.forEach((k, v)-> {
 101                         JsonObject jf;
 102                         String str;
 103                         Category cat;
 104                         JsonArray jcategories;
 105
 106                         jf = (JsonObject)v;
 107                         jcategories = jf.getJsonArray("categories");
 108                         str = jcategories.getString(0);
 109
 110                         cat = getCategory(str);
 111
 112                         if (cat != null)
 113                                 feedList.add(new Feed(k, cat));
 114                         else
 115                                 LOG.severe("Missing category: " + str);
 116                 });
 117
 118                 feeds = feedList.toArray(new Feed[0]);
 119         }
 120
 121         public Feed[] getFeeds() {
 122                 return feeds;
 123         }
 124
 125         public Map<Category, List<Feed>> getFeedsByCategory() {
 126                 Map<Category, List<Feed>> result;
 127                 Feed[] feeds;
 128                 List<Feed> catFeeds;
 129                 Category cat;
 130
 131                 result = new HashMap<>();
 132
 133                 feeds = getFeeds();
 134                 for (Feed f: feeds) {
 135                         cat = f.getCategory();
 136
 137                         catFeeds = result.get(cat);
 138                         if (catFeeds == null) {
 139                                 catFeeds = new ArrayList<Feed>();
 140                                 result.put(cat, catFeeds);
 141                         }
 142                         catFeeds.add(f);
 143                 }
 144
 145                 return result;
 146         }
 147
 148         public Category[] getCategories() {
 149                 return categories;
 150         }
 151
 152         public Category getDefaultCategory(Language lang) {
 153                 return defaultCategories.get(lang.getId());
 154         }
 155
 156         public Language[] getLanguages() {
 157                 return languages;
 158         }
 159
 160         public Language getDefaultLanguage() {
 161                 return languages[0];
 162         }
 163
 164         public static void main(String[] args) throws UnsupportedEncodingException {
 165                 Config cfg;
 166                 Feed[] feeds;
 167                 Category[] cats;
 168
 169                 cfg = new Config();
 170                 cfg.loadConfig();
 171
 172                 cats = cfg.getCategories();
 173                 for (Category cat: cats)
 174                         System.out.println(cat);
 175
 176                 feeds = cfg.getFeeds();
 177
 178                 System.out.println("Number of feeds: " + feeds.length);
 179                 for (Feed f: feeds)
 180                         System.out.println(f);
 181         }
 182 }