mcs-ng-material/resources/Unify.js

MCS NG-Meterial is based on mcs-web.

requirejs.config({
	baseUrl:'resource',
	paths:{
		'requirecss': 'lib/require-css/css',
		'angular': 'lib/angular/angular',
		'uiRouter': 'lib/angular-ui-router/release/angular-ui-router',
	    'hammer': 'lib/hammerjs/hammer',
	  	'ngMaterial': 'lib/angular-material/angular-material',
	    'ngMaterialIcons': 'lib/angular-material-icons/angular-material-icons',
        'ngAnimate': 'lib/angular-animate/angular-animate',
        'ngAria': 'lib/angular-aria/angular-aria',
        'ngMessages': 'lib/angular-messages/angular-messages',
	},
	shim:{
		'angular':{exports:'angular'},
		'uiRouter': {
			exports:'ui.router',
			deps: ['angular']
		},
		'ngAnimate': {
			exports:'ngAnimate',
            deps: ['angular']
        },
        'ngAria': {
        	exports:'ngAria',
            deps:[ 'angular']
        },
        'ngMessages' : {
        	exports:'ngMessages',
        	deps: ['angular']
        },
        'hammer':{
			exports: 'Hammer'
		},
	    'ngMaterial': {
        	exports:'ngMaterial',
	        deps: ['angular', 'ngAnimate', 'ngAria', 'ngMessages','css!lib/angular-material/angular-material']
	    },
	    'app':{
	    	deps: ['angular','uiRouter','requirecss']
	    }
	},
	map:{
		'*':{
			'css':'requirecss'
		}
	},
	urlArgs: function(url,id){
		var args="ver="+Unify.versionId
		if (location.href.indexOf('debug=')>=0){
			if (url.indexOf('.js')||url.indexOf('.css')){
				args+='&debug=1'
			}
		}
		return (url.indexOf('?') === -1 ? '?' : '&') + args;
	}
})

define('app',['uiRouter', 'ngMaterial'], function () {
    var app = angular.module("app", [ 'ui.router','ngMaterial']);
	
    //Configure the angular-material theme.
    app.config(function($mdThemingProvider) {
        $mdThemingProvider.theme('dark-blue').backgroundPalette('blue').dark();
    });

    console.info('app ready');
    return app;
})

require(['app'],function(app){
	app.factory('CrcCalc', function () {
		return {
            request: function (config) {
            	config.url+=config.url.indexOf('?')>0?'&':'?';
            	config.url+="ver="+((Unify.profile||{}).versionId||Unify.versionId);
                return config;
           }
       }
	})
	
	app.service('moduleService',function($http,$q){
		
		function scan(cfg,deps){
			if (cfg.constructor==Array){
				for (var i=0;i<cfg.length;i++){
					scan(cfg[i],deps);
				}
			}
			if (cfg.constructor==Object){
				if (cfg.$type){
					var id='lib/'+cfg.$type;
					if (deps.indexOf(id)<0) deps.push(id);
				}
				for (var attr in cfg){
					scan(cfg[attr],deps);
				}
			}
		}
		
		function loadModule(moduleId){
			 var defer=$q.defer();
			 $http.get('/module/'+moduleId).then(function(resp){
			 	 var ret=resp.data;
				 ret.$id=moduleId;
				 defer.resolve(ret); 
			 });
			 return defer.promise;
		}
		
		//op=root, path, id
		function runModule(cfg,op){
			var defer=$q.defer();
			var deps=[];
			if (!cfg.$type){
				cfg.$type="PANEL";
				cfg.tile="Undefined";
			}
			scan(cfg,deps);
			require(deps,function(m){
				var tar=new m(cfg,op);
				defer.resolve(tar);
			})
			return defer.promise;
		}
		
		function innerModule(cfg, op){
			var defer=$q.defer();				
			runModule(cfg,op)
			.then(function(m){
				if (app.loaded[m.$id]) return;
				app.loaded[m.$id]=m;
				app.injector.invoke(function ($stateProvider) {
		            for (var i=0;i<m.states.length;i++){
		            	$stateProvider
		            	.state(m.states[i]);
		            }
		            defer.resolve(m);
				})
			})			
			return defer.promise;
		}
		
		function lazyModule(moduleId, op){
			var defer=$q.defer();				
			loadModule(moduleId)
			.then(function(cfg){
				innerModule(cfg,op)
				.then(function(cfg){
					defer.resolve(cfg);
				})					
			})
			return defer.promise;
		}
		
		return{
			getProfile: function(){
				var defer=$q.defer();
				$http.post('/init').then(function(resp){
					if (resp.data.success){
						Unify.profile=resp.data.result;
						if (Unify.profile.versionId!=Unify.versionId){
							  //location.reload(true);
							defer.reject('#[VersionMismatch]');
						}
						else defer.resolve(Unify.profile);	
					}
					else{
						defer.reject(resp.data.result);
					}
				})
				return defer.promise;
			},
			loadModule: loadModule,
			runModule: runModule,
			lazyModule: lazyModule,
			innerModule: innerModule,
		}
	
	})
	
	app.config(['$httpProvider', function($httpProvider) {
		$httpProvider.interceptors.push('CrcCalc');
	}])
	
	app.filter('rawHtml', ['$sce', function($sce){
		return function(val) {
			return $sce.trustAsHtml(val);
		}
	}])
	
	app.filter('keyboardShortcut', function($window) {
	    return function(str) {
	        if (!str) return;
	        var keys = str.split('-');
	        var isOSX = /Mac OS X/.test($window.navigator.userAgent);

	        var seperator = (!isOSX || keys.length > 2) ? '+' : '';

	        var abbreviations = {
	          M: isOSX ? '⌘' : 'Ctrl',
	          A: isOSX ? 'Option' : 'Alt',
	          S: 'Shift'
	        };

	        return keys.map(function(key, index) {
	          var last = index == keys.length - 1;
	          return last ? key : abbreviations[key];
	        }).join(seperator);
	    };
    })
	app.getLazyLoad=function(moduleId,op){
		return function (moduleService) {
			return moduleService.lazyModule(moduleId,op);
		}
	}
	app.getLazyCtrl=function(){
		return function(lazyLoad,$state){
			console.info('sub-view: %o',lazyLoad.$id);
			if (lazyLoad.target) $state.go(lazyLoad.target);
		}
	}
	
	app.modules=[];
	
	app.reg=function(name,m){
		if (!app.modules[name]){
			app.modules[name]=m;
		}
	}
	
	app.extend=function(name,base,op){
		var me= new Function("base",
			"return function " + name + "(){base.apply(this,arguments)}"
		)(base);
		me.prototype=Object.create(base.prototype);
		me.prototype.callParent=function(){
			var caller=this.callParent.caller;
			return caller.$parent.apply(this,arguments);
		}
		//console.info('DEFINE '+name+" extends %o",base)
		app.reg(name,me);
		if (op){
			for (var id in op){
				var old=me.prototype[id];
				me.prototype[id]=op[id];
				if (old){
					op[id].$parent=old;
				}
			}
		}
		return me;
	}
	
	app.config([
		'$locationProvider',
		'$controllerProvider',
		'$compileProvider',
		'$filterProvider',
		'$provide',
		'$stateProvider',
		'$urlRouterProvider','$injector',
		function($locationProvider, $controllerProvider,
				$compileProvider, $filterProvider, $provide,
				$stateProvider, $urlRouterProvider,$injector) {
			app.controller = $controllerProvider.register;
			app.directive = $compileProvider.directive;
			app.component = $compileProvider.component;
			app.filter = $filterProvider.register;
			app.factory = $provide.factory;
			app.service = $provide.service;
			app.injector=$injector;
			app.loaded={};
			
			$stateProvider.state({
				name:'home',
				path:"/",
				template:`<ui-view></ui-view>`,
				resolve:{
					lazyLoad: function ($state,moduleService, $q) {
						var defer=$q.defer();
						moduleService.getProfile()
						.then(function(profile){
							moduleService.lazyModule(profile.welcome, {root:"home", path:"/",id:profile.welcome,lazyLoad:true})
							.then (function(m){
								defer.resolve(m);
							})
						})
						return defer.promise;						
					}	
				},
				controller: function(lazyLoad,$state){
					console.info('first ctl=%o',lazyLoad);
					if (lazyLoad.target) $state.go(lazyLoad.target);
				}
				
			})
			$urlRouterProvider.otherwise("/");
		}
	]);
	
	app.controller('appCtrl',function($state,$stateRegistry){
		$state.go('home');
	})
	
	angular.bootstrap(document, ['app']);
})