public async Task <bool> Handle(IncluirFilaCalcularFrequenciaPorTurmaCommand request, CancellationToken cancellationToken)
        {
            //Verificar se já há essa turma/bimestre/disciplina
            var processoNaFila = await repositorioProcessoExecutando.ObterProcessoCalculoFrequenciaAsync(request.TurmaId, request.DisciplinaId, request.Bimestre,
                                                                                                         Dominio.TipoProcesso.CalculoFrequenciaFilaRabbit);

            if (processoNaFila == null)
            {
                await repositorioProcessoExecutando.SalvarAsync(new Dominio.ProcessoExecutando()
                {
                    Bimestre     = request.Bimestre,
                    DisciplinaId = request.DisciplinaId,
                    TipoProcesso = Dominio.TipoProcesso.CalculoFrequenciaFilaRabbit,
                    TurmaId      = request.TurmaId
                });

                var comando = new CalcularFrequenciaPorTurmaCommand(request.Alunos, request.DataAula, request.TurmaId, request.DisciplinaId, request.Bimestre);

                //var usuarioLogado = await mediator.Send(new ObterUsuarioLogadoQuery());

                await mediator.Send(new PublicarFilaSgpCommand(RotasRabbit.RotaCalculoFrequenciaPorTurmaComponente, comando, Guid.NewGuid(), null));
            }

            return(true);
        }
        public async Task <bool> Handle(CalcularFrequenciaPorTurmaCommand request, CancellationToken cancellationToken)
        {
            await repositorioProcessoExecutando.SalvarAsync(new ProcessoExecutando()
            {
                Bimestre     = request.Bimestre,
                DisciplinaId = request.DisciplinaId,
                TipoProcesso = TipoProcesso.CalculoFrequencia,
                TurmaId      = request.TurmaId
            });

            try
            {
                var totalAulasNaDisciplina = repositorioRegistroAusenciaAluno.ObterTotalAulasPorDisciplinaETurma(request.DataAula, request.DisciplinaId, request.TurmaId);
                var totalAulasDaTurmaGeral = repositorioRegistroAusenciaAluno.ObterTotalAulasPorDisciplinaETurma(request.DataAula, string.Empty, request.TurmaId);

                foreach (var codigoAluno in request.Alunos)
                {
                    RegistraFrequenciaPorDisciplina(request.TurmaId, request.DisciplinaId, request.DataAula, totalAulasNaDisciplina, codigoAluno);
                    RegistraFrequenciaGeral(request.TurmaId, request.DataAula, codigoAluno, totalAulasDaTurmaGeral);
                }
            }
            finally
            {
                var idsParaRemover = await repositorioProcessoExecutando.ObterIdsPorFiltrosAsync(request.Bimestre, request.DisciplinaId, request.TurmaId);

                await repositorioProcessoExecutando.RemoverIdsAsync(idsParaRemover.ToArray());
            }

            return(true);
        }
        public async Task <long> Handle(IncluirProcessoEmExecucaoCommand request, CancellationToken cancellationToken)
        {
            var processoExecutando = new ProcessoExecutando()
            {
                TipoProcesso = request.TipoProcesso
            };

            return(await repositorio.SalvarAsync(processoExecutando));
        }
        public async Task <IEnumerable <ProcessoExecutando> > Handle(InserirAulaEmManutencaoCommand request, CancellationToken cancellationToken)
        {
            var processosExecutando = new List <ProcessoExecutando>();

            foreach (var aulaId in request.AulasIds)
            {
                var processoExecutando = new ProcessoExecutando()
                {
                    TipoProcesso = TipoProcesso.ManutencaoAula,
                    AulaId       = aulaId
                };

                await repositorio.SalvarAsync(processoExecutando);

                processosExecutando.Add(processoExecutando);
            }

            return(processosExecutando);
        }
 public async Task Incluir(ProcessoExecutando processo)
 => await repositorio.SalvarAsync(processo);