not-locale 0.0.21 → 0.0.24

package/index.js

@@ -1,20 +1,28 @@
 const {
-	getMiddleware,
-	fromJSON,
-	fromDir,
-	say,
-	sayForModule,
-	modulePhrase,
-	vocabulary,
-	OPTS
-} = require('./src/common/lib.js');
+    getMiddleware,
+    fromJSON,
+    fromDir,
+    say,
+    sayForModule,
+    modulePhrase,
+    vocabulary,
+    OPTS,
+} = require("./src/common/lib.js");
 
 module.exports = {
-	name: 'not-locale',
-	paths:{
-		controllers:  __dirname + '/src/controllers',
-    logics:  __dirname + '/src/logics',
-		routes:  __dirname + '/src/routes',
-	},
-	getMiddleware, fromJSON, fromDir, say, sayForModule, modulePhrase, vocabulary, OPTS
+    name: "not-locale",
+    paths: {
+        controllers: __dirname + "/src/controllers",
+        logics: __dirname + "/src/logics",
+        locales: __dirname + "/src/locales",
+        routes: __dirname + "/src/routes",
+    },
+    getMiddleware,
+    fromJSON,
+    fromDir,
+    say,
+    sayForModule,
+    modulePhrase,
+    vocabulary,
+    OPTS,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "not-locale",
-	"version": "0.0.21",
+	"version": "0.0.24",
 	"description": "not-* family module for localization in not- environment",
 	"main": "index.js",
 	"scripts": {
@@ -37,4 +37,4 @@
 		"mocha": "*",
 		"nyc": "*"
 	}
-}
+}

package/src/controllers/common/index.js

@@ -12,7 +12,7 @@ const manifest = {
       sections:[
 				{
 					id: 'locale',
-          title: '',
+          			title: '',
 					icon: {
 						font: 'language',
 						size: 'medium',

package/src/controllers/common/nsLocale.js

@@ -3,170 +3,166 @@
  *
  **/
 
-const SECTION_ID = 'locale';
+const SECTION_ID = "locale";
 
-import {
-  notCommon,
-  notLocale,
-  Frame
-} from 'not-bulma';
+import { notCommon, notLocale, Frame } from "not-bulma";
 
-const {notTopMenu} = Frame;
+const { notTopMenu } = Frame;
 
 class nsLocale {
-  constructor(app) {
-    this.app = app;
-    this.locales = [];
-    this.failures = 0;
-    this.app.on('wsClient:main:connected', this.update.bind(this));
-    notLocale.on('change', () => {
-      this.app.emit('locale');
-    });
-  }
-
-  /**
-   * Creates network interface for this service
-   */
-  interface(data) {
-    return this.app.getInterface('locale')(data);
-  }
-
-  /**
-   * Retrieves dictionary for current locale
-   * sets dictionary in notLocale object
-   */
-  async update() {
-    try {
-      await this.updateAvailable();
-      let res = await this.interface({
-        locale: this.getCurrentLocale()
-      }).$get({});
-      if (res.status === 'ok' && res.result) {
-        notLocale.set(res.result);
-      } else {
-        this.scheduleUpdate();
-      }
-    } catch (e) {
-      notCommon.error(e);
-      this.scheduleUpdate();
+    constructor(app) {
+        this.app = app;
+        this.locales = [];
+        this.failures = 0;
+        this.app.on("wsClient:main:connected", this.update.bind(this));
+        notLocale.on("change", () => {
+            this.app.emit("locale");
+        });
     }
-  }
-
-  scheduleUpdate() {
-    this.failures++;
-    if (this.failures < 100) {
-      setTimeout(this.update.bind(this), 1000 * this.failures);
-    } else {
-      notCommon.error('Too many failures of locale loading');
+
+    /**
+     * Creates network interface for this service
+     */
+    interface(data) {
+        return this.app.getInterface("locale")(data);
+    }
+
+    /**
+     * Retrieves dictionary for current locale
+     * sets dictionary in notLocale object
+     */
+    async update() {
+        try {
+            await this.updateAvailable();
+            let res = await this.interface({
+                locale: this.getCurrentLocale(),
+            }).$get({});
+            if (res.status === "ok" && res.result) {
+                notLocale.set(res.result);
+            } else {
+                this.scheduleUpdate();
+            }
+        } catch (e) {
+            notCommon.error(e);
+            this.scheduleUpdate();
+        }
     }
-  }
-
-  async updateAvailable() {
-    try {
-      let res = await this.interface({}).$available({});
-      if (res.status === 'ok' && res.result) {
-        this.setAvailable(res.result);
-      }
-    } catch (e) {
-      notCommon.error(e);
+
+    scheduleUpdate() {
+        this.failures++;
+        if (this.failures < 100) {
+            setTimeout(this.update.bind(this), 1000 * this.failures);
+        } else {
+            notCommon.error("Too many failures of locale loading");
+        }
     }
-  }
-
-  updateUI(list) {
-    let menuItems = this.createMenuItems(list);
-    notTopMenu.updateSectionItems(SECTION_ID, () => {
-      return menuItems;
-    });
-    setTimeout(() => {
-      this.app.emit(`tag-${SECTION_ID}:update`, {
-        title: this.getCurrentLocale()
-      });
-    }, 1000);
-  }
-
-  createMenuItems(list) {
-    let items = list.map(this.createMenuItem.bind(this));
-    return items;
-  }
-
-  createMenuItem(item) {
-    return {
-      id: `${SECTION_ID}.${item}`,
-      section: SECTION_ID,
-      title: item,
-      classes: ' is-clickable ',
-      action: this.changeLocale.bind(this, item)
-    };
-  }
-
-  changeLocale(locale) {
-    this.saveLocaleToStore(locale);
-    this.update();
-  }
-
-  /**
-   * @returns {string}   code of current locale
-   **/
-  getCurrentLocale() {
-    let stored = this.restoreLocaleFromStore();
-    if (stored) {
-      if (this.locales.includes(stored)) {
-        return stored;
-      }
+
+    async updateAvailable() {
+        try {
+            let res = await this.interface({}).$available({});
+            if (res.status === "ok" && res.result) {
+                this.setAvailable(res.result);
+            }
+        } catch (e) {
+            notCommon.error(e);
+        }
     }
-    return this.selectBest();
-  }
-
-  /**
-   * @returns {Promise<Array>}   of locales objects {code, title}
-   **/
-  getAvailable() {
-    return this.interface().$available({});
-  }
-
-
-  setAvailable(list) {
-    this.locales = list;
-    this.updateUI(list);
-  }
-
-  restoreLocaleFromStore() {
-    if (window.localStorage) {
-      try {
-        return window.localStorage.getItem('locale');
-      } catch (e) {
-        this.app.error(e);
-        return false;
-      }
+
+    updateUI(list) {
+        let menuItems = this.createMenuItems(list);
+        notTopMenu.updateSectionItems(SECTION_ID, () => {
+            return menuItems;
+        });
+        setTimeout(() => {
+            this.app.emit(`tag-${SECTION_ID}:update`, {
+                title: this.getCurrentLocale(),
+            });
+        }, 1000);
+    }
+
+    createMenuItems(list) {
+        let items = list.map(this.createMenuItem.bind(this));
+        return items;
+    }
+
+    createMenuItem(item) {
+        return {
+            id: `${SECTION_ID}.${item}`,
+            section: SECTION_ID,
+            title: item,
+            class: " is-clickable ",
+            action: this.changeLocale.bind(this, item),
+        };
+    }
+
+    changeLocale(locale) {
+        this.saveLocaleToStore(locale);
+        this.update();
+    }
+
+    /**
+     * @returns {string}   code of current locale
+     **/
+    getCurrentLocale() {
+        let stored = this.restoreLocaleFromStore();
+        if (stored) {
+            if (this.locales.includes(stored)) {
+                return stored;
+            }
+        }
+        return this.selectBest();
+    }
+
+    /**
+     * @returns {Promise<Array>}   of locales objects {code, title}
+     **/
+    getAvailable() {
+        return this.interface().$available({});
+    }
+
+    setAvailable(list) {
+        this.locales = list;
+        this.updateUI(list);
     }
-    return false;
-  }
-
-  saveLocaleToStore(locale) {
-    if (window.localStorage) {
-      try {
-        return window.localStorage.setItem('locale', locale);
-      } catch (e) {
-        this.app.error(e);
+
+    restoreLocaleFromStore() {
+        if (window.localStorage) {
+            try {
+                return window.localStorage.getItem("locale");
+            } catch (e) {
+                this.app.error(e);
+                return false;
+            }
+        }
         return false;
-      }
     }
-    return false;
-  }
-
-  selectBest() {
-    if (navigator.languages) {
-      let locale = navigator.languages.find((itm) => {
-        return this.locales.includes(itm);
-      });
-      if (locale) {
-        return locale;
-      }
+
+    saveLocaleToStore(locale) {
+        if (window.localStorage) {
+            try {
+                return window.localStorage.setItem("locale", locale);
+            } catch (e) {
+                this.app.error(e);
+                return false;
+            }
+        }
+        return false;
     }
-    return this.app.getWorking('locale', this.app.getOptions('modules.locale.default', 'ru'));
-  }
 
+    selectBest() {
+        if (navigator.languages) {
+            let locale = navigator.languages.find((itm) => {
+                return this.locales.includes(itm);
+            });
+            if (locale) {
+                return locale;
+            }
+        }
+        return this.app.getWorking(
+            "locale",
+            this.app.getOptions("modules.locale.default", "ru")
+        );
+    }
 }
 
-
 export default nsLocale;

package/src/exceptions.js

@@ -0,0 +1,17 @@
+const { notError } = require("not-error");
+
+class LocaleExceptionGetError extends notError {
+    constructor(params = {}, cause) {
+        super(`not-locale:exception_logic_get`, params, cause);
+    }
+}
+
+module.exports.LocaleExceptionGetError = LocaleExceptionGetError;
+
+class LocaleExceptionAvailableError extends notError {
+    constructor(params = {}, cause) {
+        super(`not-locale:exception_logic_available`, params, cause);
+    }
+}
+
+module.exports.LocaleExceptionAvailableError = LocaleExceptionAvailableError;

package/src/locales/en.json

@@ -0,0 +1,4 @@
+{
+    "exception_logic_available": "Exception while listing available locales",
+    "exception_logic_get": "Exception while retrieving locale library"
+}

package/src/locales/ru.json

@@ -0,0 +1,4 @@
+{
+    "exception_logic_available": "Исключение при листинге доступных локалей",
+    "exception_logic_get": "Исключение при получении локали"
+}

package/src/logics/locale.js

@@ -1,63 +1,30 @@
-const notNode = require('not-node');
-const Log = require('not-log')(module, 'locale:logics');
+const notLocale = require("../common/lib.js");
 const {
-	notError
-} = require('not-error');
+    LocaleExceptionGetError,
+    LocaleExceptionAvailableError,
+} = require("../exceptions");
 
-const notLocale = require('../common/lib.js');
-
-const MODEL_NAME = 'Locale';
+const MODEL_NAME = "Locale";
 exports.thisLogicName = MODEL_NAME;
 
 class LocaleLogic {
-	static async get({
-		locale
-	}){
-		try{
-			let result = notLocale.get(locale);
-			return {
-				status: 'ok',
-				result
-			};
-		}catch(err){
-			Log.error(err);
-			notNode.Application.report(
-				new notError(
-					`locale:logic.get`,
-					{locale},
-					err
-				)
-			);
-			return {
-				status: 'error',
-				error:  err.message
-			};
-		}
-	}
-
-	static async available() {
-		try{
-			let result = notLocale.available();
-			return {
-				status: 'ok',
-				result
-			};
-		}catch(err){
-			Log.error(err);
-			notNode.Application.report(
-				new notError(
-					`locale:logic.available`,
-					{},
-					err
-				)
-			);
-			return {
-				status: 'error',
-				error:  err.message
-			};
-		}
-	}
+    static async get({ locale }) {
+        try {
+            let result = notLocale.get(locale);
+            return result;
+        } catch (err) {
+            throw new LocaleExceptionGetError({ locale }, err);
+        }
+    }
 
+    static async available() {
+        try {
+            let result = notLocale.available();
+            return result;
+        } catch (err) {
+            throw new LocaleExceptionAvailableError({}, err);
+        }
+    }
 }
 
 exports[MODEL_NAME] = LocaleLogic;

package/src/routes/locale.js

@@ -1,55 +1,58 @@
-const Log = require('not-log')(module, 'locale:route');
-const {notError} = require('not-error');
-const notNode = require('not-node');
+const Log = require("not-log")(module, "locale:route");
+const { notError } = require("not-error");
+const notNode = require("not-node");
 
-async function get(req, res){
-  try{
-    let locale = req.params.locale;
-    let result = await notNode.Application.getLogic('Locale').get({locale});
-    res.status(200).json(result);
-  }catch(err){
-    Log.error(err);
-    notNode.Application.report(
-      new notError(
-        `locale:route.get`, {
-          locale:            req.query.locale,
-          owner:             req.user?req.user._id:undefined,
-          ownerModel:        'User'
-        },
-        err
-      )
-    );
-    res.status(500).json({
-      status: 'error'
-    });
-  }
+async function get(req, res) {
+    try {
+        let locale = req.params.locale;
+        let result = await notNode.Application.getLogic("Locale").get({
+            locale,
+        });
+        res.status(200).json(result);
+    } catch (err) {
+        Log.error(err);
+        notNode.Application.report(
+            new notError(
+                `locale:route.get`,
+                {
+                    locale: req.query.locale,
+                    owner: req.user ? req.user._id : undefined,
+                    ownerModel: "User",
+                },
+                err
+            )
+        );
+        res.status(500).json({
+            status: "error",
+        });
+    }
 }
 
-async function available(req, res){
-  try{
-    let result = await notNode.Application.getLogic('Locale').available();
-    res.status(200).json(result);
-  }catch(err){
-    Log.error(err);
-    notNode.Application.report(
-      new notError(
-        `locale:route.available`, {
-          owner:             req.user?req.user._id:undefined,
-          ownerModel:        'User'
-        },
-        err
-      )
-    );
-    res.status(500).json({
-      status: 'error'
-    });
-  }
+async function available(req, res) {
+    try {
+        let result = await notNode.Application.getLogic("Locale").available();
+        res.status(200).json(result);
+    } catch (err) {
+        Log.error(err);
+        notNode.Application.report(
+            new notError(
+                `locale:route.available`,
+                {
+                    owner: req.user ? req.user._id : undefined,
+                    ownerModel: "User",
+                },
+                err
+            )
+        );
+        res.status(500).json({
+            status: "error",
+        });
+    }
 }
 
-
 module.exports = {
-  get,
-  _get: get,
-  available,
-  _available: available,
+    get,
+    _get: get,
+    available,
+    _available: available,
 };

package/src/routes/locale.manifest.js

@@ -1,37 +1,43 @@
-const {error} = require('not-log')(module, 'locale:route');
+const { error } = require("not-log")(module, "locale:route");
 
 try {
-	module.exports = {
-		model: 'locale',
-		url: '/api/:modelName',
-		fields: {},
-		actions: {
-			get: {
-				ws: true,
-				method: 'GET',
-				isArray: false,
-				postFix: '/:actionName',
-				data: ['record'],
-				rules: [{
-					auth: true
-				}, {
-					auth: false
-				}]
-			},
-			available:{
-				ws: true,
-				method: 'GET',
-				isArray: false,
-				postFix: '/:actionName',
-				data: ['record'],
-				rules: [{
-					auth: true
-				},{
-					auth: false
-				}]
-			}
-		}
-	};
+    module.exports = {
+        model: "locale",
+        url: "/api/:modelName",
+        fields: {},
+        actions: {
+            get: {
+                ws: true,
+                method: "GET",
+                isArray: false,
+                postFix: "/:actionName",
+                data: ["record"],
+                rules: [
+                    {
+                        auth: true,
+                    },
+                    {
+                        auth: false,
+                    },
+                ],
+            },
+            available: {
+                ws: true,
+                method: "GET",
+                isArray: false,
+                postFix: "/:actionName",
+                data: ["record"],
+                rules: [
+                    {
+                        auth: true,
+                    },
+                    {
+                        auth: false,
+                    },
+                ],
+            },
+        },
+    };
 } catch (e) {
-	error(e);
+    error(e);
 }

package/src/routes/locale.ws.js

@@ -1,22 +1,25 @@
-const notNode = require('not-node');
+const notNode = require("not-node");
 
-async function get({data}){
-	let result = await notNode.Application.getLogic('Locale').get({locale: data.locale});
-	return result;
+async function get({ data }) {
+    return await notNode.Application.getLogic("Locale").get({
+        locale: data.locale,
+    });
 }
 
-async function available(){
-	let result = await notNode.Application.getLogic('Locale').available();
-	return result;
+async function available() {
+    return await notNode.Application.getLogic("Locale").available();
 }
 
 module.exports = {
-	servers:{					//collection type
-		main:{					//collection name
-			request: { 		//routes(end-points) type
-				get,				//end-points
-				available
-			}
-		}
-	}
+    servers: {
+        //collection type
+        main: {
+            //collection name
+            request: {
+                //routes(end-points) type
+                get, //end-points
+                available,
+            },
+        },
+    },
 };