Source: components/main/main.controller.js

    /**
     * @ngdoc main
     * @name MainCtrl
     * @module s4c.components.main.MainCtrl
     * 
     * @description Principal controller da aplicação. Todos os eventos do menu superior da tela inicial são configurados aqui.
     * 
     *
     */
(function () {
    'use strict';
    angular.module('s4c.controllers.MainCtrl', [
        's4c.components.busca',
        's4c.components.rotas',
        's4c.components.rotas-unificadas',
        's4c.components.baseConhecimento',
        's4c.components.camadas',
        's4c.components.cameras',
        's4c.components.telegram',
        's4c.components.detalhamento',
        's4c.components.deteccaoImpacto',
        's4c.components.collaboration',
        's4c.components.mapa',
        's4c.components.incidentes',
        's4c.components.tarefas',
        's4c.components.voip',
        's4c.components.zonaObservacao',
        's4c.components.planejamento',
        's4c.components.msi',
        's4c.components.briefingOperacional',
        's4c.components.timeline',
        's4c.components.briefingOperacional',
        's4c.components.terminal',
        's4c.components.detalhamentoRotasOlimpicas',
        's4c.directives.escolhaZona',
        's4c.directives.scroller',
        's4c.directives.twitterArea',
        's4c.directives.timepicker',
        's4c.services.PresetService',
        's4c.services.ParametrosS4C',
        's4c.services.PermissoesService',
        's4c.services.CommService',
        's4c.services.WebSocket',
        's4c.services.MainState',
        's4c.managers',
        'ng-dropdown',
        'datePicker',
        'angular-toasty',
        'color.picker',
        's4c.components.regiao',
        's4c.components.areaAtuacao',
        's4c.services.AuthService',
        's4c.components.rastreamento',
        's4c.components.pontoMovel',
        's4c.components.poi',
        's4c.components.webview',
        's4c.components.video',
        's4c.components.imagem',
        's4c.components.pdf',
        's4c.components.calendar',
        's4c.components.contacts',
        's4c.components.multivis',
        's4c.components.dashboard',
        's4c.components.rdp',
        's4c.components.chartBar',
        's4c.components.chartLine',
        's4c.components.chartPie',
        's4c.components.chartTreeMap',
        's4c.components.hdmi',
        's4c.components.whatsapp'
    ])
        .constant('FACES', {
            'FACE_FECHADA': {
                'sizeX': 1,
                'sizeY': 1,
                'row': 0,
                'col': 3,
                'name': 'Fechado',
                'template': 'app/components/modulos/face-fechada.html'
            }
        })
        .controller('MainCtrl', MainCtrl)
        .directive('compareToo', compareToo)
        .directive('safePasswordd', safePasswordd);
    /**     
     * @method compareToo
     */
    function compareToo() {
        return {
            require: "ngModel",
            scope: {
                otherModelValue: "=compareToo"
            },
            link: function (scope, element, attributes, ngModel) {
                ngModel.$validators.compareToo = function (modelValue) {
                    return modelValue === scope.otherModelValue;
                };
                scope.$watch("otherModelValue", function () {
                    ngModel.$validate();
                });
            }
        };
    }
    /**
     * @method safePasswordd
     */
    function safePasswordd() {
        return {
            require: "ngModel",
            scope: {
                username: '=username',
                nome: '=nome'
            },
            /**
             * @method safePasswordd
             * @param {*} scope 
             * @param {*} element 
             * @param {*} attributes 
             * @param {*} ngModel 
             */
            link: function (scope, element, attributes, ngModel) {
                /*
                 * Valid passwords:
                 * @a0Abcab
                 * 0@acanan
                 */
                // Retorno:
                // true = tudo OK
                /** 
                 * @method ngModel.$validators.safePasswordd
                 * @param modelValue
                 */
                ngModel.$validators.safePasswordd = function (modelValue) {
                    // Queremos que seja true:
                    var checkMinusculas = /(.*[a-z]){1,}/.test(modelValue);
                    var checkMaiusculas = /(.*[A-Z]){1,}/.test(modelValue);
                    var checkNumeros = /(.*[0-9]){1,}/.test(modelValue);
                    var checkCaracteres = /(.*[!@#$&*,.()%^]){1,}/.test(modelValue);
                    var checkName = true;
                    var checkUsername = true;
                    var checks = [
                        checkMinusculas,
                        checkMaiusculas,
                        checkNumeros,
                        checkCaracteres
                    ].filter(function (check) {
                        return check;
                    });
                    if (modelValue !== undefined) {
                        var usernameTester = new RegExp(scope.username, 'i');
                        checkUsername = !usernameTester.test(modelValue.trim());
                    }
                    var nomeSobrenome = scope.nome.split(' ');
                    for (var i = 0; i < nomeSobrenome.length; i++) {
                        var nameTester = new RegExp(nomeSobrenome[i], 'i');
                        checkName = !nameTester.test(modelValue);
                        if (!checkName) {
                            break;
                        }
                    }
                    // Pelo menos cumpre 3 das regras
                    var valido = checks.length >= 3 &&
                        checkName && checkUsername;
                    /*checkMinusculas && checkMaiusculas &&
                    checkNumeros && checkCaracteres*/
                    return valido;
                };
            }
        };
    }
    MainCtrl.$inject = [
        '$scope',
        '$rootScope',
        '$timeout',
        'GRIDSTER_OPTIONS_EDICAO',
        'GRIDSTER_OPTIONS_VISUALIZACAO',
        'UserInfo',
        'UserPresets',
        '$mdDialog',
        'DetalhamentoService',
        '$state',
        'MsiService',
        'CommService',
        '$stateParams',
        'toasty',
        'CamadasService',
        'AuthService',
        'MapaService',
        'MainState',
        'MainManager',
        'ModuloTwitterManager',
        'CamerasManager',
        'BuscaManager',
        'MensageriaManager',
        'AvisoOperacionalManager',
        'RotasManager',
        'RotasUnificadasManager',
        'IncidentesManager',
        'BaseConhecimentoManager',
        'FacebookManager',
        'EmailManager',
        'TwitterManager',
        'MSIManager',
        'SubDetalhamentoManager',
        'DetalhamentoManager',
        'ZonaDeObservacaoManager',
        'PlanejamentoManager',
        'DeteccaoImpactoManager',
        'MinhasTarefasManager',
        'TarefaManager',
        'BriefingOperacionalManager',
        'MapaManager',
        'BotoesManager',
        'IncidenteEnterManager',
        'AlarmeDisparadoManager',
        'Preset',
        'PermissoesService',
        '$interval',
        'EditPTarefaManager',
        'TerminalManager',
        'BuscaUsuariosTelegramManager',
        'MainService',
        'DetalhamentoRotasOlimpicasManager',
        'HabilitarCamadasManager',
        'localize',
        'Modulo',
        'AreaAtuacaoManager',
        'RastreamentoManager',
        'PontoMovelManager',
        'ZonasDeObservacaoFilter',
        'Usuario',
        'FileUploader',
        'API_ENDPOINT',
        '$window',
        'Base',
        'MsiFilter',
        '$http',
        'PoiManager',
        'Menu',
        'ParametrosS4C',
        'VoipManager',
        'WebSocket',
        'FileReaderService',
        'VideoStreamService'
    ];
        /**
         * @method MainCtrl
         * @param {*} $scope 
         * @param {*} $rootScope 
         * @param {*} $timeout 
         * @param {*} GRIDSTER_OPTIONS_EDICAO 
         * @param {*} GRIDSTER_OPTIONS_VISUALIZACAO 
         * @param {*} UserInfo 
         * @param {*} UserPresets 
         * @param {*} $mdDialog 
         * @param {*} DetalhamentoService 
         * @param {*} $state 
         * @param {*} MsiService 
         * @param {*} CommService 
         * @param {*} $stateParams 
         * @param {*} toasty 
         * @param {*} CamadasService 
         * @param {*} AuthService 
         * @param {*} MapaService 
         * @param {*} MainState 
         * @param {*} MainManager 
         * @param {*} ModuloTwitterManager 
         * @param {*} CamerasManager 
         * @param {*} BuscaManager 
         * @param {*} MensageriaManager 
         * @param {*} AvisoOperacionalManager 
         * @param {*} RotasManager 
         * @param {*} RotasUnificadasManager 
         * @param {*} IncidentesManager 
         * @param {*} BaseConhecimentoManager 
         * @param {*} FacebookManager 
         * @param {*} EmailManager 
         * @param {*} TwitterManager 
         * @param {*} MSIManager 
         * @param {*} SubDetalhamentoManager 
         * @param {*} DetalhamentoManager 
         * @param {*} ZonaDeObservacaoManager 
         * @param {*} PlanejamentoManager 
         * @param {*} DeteccaoImpactoManager 
         * @param {*} MinhasTarefasManager 
         * @param {*} TarefaManager 
         * @param {*} BriefingOperacionalManager 
         * @param {*} MapaManager 
         * @param {*} BotoesManager 
         * @param {*} IncidenteEnterManager 
         * @param {*} AlarmeDisparadoManager 
         * @param {*} Preset 
         * @param {*} PermissoesService 
         * @param {*} $interval 
         * @param {*} EditPTarefaManager 
         * @param {*} TerminalManager 
         * @param {*} BuscaUsuariosTelegramManager 
         * @param {*} MainService 
         * @param {*} DetalhamentoRotasOlimpicasManager 
         * @param {*} HabilitarCamadasManager 
         * @param {*} localize 
         * @param {*} Modulo 
         * @param {*} AreaAtuacaoManager 
         * @param {*} RastreamentoManager 
         * @param {*} PontoMovelManager 
         * @param {*} ZonasDeObservacaoFilter 
         * @param {*} Usuario 
         * @param {*} FileUploader 
         * @param {*} API_ENDPOINT 
         * @param {*} $window 
         * @param {*} Base 
         * @param {*} MsiFilter 
         * @param {*} $http 
         * @param {*} PoiManager 
         * @param {*} Menu 
         * @param {*} ParametrosS4C 
         * @param {*} VoipManager 
         * @param {*} WebSocket 
         * @param {*} FileReaderService 
         * @param {*} VideoStreamService 
         */
    function MainCtrl($scope,
        $rootScope,
        $timeout,
        GRIDSTER_OPTIONS_EDICAO,
        GRIDSTER_OPTIONS_VISUALIZACAO,
        UserInfo,
        UserPresets,
        $mdDialog,
        DetalhamentoService,
        $state,
        MsiService,
        CommService,
        $stateParams,
        toasty,
        CamadasService,
        AuthService,
        MapaService,
        MainState,
        MainManager,
        ModuloTwitterManager,
        CamerasManager,
        BuscaManager,
        MensageriaManager,
        AvisoOperacionalManager,
        RotasManager,
        RotasUnificadasManager,
        IncidentesManager,
        BaseConhecimentoManager,
        FacebookManager,
        EmailManager,
        TwitterManager,
        MSIManager,
        SubDetalhamentoManager,
        DetalhamentoManager,
        ZonaDeObservacaoManager,
        PlanejamentoManager,
        DeteccaoImpactoManager,
        MinhasTarefasManager,
        TarefaManager,
        BriefingOperacionalManager,
        MapaManager,
        BotoesManager,
        IncidenteEnterManager,
        AlarmeDisparadoManager,
        Preset,
        PermissoesService,
        $interval,
        EditPTarefaManager,
        TerminalManager,
        BuscaUsuariosTelegramManager,
        MainService,
        DetalhamentoRotasOlimpicasManager,
        HabilitarCamadasManager,
        localize,
        Modulo,
        AreaAtuacaoManager,
        RastreamentoManager,
        PontoMovelManager,
        ZonasDeObservacaoFilter,
        Usuario,
        FileUploader,
        API_ENDPOINT,
        $window,
        Base,
        MsiFilter,
        $http,
        PoiManager,
        Menu,
        ParametrosS4C,
        VoipManager,
        WebSocket,
        FileReaderService,
        VideoStreamService
    ) {
        /* Making sure the socket is initialized. */
        //CommService.start();
        var permissoesAreaAtuacao;
        $scope.version = MainState.getVersion();
        $interval(function () {
            $scope.noError = MainState.noError();
            $scope.errorMessage = MainState.getErrorMessage();
        }, 1000);
        /**    
         * @method isToShow     
         * @param label 
         */
        $scope.isToShow = function (label) {
            return MainState.isToShow(label);
        }
        /** 
         * @method moduleActive
         */
        $scope.moduleActive = function () {
            for (var index in Preset.config.preset.PresetModulos) {
                var name = Preset.config.preset.PresetModulos[index].Face ? Preset.config.preset.PresetModulos[index].Face.name : '';
                if (Preset.config.preset.PresetModulos[index].name == 'MODULO_DETALHAMENTO' ||
                    Preset.config.preset.PresetModulos[index].name == $scope.res('MODULO_DETALHAMENTO') ||
                    name == 'MODULO_DETALHAMENTO' ||
                    name == $scope.res('MODULO_DETALHAMENTO')
                ) {
                    DetalhamentoManager.ativo = false;
                    SubDetalhamentoManager.ativo = false;
                    return true;
                }
            }
            return false;
        }
        if (!AuthService.user.info.permissoesAreaAtuacao) {
            $http.get(API_ENDPOINT + 'area_atuacao/permissoes')
                .then(function (permissoes) {
                    AuthService.getUserInfo().then(function (user) {
                        user.permissoesAreaAtuacao = permissoes.data;
                        AuthService.user.info.permissoesAreaAtuacao = permissoes.data;
                        permissoesAreaAtuacao = permissoes.data;
                    });
                }, function (err) {
                    p.reject(err);
                });
        }
        $scope.res = $rootScope.res;
        $scope.blackList = $rootScope.blackList;
        if (moment.locale() == 'en') {
            localize.replacejscssfile("assets/i18n/leaflet.draw.pt-br.js", "assets/i18n/leaflet.draw.en-us.js", "js")
        } else {
            localize.replacejscssfile("assets/i18n/leaflet.draw.en-us.js", "assets/i18n/leaflet.draw.pt-br.js", "js")
        }
        var flyTo = $stateParams.flyTo;
        if (flyTo) {
            var data = flyTo.split('|');
            var method = data[0];
            var id = data[1];
            if (method === 'incidente') {
                $timeout(function () {
                    DetalhamentoService.pegarIncidente(id)
                        .then(function (incidente) {
                            incidente.geojson = JSON.parse(incidente.geojson);
                            CamadasService.reloadIncidentes(true);
                            $scope.IncidentesManager.voarParaIncidente(incidente);
                            $scope.MapaManager.voarParaObjeto(incidente);
                        });
                }, 5000);
            } else if (method === 'zona_observacao') {
                $timeout(function () {
                    CamadasService.exibirZonasDeObservacao();
                    $scope.DetalhamentoManager.abrirZonaDeObservacao(id);
                }, 5000);
            }
        }
        /**
         * @method getPermissoes
         * @param perms
         */
        PermissoesService.getPermissoes().then(function (perms) {
            $scope.permissoesVisualizacao = perms.permissoesVisualizacao;
            $scope.permissoesCriacao = perms.permissoesCriacao;
            $scope.permissoesEdicao = perms.permissoesEdicao;
            $scope.permissoesRemocao = perms.permissoesRemocao;
            $scope.permissoesExtras = perms.permissoesExtras;
            if (!_.includes(perms.permissoesCriacao, true)) {
                $scope.nenhumaPermissaoCriacao = true;
            }
            MainState.setPermissoes(perms);
        });
        MainService.on('logout', logout);
        MainService.on('alarmes', function (data) {
            if (!data) {
                return;
            }
            // Se o tipo de alarme for de rota
            if (data.rota) {
                if (!_belongsDataRangeRota(data.alarme)) {
                    return;
                }
            }
            // Se o tipo de alarme for de Zona de observação
            if (data.zonaDeObservacao) {
                if (!_belongsDataRange(data.alarme)) {
                    return;
                }
                _atualizaDetalhamentoZO(data.zonaDeObservacao.id);
            }
            var tweetsNovos;
            var detalhamentoManager = DetalhamentoManager;
            /*
             * Se o Detalhamento da Zona de Observação estiver Ativo
             * e algum alarme for disparado pertencer a ela,
             * o Detalhamento é recarregado
             */
            
            /**
             * @method _atualizaDetalhamentoZO
             * @param {*} id 
             */
            function _atualizaDetalhamentoZO(id) {
                var zonaManager = MainState.getManager('ZonaDeObservacaoManager');
                if (zonaManager.ativo) {
                    if (id === zonaManager.data.id) {
                        DetalhamentoManager.abrirZonaDeObservacao(id);
                    }
                }
            }
            /**
             * @method _belongsDataRangeRota
             * @param {*} alarme 
             */
            function _belongsDataRangeRota(alarme) {
                var dateNow = moment();
                if (!alarme.detalhes) return true;
                if (!alarme.detalhes.ranges) return true;
                var hasRange = alarme.detalhes.ranges.filter(function (range) {
                    if (range.start) {
                        if (!(moment(range.start).isSame(dateNow) || moment(range.start).isBefore(dateNow))) {
                            return
                        }
                    }
                    if (range.end) {
                        if (!(moment(range.end).isSame(dateNow) || moment(range.end).isAfter(dateNow))) {
                            return
                        }
                    }
                    return true;
                });
                return (hasRange.length > 0);
            }
            /**
             * @method _belongsDataRange
             * @param {*} alarme 
             */
            function _belongsDataRange(alarme) {
                var dateNow = moment();
                if (!alarme.detalhes.start && !alarme.detalhes.end && !alarme.detalhes.ranges) return true;
                var fullRange = {
                    start: moment(alarme.detalhes.start, 'DD/MM/YYYY HH:mm') || null,
                    end: moment(alarme.detalhes.end, 'DD/MM/YYYY HH:mm') || null
                };
                if (fullRange.start) {
                    TarefaManager.close = true;
                    if (!(fullRange.start.isSame(dateNow) || fullRange.start.isBefore(dateNow))) {
                        return;
                    }
                }
                if (fullRange.end) {
                    if (!(fullRange.end.isSame(dateNow) || fullRange.end.isAfter(dateNow))) {
                        return;
                    }
                }
                return true;
            }
            /**
             * @method  ativarPlanejamento
             * @param {*} data 
             */
            var ativarPlanejamento = function (data) {
                var planejamento = MainState.getDirective('planejamento');
                var usuario = MainState.getManager('UserInfo');
                var payload = data.alarme.planejamento;
                CamadasService.exibirPlanejamentos();
                MapaService.voarPara(data.alarme.planejamento.geometricPOI.coordinates);
                if (planejamento.ativo) {
                    planejamento.fecharPlanejamento();
                }
                if (PlanejamentoManager.ativo) {
                    PlanejamentoManager.fecharPlanejamento();
                }
                PlanejamentoManager.ativo = true;
                planejamento.ativo = true;
                planejamento.abrirPlanejamento({
                    draggable: function () { },
                    undraggable: function () {
                    },
                    marker: {
                        getLatLng: function () {
                            return L.latLng(
                                payload.geojson.coordinates[1], payload.geojson.coordinates[0]
                            );
                        },
                        setLatLng: function (lat, lng) {
                            return L.latLng(lat, lng);
                        }
                    },
                    oldLat: data.alarme.planejamento.geometricPOI.coordinates[1],
                    oldLng: data.alarme.planejamento.geometricPOI.coordinates[0]
                }, payload, usuario);
            }
            /**
             * @method ativarCamadaZO
             * @param {*} data 
             */
            var ativarCamadaZO = function (data) {
                CamadasService.exibirZonasDeObservacao();
                detalhamentoManager.abrirZonaDeObservacao(data.alarme.zonaObservacao.id);
                CamadasService.ativarMenuCategoria(data.alarme.detalhes.categoriaId);
                CamadasService.ativarSubCategorias(data.alarme.detalhes.categoriaId);
            }
            /**
             * @method ativarZO
             * @param {*} data 
             */
            var ativarZO = function (data) {
                CamadasService.exibirZonasDeObservacao();
                detalhamentoManager.abrirZonaDeObservacao(data.zonaDeObservacao.id);
                CamadasService.ativarMenuCategoria(data.alarme.detalhes.categoriaId);
            }
            /**
             * @method tocarSom
             * @param {*} arquivo
             */
            var tocarSom = _.debounce(function (arquivo) {
                var som = new Audio(arquivo);
                som.play();
            }, 1000);
            /**
             * @method abrirIncidente
             * @param {*} data 
             */
            var abrirIncidente = function (data) {
                if (!data.alarme.incidente.geojson) {
                    var latLng = data.alarme.incidente.poiGeometrico.match(/\(([^)]+)\)/)[1].split(' ');
                    data.alarme.incidente.geojson = {
                        coordinates: [latLng[0], latLng[1]]
                    };
                } else {
                    if (typeof data.alarme.incidente.geojson === 'string') {
                        data.alarme.incidente.geojson = JSON.parse(data.alarme.incidente.geojson);
                    }
                }
                CamadasService.reloadIncidentes(true);
                IncidentesManager.voarParaIncidente(data.alarme.incidente);
                MapaManager.voarParaObjeto(data.alarme.incidente);
                detalhamentoManager.abrirIncidente(data.alarme.incidente.id, {
                    lat: data.alarme.incidente.geojson.coordinates[1],
                    lng: data.alarme.incidente.geojson.coordinates[0]
                });
            };
            /**
             * @method abrirBriefing
             * @param {*} data 
             * @param {*} context 
             */
            var abrirBriefing = function (data, context) {
                BriefingOperacionalManager.responderBriefing();
                toasty.clear(context.id);
            };
            /**
             * @method fitTweets
             * @param {*} data 
             */
            var fitTweets = function (data) {
                var tweets = data.tweets;
                var coordinates = data.tweets.map(function (tweet) {
                    var coordinates = tweet.geo.coordinates.slice();
                    return coordinates;
                });
                MapaService.fitBounds(coordinates, tweets);
            };
            var acoesExternas = {
                /**
                 * @method voarParaIncidente
                 * @param {*} id 
                 */
                'voarParaIncidente': function (id) {
                    DetalhamentoService.pegarIncidente(id)
                        .then(function (incidente) {
                            incidente.geojson = JSON.parse(incidente.geojson);
                            incidente.geometry = incidente.geojson;
                            var inc = DetalhamentoManager.abrirIncidente(incidente.id, {
                                lat: incidente.geojson.coordinates[1],
                                lng: incidente.geojson.coordinates[0]
                            });
                            MainState.getDirective('filtro-msi').voarIncidente(incidente);
                        });
                },
                /** 
                 * @method abrirPoi
                 * @param {*} chaves_estrangeira
                 */
                'abrirPoi': function (chave_estrangeira) {
                    DetalhamentoService.pegarPoiPorChaveEstrangeira(chave_estrangeira).then(function (poi) {
                        var latlng = {
                            lat: poi.latitude,
                            lng: poi.longitude
                        };
                        DetalhamentoManager.abrirPoi(poi.id, latlng);
                        CamadasService.ativarMenuCategoria(poi.CategoriumId);
                        MapaService.voarPara([
                            poi.longitude,
                            poi.latitude
                        ]);
                        MapaService.piscarAzul(latlng);
                    });
                },
                /**
                 * @method voarPara
                 * @param {*} coordenadas 
                 */
                'voarPara': function (coordenadas) {
                    MapaService.voarPara([
                        coordenadas.longitude,
                        coordenadas.latitude
                    ]);
                },
                'ligarParaRamal': function (obj) {
                    call(obj.ramal);
                }
            }
            /**
             * @method acoesAlarmeExterno
             * @param {*} data 
             */
            var acoesAlarmeExterno = function (data) {
                _.each(data.alarme.alarmeExterno.detalhes.acoes, function (acao) {
                    acoesExternas[acao.nome](acao.parametro)
                })
            }
            /**
             * @method voarParaZona
             * @param {*} data 
             */
            var voarParaZona = function (data) {
                $scope.MapaManager.voarParaObjeto(data.zonaDeObservacao);
            };
            /**
             * @method aceitarVideoChamada
             * @param {*} data 
             */
            var aceitarVideoChamada = function (data) {
                var url_ = ParametrosS4C.wowzaUrl + '/live/' + data.poiChaveEstrangeira + '.stream/playlist.m3u8';
                acoesExternas['voarPara'](data.coordenadas);
                acoesExternas['abrirPoi'](data.poiChaveEstrangeira);
                //window.open(data.url, '_blank', 'toolbar=no,location=no,status=no,menubar=no,scrollbars=false,resizable=false,width=670,height=512');
                window.open("/Cam/rtsp/?url=" + url_, '_blank', 'toolbar=no,location=no,status=no,menubar=no,scrollbars=false,resizable=false,width=' + 670 + ',height=' + 400);
            }
            var acoes = {
                'TwitterZO': fitTweets,
                'TempoZO': voarParaZona,
                'IncidenteZO': abrirIncidente,
                'Incidente': abrirIncidente,
                'agendarAlertaBriefing': abrirBriefing,
                'Externo': acoesAlarmeExterno,
                'External': acoesAlarmeExterno,
                'AtivarCamadaZO': ativarCamadaZO,
                'CercaVirtualSaidaZO': ativarZO,
                'CercaVirtualEntradaZO': ativarZO,
                'CercaVirtualPermanenciaZO': ativarZO,
                'Planejamento': ativarPlanejamento,
                'VideoChamada': aceitarVideoChamada
            };
            var som = _.get(data, 'alarme.detalhes.som');
            if (som !== undefined) {
                tocarSom(som);
            }
            /**
             * Verifica se os tweets passados pelo backend já foram notificados
             * ao usuário.
             */
            if (data.alarme && (data.alarme.tipo === 'Twitter' || data.alarme.tipo == 'TwitterZO')) {
                var tweetsAlarmados = localStorage.getItem('tweetsAlarmados');
                var alarmados = null;
                if (tweetsAlarmados) {
                    alarmados = tweetsAlarmados.split(',');
                    // Filtrando para existirem apenas tweets que não estão no
                    // localStorage
                    tweetsNovos = _.filter(data.tweets, function (tweet) {
                        return alarmados.indexOf(tweet.id_str) < 0;
                    });
                    if (tweetsNovos.length === 0) {
                        // Não há novos tweets, retornando
                        return;
                    }
                    // Existem novos tweets, concatenando
                    alarmados = alarmados.concat(_.map(tweetsNovos, function (tweet) {
                        return tweet.id_str;
                    }));
                } else {
                    alarmados = _.map(data.tweets, function (tweet) {
                        return tweet.id_str;
                    });
                }
                if (alarmados.length > 0) {
                    localStorage.setItem('tweetsAlarmados', alarmados);
                }
            }
            if (data.mensagem) {
                if (data.tipo) {
                    if (data.tipo === 'Briefing') {
                        var permissoes = _.chain(AuthService.user.info.Perfils)
                            .map(function (perfil) {
                                return perfil.PermissaoAcessos;
                            })
                            .flatten()
                            .filter(function (permissao) {
                                return permissao.modulo === 'Briefing';
                            })
                            .value();
                        if (permissoes.length <= 0) {
                            // Usuário não tem permissãoo para responder o Briefing
                            return;
                        }
                        data.mensagem += '. ' + $scope('COMUM_CLICK_RESPONDER');
                        data.alarme = {
                            tipo: 'Briefing'
                        };
                    }
                    if (data.tipo === 'VideoChamada') {
                        toasty({
                            title: 'Chamada de Vídeo',
                            msg: data.data + '<br/>' + data.mensagem,
                            showClose: true,
                            timeout: false,
                            sound: false,
                            html: true,
                            shake: false,
                            onClick: function () {
                                acoes[data.tipo](data, this);
                            }
                        });
                    }
                }
                if (data.alarme) {
                    if (data.alarme.alarmeExterno) {
                        toasty({
                            title: data.alarme.alarmeExterno.titulo,
                            msg: data.alarme.alarmeExterno.dataHora + '<br/>' + data.alarme.alarmeExterno.mensagem,
                            showClose: true,
                            timeout: false,
                            sound: false,
                            html: true,
                            shake: false,
                            onClick: function () {
                                acoes[data.alarme.tipo](data, this);
                            }
                        });
                    } else {
                        if (data.time != null && data.qtdTime != null) {
                            toasty({
                                msg: localize.res(data.mensagem) + data.qtdTime + ' ' + localize.res(data.time),
                                html: true,
                                onClick: function () {
                                    acoes[data.alarme.tipo](data, this);
                                }
                            });
                        } else {
                            toasty({
                                msg: localize.res(data.mensagem),
                                html: true,
                                onClick: function () {
                                    acoes[data.alarme.tipo](data, this);
                                }
                            });
                        }
                    }
                }
            }
        });
        ParametrosS4C.showing = false;
        
        /**     
         * @method addEventListener('keydown')
         * @param {*} e
         */
        window.addEventListener('keydown', function (e) {
            if ((e.altKey) && (e.which === 65)) { // Pesquisar (Alt + A)
                e.Handled = true;
                if (!ParametrosS4C.showing) {
                    $('.barraModulo').addClass('mostraBarra');
                    $('.barraModulo .md-toolbar-tools span').addClass('menuFonte');
                    $('.barraModulo').css('position', 'absolute');
                    $('.btn-action').removeClass('show');
                    $('.wrapper').removeClass('topClass');
                    $('.webViewNav').parent().next().addClass('mt-5');
                    ParametrosS4C.showing = true;
                } else {
                    $('.barraModulo').removeClass('mostraBarra');
                    $('.barraModulo .md-toolbar-tools span').removeClass('menuFonte');
                    // $('.btn-action').addClass('show');
                    $('.wrapper').addClass('topClass');
                    $('.webViewNav').parent().next().removeClass('mt-5');
                    ParametrosS4C.showing = false;
                }
            }
        }, true);
        /**
         * @method addEventListener(keydown')
         * @param {*} e
         */
        window.addEventListener('keydown', function (e) {
            if ((e.altKey) && (e.which === 81)) { // Pesquisar (Alt + Q)
                e.Handled = true;
                if (!ParametrosS4C.showing) {
                    $('.menu-superior').addClass('hoverMain');
                    ParametrosS4C.showing = true;
                } else {
                    $('.menu-superior').removeClass('hoverMain');
                    ParametrosS4C.showing = false;
                }
            }
        }, true);
        /**
         * @method addEventListener('DOMContentLoaded')
         */
        document.body.addEventListener('DOMContentLoaded', function () {
            var elems = document.querySelectorAll('.collapsible');
            var instances = M.Collapsible.init(elems, options);
        });
        $timeout(MainState.menuButtonFunction, 2000);
        $timeout(function () {
            var electron = navigator.userAgent.indexOf("Electron") != -1;
            if (!electron) {
                $('.menuMain').addClass('hoverMain');
                $('.menuMain').removeClass('menuMain');
                $('.icone-toolbar img').addClass('png-icon');
                $('#mainDiv').addClass('hoverMain');
                $('#mainDiv').removeClass('menuMain');
                $(".face .wrapper").addClass('topClass');
                $(".face .wrapper").css('position', 'absolute');
            }
        }, 300);
        $timeout(function () {
            var electron = navigator.userAgent.indexOf("Electron") != -1;
            if (!electron) {
                $('.barraModulo').addClass('mostraBarra');
                $('.barraModulo .md-toolbar-tools span').addClass('menuFonte');
                $('.barraModulo').css('position', 'absolute');
                $('.btn-action').removeClass('show');
                $('.wrapper').removeClass('topClass');
                $('.webViewNav').parent().next().addClass('mt-5');
                ParametrosS4C.showing = true;
            }else{
                $('.wrapper').addClass('topClass');
            }
        }, 2500);
        //Função para ter sempre disponível na window a posição do mouse
        /**
         * @method handler
         * @param {*} e 
         */
        function handler(e) {
            e = e || window.event;
            var pageX = e.pageX;
            var pageY = e.pageY;
            if (pageX === undefined) {
                pageX = e.clientX + document.body.scrollLeft + document.documentElement.scrollLeft;
                pageY = e.clientY + document.body.scrollTop + document.documentElement.scrollTop;
            }
            window.positionX = pageX;
            window.positionY = pageY;
        }
        // attach handler to the click event of the document
        if (document.attachEvent) document.attachEvent('onclick', handler);
        else document.addEventListener('click', handler);
        /**
         * @method errHandler
         * @param {*} err 
         */
        let errHandler = function (err) {
            alert(err.message);
        };
        /**
         * @method readTextFile
         * @param {*} text
         */
        FileReaderService.readTextFile("/s4c_dir/videoServers.json", function (text) {
            var data = JSON.parse(text);
            ParametrosS4C.wowzaUrl = data.wowzaUrl;
            VideoStreamService.setPlayerOptions({
                socket: data.videoServerUrl,
                redirectNativeMediaErrors: true,
                bufferDuration: 30,
                errHandler: errHandler
            });
        });
        /**
         * @method $on
         * @param {*} e 
         * @param {*} data
         */
        $rootScope.$on('s4c:windowResize', function (e, data) {
            // Gridster responsivo:
            GRIDSTER_OPTIONS_EDICAO.colWidth = parseInt((($(window).width() - 5) / GRIDSTER_OPTIONS_EDICAO.columns).toFixed(), 10);
            var electron = navigator.userAgent.indexOf("Electron") != -1;
            if (!electron) {
                GRIDSTER_OPTIONS_EDICAO.rowHeight = parseInt((($(window).height() + 0) / GRIDSTER_OPTIONS_EDICAO.maxRows).toFixed() - 9, 10);
            } else {
                GRIDSTER_OPTIONS_EDICAO.rowHeight = parseInt((($(window).height() + 0) / GRIDSTER_OPTIONS_EDICAO.maxRows).toFixed(), 10);
            }
        });
        MainState.loadGridsterOptions(alterPreset);
        /**
         * @method alterPreset
         */
        function alterPreset(){
            Preset.alterar(_.find(UserPresets, 'padrao') || _.find(UserPresets, 'DepartamentoId'));
        }
        /**
         * @method logout
         */
        function logout() {
            releaseResources();
            AuthService.logout();
            $state.go('inicio');
            if (MainState.getDirective('voip') != null) {
                MainState.getDirective('voip').deslogar();
            }
        }
        setTimeout(function () { MainState.resizeMenuMapa() }, 3000)
        /**
         * @method novoUsuario
         */
        function novoUsuario() {
            $mdDialog.show({
                templateUrl: 'app/components/admin/modulos/usuarios/Usuario/novo.html',
                controller: NovoUsuarioCtrl,
                targetEvent: event
            });
        }
        /**
         * @method hideShare
         */
        function hideShare() {
            $scope.isCancelled = false;
        }
        /**
         * @method showShare
         */
        function showShare() {
            $scope.isCancelled = true;
        }
        $scope.isCancelled = true;
        $scope.renderers = [];
        Preset.setMainRenderes($scope.renderers);
        /**
         * @method share
         */
        $scope.share = function () {
            if (ParametrosS4C.parametros.multivisConfig.length == 0) {
                return;
            }
            if (ParametrosS4C.parametros.multivisConfig.length == 1) {
                var constraint = {
                    url: ParametrosS4C.parametros.multivisConfig[0].hostname.replace('http', 'ws').replace('https', 'wss'),
                    positionX: $scope.positionX,
                    positionY: $scope.positionY
                }
                if (!$scope.renderers[ParametrosS4C.parametros.multivisConfig[0].hostname]) {
                    var connection1 = new render.Screenshare(constraint);
                    $scope.renderers[ParametrosS4C.parametros.multivisConfig[0].hostname] = connection1;
                }
                hideShare();
                return;
            }
            var confirm = $mdDialog.confirm({
                locals: { render: render, renderers: $scope.renderers },
                templateUrl: 'app/directives/preset/escolhaMultivis.html',
                controller: function ($scope, $mdDialog, render, renderers) {
                    $scope.res = $scope.$root.res;
                    $scope.multivisSelecionado;
                    $scope.multivisList = ParametrosS4C.parametros.multivisConfig;
                    $scope.positionX;
                    $scope.positionY;
                    $scope.rect = document.getElementById("bodyDiv").getBoundingClientRect();
                    $scope.ok = function () {
                        if (!$scope.multivisSelecionado) {
                            return;
                        }
                        var constraint = {
                            url: $scope.multivisSelecionado.hostname.replace('http', 'ws').replace('https', 'wss'),
                            positionX: $scope.positionX,
                            positionY: $scope.positionY
                        }
                        if (!renderers[$scope.multivisSelecionado.hostname]) {
                            var connection1 = new render.Screenshare(constraint);
                            renderers[$scope.multivisSelecionado.hostname] = connection1;
                        }
                        hideShare();
                        $mdDialog.hide();
                    }
                    $scope.cancelar = function () {
                        $mdDialog.hide();
                    };
                    $scope.rendered = false;
                    var interval = $interval(function () {
                        if (!$scope.rendered && document.getElementById("escolhaMultivis")) {
                            document.getElementById("escolhaMultivis").style.top = (window.positionY + 100) + "px";
                            if (window.positionX - 200 > 0) {
                                document.getElementById("escolhaMultivis").style.left = (window.positionX - 200) + "px";
                            } else {
                                document.getElementById("escolhaMultivis").style.left = window.positionX + "px";
                            }
                            $scope.rendered = true;
                            $interval.cancel(interval);
                        }
                    }, 30);
                },
                parent: angular.element(document.body)
            });
            $mdDialog.show(confirm).then(function () { }, function () { });
        }
        /**
         * @method stopShare
         */
        $scope.stopShare = function () {
            if (ParametrosS4C.parametros.multivisConfig.length == 0) {
                return;
            }
            if (ParametrosS4C.parametros.multivisConfig.length == 1) {
                $scope.multivisSelecionado = ParametrosS4C.parametros.multivisConfig[0];
                if ($scope.renderers[$scope.multivisSelecionado.hostname]) {
                    $scope.renderers[$scope.multivisSelecionado.hostname].closeApp($scope.renderers[$scope.multivisSelecionado.hostname]);
                    $scope.renderers[$scope.multivisSelecionado.hostname] = null;
                }
                showShare();
                return;
            }
            var confirm = $mdDialog.confirm({
                locals: { renderers: $scope.renderers },
                templateUrl: 'app/directives/preset/escolhaMultivis.html',
                controller: function ($scope, $mdDialog, renderers) {
                    $scope.res = $scope.$root.res;
                    $scope.multivisSelecionado;
                    $scope.multivisList = ParametrosS4C.parametros.multivisConfig;
                    $scope.rendered = false;
                    var interval = $interval(function () {
                        if (!$scope.rendered && document.getElementById("escolhaMultivis")) {
                            document.getElementById("escolhaMultivis").style.top = (window.positionY + 100) + "px";
                            if (window.positionX - 200 > 0) {
                                document.getElementById("escolhaMultivis").style.left = (window.positionX - 200) + "px";
                            } else {
                                document.getElementById("escolhaMultivis").style.left = window.positionX + "px";
                            }
                            $scope.rendered = true;
                            $interval.cancel(interval);
                        }
                    }, 30);
                    $scope.ok = function () {
                        if (!$scope.multivisSelecionado) {
                            return;
                        }
                        if (renderers[$scope.multivisSelecionado.hostname]) {
                            renderers[$scope.multivisSelecionado.hostname].closeApp(renderers[$scope.multivisSelecionado.hostname]);
                            renderers[$scope.multivisSelecionado.hostname] = null;
                        }
                        showShare();
                        $mdDialog.hide();
                    }
                    $scope.cancelar = function () {
                        $mdDialog.hide();
                    };
                },
                parent: angular.element(document.body)
            });
            $mdDialog.show(confirm).then(function () {
            }, function () { });
        }
        /**
         * @method NovoUsuarioCtrl
         * @param {*} $scope 
         * @param {*} Usuario 
         * @param {*} $mdDialog 
         * @param {*} localize 
         * @param {*} FileUploader 
         * @param {*} API_ENDPOINT 
         * @param {*} AuthService 
         */
        function NovoUsuarioCtrl($scope, Usuario, $mdDialog, localize, FileUploader, API_ENDPOINT, AuthService) {
            $scope.username = AuthService.user.info.username;
            $scope.name = AuthService.user.info.nome;
            $scope.res = $scope.$root.res;
            /**
             * @method obterPorId 
             * @param  usuario
             */
            Usuario.obterPorId(AuthService.user.info.id)
                .then(function (usuario) {
                    $scope.user = usuario;
                    if ($scope.user.urlImagem != null) {
                        $scope.hasImage = true;
                    } else {
                        $scope.hasImage = false;
                    }
                });
            /**
             * @method cancelar
             */
            $scope.cancelar = function () {
                $mdDialog.hide();
            };
            /** 
             * @method criar
             */
            $scope.criar = function () {
                $scope.cpfExists = false;
                $scope.emailExists = false;
                if ($scope.trocaSenha.$valid) {
                    $scope.user.password = $scope.senha;
                } else {
                    $scope.user.password = null;
                }
                /**
                 * @method atualizarPerfil 
                 * @param {*} u
                 */
                Usuario.atualizarPerfil($scope.user.id, $scope.user).then(function (u) {
                    if (!u.id) {
                        if (u.Status == 'CPF_USUARIO_EXISTE') {
                            $scope.cpfExists = true;
                        }
                        if (u.Status == 'EMAIL_USUARIO_EXISTE') {
                            $scope.emailExists = true;
                        }
                        return;
                    } else {
                        toBlob();
                        MainState.getManager('UserInfo').nome = u.nome;
                        MainState.getManager('UserInfo').cpf = u.cpf;
                        /**
                         * @method obterShortUsers 
                         * @param usuarios
                         */
                        Usuario.obterShortUsers().then(function (usuarios) {
                            var usuario_ = _.find(usuarios, function (user) { return user.id === u.id; });
                            if (usuario_) {
                                usuario_.nome = u.nome;
                            }
                        });
                        $mdDialog
                            .show($mdDialog.alert()
                                .title($scope.res('COMUM_SUCESSO'))
                                .content($scope.res('USUARIO_ATUALIZADO'))
                                .ok($scope.res('COMUM_OK')));
                        $mdDialog.hide(u);
                    }
                });
            };
            /**
             * @method setTimeout
             */
            setTimeout(function () {
                $scope.input = angular.element('#arquivo');
            }, 1000);
            /**
             * @method abrirUpload
             */
            $scope.abrirUpload = function () {
                $scope.input.click();
            }
            var uploader = $scope.uploader = new FileUploader(),
                uploadCallbackQueue = [];
            uploader.clearQueue();
            $scope.uploader.filters.push({
                'name': 'enforceMaxFileSize',
                'fn': function (item, evt) {
                    var megaByte = parseInt(item.size / 1000000) + "MB";
                    if (item.size <= 26214400) {
                        return item.size <= 26214400
                    } else {
                        $mdDialog
                            .show($mdDialog.alert()
                                .title($scope.res('COMUM_TAMANHOFILEULTRAPASSADO'))
                                .content($scope.res('LIMITE_ARQUIVO_ULTRAPASSADO', megaByte))
                                .ok($scope.res('COMUM_OK')))
                        return item.size <= 26214400
                    }
                }
            });
            /**
             * @method
             * @param item
             * @param response
             */
            $scope.uploader.onCompleteItem = function (item, response) {
                $scope.mensagem = response;
            };
            /** 
             * @method onAfterAddingFile
             * @param Item
             * @param evt
             * @param arquivo
             */
            $scope.uploader.onAfterAddingFile = function (item, evt, arquivo) {
                item.novoNome = item.file.name;
                enviarArquivo();
            }
            /**
             * @method exit
             * @param {*} filename 
             */
            function ext(filename) {
                var index = _.lastIndexOf(filename, '.');
                return filename.substring(index, filename.length);
            }
            /** 
             * @method onBeforeUploadItem
             * @param Item
             */
            $scope.uploader.onBeforeUploadItem = function (item) {
                item.url = uploader.url;
                var token = window.sessionStorage.getItem('s4cToken');
                var tokenObj = JSON.parse(token);
                item.headers = {
                    'Authorization': 'Bearer ' + tokenObj.access_token
                };
                item.file.name = item.novoNome + ext(item.file.name);
            };
            /** 
             * @method onProgressItem
             * @param fileItem
             * @param progress
             */
            $scope.uploader.onProgressItem = function (fileItem, progress) {
                console.info('onProgressItem', fileItem, progress);
            };
            /**
             * @method onCompleteAll
             * @param {*} result
             */
            $scope.uploader.onCompleteAll = function (result) {
                _.each(uploadCallbackQueue, function (callback) {
                    callback();
                });
            };
            /**
             * @method mostrarImagem
             */
            $scope.mostrarImagem = function () {
                $('#arquivo').each(function (index) {
                    if ($('#arquivo').eq(index).val() != "") {
                        $scope.readURL(this);
                    }
                });
            }
            /**
             * @method removeImage
             */
            $scope.removeImage = function () {
                $scope.hasImage = false;
            }
            /**
             * @method readURL
             * @param input
             */
            $scope.readURL = function (input) {
                if (input.files && input.files[0]) {
                    $scope.hasImage = true;
                    var reader = new FileReader();
                    reader.onload = function (e) {
                        $("#renderCropper_perfil").empty();
                        var img = $('<img />', {
                            id: 'image',
                            src: e.target.result,
                            style: 'width: 100%'
                        }).appendTo($('#renderCropper_perfil'));
                        var cropper = new Cropper(img[0], {
                            aspectRatio: 1,
                            crop: function (e) {
                                document.getElementById('editarX').value = e.detail.x;
                                document.getElementById('editarY').value = e.detail.y;
                                document.getElementById('editarWidth').value = e.detail.width;
                                document.getElementById('editarHeight').value = e.detail.height;
                            },
                            zoomable: true,
                            scalable: true,
                            movable: true,
                            background: false,
                            viewMode: 1
                        });
                    };
                    reader.readAsDataURL(input.files[0]);
                }
            }
            /**
             * @method enviarArquivo
             */
            function enviarArquivo() {
                $scope.mostrarImagem();
            }
            $scope.uploader.alias = 'arquivo';
            $scope.uploader.removeAfterUpload = true;
            /**
             * @method toBlob
             */
            function toBlob() {
                var canvas = document.createElement('canvas');
                var ctx = canvas.getContext('2d');
                canvas.height = document.getElementById('editarHeight').value;
                canvas.width = document.getElementById('editarWidth').value;
                if (!document.getElementById('image') || !$scope.hasImage) {
                    return;
                }
                ctx.drawImage(document.getElementById('image'), document.getElementById('editarX').value, document.getElementById('editarY').value, canvas.width, canvas.height, 10, 10, canvas.width, canvas.height);
                if (canvas.toBlob) {
                    canvas.toBlob(function (blob) {
                        var formData = new FormData();
                        var token = window.sessionStorage.getItem('s4cToken');
                        var tokenObj = JSON.parse(token);
                        formData.append('arquivo', blob, "avatar.png");
                        $.ajax('/usuarios/' + $scope.user.id, {
                            method: "POST",
                            data: formData,
                            processData: false,
                            contentType: false,
                            headers: {
                                'Authorization': 'Bearer ' + tokenObj.access_token
                            },
                            success: function (data) {
                                MainState.getManager('UserInfo').urlImagem = data.imgUrl;
                                $('.imagem-usuario').attr("src", data.imgUrl);
                            },
                            error: function () {
                                console.log('Upload error');
                            }
                        });
                    });
                }
            }
        }
        /**
         * @method onunload
         */
        window.onunload = function () {
            if (MainState.getDirective('voip') != null) {
                MainState.getDirective('voip').deslogar();
            }
            releaseResources();
        }
        /**
         * @method onclose
         */
        window.onclose = function () {
            if (MainState.getDirective('voip') != null) {
                MainState.getDirective('voip').deslogar();
            }
            releaseResources();
        }
        $scope.MainManager = {
            'usuarioAtivo': UserInfo
        };
        /**
         * @method atualizarRotas
         */
        $scope.atualizarRotas = function () {
            var rotas = $scope.$directives.rotas || {};
            rotas.atualizarRotas();
        };
        $scope.notificacaoManager = {
            'contarNofificacao': MensageriaManager.notificacao
        };
        $scope.BotoesManager = {
            'abrirTwitter': TwitterManager.abrir,
            'abrirFacebook': FacebookManager.abrir,
            'abrirMensageria': MensageriaManager.abrir,
            'abrirAvisoOperacional': AvisoOperacionalManager.abrir
        };
        $scope.CamadasManager = {
            'categoriasSelecionadas': []
        };
        $scope.disable = false;
        $scope.showDeleteIcon = true;
        /**
         * @method visualizarPreset
         */
        $scope.visualizarPreset = function () {
            var atualPreset = Preset.config.preset;
            $scope.showDeleteIcon = true;
            $scope.disable = true;
            Preset.salvar().then(function (preset) {
                if (preset.status == 403) {
                    toasty({
                        msg: preset.message
                    });
                    atualPreset = Preset.config.preset;
                    Preset.editar();
                } else {
                    if (atualPreset.id === undefined) {
                        atualPreset.id = preset.id;
                        atualPreset.nome = preset.nome;
                        $scope.presets.push(atualPreset);
                    }
                    Preset.editar();
                }
                $scope.disable = false;
            }, function (err) {
                if (err.status == 422) {
                    $mdDialog
                        .show($mdDialog.alert()
                            .title('Erro')
                            .content($scope.res(err.message.message))
                            .ok('OK'));
                }
            });
        };
        /**
         * @method editarPreset
         */
        $scope.editarPreset = function () {
            // Pegar permissões de usuário
            var permissoes = $scope.permissoesExtras,
                isPresetDeAgencia = Preset.isPresetDeAgencia();
            // Verificar se user tem permissão para modificar preset de grupo
            if (!permissoes.alterarPresetAgencia && isPresetDeAgencia) {
                toasty({
                    msg: $scope.res('COMUM_MSG_ALERT_EDITAR_PRESET')
                });
                return false;
            }
            if (_.keys(MainState.detalhamentosAtivos).length > 0) {
                var confirm = $mdDialog.confirm()
                    .title($scope.res('COMUM_ATENCAO'))
                    .content($scope.res('COMUM_MSG_ALERT_MODO_EDICAO'))
                    .ariaLabel($scope.res('COMUM_CONFIRMAR_EDICAO'))
                    .ok($scope.res('COMUM_SIM'))
                    .cancel($scope.res('COMUM_CANCELAR'));
                $mdDialog
                    .show(confirm)
                    .then(function () {
                        _.each(MainState.detalhamentosAtivos, function (detalhamento) {
                            detalhamento.fechar();
                        })
                        Preset.editar();
                    });
            } else {
                Preset.editar();
            }
        };
        /**
         * @method releaseResources
         */
        function releaseResources() {
            CommService.stop();
            closeModals();
            VideoStreamService.closeAll();
            CamadasService.clearReloadNodes();
            Menu.clearPromise();
            Preset.stopAllShare();
            DetalhamentoManager.fecharTodos();
            Preset.rollBackEmptyModules();
        }
        /**
         * @method alterarPreset
         * @param {*} preset 
         */
        function alterarPreset(preset) {
            const alterarPresetFinal = new Promise((resolve)=>{
            Preset.alterar(preset);
            setTimeout(()=>{resolve()},200)
            });
            alterarPresetFinal.then(()=> $('.wrapper').addClass('topClass'))
        }
        /**
         * @method desenharPoligono
         * @param {*} e 
         * @param {*} data
         */
        function desenharPoligono(e, data) {
            $scope.RotasManager.desenharPoligono(data);
        }
        $rootScope.$on('mapa:desenharPoligono', desenharPoligono);
        /**
         * @method saveMapPosition
         */
        function saveMapPosition() {
            MapaService.obterPontoCentral()
                .then(function (center) {
                    MapaService.pegarZoom(function (zoom) {
                        var jsonObject = {};
                        jsonObject.lat = center.lat;
                        jsonObject.lng = center.lng;
                        jsonObject.zoom = zoom;
                        Preset.saveMapPosition(Preset.config.preset.id, jsonObject);
                        $mdDialog.show($mdDialog.alert()
                            .title($scope.res('COMUM_SUCESSO'))
                            .content($scope.res('MSG_PRESET_ATUALIZADO'))
                            .ok($scope.res('COMUM_OK')));
                    });
                });
        }
        /**
         * @method novoPreset
         * @param {*} duplicarPreset 
         */
        function novoPreset(duplicarPreset) {
            var presetModulos = Preset.config.preset ? angular.copy(Preset.config.preset.PresetModulos) : [],
                presetAntigo = Preset.obter(),
                novoPreset = Preset.novo(),
                presetNomes = _.map($scope.presets, 'nome');
            $mdDialog.show({
                templateUrl: 'app/directives/preset/dialog.html',
                controller: function ($scope) {
                    $scope.res = $scope.$root.res;
                    $scope.titulo = ((duplicarPreset) ? $scope.res('MSG_SALVAR_NOVO_PRESET') : 'Preset');
                    $scope.erroNomeExistente = false;
                    $scope.erroNome = false;
                    $scope.preset = {
                        nome: ''
                    };
                    $scope.ok = function () {
                        if ($scope.preset.nome.length === 0) {
                            $scope.erroNome = true;
                            $scope.erroNomeExistente = false;
                            return false;
                        }
                        if ($scope.preset.nome && _.indexOf(presetNomes, $scope.preset.nome) !== -1) {
                            $scope.erroNomeExistente = true;
                            $scope.erroNome = false;
                            return false;
                        }
                        $mdDialog.hide($scope.preset.nome);
                    };
                    $scope.cancelar = function () {
                        Preset.alterar(presetAntigo)
                        $mdDialog.cancel();
                    };
                },
                clickOutsideToClose: false,
                escapeToClose: false,
            }).then(function (nome) {
                Preset.renomear(nome);
                if (duplicarPreset && duplicarPreset === true) {
                    novoPreset.PresetModulos = presetModulos;
                    Preset.obterMeus().then(function (meus) {
                        $scope.presets = meus;
                        $scope.presets.push(novoPreset);
                    });
                }
                novoPreset.padrao = false;
                $scope.presets.push(novoPreset);
                $scope.alterarPreset(novoPreset);
            });
        }
        /**
         * @method renomearPreset
         */
        function renomearPreset() {
            var presetNomes = _.map($scope.presets, 'nome');
            $mdDialog.show({
                templateUrl: 'app/directives/preset/dialog.html',
                controller: function ($scope) {
                    $scope.res = $scope.$root.res;
                    $scope.preset = Preset.obter();
                    $scope.ok = function () {
                        if (_.indexOf(presetNomes, $scope.preset.nome) !== -1) {
                            $scope.erroNomeExistente = true;
                            return false;
                        }
                        $mdDialog.hide($scope.preset.nome);
                    };
                    $scope.cancelar = function () {
                        $mdDialog.cancel();
                    }
                },
                clickOutsideToClose: false,
                escapeToClose: false
            }).then(function (nome) {
                Preset.renomear(nome);
            });
        }
        /**
         *  @method excluirPreset
         * @param {*} e 
         * @param {*} preset 
         */
        function excluirPreset(e, preset) {
            PermissoesService.getPermissoes().then(function (perms) {
                $scope.permissoesVisualizacao = perms.permissoesVisualizacao;
                $scope.permissoesCriacao = perms.permissoesCriacao;
                $scope.permissoesEdicao = perms.permissoesEdicao;
                $scope.permissoesRemocao = perms.permissoesRemocao;
                $scope.permissoesExtras = perms.permissoesExtras;
                if (!$scope.permissoesRemocao.presetPublico) {
                    // Usuário não tem permissãoo para remover preset
                    $mdDialog
                        .show($mdDialog.alert()
                            .title($scope.res('COMUM_ERRO'))
                            .content($scope.res('PRESET_SEM_PERMISSAO_REMOVER'))
                            .ok($scope.res('COMUM_OK')));
                    return;
                }
            });
            var confirm = $mdDialog.confirm()
                .title($scope.res('MSG_DESEJA_EXCLUIR'))
                .ariaLabel($scope.res('MSG_EXCLUIR_PRESET'))
                .ok($scope.res('COMUM_SIM'))
                .cancel($scope.res('COMUM_NAO'));
            $mdDialog.show(confirm).then(function () {
                Preset.remover(preset).then(function () {
                    var presetIndex = $scope.presets.indexOf(preset);
                    $scope.presets.splice(presetIndex, 1);
                    //Alterar para o preset padrão ou o primeiro da lista, caso tenha excluído o preset atual
                    if (preset === Preset.obter()) {
                        Preset.alterar(_.find($scope.presets, 'padrao') || _.find($scope.presets, 'DepartamentoId'));
                    }
                    $mdDialog
                        .show($mdDialog.alert()
                            .title($scope.res('COMUM_EXCLUIDO'))
                            .content($scope.res('PRESET_EXCLUIDO_SUCESSO'))
                            .ok($scope.res('COMUM_OK')));
                }, function () {
                    $mdDialog
                        .show($mdDialog.alert()
                            .title($scope.res('COMUM_ERRO'))
                            .content($scope.res('MSG_ERRO_PRESET_EXCLUIR'))
                            .ok($scope.res('COMUM_OK')));
                });
            });
            e.stopPropagation();
        }
        /**
         * @method togglePresetPadrao
         * @param {*} preset 
         */
        function _togglePresetPadrao(preset) {
            preset.padrao = !preset.padrao;
            Preset.salvar(preset).then(angular.noop, function () {
                $mdDialog
                    .show($mdDialog.alert()
                        .title($scope.res('COMUM_ERRO'))
                        .content($scope.res('COMUM_MSG_ERRO_PRESET'))
                        .ok($scope.res('COMUM_OK')));
            });
        }
        var alteracaoEmAndamento = false;
        /**
         * @method togglePresetPadrao
         * @param {*} e 
         * @param {*} preset 
         */
        function togglePresetPadrao(e, preset) {
            var antigoPresetPadrao = _.find($scope.presets, 'padrao');
            if (antigoPresetPadrao && antigoPresetPadrao != preset) {
                alteracaoEmAndamento = true;
                antigoPresetPadrao.padrao = false;
                Preset.salvar(antigoPresetPadrao).then(function () {
                    _togglePresetPadrao(preset);
                    alteracaoEmAndamento = false;
                }, function () {
                    $mdDialog
                        .show($mdDialog.alert()
                            .title($scope.res('COMUM_ERRO'))
                            .content($scope.res('COMUM_MSG_ERRO_PRESET'))
                            .ok($scope.res('COMUM_OK')));
                })
            } else if (alteracaoEmAndamento == false){
                _togglePresetPadrao(preset);
            }
            e.stopPropagation();
        }
        /**
         * @method meusPresets
         */
        function meusPresets() {
            return _.reject($scope.presets, 'DepartamentoId');
        }
        /**
         * @method presetAgencia
         */
        function presetAgencia() {
            return _.find($scope.presets, 'DepartamentoId')
        }
        $scope.optionDropdownActive = false;
        $scope.abrirScroller = function () {
            var params = 'toolbar=no,location=no,status=no,menubar=no,scrollbars=false,resizable=false,width=' + screen.width + ',height=100';
            var windowRef = window.open('/#/scroller', 'Scroller', params);
            windowRef.aberto = true;
            windowRef.onclose = function () {
                windowRef.aberto = false;
            }
        };
        /**
         * @method updateMessage
         */
        function updateMessage() {
            var msg = getCookie();
            document.cookie = "cookie-msg-s4c=; path=/";
            if (msg && msg.indexOf(":") != -1) {
                var comando = msg.split(":")[0];
                var id = msg.split(":")[1];
                if (comando === "voarParaIncidente") {
                    DetalhamentoService.pegarIncidente(id)
                        .then(function (incidente) {
                            incidente.geojson = JSON.parse(incidente.geojson);
                            incidente.geometry = incidente.geojson;
                            incidente.filtro = $scope.res('TITULO_DASHBOARD');
                            MainState.getDirective('filtro-msi').addIncidente(incidente);
                        });
                }
            }
            $timeout(updateMessage, 500);
        }
        /**
         * @method getCookie
         */
        function getCookie() {
            var cname = "cookie-msg-s4c=";
            var ca = document.cookie.split(';');
            for (var i = 0; i < ca.length; i++) {
                var c = ca[i];
                while (c.charAt(0) == ' ') c = c.substring(1, c.length);
                if (c.indexOf(cname) == 0) {
                    return c.substring(cname.length, c.length);
                }
            }
            return null;
        }
        FileReaderService.readTextFile("/s4c_dir/dashboard.json", function (text) {
            var data = JSON.parse(text);
            $scope.url = data.url_dashboard;
        });
        /**
         * @method abrirDashboard
         */
        $scope.abrirDashboard = function () {
            var params = 'toolbar=no,location=no,status=no,menubar=no,scrollbars=false,resizable=false,width=1200,height=800';
            var win = window.open('', 'TPID', params);
            win.document.body.innerHTML = '<body style="margin:0px;padding:0px;overflow:hidden"><iframe src="' + $scope.url + '" sandbox="allow-same-origin allow-scripts allow-forms allow-modals"' +
                'scroll="no" frameborder="0" style="overflow:hidden;height:98%;width:100%"></iframe></body>';
            $timeout(updateMessage(), 500);
        };
        /**
         * @method abrirPop  
         */ 
        $scope.abrirPop = function () {
            $mdDialog.show({
                controller: popConsultaCtrl,
                templateUrl: 'app/components/pop/popConsulta.html',
                parent: document.body,
                locals: {
                    res: $scope.res
                }
            });
        }
        /**
         * @method popConsultaCtrl
         * @param {*} $scope 
         * @param {*} Base 
         */
        function popConsultaCtrl($scope, Base) {
            $scope.res = $scope.$root.res;
            $scope.tipoIncidenteSelecionado = null;
            $scope.popPerfis = {};
            Base.obter('tipo_incidentes/getByTipoIncidenteAndPerfilInPop').then(function (resultado_tipo) {
                ordenaArray(resultado_tipo);
                $scope.tipos = resultado_tipo;
                angular.forEach($scope.tipos, function (tipo) {
                    tipo.ativo = false;
                });
                $scope.tiposPesquisa = resultado_tipo;
            });
            /**
             * @method ordenaArray
             * @param {*} array 
             */
            function ordenaArray(array) {
                array = array.sort(function (a, b) {
                    return a.nome > b.nome ? 1 : a.nome < b.nome ? -1 : 0
                });
            }
            /**
             * @method selecionaTipoIncidente
             * @param {*} tipoIncidente 
             */
            function selecionaTipoIncidente(tipoIncidente) {
                if (tipoIncidente.ativo) {
                    return;
                }
                /**
                 * @method .map
                 * @param tipoIncidente
                 */
                $scope.tipos = _.map($scope.tipos, function (tipoIncidente) {
                    tipoIncidente.ativo = false;
                    return tipoIncidente;
                });
                tipoIncidente.ativo = true;
                $scope.tipoIncidenteSelecionado = tipoIncidente;
                getPopPerfisByUserAndTipoIncidente($scope.tipoIncidenteSelecionado);
            }
            /**
             * @method getPopPerfisByUserAndTipoIncidente
             * @param {*} tipoIncidente 
             */
            function getPopPerfisByUserAndTipoIncidente(tipoIncidente) {
                Base.obter('pop_perfis/getPopPerfisByUserAndTipoIncidente/' + tipoIncidente.id).then(function (resultado) {
                    $scope.popPerfis = resultado;
                    $scope.showResults = true;
                });
            }
            /**
             * @method executeSearchTipoIncidente
             * @param {*} textoTipoIncidente 
             */
            function executeSearchTipoIncidente(textoTipoIncidente) {
                $scope.tipos = [];
                var texto = textoTipoIncidente.toLowerCase();
                angular.forEach($scope.tiposPesquisa, function (tipoPesquisa) {
                    var nome = tipoPesquisa.nome.toLowerCase();
                    if (nome.indexOf(texto) !== -1) {
                        $scope.tipos.push(tipoPesquisa);
                    }
                });
            }
            /**
             * @method fechar
             */
            function fechar() {
                $mdDialog.hide();
            }
            angular.extend($scope, {
                selecionaTipoIncidente: selecionaTipoIncidente,
                executeSearchTipoIncidente: executeSearchTipoIncidente,
                fechar: fechar
            });
        }
        $scope.showingElements = {
            'documento_button': false,
            'briefing_button': false,
            'share_button': false,
            'preset_button': false
        };
        /**
         * @method toggleSelect 
         * @param elementId
         * @param id
         */
        $scope.toggleSelect = function (elementId, id) {
            if (elementId != 'documento_button') {
                $scope.showingElements['documento_button'] = false;
            }
            if (elementId == 'documento_button') {
                if (!id) {
                    $('.menu-adicionar').toggleClass(' open ');
                } else {
                    if (id !== 'dropdown-demo-menu') {
                        $('.menu-adicionar').removeClass(' open ');
                        $('#' + id).toggleClass(' open ');
                    } else {
                        if ($('#' + id).hasClass('open')) {
                            $('#' + id).removeClass(' open ');
                        } else {
                            $('#' + id).addClass(' open ');
                        }
                    }
                }
            }
            if (elementId != 'briefing_button') {
                $scope.showingElements['briefing_button'] = false;
            }
            if (elementId != 'share_button') {
                $scope.showingElements['share_button'] = false;
            }
            if (elementId != 'preset_button') {
                $scope.showingElements['preset_button'] = false;
            }
            $scope.showingElements[elementId] = !$scope.showingElements[elementId];
            if ($scope.showingElements[elementId]) {
                $window.onclick = function (event) {
                    event.stopPropagation();
                    var clickedElement = event.target;
                    if (!clickedElement) {
                        return;
                    }
                };
            } else {
                $window.onclick = null;
            }
        }
        /**
         * @method showAlarmes
         */
        function showAlarmes() {
            ZonasDeObservacaoFilter.getInstance('zonas-de-observacao-filter').trigger('alarmesConfigurados');
            TarefaManager.closePush();
        }
        AuthService.user.info.showFilters = false;
        AuthService.user.info.filterNames = "";
        AuthService.user.info.areaInterna = true;
        /**
         * @method openAreaDialog
         */
        function openAreaDialog() {
            $mdDialog.show({
                templateUrl: 'app/directives/area-atuacao/trocar_area_atuacao.html',
                controller: function ($scope, Modulo, AuthService) {
                    $scope.areaInterna = AuthService.user.info.areaInterna;
                    document.body.style.overflow = 'hidden';
                    $scope.res = $scope.$root.res;
                    if (AuthService.user.info.permissoesAreaAtuacao) {
                        $scope.permissoesArea = AuthService.user.info.permissoesAreaAtuacao;
                    } else {
                        $scope.permissoesArea = permissoesAreaAtuacao;
                        AuthService.user.info.permissoesAreaAtuacao = permissoesAreaAtuacao;
                    }
                    $scope.permissoesArea = $scope.permissoesArea.sort(function (perm1, perm2) {
                        return perm1.nomeArea > perm2.nomeArea ? 1 : perm1.nomeArea < perm2.nomeArea ? -1 : 0
                    });
                    /**
                     * @method each
                     * @param permissao
                     */
                    _.each($scope.permissoesArea, function (permissao) {
                        if (!permissao.regiaoArray) {
                            return;
                        }
                        permissao.regiaoArray = permissao.regiaoArray.sort(function (regiao1, regiao2) {
                            return regiao1.nomeRegiao > regiao2.nomeRegiao ? 1 : regiao1.nomeRegiao < regiao2.nomeRegiao ? -1 : 0
                        });
                    });
                    $scope.ok = function () {
                        var filtro = { regioes: $scope.permissoesArea, areaInterna: $scope.areaInterna };
                        //Altera o filtro deste usuário no servidor
                        Base.salvar('area_atuacao/filtrar', filtro).then(function () {
                            reloadFrontendInfo();
                        });
                        AuthService.user.info.filterNames = "";
                        for (var index in $scope.permissoesArea) {
                            for (var index2 in $scope.permissoesArea[index].regiaoArray) {
                                if ($scope.permissoesArea[index].regiaoArray[index2].check) {
                                    AuthService.user.info.showFilters = true;
                                    AuthService.user.info.filterNames += $scope.permissoesArea[index].regiaoArray[index2].nomeRegiao + ' - ';
                                }
                            }
                        }
                        AuthService.user.info.filterNames = AuthService.user.info.filterNames.substring(0, AuthService.user.info.filterNames.length - 3);
                        if (AuthService.user.info.filterNames.length > 80) {
                            AuthService.user.info.filterNames = AuthService.user.info.filterNames.substring(0, 80);
                            AuthService.user.info.filterNames += ' ...';
                        }
                        AuthService.user.info.areaInterna = $scope.areaInterna;
                        $mdDialog.hide();
                        document.body.style.overflow = 'auto';
                    };
                    /**
                     * @method cancelar
                     */
                    $scope.cancelar = function () {
                        $mdDialog.cancel();
                        document.body.style.overflow = 'auto';
                    }
                    /**
                     * @method selectAllChild
                     * @param permissao
                     */
                    $scope.selectAllChild = function (permissao) {
                        _.each(permissao.regiaoArray, function (regiao) {
                            if (!permissao.check) {
                                regiao.check = true;
                            } else {
                                regiao.check = false;
                            }
                        });
                    }
                    /**
                     * @method unselectParent
                     * @param regiao
                     * @param permissao
                     */
                    $scope.unselectParent = function (regiao, permissao) {
                        if (regiao.check) {
                            permissao.check = false;
                        }
                    }
                }
            }).then(function () {
            });
        }
        /**
         * @method removeFilters
         */
        function removeFilters() {
            for (var index in AuthService.user.info.permissoesAreaAtuacao) {
                for (var index2 in AuthService.user.info.permissoesAreaAtuacao[index].regiaoArray) {
                    AuthService.user.info.permissoesAreaAtuacao[index].check = false;
                    AuthService.user.info.permissoesAreaAtuacao[index].regiaoArray[index2].check = false;
                }
            }
            var filtro = { regioes: AuthService.user.info.permissoesAreaAtuacao, areaInterna: false };
            //Altera o filtro deste usuário no servidor
            Base.salvar('area_atuacao/filtrar', filtro).then(function () {
                reloadFrontendInfo();
                AuthService.user.info.showFilters = false;
            });
        }
        /**
         * @method reloadFrontendInfo
         */
        function reloadFrontendInfo() {
            Modulo.reInitModules();
            CamadasService.reloadNodes();
            RotasUnificadasManager.reloadRotas();
            if (MainState.getDirective('filtro-msi') && !MainState.getDirective('filtro-msi').msiFechado()) {
                MsiFilter.getInstance('filtro-msi').trigger('filterChanged', 'origem');
            }
            if (MainState.getDirective('moduloPoi')) {
                MainState.getDirective('moduloPoi').reloadPois();
            }
        }
        //Atualizar o relógio
        $interval(function () {
            $scope.horario = moment().format('HH:mm');
        }, 60000);
        function showAdminDiv() {
            closeModals();
            VideoStreamService.closeAll();
            DetalhamentoManager.fecharTodos();
            $state.go('admin.main');
            Preset.rollBackEmptyModules();
            releaseResources();
        }
        /**
         * @method hasPermission
         */
        $scope.hasPermission = function () {
            if (!AuthService.user.info) {
                return;
            }
            return AuthService.user.info.superuser || _isLdapAdmin(AuthService.user.info.ldapPerfis);
        }
        /**
         * @method _isLdapAdmin
         * @param {*} ldapPerfis 
         */
        function _isLdapAdmin(ldapPerfis) {
            var isAdmin = false;
            if (ldapPerfis != null && ldapPerfis.length > 0) {
                var i = 0;
                for (; i < ldapPerfis.length; i++) {
                    if (ldapPerfis[i].contains("ADMIN")) {
                        isAdmin = true;
                    }
                }
            }
            return isAdmin;
        }
        /**
         * @method franquias
         */
        $scope.franquias = function () {
            getCookie();
            FileReaderService.readTextFile("/s4c_dir/url_s4s.json", function (text) {
                var data = JSON.parse(text);
                $window.location.href = data.url_s4s;
            });
        }
        $scope.isElectron = navigator.userAgent.indexOf("Electron") != -1
        /**
         * @method reboot
         */
        $scope.reboot = function () {
            MainState.reboot(true, logout);
        }
        /**
         * @method updateCockpit 
         */
        $scope.updateCockpit = function () {
            MainState.reboot();
        }
        /**
         * @method shutdown 
         */
        $scope.shutdown = function () {
            MainState.shutdown(true, logout);
        }
        /**
         * @method multivisManager 
         */    
        $scope.multivisManager = function () {
            getCookie();
            FileReaderService.readTextFile("/s4c_dir/url_s4s.json", function (text) {
                var data = JSON.parse(text);
                $window.location.href = data.url_multivismanager;
            });
        }
        /**
         * @method getCookie
         */
        function getCookie() {
            try {
                var tokenObj = JSON.parse($window.sessionStorage.getItem('s4cToken'));
                document.cookie = "token=" + tokenObj.access_token;
            } catch (erro) {
                document.cookie = "token=" + $window.sessionStorage.getItem('s4cToken');
            }
        }
        angular.extend($scope, {
            $directives: {},
            presetConfig: Preset.config,
            buscaAtiva: false,
            seletorAtivo: false,
            buscaResults: [],
            textoBusca: '',
            criandoPreset: false,
            detalhamentoAtivo: false,
            usuario: UserInfo,
            presets: UserPresets,
            AuthService: AuthService,
            showAdminDiv: showAdminDiv,
            modais: {
                baseConhecimento: false,
                detalhamento: false,
                editorRotas: false,
                scroller: false,
                planejamento: false,
                tarefa: false,
                twitter: false
            },
            menu: {
                isOpen: false
            },
            //Managers:
            MsiDetalhamentoManager: MsiService,
            // Métodos:
            renomearPreset: renomearPreset,
            novoPreset: novoPreset,
            alterarPreset: alterarPreset,
            logout: logout,
            excluirPreset: excluirPreset,
            togglePresetPadrao: togglePresetPadrao,
            meusPresets: meusPresets,
            presetAgencia: presetAgencia,
            showAlarmes: showAlarmes,
            novoUsuario: novoUsuario,
            saveMapPosition: saveMapPosition,
            openAreaDialog: openAreaDialog,
            removeFilters: removeFilters,
            noError: $scope.noError,
            errorMessage: $scope.errorMessage,
            version: $scope.version
        });
        // Registrando managers no scope
        $scope.DetalhamentoManager = DetalhamentoManager;
        $scope.ModuloTwitterManager = ModuloTwitterManager;
        $scope.CamerasManager = CamerasManager;
        $scope.BuscaManager = BuscaManager;
        $scope.MensageriaManager = MensageriaManager;
        $scope.AvisoOperacionalManager = AvisoOperacionalManager;
        $scope.RotasManager = RotasManager;
        $scope.RotasUnificadasManager = RotasUnificadasManager;
        $scope.BriefingOperacionalManager = BriefingOperacionalManager;
        $scope.MapaManager = MapaManager;
        $scope.IncidentesManager = IncidentesManager;
        $scope.BaseConhecimentoManager = BaseConhecimentoManager;
        $scope.TwitterManager = TwitterManager;
        $scope.MSIManager = MSIManager;
        $scope.SubDetalhamentoManager = SubDetalhamentoManager;
        $scope.ZonaDeObservacaoManager = ZonaDeObservacaoManager;
        $scope.PlanejamentoManager = PlanejamentoManager;
        $scope.DeteccaoImpactoManager = DeteccaoImpactoManager;
        $scope.MinhasTarefasManager = MinhasTarefasManager;
        $scope.VoipManager = VoipManager;
        $scope.TarefaManager = TarefaManager;
        $scope.FacebookManager = FacebookManager;
        $scope.EmailManager = EmailManager;
        $scope.IncidenteEnterManager = IncidenteEnterManager;
        $scope.AlarmeDisparadoManager = AlarmeDisparadoManager;
        $scope.EditPTarefaManager = EditPTarefaManager;
        $scope.TerminalManager = TerminalManager;
        $scope.BuscaUsuariosTelegramManager = BuscaUsuariosTelegramManager;
        $scope.DetalhamentoRotasOlimpicasManager = DetalhamentoRotasOlimpicasManager;
        $scope.HabilitarCamadasManager = HabilitarCamadasManager;
        $scope.AreaAtuacaoManager = AreaAtuacaoManager;
        $scope.RastreamentoManager = RastreamentoManager;
        $scope.PontoMovelManager = PontoMovelManager;
        $scope.PoiManager = PoiManager;
        /*
         * Registrando managers no Service
         */
        var managersList = [
            'MainManager',
            'ModuloTwitterManager',
            'CamerasManager',
            'BuscaManager',
            'MensageriaManager',
            'TelegramManager',
            'RotasManager',
            'RotasUnificadasManager',
            'IncidentesManager',
            'BaseConhecimentoManager',
            'FacebookManager',
            'EmailManager',
            'TwitterManager',
            'MSIManager',
            'SubDetalhamentoManager',
            'DetalhamentoManager',
            'ZonaDeObservacaoManager',
            'PlanejamentoManager',
            'DeteccaoImpactoManager',
            'MinhasTarefasManager',
            'TarefaManager',
            'BriefingOperacionalManager',
            'MapaManager',
            'BotoesManager',
            'IncidenteEnterManager',
            'AlarmeDisparadoManager',
            'EditPTarefaManager',
            'TerminalManager',
            'BuscaUsuariosTelegramManager',
            'DetalhamentoRotasOlimpicasManager',
            'HabilitarCamadasManager',
            'AreaAtuacaoManager',
            'RastreamentoManager',
            'PontoMovelManager',
            'PoiManager',
            'VoipManager'
        ];
        var managers = [];
        /**
         * @method forEach
         * @param manager
         */
        managersList.forEach(function (manager) {
            if ($scope.hasOwnProperty(manager)) {
                MainState.registerManager(manager, $scope[manager]);
                managers.push($scope[manager]);
            }
        });
        DetalhamentoManager.setManagers(managers);
        MainState.registerManager('UserInfo', UserInfo);
        /*
         * Removendo managers do Service:
         */
        $scope.$on('$destroy', function () {
            managersList.forEach(function (manager) {
                MainState.unregisterManager(manager);
            });
        });
    }
}());