Source: directives/area-atuacao/area_atuacao.js

/**
 * @ngdoc directives
 * @name area_Atuacao
 * @module s4c.directives.area_Atuacao
 *
 * @description
 * `areaAtuacaoCtrl` Responsável por exibir as funções da Area de Atuação na tela, bem como o seu funcionamento.
 * 
 * @example
 *   <s4c-area-atuacao>
 *   </s4c-area-atuacao> 
 */
(function () {
    'use strict';
    areaAtuacaoCtrl.$inject = [
        '$scope',
        '$q',
        'DetalhamentoService',
        'ZonaObservacaoService',
        'RegiaoService',
        '$state',
        'AuthService',
        'ParametrosS4C',
        '$mdDialog',
        'CommService',
        'MainState',
        'IncidentesService',
        'MapaService',
        'BotoesManager',
        'DetalhamentoManager',
        'ZonaDeObservacaoManager',
        'IncidentesManager',
        'FileUploader',
        'RotasManager',
        '$http',
        'PermissoesService',
        'LegendaIncidenteFilter',
        'CamadasService',
        'toasty',
        'BlackList',
        'Validate',
        'localize',
        'API_ENDPOINT',
        'AreaAtuacaoManager'
    ];
    function areaAtuacaoCtrl($scope,
        $q,
        DetalhamentoService,
        ZonaObservacaoService,
        RegiaoService,
        $state,
        AuthService,
        ParametrosS4C,
        $mdDialog,
        CommService,
        MainState,
        IncidentesService,
        MapaService,
        BotoesManager,
        DetalhamentoManager,
        ZonaDeObservacaoManager,
        IncidentesManager,
        FileUploader,
        RotasManager,
        $http,
        PermissoesService,
        LegendaIncidenteFilter,
        CamadasService,
        toasty,
        BlackList,
        Validate,
        localize,
        API_ENDPOINT,
        AreaAtuacaoManager) {
        var usuarios = [];
        $scope.hasError = Validate.hasError;
        $scope.my_id = AuthService.user.info.id;
        $scope.areaAtuacao = {};
        $scope.censoHidden = true;
        $scope.poiHidden = true;
        $scope.cameraHidden = true;
        $scope.subItens = new L.LayerGroup([]);
        $scope.layerAnterior = null;
        $scope.poisProximos = [];
        $scope.camerasProximas = [];
        $scope.categoriasPoi = [];
        $scope.categoriasCamera = [];
        $scope.dados = {};
       /**
        * Obtem a lista de Permissões
        *
        * @method getPermissoes
		*        
        *
        */   
        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;
        });
        $scope.$botoes = BotoesManager;
        $scope.openShare = false;
       /**
        * Busca uma região pelo id
        *
        * @method buscarRegiao
        * @param id {Integer} Identificação da região
		*        
        *
        */ 
        function buscarRegiao(id) {
            RegiaoService
                .pegarRegiao(id)
                .then(function (regiao) {
                    $scope.data = regiao;
                    removerLayers(regiao.idArea);
                    CamadasService.ativarMenuDaAreaAtuacao(regiao.idArea, regiao.id);
                });
        }
       /**
        * Carrega a camada da area de atuação
        *
        * @method carregarLayerAreaAtuacao
        * @param regiao {Object} Região com os seus atributos
        * @param node {Object} Camada do menu
		*        
        *
        */ 
        function carregarLayerAreaAtuacao(regiao, node) {
            node.disabled = true;
            $http.get(API_ENDPOINT + "area_atuacao/" + regiao.idArea)
                .then(function (result) {
                    node.disabled = false;
                    $scope.areaAtuacao = result.data;
                    if (verificaExistenciaLayer($scope.areaAtuacao.id)) {
                        if (regiao.remover) {
                            removerLayers($scope.areaAtuacao.id);
                        }
                    }
                    else {
                        MapaService.desenharRegioes(result.data, regiao.id, abrirJanela).then(function (arrayLayers) {
                            _.each(arrayLayers, function (layer) {
                                $scope.subItens.addLayer(layer);
                                if (layer.idRegiao == regiao.id) {
                                    $scope.layerAnterior = layer;
                                }
                            });
                        });
                    }
                });
        }
       /**
        * Abre uma região em uma camada do mapa já existente
        *
        * @method abrirJanela
        *
        * @param idRegiao {Object} Identificador da Região
        * @param layer {Object} Camada do menu
		*        
        *
        */ 
        function abrirJanela(idRegiao, layer) {
            AreaAtuacaoManager.ativo = true;
            $scope.data = {};
            //Verifica se já existe um layer ativo, caso exista desativa
            fechar();
            RegiaoService
                .pegarRegiao(idRegiao)
                .then(function (regiao) {
                    $scope.data = regiao;
                    layer.setStyle({
                        fillOpacity: 0.8
                    });
                    $scope.layerAnterior = layer;
                });
        }
       /**
        * Desativa uma camada
        *
        * @method desativarLayer
        *
        *
        */ 
        function desativarLayer() {
            if ($scope.layerAnterior != null) {
                if ($scope.layerAnterior.setStyle) {
                    $scope.layerAnterior.setStyle({
                        fillOpacity: 0.4
                    });
                }
            }
        }
       /**
        * Verifica se uma Area já está em alguma camada carregada
        *
        * @method verificaExistenciaLayer
        *
        * @param idArea {Object} Identificador da Area
        * 
        *
        */ 
        function verificaExistenciaLayer(idArea) {
            var existe = false;
            _.each($scope.subItens.getLayers(), function (layer) {
                _.each(layer, function (region) {
                    if (region.idArea == idArea) {
                        existe = true;
                    }
                });
            });
            return existe;
        }
       /**
        * Remove a Area de uma determinada camada
        *
        * @method removerLayers
        *
        * @param idArea {Object} Identificador da Area
        * 
        *
        */ 
        function removerLayers(idArea) {
            var layersToRemove = [];
            _.each($scope.subItens.getLayers(), function (layer) {
                _.each(layer, function (region) {
                    if (region != undefined && region.idArea == idArea) {
                        layersToRemove.push(region);
                        $scope.subItens.removeLayer(layer);
                    }
                });
            });
            MapaService.removerLayers(layersToRemove);
            fechar();
        }
       /**
        * Remove todos os itens referente a Area de Atuação do mapa
        *
        * @method fechar
        *
        *
        */ 
        function fechar() {
            $scope.censoHidden = true;
            $scope.poiHidden = true;
            $scope.cameraHidden = true;
            $scope.poisProximos = [];
            $scope.camerasProximas = [];
            desativarLayer();
        }
       /**
        * Obtem dados refetente ao censo populacional
        *
        * @method pegarCenso
        *
        *
        */ 
        function pegarCenso() {
            $scope.ZO = {
                censo: {
                    populacao: 0,
                    criancas: 0,
                    domicilios: 0,
                    idosos: 0
                },
                multidao: {
                    erro: false
                }
            };
            if ($scope.censoHidden) {
                var geometry = JSON.parse($scope.data.poiGeometricoBuffer);
                ZonaObservacaoService
                    .pegarCenso(geometry)
                    .then(function (data) {
                        $scope.ZO.censo = {
                            populacao: data.populacao,
                            criancas: data.criancas,
                            domicilios: data.domicilios,
                            idosos: data.idosos
                        };
                    });
            }
            $scope.censoHidden = !$scope.censoHidden;
        }
       /**
        * Obtem as cameras que estão proximas a uma determinada região
        *
        * @method pegarCameras
        *
        *
        */ 
        function pegarCameras() {
            if ($scope.cameraHidden) {
                $scope.categoriasCamera = [];
                $http.post(API_ENDPOINT + 'cameras/geojson', $scope.data.poiGeometricoBuffer)
                    .then(function (res) {
                        $scope.camerasProximas = res.data;
                        MapaService.removerLinhas();
                        $scope.camerasProximas = _.map($scope.camerasProximas, function (camera) {
                            var existeCategoria = false;
                            _.each($scope.categoriasCamera, function (categoriaCamera) {
                                if (categoriaCamera == camera.categoriaNome) {
                                    existeCategoria = true;
                                }
                            });
                            if (!existeCategoria) {
                                $scope.categoriasCamera.push(camera.categoriaNome);
                                $scope.dados[camera.categoriaNome + '_hidden'] = true;
                                $scope.dados[camera.categoriaNome + '_camerasProximas'] = [];
                            }
                            $scope.dados[camera.categoriaNome + '_camerasProximas'].push(camera);
                            return camera;
                        });
                        if ($scope.camerasProximas.length > 0) {
                            _.chain($scope.camerasProximas)
                                .map('CategoriaCameraId')
                                .uniq()
                                .each(function (categoriaCameraId) {
                                    CamadasService.ativarMenuCategoriaCamera(categoriaCameraId);
                                })
                                .value();
                        }
                    }, function (err) {
                        $mdDialog
                            .show($mdDialog.alert()
                                .title($scope.res('COMUM_ERRO'))
                                .content(err.data.message)
                                .ok($scope.res('COMUM_OK')));
                    });
            }
            $scope.cameraHidden = !$scope.cameraHidden;
        }
       /**
        * Obtem os pois que estão proximas a uma determinada região
        *
        * @method pegarPOIs
        *
        *
        */ 
        function pegarPOIs() {
            if ($scope.poiHidden) {
                $scope.categoriasPoi = [];
                $http.post(API_ENDPOINT + 'datamining/geojson', $scope.data.poiGeometricoBuffer)
                    .then(function (res) {
                        $scope.poisProximos = res.data;
                        $scope.poisProximos = _.map($scope.poisProximos, function (poi) {
                            poi.tipo = 'poi';
                            var existeCategoria = false;
                            _.each($scope.categoriasPoi, function (categoriaPoi) {
                                if (categoriaPoi == poi.categoriaNome) {
                                    existeCategoria = true;
                                }
                            });
                            if (!existeCategoria) {
                                $scope.categoriasPoi.push(poi.categoriaNome);
                                $scope.dados[poi.categoriaNome + '_hidden'] = true;
                                $scope.dados[poi.categoriaNome + '_poisProximos'] = [];
                            }
                            $scope.dados[poi.categoriaNome + '_poisProximos'].push(poi);
                            return poi;
                        });
                    }, function (err) {
                        $mdDialog
                            .show($mdDialog.alert()
                                .title($scope.res('COMUM_ERRO'))
                                .content(err.data.message)
                                .ok($scope.res('COMUM_OK')));
                    });
            }
            $scope.poiHidden = !$scope.poiHidden;
        }
       /**
        * Exibe a categoria
        *
        * @method exibirCategoria
        * @param categoria {String} codigo da categoria
        *
        */ 
        function exibirCategoria(categoria) {
            $scope.dados[categoria + '_hidden'] = !$scope.dados[categoria + '_hidden'];
        }
       /**
        * Voa para um item do mapa
        *
        * @method voarParaSubItem
        * @param obj {Object} Objetos com as informações de lat e Lng
        *
        */ 
        function voarParaSubItem(obj) {
            AreaAtuacaoManager.voarParaSubItem($scope.data, obj);
        }
       /**
        * Ativa uma camada do mapa
        *
        * @method ativarLayer
        * @param idRegiao {Integer} Identificador da Região
        *
        */ 
        function ativarLayer(idRegiao) {
            _.each($scope.subItens.getLayers(), function (layer) {
                if (layer != undefined && layer.idRegiao == idRegiao) {
                    layer.setStyle({
                        fillOpacity: 0.8
                    });
                }
            });
        }
       /**
        * Carrega regiões da area de atuação na camada do mapa
        *
        * @method carregarLayerAreaAtuacaoNaoPermitida
        * @param regioes {Object} Regiões
        *
        */ 
        function carregarLayerAreaAtuacaoNaoPermitida(regioes) {
            var areasCarregadas = [];
            //Remove os layers existentes para carregar novamente
            _.each(regioes, function (regiao) {
                if (verificaExistenciaLayer(regiao.idArea)) {
                    removerLayers(regiao.idArea);
                }
            });
            _.each(regioes, function (regiao) {
                if (!verificaAreaCarregada(areasCarregadas, regiao.idArea)) {
                    CamadasService.ativarMenuDaAreaAtuacao(regiao.idArea, regiao.id);
                    areasCarregadas.push(regiao.idArea);
                }
                else {
                    setTimeout(function () { ativarLayer(regiao.id); }, 1000);
                }
            });
        }
       /**
        * Verifica as areas carregadas no mapa
        *
        * @method verificaAreaCarregada
        * @param areasCarregadas {Object} Identificadores das areas carregadas
        * @param idArea {Integer} Id da Area de Atuação
        *
        */
        function verificaAreaCarregada(areasCarregadas, idArea) {
            var idAreaCarregada;
            for (var i = 0; i < areasCarregadas.length; i++) {
                idAreaCarregada = areasCarregadas[i];
                if (idArea == idAreaCarregada) {
                    return true;
                }
            }
            return false;
        }
        angular.extend($scope, {
            data: {},
            pegarCenso: pegarCenso,
            pegarCameras: pegarCameras,
            pegarPOIs: pegarPOIs,
            voarParaSubItem: voarParaSubItem,
            exibirCategoria: exibirCategoria,
            $apiAreaAtuacao: {
                buscarRegiao: buscarRegiao,
                carregarLayerAreaAtuacao: carregarLayerAreaAtuacao,
                removerLayers: removerLayers,
                fechar: fechar,
                desativarLayer: desativarLayer,
                carregarLayerAreaAtuacaoNaoPermitida: carregarLayerAreaAtuacaoNaoPermitida
            }
        });
        MainState.registerDirective('areaAtuacao', $scope.$apiAreaAtuacao);
        $scope.$on('$destroy', function () {
            MainState.unregisterDirective('areaAtuacao');
        });
    }
    function s4cAreaAtuacao() {
        return {
            restrict: 'E',
            replace: true,
            scope: {},
            templateUrl: 'app/directives/area-atuacao/area_atuacao.html',
            controller: areaAtuacaoCtrl,
            link: function ($scope, $elem) {
                $scope.res = $scope.$root.res;
            }
        };
    }
    /**
	 * @ngdoc overview
	 * @name s4c.components.areaAtuacao
	 */
    angular.module('s4c.components.areaAtuacao', ['angularMoment'])
        .directive('s4cAreaAtuacao', s4cAreaAtuacao);
}());