Example #1
0
 private async Task SalvarListaEventos(IEnumerable <Evento> eventos, List <long> feriadosErro)
 {
     foreach (var evento in eventos)
     {
         try
         {
             await repositorioEvento.SalvarAsync(evento);
         }
         catch (Exception ex)
         {
             feriadosErro.Add(evento.FeriadoId.Value);
         }
     }
 }
Example #2
0
        public async Task <string> Salvar(Evento evento, bool alterarRecorrenciaCompleta = false, bool dataConfirmada = false, bool unitOfWorkJaEmUso = false)
        {
            ObterTipoEvento(evento);

            evento.ValidaPeriodoEvento();

            var usuario = await servicoUsuario.ObterUsuarioLogado();

            bool ehAlteracao = true;

            if (evento.Id == 0)
            {
                ehAlteracao = false;
                evento.TipoPerfilCadastro = usuario.ObterTipoPerfilAtual();
            }
            else
            {
                var entidadeNaoModificada = repositorioEvento.ObterPorId(evento.Id);
                ObterTipoEvento(entidadeNaoModificada);
                usuario.PodeAlterarEvento(entidadeNaoModificada);
            }

            usuario.PodeCriarEvento(evento);

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

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

            bool devePassarPorWorkflowLiberacaoExcepcional = await ValidaDatasETiposDeEventos(evento, dataConfirmada, usuario, periodos);

            AtribuirNullSeVazio(evento);

            if (!unitOfWorkJaEmUso)
            {
                unitOfWork.IniciarTransacao();
            }

            await repositorioEvento.SalvarAsync(evento);

            // Envia para workflow apenas na Inclusão ou alteração apos aprovado
            var enviarParaWorkflow = !string.IsNullOrWhiteSpace(evento.UeId) && devePassarPorWorkflowLiberacaoExcepcional;

            if (!ehAlteracao || (evento.Status == EntidadeStatus.Aprovado))
            {
                if (enviarParaWorkflow)
                {
                    await PersistirWorkflowEvento(evento, devePassarPorWorkflowLiberacaoExcepcional);
                }
            }

            if (!unitOfWorkJaEmUso)
            {
                unitOfWork.PersistirTransacao();
            }

            if (evento.EventoPaiId.HasValue && evento.EventoPaiId > 0 && alterarRecorrenciaCompleta)
            {
                SME.Background.Core.Cliente.Executar(() => AlterarRecorrenciaEventos(evento, alterarRecorrenciaCompleta));
            }

            // Verifica existencia de pendencia de calendario com dias letivos insuficientes
            if (evento.EhEventoDRE() && evento.EhEventoUE())
            {
                await VerificaPendenciaDiasLetivosInsuficientes(ehAlteracao, enviarParaWorkflow, evento, usuario);
            }

            if (evento.EhEventoUE())
            {
                await VerificaPendenciaParametroEvento(evento, usuario);
            }

            if (ehAlteracao)
            {
                if (enviarParaWorkflow)
                {
                    return("Evento alterado e será válido após aprovação.");
                }
                else
                {
                    return("Evento alterado com sucesso.");
                }
            }
            else
            {
                if (enviarParaWorkflow)
                {
                    return("Evento cadastrado e será válido após aprovação.");
                }
                else
                {
                    return("Evento cadastrado com sucesso.");
                }
            }
        }