Update localisation service

src/main/java/org/telegram/BuildVars.java

@@ -31,7 +31,7 @@ public class BuildVars {
     public static final String pathToLogs = "./";
 
     public static final String linkDB = "jdbc:mysql://localhost:3306/YOURDATABSENAME?useUnicode=true&characterEncoding=UTF-8";
-    public static final String controllerDB = "com.mysql.jdbc.Driver";
+    public static final String controllerDB = "com.mysql.cj.jdbc.Driver";
     public static final String userDB = "<your-database-user>";
     public static final String password = "<your-databas-user-password>";
 

src/main/java/org/telegram/database/ConectionDB.java

@@ -76,7 +76,7 @@ public class ConectionDB {
         int max = 0;
         try {
             final DatabaseMetaData metaData = this.currentConection.getMetaData();
-            final ResultSet res = metaData.getTables(null, null, null,
+            final ResultSet res = metaData.getTables(null, null, "",
                     new String[]{"TABLE"});
             while (res.next()) {
                 if (res.getString("TABLE_NAME").compareTo("Versions") == 0) {

src/main/java/org/telegram/services/DirectionsService.java

@@ -84,7 +84,7 @@ public class DirectionsService {
             JSONObject jsonObject = new JSONObject(responseContent);
             if (jsonObject.getString("status").equals("OK")) {
                 JSONObject route = jsonObject.getJSONArray("routes").getJSONObject(0);
-                String startOfAddress = LocalisationService.getInstance().getString("directionsInit", language);
+                String startOfAddress = LocalisationService.getString("directionsInit", language);
                 String partialResponseToUser = String.format(startOfAddress,
                         route.getJSONArray("legs").getJSONObject(0).getString("start_address"),
                         route.getJSONArray("legs").getJSONObject(0).getJSONObject("distance").getString("text"),
@@ -95,11 +95,11 @@ public class DirectionsService {
                 responseToUser.addAll(getDirectionsSteps(
                         route.getJSONArray("legs").getJSONObject(0).getJSONArray("steps"), language));
             } else {
-                responseToUser.add(LocalisationService.getInstance().getString("directionsNotFound", language));
+                responseToUser.add(LocalisationService.getString("directionsNotFound", language));
             }
         } catch (Exception e) {
             BotLogger.warn(LOGTAG, e);
-            responseToUser.add(LocalisationService.getInstance().getString("errorFetchingDirections", language));
+            responseToUser.add(LocalisationService.getString("errorFetchingDirections", language));
         }
         return responseToUser;
     }
@@ -126,7 +126,7 @@ public class DirectionsService {
     }
 
     private String getDirectionForStep(JSONObject jsonObject, String language) {
-        String direction = LocalisationService.getInstance().getString("directionsStep", language);
+        String direction = LocalisationService.getString("directionsStep", language);
         String htmlIntructions = Jsoup.parse(jsonObject.getString("html_instructions")).text();
         String duration = jsonObject.getJSONObject("duration").getString("text");
         String distance = jsonObject.getJSONObject("distance").getString("text");

src/main/java/org/telegram/services/LocalisationService.java

@@ -1,134 +1,61 @@
 package org.telegram.services;
 
-import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.HashMap;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
 import java.util.Locale;
 import java.util.MissingResourceException;
+import java.util.PropertyResourceBundle;
 import java.util.ResourceBundle;
 
 /**
  * @author Ruben Bermudez
  * @version 1.0
- * @brief Localisation
- * @date 25/01/15
  */
 public class LocalisationService {
-    private static LocalisationService instance = null;
-    private final HashMap<String, String> supportedLanguages = new HashMap<>();
-
-    private ResourceBundle english;
-    private ResourceBundle spanish;
-    private ResourceBundle dutch;
-    private ResourceBundle german;
-    private ResourceBundle italian;
-    private ResourceBundle french;
-    private ResourceBundle malayalam;
-    private ResourceBundle hindi;
-    private ResourceBundle portuguese;
-    private ResourceBundle portuguesebr;
-    private ResourceBundle russian;
-    private ResourceBundle arabic;
-    private ResourceBundle catalan;
-    private ResourceBundle galician;
-    private ResourceBundle persian;
-    private ResourceBundle turkish;
-    private ResourceBundle esperanto;
-
-    private class CustomClassLoader extends ClassLoader {
-        public CustomClassLoader(ClassLoader parent) {
-            super(parent);
+    private static final String STRINGS_FILE = "strings";
+    private static final Object lock = new Object();
 
-        }
+    private static final List<Language> supportedLanguages = new ArrayList<>();
+    private static final Utf8ResourceBundle defaultLanguage;
+    private static final Utf8ResourceBundle spanish;
+    private static final Utf8ResourceBundle dutch;
+    private static final Utf8ResourceBundle italian;
+    private static final Utf8ResourceBundle portuguese;
+    private static final Utf8ResourceBundle esperanto;
 
-        public InputStream getResourceAsStream(String name) {
-            InputStream utf8in = getParent().getResourceAsStream(name);
-            if (utf8in != null) {
-                try {
-                    byte[] utf8Bytes = new byte[utf8in.available()];
-                    utf8in.read(utf8Bytes, 0, utf8Bytes.length);
-                    byte[] iso8859Bytes = new String(utf8Bytes, "UTF-8").getBytes("ISO-8859-1");
-                    return new ByteArrayInputStream(iso8859Bytes);
-                } catch (IOException e) {
-                    e.printStackTrace();
-
-                } finally {
-                    try {
-                        utf8in.close();
-                    } catch (IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-            }
-            return null;
+    static {
+        synchronized (lock) {
+            defaultLanguage = new Utf8ResourceBundle(STRINGS_FILE, Locale.ROOT);
+            supportedLanguages.add(new Language("en", "English"));
+            spanish = new Utf8ResourceBundle(STRINGS_FILE, new Locale("es", "ES"));
+            supportedLanguages.add(new Language("es", "Español"));
+            portuguese = new Utf8ResourceBundle(STRINGS_FILE, new Locale("pt", "PT"));
+            supportedLanguages.add(new Language("pt", "Português"));
+            dutch = new Utf8ResourceBundle(STRINGS_FILE, new Locale("nl", "NL"));
+            supportedLanguages.add(new Language("nl", "Nederlands"));
+            italian = new Utf8ResourceBundle(STRINGS_FILE, new Locale("it", "IT"));
+            supportedLanguages.add(new Language("it", "Italiano"));
+            esperanto = new Utf8ResourceBundle(STRINGS_FILE, new Locale("eo", "EO"));
+            supportedLanguages.add(new Language("eo", "Esperanto"));
         }
     }
 
-    /**
-     * Singleton
-     *
-     * @return Instance of localisation service
-     */
-    public static LocalisationService getInstance() {
-        if (instance == null) {
-            synchronized (LocalisationService.class) {
-                if (instance == null) {
-                    instance = new LocalisationService();
-                }
-            }
-        }
-        return instance;
-    }
-
-    /**
-     * Private constructor due to singleton
-     */
-    private LocalisationService() {
-        CustomClassLoader loader = new CustomClassLoader(Thread.currentThread().getContextClassLoader());
-        english = ResourceBundle.getBundle("localisation.strings", new Locale("en", "US"), loader);
-        supportedLanguages.put("en", "English");
-        spanish = ResourceBundle.getBundle("localisation.strings", new Locale("es", "ES"), loader);
-        supportedLanguages.put("es", "Español");
-        portuguese = ResourceBundle.getBundle("localisation.strings", new Locale("pt", "PT"), loader);
-        supportedLanguages.put("pt", "Português");
-        dutch = ResourceBundle.getBundle("localisation.strings", new Locale("nl", "NL"), loader);
-        supportedLanguages.put("nl", "Nederlands");
-        italian = ResourceBundle.getBundle("localisation.strings", new Locale("it", "IT"), loader);
-        supportedLanguages.put("it", "Italiano");
-        esperanto = ResourceBundle.getBundle("localisation.strings", new Locale("eo", "EO"), loader);
-        supportedLanguages.put("eo", "Esperanto");
-        /*
-        german = ResourceBundle.getBundle("localisation.strings", new Locale("de", "DE"), loader);
-        supportedLanguages.put("de", "Deutsch");
-        italian = ResourceBundle.getBundle("localisation.strings", new Locale("it", "IT"), loader);
-        supportedLanguages.put("it", "Italian");
-        french = ResourceBundle.getBundle("localisation.strings", new Locale("fr", "FR"), loader);
-        supportedLanguages.put("fr", "French");
-        portuguesebr = ResourceBundle.getBundle("localisation.strings", new Locale("pt", "BR"), loader);
-        supportedLanguages.put("pt_br", "Portuguese BR");*/
-        /**
-        malayalam = ResourceBundle.getBundle("localisation.strings", new Locale("ml", "ML"), loader);
-        hindi = ResourceBundle.getBundle("localisation.strings", new Locale("hi", "HI"), loader);
-        russian = ResourceBundle.getBundle("localisation.strings", new Locale("ru", "RU"), loader);
-        arabic = ResourceBundle.getBundle("localisation.strings", new Locale("ar", "AR"), loader);
-        catalan = ResourceBundle.getBundle("localisation.strings", new Locale("ca", "CA"), loader);
-        galician = ResourceBundle.getBundle("localisation.strings", new Locale("gl", "ES"), loader);
-        persian = ResourceBundle.getBundle("localisation.strings", new Locale("fa", "FA"), loader);
-        turkish = ResourceBundle.getBundle("localisation.strings", new Locale("tr", "TR"), loader);
-         */
-    }
-
     /**
      * Get a string in default language (en)
      *
      * @param key key of the resource to fetch
      * @return fetched string or error message otherwise
      */
-    public String getString(String key) {
+    public static String getString(String key) {
         String result;
         try {
-            result = english.getString(key);
+            result = defaultLanguage.getString(key);
         } catch (MissingResourceException e) {
             result = "String not found";
         }
@@ -142,13 +69,10 @@ public class LocalisationService {
      * @param key key of the resource to fetch
      * @return fetched string or error message otherwise
      */
-    public String getString(String key, String language) {
+    public static String getString(String key, String language) {
         String result;
         try {
             switch (language.toLowerCase()) {
-                case "en":
-                    result = english.getString(key);
-                    break;
                 case "es":
                     result = spanish.getString(key);
                     break;
@@ -164,55 +88,127 @@ public class LocalisationService {
                 case "eo":
                     result = esperanto.getString(key);
                     break;
-                /*case "de":
-                    result = german.getString(key);
-                    break;
-                case "fr":
-                    result = french.getString(key);
-                    break;
-                case "ml":
-                    result = malayalam.getString(key);
-                    break;
-                case "hi":
-                    result = hindi.getString(key);
-                    break;
-                case "pt-BR":
-                    result = portuguesebr.getString(key);
-                    break;
-                case "ru":
-                    result = russian.getString(key);
-                    break;
-                case "ar":
-                    result = arabic.getString(key);
-                    break;
-                case "ca":
-                    result = catalan.getString(key);
-                    break;
-                case "gl":
-                    result = galician.getString(key);
-                    break;
-                case "fa":
-                    result = persian.getString(key);
-                    break;
-                case "tr":
-                    result = turkish.getString(key);
-                    break;*/
                 default:
-                    result = english.getString(key);
+                    result = defaultLanguage.getString(key);
                     break;
             }
         } catch (MissingResourceException e) {
-            result = english.getString(key);
+            result = defaultLanguage.getString(key);
         }
 
         return result;
     }
 
-    public HashMap<String, String> getSupportedLanguages() {
+    public static List<Language> getSupportedLanguages() {
         return supportedLanguages;
     }
 
-    public String getLanguageCodeByName(String language) {
-        return supportedLanguages.entrySet().stream().filter(x -> x.getValue().equals(language)).findFirst().get().getKey();
+    public static Language getLanguageByCode(String languageCode) {
+        return supportedLanguages.stream().filter(x -> x.getCode().equals(languageCode)).findFirst().orElse(null);
+    }
+
+    public static Language getLanguageByName(String languageName) {
+        return supportedLanguages.stream().filter(x -> x.getName().equals(languageName)).findFirst().orElse(null);
+    }
+
+    public static String getLanguageCodeByName(String language) {
+        return supportedLanguages.stream().filter(x -> x.getName().equals(language))
+                .map(Language::getCode).findFirst().orElse(null);
+    }
+
+    public static class Language {
+        private String code;
+        private String name;
+        private String emoji;
+
+        public Language(String code, String name) {
+            this.code = code;
+            this.name = name;
+        }
+
+        public String getCode() {
+            return code;
+        }
+
+        public void setCode(String code) {
+            this.code = code;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public String getEmoji() {
+            return emoji;
+        }
+
+        public void setEmoji(String emoji) {
+            this.emoji = emoji;
+        }
+
+        @Override
+        public String toString() {
+            if (emoji == null || emoji.isEmpty()) {
+                return name;
+            } else {
+                return emoji + " " + name;
+            }
+        }
+    }
+
+    private static class Utf8ResourceBundle extends ResourceBundle {
+
+        private static final String BUNDLE_EXTENSION = "properties";
+        private static final String CHARSET = "UTF-8";
+        private static final ResourceBundle.Control UTF8_CONTROL = new UTF8Control();
+
+        Utf8ResourceBundle(String bundleName, Locale locale) {
+            setParent(ResourceBundle.getBundle(bundleName, locale, UTF8_CONTROL));
+        }
+
+        @Override
+        protected Object handleGetObject(String key) {
+            return parent.getObject(key);
+        }
+
+        @Override
+        public Enumeration<String> getKeys() {
+            return parent.getKeys();
+        }
+
+        private static class UTF8Control extends Control {
+            public ResourceBundle newBundle
+                    (String baseName, Locale locale, String format, ClassLoader loader, boolean reload)
+                    throws IllegalAccessException, InstantiationException, IOException {
+                String bundleName = toBundleName(baseName, locale);
+                String resourceName = toResourceName(bundleName, BUNDLE_EXTENSION);
+                ResourceBundle bundle = null;
+                InputStream stream = null;
+                if (reload) {
+                    URL url = loader.getResource(resourceName);
+                    if (url != null) {
+                        URLConnection connection = url.openConnection();
+                        if (connection != null) {
+                            connection.setUseCaches(false);
+                            stream = connection.getInputStream();
+                        }
+                    }
+                } else {
+                    stream = loader.getResourceAsStream(resourceName);
+                }
+                if (stream != null) {
+                    try {
+                        bundle = new PropertyResourceBundle(new InputStreamReader(stream, CHARSET));
+                    } finally {
+                        stream.close();
+                    }
+                }
+                return bundle;
+            }
+        }
     }
 }

src/main/java/org/telegram/services/WeatherService.java

@@ -96,15 +96,15 @@ public class WeatherService {
                 cityFound = jsonObject.getJSONObject("city").getString("name") + " (" +
                         jsonObject.getJSONObject("city").getString("country") + ")";
                 saveRecentWeather(userId, cityFound, jsonObject.getJSONObject("city").getInt("id"));
-                responseToUser = String.format(LocalisationService.getInstance().getString("weatherAlert", language),
+                responseToUser = String.format(LocalisationService.getString("weatherAlert", language),
                         cityFound, convertListOfForecastToString(jsonObject, language, units, false));
             } else {
                 BotLogger.warn(LOGTAG, jsonObject.toString());
-                responseToUser = LocalisationService.getInstance().getString("cityNotFound", language);
+                responseToUser = LocalisationService.getString("cityNotFound", language);
             }
         } catch (Exception e) {
             BotLogger.error(LOGTAG, e);
-            responseToUser = LocalisationService.getInstance().getString("errorFetchingWeather", language);
+            responseToUser = LocalisationService.getString("errorFetchingWeather", language);
         }
         return responseToUser;
     }
@@ -137,15 +137,15 @@ public class WeatherService {
                 cityFound = jsonObject.getJSONObject("city").getString("name") + " (" +
                         jsonObject.getJSONObject("city").getString("country") + ")";
                 saveRecentWeather(userId, cityFound, jsonObject.getJSONObject("city").getInt("id"));
-                responseToUser = String.format(LocalisationService.getInstance().getString("weatherForcast", language),
+                responseToUser = String.format(LocalisationService.getString("weatherForcast", language),
                         cityFound, convertListOfForecastToString(jsonObject, language, units, true));
             } else {
                 BotLogger.warn(LOGTAG, jsonObject.toString());
-                responseToUser = LocalisationService.getInstance().getString("cityNotFound", language);
+                responseToUser = LocalisationService.getString("cityNotFound", language);
             }
         } catch (Exception e) {
             BotLogger.error(LOGTAG, e);
-            responseToUser = LocalisationService.getInstance().getString("errorFetchingWeather", language);
+            responseToUser = LocalisationService.getString("errorFetchingWeather", language);
         }
         return responseToUser;
     }
@@ -176,15 +176,15 @@ public class WeatherService {
                 cityFound = jsonObject.getJSONObject("city").getString("name") + " (" +
                         jsonObject.getJSONObject("city").getString("country") + ")";
                 saveRecentWeather(userId, cityFound, jsonObject.getJSONObject("city").getInt("id"));
-                responseToUser = String.format(LocalisationService.getInstance().getString("weatherForcast", language),
+                responseToUser = String.format(LocalisationService.getString("weatherForcast", language),
                         cityFound, convertListOfForecastToString(jsonObject, language, units, true));
             } else {
                 BotLogger.warn(LOGTAG, jsonObject.toString());
-                responseToUser = LocalisationService.getInstance().getString("cityNotFound", language);
+                responseToUser = LocalisationService.getString("cityNotFound", language);
             }
         } catch (Exception e) {
             BotLogger.error(LOGTAG, e);
-            responseToUser = LocalisationService.getInstance().getString("errorFetchingWeather", language);
+            responseToUser = LocalisationService.getString("errorFetchingWeather", language);
         }
         return responseToUser;
     }
@@ -217,15 +217,15 @@ public class WeatherService {
                         jsonObject.getJSONObject("sys").getString("country") + ")";
                 saveRecentWeather(userId, cityFound, jsonObject.getInt("id"));
                 emoji = getEmojiForWeather(jsonObject.getJSONArray("weather").getJSONObject(0));
-                responseToUser = String.format(LocalisationService.getInstance().getString("weatherCurrent", language),
+                responseToUser = String.format(LocalisationService.getString("weatherCurrent", language),
                         cityFound, convertCurrentWeatherToString(jsonObject, language, units, emoji));
             } else {
                 BotLogger.warn(LOGTAG, jsonObject.toString());
-                responseToUser = LocalisationService.getInstance().getString("cityNotFound", language);
+                responseToUser = LocalisationService.getString("cityNotFound", language);
             }
         } catch (Exception e) {
             BotLogger.error(LOGTAG, e);
-            responseToUser = LocalisationService.getInstance().getString("errorFetchingWeather", language);
+            responseToUser = LocalisationService.getString("errorFetchingWeather", language);
         }
         return responseToUser;
     }
@@ -256,15 +256,15 @@ public class WeatherService {
                 cityFound = jsonObject.getString("name") + " (" +
                         jsonObject.getJSONObject("sys").getString("country") + ")";
                 saveRecentWeather(userId, cityFound, jsonObject.getInt("id"));
-                responseToUser = String.format(LocalisationService.getInstance().getString("weatherCurrent", language),
+                responseToUser = String.format(LocalisationService.getString("weatherCurrent", language),
                         cityFound, convertCurrentWeatherToString(jsonObject, language, units, null));
             } else {
                 BotLogger.warn(LOGTAG, jsonObject.toString());
-                responseToUser = LocalisationService.getInstance().getString("cityNotFound", language);
+                responseToUser = LocalisationService.getString("cityNotFound", language);
             }
         } catch (Exception e) {
             BotLogger.error(LOGTAG, e);
-            responseToUser = LocalisationService.getInstance().getString("errorFetchingWeather", language);
+            responseToUser = LocalisationService.getString("errorFetchingWeather", language);
         }
         return responseToUser;
     }
@@ -276,9 +276,9 @@ public class WeatherService {
 
         String responseToUser;
         if (units.equals(METRICSYSTEM)) {
-            responseToUser = LocalisationService.getInstance().getString("currentWeatherPartMetric", language);
+            responseToUser = LocalisationService.getString("currentWeatherPartMetric", language);
         } else {
-            responseToUser = LocalisationService.getInstance().getString("currentWeatherPartImperial", language);
+            responseToUser = LocalisationService.getString("currentWeatherPartImperial", language);
         }
         responseToUser = String.format(responseToUser, emoji == null ? weatherDesc : emoji.toString(), cloudiness, temp);
 
@@ -321,15 +321,15 @@ public class WeatherService {
 
         if (units.equals(METRICSYSTEM)) {
             if (addDate) {
-                responseToUser = LocalisationService.getInstance().getString("forecastWeatherPartMetric", language);
+                responseToUser = LocalisationService.getString("forecastWeatherPartMetric", language);
             } else {
-                responseToUser = LocalisationService.getInstance().getString("alertWeatherPartMetric", language);
+                responseToUser = LocalisationService.getString("alertWeatherPartMetric", language);
             }
         } else {
             if (addDate) {
-                responseToUser = LocalisationService.getInstance().getString("forecastWeatherPartImperial", language);
+                responseToUser = LocalisationService.getString("forecastWeatherPartImperial", language);
             } else {
-                responseToUser = LocalisationService.getInstance().getString("alertWeatherPartImperial", language);
+                responseToUser = LocalisationService.getString("alertWeatherPartImperial", language);
             }
         }
         if (addDate) {

src/main/java/org/telegram/updateshandlers/DirectionsHandlers.java

@@ -21,9 +21,7 @@ import org.telegram.telegrambots.updateshandlers.SentCallback;
 
 import java.io.InvalidObjectException;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
 /**
@@ -89,7 +87,7 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
                             sendHelpMessage(message, language);
                         } else {
                             SendMessage sendMessageRequest = new SendMessage();
-                            sendMessageRequest.setText(LocalisationService.getInstance().getString("youNeedReplyDirections", language));
+                            sendMessageRequest.setText(LocalisationService.getString("youNeedReplyDirections", language));
                             sendMessageRequest.setChatId(message.getChatId());
                             try {
                                 sendMessage(sendMessageRequest);
@@ -146,7 +144,7 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
         ForceReplyKeyboard forceReplyKeyboard = new ForceReplyKeyboard();
         forceReplyKeyboard.setSelective(true);
         sendMessageRequest.setReplyMarkup(forceReplyKeyboard);
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("sendDestination", language));
+        sendMessageRequest.setText(LocalisationService.getString("sendDestination", language));
 
         try {
             sendMessageAsync(sendMessageRequest, new SentCallback<Message>() {
@@ -175,7 +173,7 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
     private void sendHelpMessage(Message message, String language) throws InvalidObjectException {
         SendMessage sendMessageRequest = new SendMessage();
         String helpDirectionsFormated = String.format(
-                LocalisationService.getInstance().getString("helpDirections", language),
+                LocalisationService.getString("helpDirections", language),
                 Commands.startDirectionCommand);
         sendMessageRequest.setText(helpDirectionsFormated);
         sendMessageRequest.setChatId(message.getChatId());
@@ -193,7 +191,7 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
         ForceReplyKeyboard forceReplyKeyboard = new ForceReplyKeyboard();
         forceReplyKeyboard.setSelective(true);
         sendMessageRequest.setReplyMarkup(forceReplyKeyboard);
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("initDirections", language));
+        sendMessageRequest.setText(LocalisationService.getString("initDirections", language));
 
         try {
             sendMessageAsync(sendMessageRequest, new SentCallback<Message>() {
@@ -223,11 +221,11 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.setChatId(message.getChatId());
         ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
-        HashMap<String, String> languages = LocalisationService.getInstance().getSupportedLanguages();
+        List<LocalisationService.Language> languages = LocalisationService.getSupportedLanguages();
         List<KeyboardRow> commands = new ArrayList<>();
-        for (Map.Entry<String, String> entry : languages.entrySet()) {
+        for (LocalisationService.Language languageItem : languages) {
             KeyboardRow commandRow = new KeyboardRow();
-            commandRow.add(entry.getKey() + " --> " + entry.getValue());
+            commandRow.add(languageItem.getCode() + " --> " + languageItem.getName());
             commands.add(commandRow);
         }
         replyKeyboardMarkup.setResizeKeyboard(true);
@@ -235,7 +233,7 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
         replyKeyboardMarkup.setKeyboard(commands);
         replyKeyboardMarkup.setSelective(true);
         sendMessageRequest.setReplyMarkup(replyKeyboardMarkup);
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("chooselanguage", language));
+        sendMessageRequest.setText(LocalisationService.getString("chooselanguage", language));
         try {
             sendMessage(sendMessageRequest);
             languageMessages.add(message.getFrom().getId());
@@ -248,11 +246,11 @@ public class DirectionsHandlers extends TelegramLongPollingBot {
         String[] parts = message.getText().split("-->", 2);
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.setChatId(message.getChatId());
-        if (LocalisationService.getInstance().getSupportedLanguages().containsKey(parts[0].trim())) {
+        if (LocalisationService.getLanguageByCode(parts[0].trim()) != null) {
             DatabaseManager.getInstance().putUserLanguage(message.getFrom().getId(), parts[0].trim());
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("languageModified", parts[0].trim()));
+            sendMessageRequest.setText(LocalisationService.getString("languageModified", parts[0].trim()));
         } else {
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("errorLanguage"));
+            sendMessageRequest.setText(LocalisationService.getString("errorLanguage"));
         }
         sendMessageRequest.setReplyToMessageId(message.getMessageId());
         ReplyKeyboardHide replyKeyboardHide = new ReplyKeyboardHide();

src/main/java/org/telegram/updateshandlers/FilesHandlers.java

@@ -106,8 +106,8 @@ public class FilesHandlers extends TelegramLongPollingBot {
             String language = DatabaseManager.getInstance().getUserLanguage(update.getMessage().getFrom().getId());
             DatabaseManager.getInstance().addFile(message.getDocument().getFileId(), message.getFrom().getId(), message.getDocument().getFileName());
             SendMessage sendMessageRequest = new SendMessage();
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("fileUploaded", language) +
-                    LocalisationService.getInstance().getString("uploadedFileURL", language) + message.getDocument().getFileId());
+            sendMessageRequest.setText(LocalisationService.getString("fileUploaded", language) +
+                    LocalisationService.getString("uploadedFileURL", language) + message.getDocument().getFileId());
             sendMessageRequest.setChatId(message.getChatId());
             sendMessage(sendMessageRequest);
         }
@@ -117,14 +117,14 @@ public class FilesHandlers extends TelegramLongPollingBot {
         HashMap<String, String> files = DatabaseManager.getInstance().getFilesByUser(message.getFrom().getId());
         SendMessage sendMessageRequest = new SendMessage();
         if (files.size() > 0) {
-            String text = LocalisationService.getInstance().getString("listOfFiles", language) + ":\n\n";
+            String text = LocalisationService.getString("listOfFiles", language) + ":\n\n";
             for (Map.Entry<String, String> entry : files.entrySet()) {
-                text += LocalisationService.getInstance().getString("uploadedFileURL", language)
+                text += LocalisationService.getString("uploadedFileURL", language)
                         + entry.getKey() + " " + Emoji.LEFT_RIGHT_ARROW.toString() + " " + entry.getValue() + "\n";
             }
             sendMessageRequest.setText(text);
         } else {
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("noFiles", language));
+            sendMessageRequest.setText(LocalisationService.getString("noFiles", language));
         }
         sendMessageRequest.setChatId(message.getChatId());
         ReplyKeyboardHide replyKeyboardHide = new ReplyKeyboardHide();
@@ -144,7 +144,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
     private void onDeleteCommandWithoutParameters(Message message, String language) throws InvalidObjectException, TelegramApiException {
         DatabaseManager.getInstance().addUserForFile(message.getFrom().getId(), DELETE_UPLOADED_STATUS);
         SendMessage sendMessageRequest = new SendMessage();
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("deleteUploadedFile", language));
+        sendMessageRequest.setText(LocalisationService.getString("deleteUploadedFile", language));
         sendMessageRequest.setChatId(message.getChatId());
         HashMap<String, String> files = DatabaseManager.getInstance().getFilesByUser(message.getFrom().getId());
         ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
@@ -169,9 +169,9 @@ public class FilesHandlers extends TelegramLongPollingBot {
         boolean removed = DatabaseManager.getInstance().deleteFile(innerParts[0].trim());
         SendMessage sendMessageRequest = new SendMessage();
         if (removed) {
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("fileDeleted", language));
+            sendMessageRequest.setText(LocalisationService.getString("fileDeleted", language));
         } else {
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("wrongFileId", language));
+            sendMessageRequest.setText(LocalisationService.getString("wrongFileId", language));
         }
         sendMessageRequest.setChatId(message.getChatId());
 
@@ -183,7 +183,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
     private void onCancelCommand(Message message, String language) throws InvalidObjectException, TelegramApiException {
         DatabaseManager.getInstance().deleteUserForFile(message.getFrom().getId());
         SendMessage sendMessageRequest = new SendMessage();
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("processFinished", language));
+        sendMessageRequest.setText(LocalisationService.getString("processFinished", language));
         sendMessageRequest.setChatId(message.getChatId());
         sendMessage(sendMessageRequest);
     }
@@ -191,7 +191,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
     private void onUploadCommand(Message message, String language) throws InvalidObjectException, TelegramApiException {
         DatabaseManager.getInstance().addUserForFile(message.getFrom().getId(), INITIAL_UPLOAD_STATUS);
         SendMessage sendMessageRequest = new SendMessage();
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("sendFileToUpload", language));
+        sendMessageRequest.setText(LocalisationService.getString("sendFileToUpload", language));
         sendMessageRequest.setChatId(message.getChatId());
         sendMessage(sendMessageRequest);
     }
@@ -199,7 +199,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
     private void sendHelpMessage(Message message, String language) throws InvalidObjectException, TelegramApiException {
         SendMessage sendMessageRequest = new SendMessage();
         String formatedString = String.format(
-                LocalisationService.getInstance().getString("helpFiles", language),
+                LocalisationService.getString("helpFiles", language),
                 Commands.startCommand, Commands.uploadCommand, Commands.deleteCommand,
                 Commands.listCommand);
         sendMessageRequest.setText(formatedString);
@@ -215,7 +215,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
             sendDocument(sendDocumentRequest);
         } else {
             SendMessage sendMessageRequest = new SendMessage();
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("wrongFileId", language));
+            sendMessageRequest.setText(LocalisationService.getString("wrongFileId", language));
             sendMessageRequest.setChatId(message.getChatId());
             sendMessage(sendMessageRequest);
         }
@@ -225,11 +225,11 @@ public class FilesHandlers extends TelegramLongPollingBot {
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.setChatId(message.getChatId());
         ReplyKeyboardMarkup replyKeyboardMarkup = new ReplyKeyboardMarkup();
-        HashMap<String, String> languages = LocalisationService.getInstance().getSupportedLanguages();
+        List<LocalisationService.Language> languages = LocalisationService.getSupportedLanguages();
         List<KeyboardRow> commands = new ArrayList<>();
-        for (Map.Entry<String, String> entry : languages.entrySet()) {
+        for (LocalisationService.Language languageItem : languages) {
             KeyboardRow commandRow = new KeyboardRow();
-            commandRow.add(entry.getKey() + " " + Emoji.LEFT_RIGHT_ARROW.toString() + " " + entry.getValue());
+            commandRow.add(languageItem.getCode() + " " + Emoji.LEFT_RIGHT_ARROW.toString() + " " + languageItem.getName());
             commands.add(commandRow);
         }
         replyKeyboardMarkup.setResizeKeyboard(true);
@@ -237,7 +237,7 @@ public class FilesHandlers extends TelegramLongPollingBot {
         replyKeyboardMarkup.setKeyboard(commands);
         replyKeyboardMarkup.setSelective(true);
         sendMessageRequest.setReplyMarkup(replyKeyboardMarkup);
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("chooselanguage", language));
+        sendMessageRequest.setText(LocalisationService.getString("chooselanguage", language));
         sendMessage(sendMessageRequest);
         languageMessages.add(message.getFrom().getId());
     }
@@ -246,11 +246,11 @@ public class FilesHandlers extends TelegramLongPollingBot {
         String[] parts = message.getText().split(Emoji.LEFT_RIGHT_ARROW.toString(), 2);
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.setChatId(message.getChatId());
-        if (LocalisationService.getInstance().getSupportedLanguages().containsKey(parts[0].trim())) {
+        if (LocalisationService.getLanguageByCode(parts[0].trim()) != null) {
             DatabaseManager.getInstance().putUserLanguage(message.getFrom().getId(), parts[0].trim());
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("languageModified", parts[0].trim()));
+            sendMessageRequest.setText(LocalisationService.getString("languageModified", parts[0].trim()));
         } else {
-            sendMessageRequest.setText(LocalisationService.getInstance().getString("errorLanguage"));
+            sendMessageRequest.setText(LocalisationService.getString("errorLanguage"));
         }
         sendMessageRequest.setReplyToMessageId(message.getMessageId());
         ReplyKeyboardHide replyKeyboardHide = new ReplyKeyboardHide();

src/main/java/org/telegram/updateshandlers/TransifexHandlers.java

@@ -82,7 +82,7 @@ public class TransifexHandlers extends TelegramLongPollingBot {
             } else if (parts[0].startsWith(Commands.help)) {
                 SendMessage sendMessageRequest = new SendMessage();
                 String helpFormated = String.format(
-                        LocalisationService.getInstance().getString("helpTransifex", language),
+                        LocalisationService.getString("helpTransifex", language),
                         Commands.transifexiOSCommand, Commands.transifexAndroidCommand, Commands.transifexWebogram,
                         Commands.transifexTDesktop, Commands.transifexOSX, Commands.transifexWP,
                         Commands.transifexAndroidSupportCommand);
@@ -107,7 +107,7 @@ public class TransifexHandlers extends TelegramLongPollingBot {
                 (message.getText().startsWith(Commands.startCommand) || !message.isGroupMessage())) {
             SendMessage sendMessageRequest = new SendMessage();
             String helpFormated = String.format(
-                    LocalisationService.getInstance().getString("helpTransifex", language),
+                    LocalisationService.getString("helpTransifex", language),
                     Commands.transifexiOSCommand, Commands.transifexAndroidCommand, Commands.transifexWebogram,
                     Commands.transifexTDesktop, Commands.transifexOSX, Commands.transifexWP,
                     Commands.transifexAndroidSupportCommand);
@@ -126,12 +126,12 @@ public class TransifexHandlers extends TelegramLongPollingBot {
         SendMessage answer = new SendMessage();
         answer.setChatId(message.getChatId());
         answer.setReplyToMessageId(message.getMessageId());
-        answer.setText(LocalisationService.getInstance().getString("movedToLangBot", language));
+        answer.setText(LocalisationService.getString("movedToLangBot", language));
         InlineKeyboardMarkup inlineKeyboardMarkup = new InlineKeyboardMarkup();
         List<List<InlineKeyboardButton>> rows = new ArrayList<>();
         List<InlineKeyboardButton> row = new ArrayList<>();
         InlineKeyboardButton button = new InlineKeyboardButton();
-        button.setText(LocalisationService.getInstance().getString("checkLangBot", language));
+        button.setText(LocalisationService.getString("checkLangBot", language));
         button.setUrl("https://telegram.me/langbot");
         row.add(button);
         rows.add(row);

src/main/java/org/telegram/updateshandlers/WeatherHandlers.java

@@ -24,6 +24,7 @@ import org.telegram.telegrambots.logging.BotLogger;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @author Ruben Bermudez
@@ -130,7 +131,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.enableMarkdown(true);
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(replyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("backToMainMenu", language));
+        sendMessage.setText(LocalisationService.getString("backToMainMenu", language));
 
         DatabaseManager.getInstance().insertWeatherState(userId, chatId, MAINMENU);
         return sendMessage;
@@ -249,7 +250,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setReplyToMessageId(message.getMessageId());
         sendMessage.setChatId(message.getChatId());
         sendMessage.setReplyMarkup(getAlertsKeyboard(language));
-        sendMessage.setText(LocalisationService.getInstance().getString("alertDeleted", language));
+        sendMessage.setText(LocalisationService.getString("alertDeleted", language));
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERT);
         return sendMessage;
@@ -261,7 +262,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setReplyToMessageId(message.getMessageId());
         sendMessage.setChatId(message.getChatId());
         sendMessage.setReplyMarkup(getAlertsKeyboard(language));
-        sendMessage.setText(LocalisationService.getInstance().getString("alertsMenuMessage", language));
+        sendMessage.setText(LocalisationService.getString("alertsMenuMessage", language));
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERT);
         return sendMessage;
@@ -276,7 +277,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
                 sendMessage.setChatId(message.getChatId());
                 sendMessage.setReplyToMessageId(message.getMessageId());
                 sendMessage.setReplyMarkup(getAlertsKeyboard(language));
-                sendMessage.setText(LocalisationService.getInstance().getString("alertsMenuMessage", language));
+                sendMessage.setText(LocalisationService.getString("alertsMenuMessage", language));
                 DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERT);
                 sendMessageRequest = sendMessage;
             } else {
@@ -361,11 +362,11 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         ReplyKeyboardMarkup replyKeyboardMarkup = getAlertsListKeyboard(message.getFrom().getId(), language);
         if (replyKeyboardMarkup != null) {
             sendMessage.setReplyMarkup(replyKeyboardMarkup);
-            sendMessage.setText(LocalisationService.getInstance().getString("chooseNewAlertCity", language));
+            sendMessage.setText(LocalisationService.getString("chooseNewAlertCity", language));
             DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERTDELETE);
         } else {
             sendMessage.setReplyMarkup(getAlertsKeyboard(language));
-            sendMessage.setText(LocalisationService.getInstance().getString("noAlertList", language));
+            sendMessage.setText(LocalisationService.getString("noAlertList", language));
         }
 
         sendMessage.setReplyToMessageId(message.getMessageId());
@@ -378,7 +379,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
 
         sendMessage.setChatId(message.getChatId());
         sendMessage.setReplyMarkup(getRecentsKeyboard(message.getFrom().getId(), language, false));
-        sendMessage.setText(LocalisationService.getInstance().getString("chooseNewAlertCity", language));
+        sendMessage.setText(LocalisationService.getString("chooseNewAlertCity", language));
         sendMessage.setReplyToMessageId(message.getMessageId());
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERTNEW);
@@ -415,7 +416,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setReplyToMessageId(message.getMessageId());
         sendMessage.setChatId(message.getChatId());
         sendMessage.setReplyMarkup(getAlertsKeyboard(language));
-        sendMessage.setText(LocalisationService.getInstance().getString("alertsMenuMessage", language));
+        sendMessage.setText(LocalisationService.getString("alertsMenuMessage", language));
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), ALERT);
         return sendMessage;
@@ -456,10 +457,10 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         if (message.hasText()) {
             if (message.getText().trim().equals(getCancelCommand(language))) {
                 sendMessageRequest = onBackUnitsCommand(message, language);
-            } else if (message.getText().trim().equals(LocalisationService.getInstance().getString("metricSystem", language))) {
+            } else if (message.getText().trim().equals(LocalisationService.getString("metricSystem", language))) {
                 sendMessageRequest = onUnitsChosen(message.getFrom().getId(), message.getChatId(),
                         message.getMessageId(), WeatherService.METRICSYSTEM, language);
-            } else if (message.getText().trim().equals(LocalisationService.getInstance().getString("imperialSystem", language))) {
+            } else if (message.getText().trim().equals(LocalisationService.getString("imperialSystem", language))) {
                 sendMessageRequest = onUnitsChosen(message.getFrom().getId(), message.getChatId(),
                         message.getMessageId(), WeatherService.IMPERIALSYSTEM, language);
             } else {
@@ -488,7 +489,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessageRequest.enableMarkdown(true);
         sendMessageRequest.setChatId(chatId.toString());
         sendMessageRequest.setReplyMarkup(getUnitsKeyboard(language));
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("errorUnitsNotFound", language));
+        sendMessageRequest.setText(LocalisationService.getString("errorUnitsNotFound", language));
         sendMessageRequest.setReplyToMessageId(messageId);
 
         return sendMessageRequest;
@@ -500,7 +501,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.enableMarkdown(true);
         sendMessageRequest.setChatId(chatId.toString());
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("unitsUpdated", language));
+        sendMessageRequest.setText(LocalisationService.getString("unitsUpdated", language));
         sendMessageRequest.setReplyToMessageId(messageId);
         sendMessageRequest.setReplyMarkup(getMainMenuKeyboard(language));
 
@@ -517,7 +518,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         if (message.hasText()) {
             if (message.getText().trim().equals(getCancelCommand(language))) {
                 sendMessageRequest = onBackLanguageCommand(message, language);
-            } else if (LocalisationService.getInstance().getSupportedLanguages().values().contains(message.getText().trim())) {
+            } else if (LocalisationService.getLanguageByName(message.getText().trim()) != null) {
                 sendMessageRequest = onLanguageChosen(message.getFrom().getId(), message.getChatId(),
                         message.getMessageId(), message.getText().trim());
             } else {
@@ -546,20 +547,20 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessageRequest.enableMarkdown(true);
         sendMessageRequest.setChatId(chatId.toString());
         sendMessageRequest.setReplyMarkup(getLanguagesKeyboard(language));
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("errorLanguageNotFound", language));
+        sendMessageRequest.setText(LocalisationService.getString("errorLanguageNotFound", language));
         sendMessageRequest.setReplyToMessageId(messageId);
 
         return sendMessageRequest;
     }
 
     private static SendMessage onLanguageChosen(Integer userId, Long chatId, Integer messageId, String language) {
-        String languageCode = LocalisationService.getInstance().getLanguageCodeByName(language);
+        String languageCode = LocalisationService.getLanguageCodeByName(language);
         DatabaseManager.getInstance().putUserWeatherLanguageOption(userId, languageCode);
 
         SendMessage sendMessageRequest = new SendMessage();
         sendMessageRequest.enableMarkdown(true);
         sendMessageRequest.setChatId(chatId.toString());
-        sendMessageRequest.setText(LocalisationService.getInstance().getString("languageUpdated", languageCode));
+        sendMessageRequest.setText(LocalisationService.getString("languageUpdated", languageCode));
         sendMessageRequest.setReplyToMessageId(messageId);
         sendMessageRequest.setReplyMarkup(getMainMenuKeyboard(languageCode));
 
@@ -640,7 +641,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setChatId(chatId.toString());
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(forceReplyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("onWeatherLocationCommand", language));
+        sendMessage.setText(LocalisationService.getString("onWeatherLocationCommand", language));
 
         DatabaseManager.getInstance().insertWeatherState(userId, chatId, FORECASTLOCATIONWEATHER);
         return sendMessage;
@@ -654,7 +655,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setChatId(chatId.toString());
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(forceReplyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("onWeatherNewCommand", language));
+        sendMessage.setText(LocalisationService.getString("onWeatherNewCommand", language));
 
         DatabaseManager.getInstance().insertWeatherState(userId, chatId, FORECASTNEWWEATHER);
         return sendMessage;
@@ -741,7 +742,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setChatId(chatId.toString());
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(forceReplyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("onWeatherLocationCommand", language));
+        sendMessage.setText(LocalisationService.getString("onWeatherLocationCommand", language));
 
         DatabaseManager.getInstance().insertWeatherState(userId, chatId, CURRENTLOCATIONWEATHER);
         return sendMessage;
@@ -755,7 +756,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setChatId(chatId.toString());
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(forceReplyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("onWeatherNewCommand", language));
+        sendMessage.setText(LocalisationService.getString("onWeatherNewCommand", language));
 
         DatabaseManager.getInstance().insertWeatherState(userId, chatId, CURRENTNEWWEATHER);
         return sendMessage;
@@ -819,9 +820,9 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setReplyToMessageId(message.getMessageId());
         sendMessage.setChatId(message.getChatId());
         if (replyKeyboardMarkup.getKeyboard().size() > 3) {
-            sendMessage.setText(LocalisationService.getInstance().getString("onForecastCommandFromHistory", language));
+            sendMessage.setText(LocalisationService.getString("onForecastCommandFromHistory", language));
         } else {
-            sendMessage.setText(LocalisationService.getInstance().getString("onForecastCommandWithoutHistory", language));
+            sendMessage.setText(LocalisationService.getString("onForecastCommandWithoutHistory", language));
         }
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), FORECASTWEATHER);
@@ -837,9 +838,9 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setReplyToMessageId(message.getMessageId());
         sendMessage.setChatId(message.getChatId());
         if (replyKeyboardMarkup.getKeyboard().size() > 3) {
-            sendMessage.setText(LocalisationService.getInstance().getString("onCurrentCommandFromHistory", language));
+            sendMessage.setText(LocalisationService.getString("onCurrentCommandFromHistory", language));
         } else {
-            sendMessage.setText(LocalisationService.getInstance().getString("onCurrentCommandWithoutHistory", language));
+            sendMessage.setText(LocalisationService.getString("onCurrentCommandWithoutHistory", language));
         }
 
         DatabaseManager.getInstance().insertWeatherState(message.getFrom().getId(), message.getChatId(), CURRENTWEATHER);
@@ -851,31 +852,31 @@ public class WeatherHandlers extends TelegramLongPollingBot {
     // region Get Messages
 
     private static String getSettingsMessage(String language) {
-        String baseString = LocalisationService.getInstance().getString("onSettingsCommand", language);
+        String baseString = LocalisationService.getString("onSettingsCommand", language);
         return String.format(baseString, Emoji.GLOBE_WITH_MERIDIANS.toString(),
                 Emoji.STRAIGHT_RULER.toString(), Emoji.ALARM_CLOCK.toString(),
                 Emoji.BACK_WITH_LEFTWARDS_ARROW_ABOVE.toString());
     }
 
     private static String getHelpMessage(String language) {
-        String baseString = LocalisationService.getInstance().getString("helpWeatherMessage", language);
+        String baseString = LocalisationService.getString("helpWeatherMessage", language);
         return String.format(baseString, Emoji.BLACK_RIGHT_POINTING_TRIANGLE.toString(),
                 Emoji.BLACK_RIGHT_POINTING_DOUBLE_TRIANGLE.toString(), Emoji.ALARM_CLOCK.toString(),
                 Emoji.EARTH_GLOBE_EUROPE_AFRICA.toString(), Emoji.STRAIGHT_RULER.toString());
     }
 
     private static String getLanguageMessage(String language) {
-        String baseString = LocalisationService.getInstance().getString("selectLanguage", language);
+        String baseString = LocalisationService.getString("selectLanguage", language);
         return String.format(baseString, language);
     }
 
     private static String getUnitsMessage(Integer userId, String language) {
-        String baseString = LocalisationService.getInstance().getString("selectUnits", language);
+        String baseString = LocalisationService.getString("selectUnits", language);
         return String.format(baseString, DatabaseManager.getInstance().getUserWeatherOptions(userId)[1]);
     }
 
     private static String getChooseNewAlertSetMessage(String city, String language) {
-        String baseString = LocalisationService.getInstance().getString("newAlertSaved", language);
+        String baseString = LocalisationService.getString("newAlertSaved", language);
         return String.format(baseString, Emoji.THUMBS_UP_SIGN.toString(), city);
     }
 
@@ -884,15 +885,15 @@ public class WeatherHandlers extends TelegramLongPollingBot {
 
         List<String> alertCities = DatabaseManager.getInstance().getAlertCitiesNameByUser(userId);
         if (alertCities.size() > 0) {
-            String baseAlertListString = LocalisationService.getInstance().getString("initialAlertList", language);
-            String partialAlertListString = LocalisationService.getInstance().getString("partialAlertList", language);
+            String baseAlertListString = LocalisationService.getString("initialAlertList", language);
+            String partialAlertListString = LocalisationService.getString("partialAlertList", language);
             String fullListOfAlerts = "";
             for (String alertCity : alertCities) {
                 fullListOfAlerts += String.format(partialAlertListString, Emoji.ALARM_CLOCK.toString(), alertCity);
             }
             alertListMessage = String.format(baseAlertListString, alertCities.size(), fullListOfAlerts);
         } else {
-            alertListMessage = LocalisationService.getInstance().getString("noAlertList", language);
+            alertListMessage = LocalisationService.getString("noAlertList", language);
         }
 
         return alertListMessage;
@@ -930,7 +931,8 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         replyKeyboardMarkup.setOneTimeKeyboad(false);
 
         List<KeyboardRow> keyboard = new ArrayList<>();
-        for (String languageName : LocalisationService.getInstance().getSupportedLanguages().values()) {
+        for (String languageName : LocalisationService.getSupportedLanguages().stream().map(
+                LocalisationService.Language::getName).collect(Collectors.toList())) {
             KeyboardRow row = new KeyboardRow();
             row.add(languageName);
             keyboard.add(row);
@@ -952,10 +954,10 @@ public class WeatherHandlers extends TelegramLongPollingBot {
 
         List<KeyboardRow> keyboard = new ArrayList<>();
         KeyboardRow row = new KeyboardRow();
-        row.add(LocalisationService.getInstance().getString("metricSystem", language));
+        row.add(LocalisationService.getString("metricSystem", language));
         keyboard.add(row);
         row = new KeyboardRow();
-        row.add(LocalisationService.getInstance().getString("imperialSystem", language));
+        row.add(LocalisationService.getString("imperialSystem", language));
         keyboard.add(row);
         row = new KeyboardRow();
         row.add(getCancelCommand(language));
@@ -1081,67 +1083,67 @@ public class WeatherHandlers extends TelegramLongPollingBot {
     // region getCommnads
 
     private static String getRateCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("rateMe", language),
+        return String.format(LocalisationService.getString("rateMe", language),
                 Emoji.HUNDRED_POINTS_SYMBOL.toString());
     }
 
     private static String getListCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("showList", language),
+        return String.format(LocalisationService.getString("showList", language),
                 Emoji.CLIPBOARD.toString());
     }
 
     private static String getDeleteCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("delete", language),
+        return String.format(LocalisationService.getString("delete", language),
                 Emoji.HEAVY_MINUS_SIGN.toString());
     }
 
     private static String getLanguagesCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("languages", language),
+        return String.format(LocalisationService.getString("languages", language),
                 Emoji.GLOBE_WITH_MERIDIANS.toString());
     }
 
     private static String getUnitsCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("units", language),
+        return String.format(LocalisationService.getString("units", language),
                 Emoji.STRAIGHT_RULER.toString());
     }
 
     private static String getAlertsCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("alerts", language),
+        return String.format(LocalisationService.getString("alerts", language),
                 Emoji.ALARM_CLOCK.toString());
     }
 
     private static String getBackCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("back", language),
+        return String.format(LocalisationService.getString("back", language),
                 Emoji.BACK_WITH_LEFTWARDS_ARROW_ABOVE.toString());
     }
 
     private static String getNewCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("new", language),
+        return String.format(LocalisationService.getString("new", language),
                 Emoji.HEAVY_PLUS_SIGN.toString());
     }
 
     private static String getLocationCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("location", language),
+        return String.format(LocalisationService.getString("location", language),
                 Emoji.ROUND_PUSHPIN.toString());
     }
 
     private static String getSettingsCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("settings", language),
+        return String.format(LocalisationService.getString("settings", language),
                 Emoji.WRENCH.toString());
     }
 
     private static String getCurrentCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("current", language),
+        return String.format(LocalisationService.getString("current", language),
                 Emoji.BLACK_RIGHT_POINTING_TRIANGLE.toString());
     }
 
     private static String getForecastCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("forecast", language),
+        return String.format(LocalisationService.getString("forecast", language),
                 Emoji.BLACK_RIGHT_POINTING_DOUBLE_TRIANGLE.toString());
     }
 
     private static String getCancelCommand(String language) {
-        return String.format(LocalisationService.getInstance().getString("cancel", language),
+        return String.format(LocalisationService.getString("cancel", language),
                 Emoji.CROSS_MARK.toString());
     }
     // endregion getCommnads
@@ -1161,7 +1163,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         sendMessage.setChatId(chatId.toString());
         sendMessage.setReplyToMessageId(messageId);
         sendMessage.setReplyMarkup(replyKeyboard);
-        sendMessage.setText(LocalisationService.getInstance().getString("chooseOption", language));
+        sendMessage.setText(LocalisationService.getString("chooseOption", language));
 
         return sendMessage;
     }
@@ -1186,7 +1188,7 @@ public class WeatherHandlers extends TelegramLongPollingBot {
         if (replyKeyboardMarkup != null) {
             sendMessage.setReplyMarkup(replyKeyboardMarkup);
         }
-        sendMessage.setText(LocalisationService.getInstance().getString("rateMeMessage", language));
+        sendMessage.setText(LocalisationService.getString("rateMeMessage", language));
 
         return sendMessage;
     }