Exemplo n.º 1
0
        public void Remover(IEnumerable <long> idsRemover)
        {
            var idFalhaExclusao = new List <long>();

            using (var transacao = unitOfWork.IniciarTransacao())
            {
                foreach (var codigo in idsRemover)
                {
                    try
                    {
                        var entidade = repositorioEventoTipo.ObterPorId(codigo);

                        entidade.Excluido = true;

                        repositorioEventoTipo.Salvar(entidade);
                    }
                    catch (Exception)
                    {
                        idFalhaExclusao.Add(codigo);
                    }
                }

                unitOfWork.PersistirTransacao();
            }

            if (idFalhaExclusao.Any())
            {
                var erroMensagem = idFalhaExclusao.Count > 1 ?
                                   $"Os tipos de evento de codigo: {string.Join(",", idFalhaExclusao)} não foram removidos" :
                                   $"O tipo de evento de codigo {idFalhaExclusao[0]} não foi removido";

                throw new NegocioException(erroMensagem);
            }
        }
        public void Remover(IEnumerable <long> idsRemover)
        {
            var idFalhaExclusao      = new List <long>();
            var tiposEventoInvalidos = new List <string>();

            using (var transacao = unitOfWork.IniciarTransacao())
            {
                foreach (var codigo in idsRemover)
                {
                    try
                    {
                        var entidade      = repositorioEventoTipo.ObterPorId(codigo);
                        var possuiEventos = repositorioEvento.ExisteEventoPorEventoTipoId(codigo);
                        if (possuiEventos)
                        {
                            tiposEventoInvalidos.Add(entidade.Descricao);
                        }
                        else
                        {
                            entidade.Excluido = true;

                            repositorioEventoTipo.Salvar(entidade);
                        }
                    }
                    catch (Exception)
                    {
                        idFalhaExclusao.Add(codigo);
                    }
                }

                unitOfWork.PersistirTransacao();
            }
            if (tiposEventoInvalidos.Any())
            {
                var erroMensagem = idFalhaExclusao.Count > 1 ?
                                   $"Os tipos de evento: {string.Join(",", tiposEventoInvalidos)} não foram removidos, pois possuem eventos vinculados" :
                                   $"O tipo de evento {tiposEventoInvalidos[0]} não foi removido, pois possue evento vinculado";

                throw new NegocioException(erroMensagem);
            }

            if (idFalhaExclusao.Any())
            {
                var erroMensagem = idFalhaExclusao.Count > 1 ?
                                   $"Os tipos de evento de codigo: {string.Join(",", idFalhaExclusao)} não foram removidos" :
                                   $"O tipo de evento de codigo {idFalhaExclusao[0]} não foi removido";

                throw new NegocioException(erroMensagem);
            }
        }
Exemplo n.º 3
0
        public async Task <IEnumerable <RetornoCopiarEventoDto> > Alterar(long id, EventoDto eventoDto)
        {
            var evento = repositorioEvento.ObterPorId(id);

            if (evento == null)
            {
                throw new NegocioException("Não foi possível obter o evento");
            }

            var tipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);

            if (tipoEvento == null)
            {
                throw new NegocioException("Não foi possível obter o tipo do evento");
            }

            try
            {
                ValidacaoPermissaoEdicaoExclusaoPorPerfilUsuarioTipoEevento(evento);
            }
            catch (NegocioException)
            {
                throw new NegocioException($"O seu perfil de usuário não permite a alteração desse evento");
            }

            evento.AdicionarTipoEvento(tipoEvento);

            if (!evento.PodeAlterar())
            {
                throw new NegocioException("Não é possível editar um evento em aprovação");
            }

            evento = MapearParaEntidade(evento, eventoDto);
            return(await SalvarEvento(eventoDto, evento));
        }
        public async Task <IEnumerable <RetornoCopiarEventoDto> > Alterar(long id, EventoDto eventoDto)
        {
            var evento = repositorioEvento.ObterPorId(id);

            if (evento == null)
            {
                throw new NegocioException("Não foi possível obter o evento");
            }

            var tipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);

            if (tipoEvento == null)
            {
                throw new NegocioException("Não foi possível obter o tipo do evento");
            }

            evento.AdicionarTipoEvento(tipoEvento);

            if (!evento.PodeAlterar())
            {
                throw new NegocioException("Não é possível editar um evento em aprovação");
            }

            evento = MapearParaEntidade(evento, eventoDto);
            return(await SalvarEvento(eventoDto, evento));
        }
Exemplo n.º 5
0
        private void ObterTipoEvento(Evento evento)
        {
            var tipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);

            if (tipoEvento == null)
            {
                throw new NegocioException("O tipo do evento deve ser informado.");
            }

            evento.AdicionarTipoEvento(tipoEvento);
        }
Exemplo n.º 6
0
        public EventoTipoDto ObterPorId(long id)
        {
            var entidade = repositorioEventoTipo.ObterPorId(id);

            if (entidade == null || entidade.Id == 0)
            {
                return(null);
            }

            if (entidade.Excluido)
            {
                return(null);
            }

            return(EntidadeParaDto(entidade));
        }
        public async Task <EventoCompletoDto> ObterPorId(long id)
        {
            var evento = repositorioEvento.ObterPorId(id);

            evento.TipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);
            var usuario = await servicoUsuario.ObterUsuarioLogado();

            //verificar se o evento e o perfil do usuário é SME para possibilitar alteração
            bool podeAlterar = !EhEventoSME(evento) || (EhEventoSME(evento) && usuario.EhPerfilSME());

            if (!EhEventoSME(evento) &&
                (evento.TipoEventoId == (long)TipoEvento.LiberacaoExcepcional ||
                 evento.TipoEventoId == (long)TipoEvento.ReposicaoNoRecesso))
            {
                podeAlterar = !usuario.TemPerfilGestaoUes();
            }

            return(MapearParaDto(evento, podeAlterar));
        }
Exemplo n.º 8
0
        public async Task Salvar(Evento evento, bool dataConfirmada = false)
        {
            var tipoEvento = repositorioEventoTipo.ObterPorId(evento.TipoEventoId);

            if (tipoEvento == null)
            {
                throw new NegocioException("O tipo do evento deve ser informado.");
            }

            var tipoCalendario = repositorioTipoCalendario.ObterPorId(evento.TipoCalendarioId);

            if (tipoCalendario == null)
            {
                throw new NegocioException("Calendário não encontrado.");
            }
            evento.AdicionarTipoEvento(tipoEvento);

            evento.ValidaPeriodoEvento();

            var usuario = await servicoUsuario.ObterUsuarioLogado();

            usuario.PodeCriarEvento(evento);

            if (!evento.PermiteConcomitancia())
            {
                var existeOutroEventoNaMesmaData = repositorioEvento.ExisteEventoNaMesmaDataECalendario(evento.DataInicio, evento.TipoCalendarioId);
                if (existeOutroEventoNaMesmaData)
                {
                    throw new NegocioException("Não é permitido cadastrar um evento nesta data pois esse tipo de evento não permite concomitância.");
                }
            }

            var periodos = repositorioPeriodoEscolar.ObterPorTipoCalendario(evento.TipoCalendarioId);

            if (evento.DeveSerEmDiaLetivo())
            {
                evento.EstaNoPeriodoLetivo(periodos);
            }

            await VerificaParticularidadesSME(evento, usuario, periodos, dataConfirmada);

            repositorioEvento.Salvar(evento);
        }