File

projects/app-base-library/src/lib/shared/config.ts

Index

Properties
Methods

Constructor

constructor()

Properties

_config
_config: any
Type : any
Default value : {}
_defaults
_defaults: any
Type : any
_locked
_locked: []
Type : []
Default value : ['_config', '_defaults']

Methods

Public add
add(object: any, extend: , castToType: )
Parameters :
Name Type Optional Default value
object any no
extend no false
castToType no false
Returns : void
Public all
all()
Returns : any
Public extend
extend(object: any, target: any)
Parameters :
Name Type Optional Default value
object any no
target any no this._config
Returns : void
Public Async fetch
fetch(url: , extend: )
Parameters :
Name Optional Default value
url no
extend no false
Returns : {}
Public get
get(key: any)
Parameters :
Name Type Optional
key any no
Returns : any
Public getLocalSettings
getLocalSettings(id: )
Parameters :
Name Optional
id no
Returns : void
initXdomain
initXdomain(object: )
Parameters :
Name Optional
object no
Returns : void
Public islocked
islocked(key: )
Parameters :
Name Optional
key no
Returns : void
Public lock
lock(key: )
Parameters :
Name Optional
key no
Returns : boolean
Public restoreDefaults
restoreDefaults()
Returns : void
Public set
set(key: any, value: any, castToType: )
Parameters :
Name Type Optional Default value
key any no
value any no
castToType no false
Returns : any
Public setDefaults
setDefaults(configDefaults: )
Parameters :
Name Optional
configDefaults no
Returns : void
Public setLocalSettings
setLocalSettings(id: , settings: any)
Parameters :
Name Type Optional Default value
id no
settings any no this._config
Returns : void
Public unLock
unLock(key: )
Parameters :
Name Optional
key no
Returns : void
import { Util } from './util/util';
import { Storage } from './util/storage';

export class Config {

    _config: any = {};
    _defaults: any;
    _locked = ['_config', '_defaults'];

    constructor() { }

    public get(key: any) {
        return this._config[key];
    }

    public set(key: any, value: any, castToType = false) {
        if (!this.islocked(key)) {
            if (castToType) {
                value = Util.castToType(value);
            }
            return this._config[key] = value;
        } else {
            console.error('Config: property "'+key+'" can not be changed.');
        }
    }

    public add(object: any, extend = false, castToType = false) {
        const self = this;
        if(!extend) {
            Object.keys(object).forEach((key) => {
                self.set(key, object[key] ,castToType);
            });
        }else{
            this.extend(object);
        }
    }

    public async fetch(url, extend = false) {
        const self = this;
        // if(self.get('api_headers')){
        //
        // }
        // let config =  await fetch(url, {headers: self.get('api_headers')})
        let config =  await fetch(url,)
            .then(function(response) {
                return response.json();
            })
            .catch(function(error) {
                console.log('config fetch error:', error.message);
            });

        if (extend) {
            this.extend(config);
        }else {
            Object.keys(config).forEach((k, i) => {
                self.set(k, config[k]);
            });
        }
        return config;
    }

    public extend(object: any, target: any = this._config) {
        Util.deepAssign(target, object);
    }

    public all() {
        return this._config;
    }

    public getLocalSettings(id) {
        if (window.localStorage && window.localStorage.getItem(id)) {
            this.add(Storage.restoreLocalModel(id));
        }
    }
    public setLocalSettings(id, settings:any = this._config) {
        if (window.localStorage) {
            Storage.saveLocalModel(settings, id);
        }
    }

    public setDefaults(configDefaults) {
        const self = this;
        self._defaults = configDefaults;
        Object.keys(configDefaults).forEach((k) => {
            self.set(k, Util.copy(configDefaults[k]));
        });
    }

    public restoreDefaults() {
        const self = this;
        Object.keys(self._defaults).forEach((k) => {
            self.set(k, self._defaults[k]);
        });
    }

    public islocked(key) {
        // todo:
        this._locked.forEach((k) => {
            if(k===key){
                console.log('Config error: property "'+k+'" is protected');
                return true;
            }
        })
    }




    // todo
    public lock(key) {
        // todo:
        return false;
        // this._locked.forEach((k) => {
        //
        // })
    }
    public unLock(key) {
        // todo:
        // this._locked.forEach((k) => {
        //
        // })
    }


    initXdomain(object) {
        if (typeof window !== 'undefined' && window['xdomain']) {
            window['xdomain'].masters(object.masters);
            window['xdomain'].slaves(object.slaves);
        }
    };



}

results matching ""

    No results matching ""