Source: directives/incidenteFilter/incidenteFilter.js

/**
 * @ngdoc directives
 * @name incidentesFilter
 * @module s4c.directives.IncidenteFilter.incidentesFilter
 *
 * @description Controller do filtro de Incidentes
 *
 *
 */
(function () {
    'use strict';

    angular.module('s4c.components.incidentes')
        .directive('incidenteFilter', IncidenteFilter)
        .filter('join', function () {
            return function (array, property) {
                var filtered = _.chain(array)
                    .filter('ativo')
                    .map(property)
                    .value();

                if (filtered.length <= 0) {
                    return '-';
                }

                return filtered.join(', ');
            }
        });

    IncidenteFilter.$inject = [
        'IncidenteFilter',
        'Base',
        'GrupoUsuarios',
        'localize',
        'IncidentesService',
        'MsiService',
        'MainState'
    ];

    function IncidenteFilter(IncidenteFilter, Base, GrupoUsuarios, localize, IncidentesService, MsiService, MainState) {
        return {
            restrict: 'E',
            templateUrl: 'app/directives/incidenteFilter/incidenteFilter.html',
            replace: true,
            scope: {},
            link: function ($scope, $elem, $attrs) {

                angular.extend($scope, {
                    categorias: [],
                    prioridades: [],
                    tipoIncidentes: [],
                    statuses: [],
                    criticidades: [],
                    gravidades: [],
                    exibirModuloAgencia: true,
                    exibirModuloTipoIncidente: true,
                    exibirModuloStatus: true,
                    exibirModuloGravidades: true,
                    exibirRange: true,
                    applyFilter: applyFilter,
                    exibirAgencias: exibirAgencias,
                    exibirDateRange: exibirDateRange,
                    exibirGravidades: exibirGravidades,
                    exibirStatus: exibirStatus,
                    exibirTipoIncidente: exibirTipoIncidente,
                    marcarTodasPrioridades: marcarTodasPrioridades,
                    desmarcarTodasPrioridades: desmarcarTodasPrioridades,
                    definirOrigem: definirOrigem,
                    preSelectCategorias: preSelectCategorias,
                    res: $scope.$root.res
                });

                var instance = IncidenteFilter.getInstance($attrs.id);

                instance.dataRange = _timeSet();
                $scope.dataRange = {
                    start: moment(instance.dataRange.start).format('D/MM/YYYY HH:mm'),
                    end: moment(instance.dataRange.end).format('D/MM/YYYY HH:mm')
                };

	        	/**
		         * Formata a data de inicio e fim. Para que as datas sejam sempre de as 00:00 de ontem até as 23:59 de hoje
		         * 
		         * @method _timeSet
		         *
		         *
		         */  
                function _timeSet() {
                    return {
                        //start: moment().startOf('day').format(), Changed to 30 days later just for Olympic games
                        start: moment().subtract(1, 'day').startOf('day').format(),
                        end: moment().endOf('day').format()
                    }
                };

                $scope.statuses = instance.statuses;

                $scope.isToShow = function (label) {
                    return MainState.isToShow(label);
                }

		        /**
		         * Busca as Categorias de Incidente e filtra pelas categorias recebidas no método preSelectCategorias(categorias)
		         * 
		         * @method getCategorias
		         *
		         *
		         */  
                MsiService.getCategorias().then(function (categorias) {
                    var categorias = preSelectCategorias(categorias);

                    instance.categorias = categorias;
                    $scope.categorias = instance.categorias;
                });

		        /**
		         * Realiza o filtro somente com as categorias recebidas
		         * 
		         * @method preSelectCategorias
		         *
		         * @param categorias {Object} 
		         *
		         */  
                function preSelectCategorias(categorias) {
                    var categoriasSelected = categorias.filter(function (categoria) {
                        categoria.ativo = true;

                        return categoria;
                    });

                    return categoriasSelected;
                }

		        /**
		         * Carrega a lista de gravidades de incidentes
		         * 
		         * @method getIncidenteGravidades
		         *
		         *
		         */   
                IncidentesService.getIncidenteGravidades().then(function (gravidades) {
                    instance.gravidades = gravidades;
                    $scope.gravidades = instance.gravidades;
                });

		        /**
		         * Carrega a lista de tipo de incidentes
		         * 
		         * @method getIncidenteTipos
		         *
		         *
		         */   
                IncidentesService.getIncidenteTipos().then(function (tipoIncidentes) {
                    instance.tipoIncidentes = tipoIncidentes;
                    $scope.tipoIncidentes = instance.tipoIncidentes;
                });

		        /**
		         * Carrega a lista de grupo de usuários
		         * 
		         * @method GrupoUsuarios.query
		         *
		         *
		         */   
                GrupoUsuarios.query().$promise.then(function (gruposUsuarios) {
                    $scope.gruposUsuarios = gruposUsuarios;
                    instance.gruposUsuarios = gruposUsuarios;
                });


                for (var i = 0; i < 9; i++) {
                    instance.prioridades.push({
                        texto: i,
                        ativo: false
                    });
                    $scope.prioridades = instance.prioridades;
                }

                for (var i = 0; i < 4; i++) {
                    $scope.prioridades[i].ativo = true;
                }

                $scope.$watch('prioridades', function () {
                    $scope.exibeMarcarTodos = _.some($scope.prioridades, 'ativo', false);
                }, true);

                $scope.$watch('gruposUsuarios', function () {
                    definirOrigem();
                }, true);

		        /**
		         * Define a origem da requisição de filtro
		         * 
		         * @method definirOrigem
		         *
		         *
		         */   
                function definirOrigem() {
                    instance.origem = 'filtro';
                };

		        /**
		         * Exibe a lista de gravidades 
		         * 
		         * @method exibirGravidades
		         *
		         *
		         */  
                function exibirGravidades() {
                    $scope.exibirModuloGravidades = !$scope.exibirModuloGravidades;
                }

		        /**
		         * Exibe a lista de status 
		         * 
		         * @method exibirStatus
		         *
		         *
		         */  
                function exibirStatus() {
                    $scope.exibirModuloStatus = !$scope.exibirModuloStatus;
                }

		        /**
		         * Exibe a lista de tipos de incidentes 
		         * 
		         * @method exibirTipoIncidente
		         *
		         *
		         */  
                function exibirTipoIncidente() {
                    $scope.exibirModuloTipoIncidente = !$scope.exibirModuloTipoIncidente;
                }

		        /**
		         * Exibe o range de data
		         * 
		         * @method exibirDateRange
		         *
		         *
		         */  
                function exibirDateRange() {
                    $scope.exibirRange = !$scope.exibirRange;
                }

		        /**
		         * Exibe a lista de Agências
		         * 
		         * @method exibirAgencias
		         *
		         *
		         */  
                function exibirAgencias() {
                    $scope.exibirModuloAgencia = !$scope.exibirModuloAgencia;
                }

		        /**
		         * Configura o formato da data
		         * 
		         * @method _setTimeWindow
		         *
		         *
		         */  
                function _setTimeWindow() {
                    var start = moment($scope.dataRange.start, 'D/MM/YYYY HH:mm').format();
                    var end = ($scope.dataRange.end) ?
                        moment($scope.dataRange.end, 'D/MM/YYYY HH:mm').format() :
                        moment().endOf('day').format();

                    instance.dataRange = {
                        start: start,
                        end: end
                    };
                }

		        /**
		         * Faz a validação da data
		         * 
		         * @method _validateTimeWindow
		         * @param range {Object} Objeto com as datas de inicio e fim
		         *
		         */  
                function _validateTimeWindow(range) {
                    var start = moment(range.start),
                        end = moment(range.end);

                    return (start.isSame(end) || start.isBefore(end));
                }

	        	/**
		         * Aplica o filtro
		         * 
		         * @method applyFilter
		         * @param toggle {Object} 
		         *
		         */ 
                function applyFilter(toggle) {
                    definirOrigem();
                    _setTimeWindow();
                    $scope.validRange = _validateTimeWindow(instance.dataRange);

                    if (!$scope.validRange) return;
                    instance.trigger('filterChanged', instance.origem);
                    IncidenteFilter.getInstance('filtro-incidentes').trigger('countByStatus', instance.origem);
                    if (!toggle) {
                        $scope.$parent.toogleFilter();
                    }
                }
                applyFilter(true);

	        	/**
		         * Marca todas as proridades
		         * 
		         * @method marcarTodasPrioridades
		         * 
		         *
		         */ 
                function marcarTodasPrioridades() {
                    _.each($scope.prioridades, function (prioridade) {
                        prioridade.ativo = true;
                    });
                }

	        	/**
		         * Desmarca todas as proridades
		         * 
		         * @method desmarcarTodasPrioridades
		         * 
		         *
		         */ 
                function desmarcarTodasPrioridades() {
                    _.each($scope.prioridades, function (prioridade) {
                        prioridade.ativo = false;
                    });
                }

                /*
                 * Paginação
                 * limit: Limite de incidentes por consulta
                 * begin: Offset da consulta. Ex: Iniciar a partir do item 7.
                 * end: End of pagination
                */
                instance.pagination = {
                    limit: 5000,
                    offset: 0,
                    end: false,
                    nextPage: function () {
                        this.offset += this.limit;
                        return this.begin;
                    },
                    reset: function () {
                        this.offset = 0;
                        this.end = false;
                    },
                    showMore: function () {
                        this.nextPage();
                        instance.trigger('filterChanged', instance.origem);
                    }
                };

            }
        }
    }
}());