Source: app.js

/**
 * @ngdoc directive
 * @name App
 * @module s4c.App
 *
 * @description Possui as configurações globais da aplicação
 * 
 * 
 */
(function () {
    'use strict';

    angular.module('s4CApp', [
        'ngCookies',
        'ngResource',
        'ngSanitize',
        'ngAnimate',
        'ngMaterial',
        'ngDragDrop',
        'ngMessages',
        'ngLocale',
        'ngTable',
        'datetTimeLocale',
        'ui.router',
        'gridster',
        'angularAwesomeSlider',
        'angular-gestures',
        's4c.helpers',
        'leaflet-directive',
        'datePicker',
        'angular-momentjs',
        'truncate',
        'notification',
        'angularMoment',
        'angularFileUpload',
        'angularGrid',
        'nsPopover',
        'angled-windows',
        's4c.filters',
        'angular-loading-bar',
        'treeControl',
        'ui.grid',
        'ui.grid.pagination',
        'ui.grid.pinning',
        'ui.grid.autoResize',
        'ui.grid.moveColumns',
        'ui.grid.selection',
        'angular.filter',
        's4c.components.collaboration',
        's4c.controllers.MainCtrl',
        's4c.controllers.AdminCtrl',
        's4c.controllers.DataEnterCtrl',
        's4c.controllers.ScrollerCtrl',
        's4c.controllers.InteligenciaCtrl',
        's4c.controllers.MosaicoCtrl',
        's4c.controllers.InicioCtrl',
        's4c.controllers.HelpCtrl',
        's4c.controllers.AcervoCtrl',
        's4c.controllers.CategoriaCtrl',
        's4c.controllers.UsuarioCtrl',
        's4c.controllers.GrupoCtrl',
        's4c.controllers.CameraCtrl',
        's4c.controllers.DashboardCtrl',
        's4c.controllers.AdminPermissaoAcessoCtrl',
        's4c.controllers.AdminUsuarioAgenciaPerfilCtrl',
        's4c.controllers.BySatCtrl',
        's4c.services.PermissoesService',
        's4c.directives.MapaEndereco',
        's4c.directives.alarme-disparado',
        's4c.directives.botaoLeituraArquivo',
        's4c.components.avisoOperacional',
        's4c.controllers.AdminUsuarioGrupoUsuariosPerfilCtrl',
        's4c.services.geocoding',
        's4c.directives.mapa-area-de-atuacao',
        's4c.directives.botaoAnexo',
        's4c.components.legenda-incidente',
        's4c.components.resposta-briefing',
        's4c.components.sala-briefing',
        's4c.components.mensageria-filter',
        's4c.components.zonas-de-observacao',
        's4c.components.rotas-olimpicas',
        's4c.components.limitartexto',
        's4c.managers',
        's4c.components.preset',
        'tmh.dynamicLocale',
        'localization',
        'google.places',
        's4c.components.buscaUsuariosTelegram',
        'zInfiniteScroll',
        'duScroll',
        'idf.br-filters',
        'filters-inArrayFilter',
        'angular-click-outside',
        's4c.components.participantes',
        'luegg.directives',
        's4c.components.modulo',
        's4c.controllers.PopUpMapaCtrl',
        's4c.controllers.LegendaCtrl'
    ])
        .constant('CSS_SLIDER', {
            'pointer': {
                'background-color': 'blue'
            }
        })
        .constant('API_ENDPOINT', '/')
        .constant('API_ENDPOINT_MULTIVIS_MANAGER', '/manager/')
        .constant('API_ENDPOINT_COB', '/')
        .constant('GRIDSTER_OPTIONS_VISUALIZACAO', {
            columns: 6,
            maxRows: 4,
            margins: [8, 8],
            outerMargin: true,
            pushing: false,
            floating: false,
            swapping: true,
            isMobile: false,
            colWidth: parseInt((($(window).width() - 10) / 6).toFixed(), 10),
            rowHeight: parseInt((($(window).height() - 0) / 4).toFixed() - 5, 10),
            minColumns: 1,
            minRows: 1,
            mobileModeEnabled: false,
            resizable: {
                enabled: true,
                handles: ['se', 'sw', 'w', 'e']
            },
            draggable: {
                handle: '.drag , .mover-modulo-active, .mover-modulo',
                enabled: true
            }
        })
        .constant('GRIDSTER_OPTIONS_EDICAO', {
            margins: [0, 0],
            outerMargin: false,
            pushing: false,
            floating: false,
            swapping: true,
            isMobile: false,
            minColumns: 1,
            minRows: 1,
            mobileModeEnabled: false,
            resizable: {
                enabled: true,
                handles: ['se', 'sw', 'w', 'e']
            },
            draggable: {
                handle: '.drag, .mover-modulo-active, .mover-modulo',
                scrollSensitivity: 20,
                scrollSpeed: 15
            }
        })
        .constant('PERMISSOES_ENUM', {
            // Base de Conhecimento:
            VISUALIZAR_BASE_CONHECIMENTO_PUBLICA: 2,
            CRIAR_BASE_CONHECIMENTO_PUBLICA: 4,
            EDITAR_BASE_CONHECIMENTO_PUBLICA: 6,
            REMOVER_BASE_CONHECIMENTO_PUBLICA: 8,

            // Planejamento
            VISUALIZAR_PLANEJAMENTO_PUBLICO: 10,
            CRIAR_PLANEJAMENTO_PUBLICO: 12,
            EDITAR_PLANEJAMENTO_PUBLICO: 14,
            REMOVER_PLANEJAMENTO_PUBLICO: 16,

            //Rota
            VISUALIZAR_ROTA_PUBLICA: 18,
            CRIAR_ROTA_PUBLICA: 20,
            EDITAR_ROTA_PUBLICA: 22,
            REMOVER_ROTA_PUBLICA: 24,

            //Zona de Observacao
            VISUALIZAR_ZONA_OBSERVACAO_PUBLICA: 26,
            CRIAR_ZONA_OBSERVACAO_PUBLICA: 28,
            EDITAR_ZONA_OBSERVACAO_PUBLICA: 30,
            REMOVER_ZONA_OBSERVACAO_PUBLICA: 32,

            //Preset
            VISUALIZAR_PRESET_PUBLICO: 34,
            CRIAR_PRESET_PUBLICO: 36,
            EDITAR_PRESET_PUBLICO: 38,
            REMOVER_PRESET_PUBLICO: 40,

            //EXTRAS
            ADICIONAR_ARQUIVO_PUBLICO: 42,
            REMOVER_ARQUIVO_PUBLICO: 44,
            GERENCIAMENTO_CAMADAS: 47,
            ADICIONAR_NOTA: 49,
            ADICIONAR_ARQUIVO: 50,
            REMOVER_ARQUIVO: 51,
            REMOVER_INCIDENTE: 52,

            //BRIEFING
            RESPONDER_BRIEFING: 45,
            SALA_DE_BRIEFING: 46,

            //PRESET
            ALTERAR_PRESET_AGENCIA: 48
        })
        .constant('MODULOS_ENUM', {
            "Base de Conhecimento": 1,
            "Zona de Observação": 2,
            "Planejamento": 3
        })
        .config(function (tmhDynamicLocaleProvider) {
            tmhDynamicLocaleProvider.localeLocationPattern("bower_components/angular-i18n/angular-locale_{{locale}}.js");
        })
        .run(function ($rootScope, $locale, $dtlocale, tmhDynamicLocale, localize, amMoment) {
            localize.languages = ['pt-br', 'en-us'];
            tmhDynamicLocale.set(localize.language).then(function () {
                amMoment.changeLocale(localize.language);
                var shortDate = $locale.DATETIME_FORMATS.shortDate;
                shortDate = shortDate.replace(new RegExp('yy', 'g'), 'yyyy');
                $locale.DATETIME_FORMATS.shortDate = shortDate;
                var datetimepickerLang = _.find($dtlocale.i18n, function (dpt) {
                    return dpt.lang.toLowerCase() === $locale.id;
                });
                $locale.DATETIME_FORMATS.datetimepicker = datetimepickerLang ? datetimepickerLang : _.find($dtlocale.i18n, { lang: 'en' });
            });
            /* Debounce para disparar evento */
            var fireEvent = _.debounce(function (channel, message) {
                $rootScope.$emit(channel, message);
            }, 300);
            /* Escuta por redimensionamento da janela e inicia um evento
             * no rootScope.
             */
            $(window).resize(function () {
                $rootScope.$apply(function () {
                    fireEvent('s4c:windowResize', {
                        width: $(window).width(),
                        height: $(window).height()
                    });
                });
            });
        })
        .run(['ParametrosS4C', 'CommService', '$q', '$rootScope', function (ParametrosS4C, CommService, $q, $rootScope) {
            $rootScope.ParametrosS4C = {};
            $rootScope.blackList = [];

            //INICIA A COMUNICAÇÃO WEBSOCKET APÓS O LOGIN
            $rootScope.$on('userLoggedIn', function (data) {
                CommService.start();
            });

            //alert(window.location.hash);
            //var  isHomePage = window.location.hash == '#/';

            //INICIA A COMINICAÇÃO WEBSOCKET APÓS REFRESH DA PAGINA
            var s4cTokenSession =  sessionStorage.getItem('s4cToken');
            var isSessionStart = (s4cTokenSession != null);
            if(isSessionStart){
                 CommService.start();
            }


            ParametrosS4C.downloadParametros()
                .then(function (parametros) {
                    $rootScope.ParametrosS4C = parametros;
                });

            ParametrosS4C.downloadBlackList()
                .then(function (blackList) {
                    $rootScope.blackList = blackList;
                });
			/* We should wait for the socket to be ready
			 * to start listening on it.
			 */
            $rootScope.socketReady.promise
                .then(function () {
                    CommService.on('parametros:update', function (parametros) {
                        $rootScope.ParametrosS4C = parametros;
                    });
                });
        }])
        .run(function () {
            var nodeToArray = function (node, property) {
                var array = [];

                function parse(node) {
                    _.each(node[property], function (item) {
                        parse(item)
                    });

                    array.push(node);
                }

                parse(node);

                return array;
            }
            var updateValues = function (oldObj, newObj) {
                _.chain(newObj)
                    .keys()
                    .each(function (key) {
                        oldObj[key] = newObj[key];
                    })
                    .value();

                return oldObj;
            }

            _.mixin({
                'nodeToArray': nodeToArray
            }, {
                'chain': false
            });
            _.mixin({
                'updateValues': updateValues
            }, {
                'chain': false
            });
        })
        .run(['$rootScope',
            function ($rootScope) {
                /* Debounce para disparar evento */
                var fireEvent = _.debounce(function (channel, message) {
                    $rootScope.$emit(channel, message);
                }, 300);

                /* Escuta por redimensionamento da janela e inicia um evento
                 * no rootScope.
                 */
                $(window).resize(function () {
                    $rootScope.$apply(function () {
                        fireEvent('s4c:windowResize', {
                            width: $(window).width(),
                            height: $(window).height()
                        });
                    });
                });
            }
        ])
        .run(['amMoment',
            function (amMoment) {
                amMoment.changeLocale('pt-br');
            }
        ])
        .run(['$templateCache',
            function ($templateCache) {
                $templateCache.put('briefing-pdf', 'app/directives/consulta/template-pdf.html');
            }
        ])
        /* Factory para adicionar token a cada requisição: */
        .factory('AuthInterceptor', [
            '$q',
            '$rootScope',
            '$location',
            '$window',
            function ($q,
                $rootScope,
                $location,
                $window) {
                return {
                    request: function (config) {

                        function configToken(token, config) {
                            try {
                                var tokenObj = JSON.parse(token);
                                config.headers.Authorization = 'Bearer ' + tokenObj.access_token;
                            }
                            catch (erro) {
                                config.headers.Authorization = 'Bearer ' + token;
                            }
                        }

                        function isJson(item) {
                            item = typeof item !== "string"
                                ? JSON.stringify(item)
                                : item;

                            try {
                                item = JSON.parse(item);
                            } catch (e) {
                                return false;
                            }

                            if (typeof item === "object" && item !== null) {
                                return true;
                            }

                            return false;
                        }

                        /**
                         * Pega token do sessionStorage e adiciona ao
                         * request:
                         */
						 
						var token = ($window.sessionStorage.getItem('s4cToken'));
						var isToken = (token != null && token != "undefined" && token != "");
						var isTokenAutoLogin = (window.location.search.includes("tokenAuth"));		

						if(isTokenAutoLogin){
							let urlAutoLogin = window.location.origin + "/autologin/";
							let tokenAutologin = window.location.search.replace('?tokenAuth=','');
							let urlRequest = urlAutoLogin + tokenAutologin;
							
							$.get(urlRequest ,function(retorno) {
								if(retorno.length > 10) {
									let jsonRetorno =  JSON.parse(retorno);
									$window.sessionStorage.setItem('s4cToken', JSON.stringify(jsonRetorno));
									configToken($window.sessionStorage.getItem('s4cToken'), config);
									window.location.replace(window.location.origin + '/#/')
								}
							});
							
						} else if (isToken){
							
							//Se veio do S4S recebeu apenas uma string sem ser json
                            if (!isJson(token)) {
                                var savedToken = angular.copy(token);
                                token = {};
                                token.access_token = savedToken;
                                configToken(JSON.stringify(token), config);
                                $window.sessionStorage.setItem('s4cToken', JSON.stringify(token));
								$location.path('/');
                            } else { configToken(token, config); }

						} else { 
							$location.path('/inicio');
						}                        
					
					
						//var token = $window.sessionStorage.getItem('s4cToken');
                        //if (token != null && token != "undefined" && token != "") {

                            //Se veio do S4S recebeu apenas uma string sem ser json
                        //    if (!isJson(token)) {
                        //        var savedToken = angular.copy(token);
                        //        token = {};
                        //        token.access_token = savedToken;
                        //        configToken(JSON.stringify(token), config);
                        //        $window.sessionStorage.setItem('s4cToken', JSON.stringify(token));
                        //        $location.path('/');
                        //    } else {
                        //        configToken(token, config);
                        //    }

                        //} else if ($location.$$absUrl.indexOf('/autoLogin') != -1) {

                        //    var token = {};
                        //    token.access_token = "0dd17dec-7063-47e8-b8a2-c3494cd509d0";
                        //    $window.sessionStorage.setItem('s4cToken', JSON.stringify(token));
                        //    configToken($window.sessionStorage.getItem('s4cToken'), config);
                        //    $location.path('/');

                        //} else {
                        //    $location.path('/inicio');
                        //}
						

                        return config || $q.when(config);
                    },
                    responseError: function (response) {
                        if (response.status === 401) {
                            /**
                             * 400 = Unauthenticated,
                             * redirecionando usuário para tela
                             * de login.
                             */
                            $location.path('/inicio');
                        }
                        return $q.reject(response);
                    }
                };
            }
        ])
        .config(['toastyConfigProvider',
            function (toastyConfigProvider) {
                toastyConfigProvider.setConfig({
                    theme: 'material',
                    timeout: false,
                    sound: false,
                    html: true
                });
            }
        ])
        .config(['$mdThemingProvider',
            function ($mdThemingProvider) {
                var s4cDefault = $mdThemingProvider.extendPalette('grey', {
                    '700': '#424242',
                    '800': '#303030'
                });

                var s4cAccent = $mdThemingProvider.extendPalette('light-blue', {
                    '700': '#00bbd3',
                    '600': '#00bbd3',
                    '500': '#00bbd3'
                });

                $mdThemingProvider.definePalette('s4cDefault', s4cDefault);
                $mdThemingProvider.definePalette('s4cAccent', s4cAccent);
                $mdThemingProvider.theme('blue');
                $mdThemingProvider.theme('cyan');
                $mdThemingProvider.theme('blue-grey');
                $mdThemingProvider.theme('default')
                    .primaryPalette('s4cDefault', {
                        'default': '900'
                    })
                    .accentPalette('s4cAccent', {
                        'default': '500'
                    })
                    .dark();

                $mdThemingProvider.theme('s4c-light')
                    .primaryPalette('s4cDefault', {
                        'default': '900'
                    })
                    .accentPalette('s4cAccent', {
                        'default': '500'
                    });
            }
        ])
        .config(['cfpLoadingBarProvider',
            function (cfpLoadingBarProvider) {
                cfpLoadingBarProvider.includeBar = false;
            }
        ])
        .config(['$mdIconProvider',
            function ($mdIconProvider) {

                $mdIconProvider
                    .iconSet('menu', '/assets/icons/menu.svg', 24)
                    .iconSet('components', '/assets/icons/components.svg', 24)
                    .iconSet('social', '/assets/icons/social.svg', 24)
                    .iconSet('extra', '/assets/icons/extra.svg', 24)
                    .iconSet('arquivos', '/assets/icons/arquivos.svg', 24)
                    .iconSet('filters', '/assets/icons/filters.svg', 24)
                    .iconSet('location', '/assets/icons/location.svg', 24)
                    .iconSet('settings', '/assets/icons/settings.svg', 24)
                    .iconSet('copy', '/assets/icons/copy.svg', 24);



            }
        ])
        .config(['$stateProvider', '$urlRouterProvider', '$locationProvider', '$httpProvider',
            function ($stateProvider, $urlRouterProvider, $locationProvider, $httpProvider) {
                $httpProvider.interceptors.push('AuthInterceptor');

                $httpProvider.interceptors.push(function ($q, $injector) {
                    var incrementalTimeout = 1000;

                    function retryRequest(httpConfig) {
                        var $timeout = $injector.get('$timeout');
                        return $timeout(function () {
                            var $http = $injector.get('$http');
                            return $http(httpConfig);
                        }, incrementalTimeout);
                        incrementalTimeout *= 2;
                    };

                    return {
                        responseError: function (response) {
                            // Retrying requests that filed dued to load
                            if (response.status === 502) {
                                if (incrementalTimeout < 5000) {
                                    return retryRequest(response.config);
                                } else {
                                    console.log('The remote server seems to be busy at the moment. Please try again in 5 minutes');
                                }
                            } else {
                                incrementalTimeout = 1000;
                            }
                            return $q.reject(response);
                        }
                    };
                });

                $urlRouterProvider
                    .otherwise('/inicio');
            }
        ]);
}());