예제 #1
0
        public async Task <IActionResult> Handle(AvaliarAtividadePactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            try
            {
                //Monta os dados do pacto de trabalho
                var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

                //Altera a atividade
                pacto.AvaliarAtividade(request.PactoTrabalhoAtividadeId, request.Nota, request.Justificativa);

                //Altera o pacto de trabalho no banco de dados
                PactoTrabalhoRepository.Atualizar(pacto);
                UnitOfWork.Commit(false);

                //Envia os emails aos envolvidos
                await EnviarEmail(request.PactoTrabalhoId, pacto.PessoaId, pacto.UnidadeId);

                result.Result = true;
                result.SetHttpStatusToOk("Atividade avaliada com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = false;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }
예제 #2
0
        public async Task <IActionResult> Handle(CadastrarPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            request.AssuntosId = request.AssuntosId != null ? request.AssuntosId : new List <Guid>();
            request.ObjetosId  = request.ObjetosId != null ? request.ObjetosId : new List <Guid>();

            //Monta os dados do pacto de trabalho
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Obtém os dias não úteis da pessoa
            var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(pacto.PessoaId, pacto.DataInicio, pacto.DataFim);

            pacto.DiasNaoUteis = diasNaoUteis.Result.ToList();

            //Obtem os dados do item
            var item = await ItemCatalogoRepository.ObterAsync(request.ItemCatalogoId);

            //Obtém o tempo previsto para o iem de acordo com a forma de execução e com o tipo do item
            var tempoPrevisto = item.TempoExecucaoPreviamenteDefinido ?
                                pacto.ModalidadeExecucaoId == (int)ModalidadeExecucaoEnum.Presencial ? item.TempoExecucaoPresencial.Value : item.TempoExecucaoRemoto.Value :
                                request.TempoPrevistoPorItem.Value;

            //Cria a atividade
            pacto.AdicionarAtividade(item, request.Quantidade, tempoPrevisto, request.Descricao, request.AssuntosId, request.ObjetosId);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(AlterarSituacaoPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta o objeto com os dados do catalogo
            var item = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Obtém os dias não úteis da pessoa
            var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(item.PessoaId, item.DataInicio, item.DataFim);

            item.DiasNaoUteis = diasNaoUteis.Result.ToList();

            //Alterar a situação da atividade
            item.AlterarSituacao(request.SituacaoId, request.UsuarioLogadoId.ToString(), request.Observacoes);

            //Altera o item de catalogo no banco de dados
            PactoTrabalhoRepository.Atualizar(item);
            UnitOfWork.Commit(false);

            //Envia os emails aos envolvidos
            await EnviarEmail(item.PessoaId, item.UnidadeId);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
예제 #4
0
        public async Task <IActionResult> Handle(CadastrarPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            var dadosPessoa = await PessoaRepository.ObterAsync(request.PessoaId);

            if (dadosPessoa.PactosTrabalho.Any(p => p.DataFim >= request.DataInicio && p.DataInicio <= request.DataFim))
            {
                result.Validations = new List <string> {
                    "A pessoa já tem um plano de trabalho cadastrado para o período"
                };
                return(result);
            }

            //Obtém os dias que não são úteis (feriados, férias, etc)
            var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(dadosPessoa.PessoaId, request.DataInicio, request.DataFim);

            //Monta o objeto com os dados do item de catalogo
            Domain.AggregatesModel.PactoTrabalhoAggregate.PactoTrabalho item =
                Domain.AggregatesModel.PactoTrabalhoAggregate.PactoTrabalho.Criar(
                    request.PlanoTrabalhoId,
                    request.UnidadeId,
                    request.PessoaId,
                    dadosPessoa.CargaHoraria,
                    request.FormaExecucaoId,
                    request.DataInicio,
                    request.DataFim,
                    request.UsuarioLogadoId.ToString(),
                    diasNaoUteis.Result.ToList(),
                    request.TermoAceite);

            //Verifica se está criando ou copiando um pacto de trabalho
            if (request.PactoTrabalhoId.HasValue)
            {
                //Obtém os dados do pacto que está copiando
                var pactoCopiar = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId.Value);

                //Adiciona ao pacto novo as atividades do que está sendo copiado
                foreach (var atividade in pactoCopiar.Atividades)
                {
                    var assuntosId = atividade.Assuntos.Select(a => a.AssuntoId);
                    var objetosId  = atividade.Objetos.Select(o => o.PlanoTrabalhoObjetoId);
                    item.AdicionarAtividade(atividade.ItemCatalogo, atividade.Quantidade, atividade.TempoPrevistoPorItem, atividade.Descricao, assuntosId, objetosId);
                }
            }

            //Adiciona o catalogo no banco de dados
            await PactoTrabalhoRepository.AdicionarAsync(item);

            UnitOfWork.Commit(false);

            result.Result = item.PactoTrabalhoId;
            result.SetHttpStatusToOk("Plano de trabalho cadastrado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(AlterarPeriodoPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            try
            {
                //Monta o objeto com os dados do catalogo
                var item = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

                //Obtém os dias não úteis da pessoa
                var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(item.PessoaId, item.DataInicio, item.DataFim);

                item.DiasNaoUteis = diasNaoUteis.Result.ToList();

                //Verifica se a pessoa tem outros pactos cadastrados para o período
                var dadosPessoa = await PessoaRepository.ObterAsync(item.PessoaId);

                if (dadosPessoa.PactosTrabalho.Any(p =>
                                                   p.PactoTrabalhoId != item.PactoTrabalhoId &&
                                                   p.DataFim.Date >= request.DataInicio.Date &&
                                                   p.DataInicio.Date <= request.DataFim.Date))
                {
                    result.Validations = new List <string> {
                        "A pessoa já tem um plano de trabalho cadastrado para o período"
                    };
                    return(result);
                }

                //Altera a situação
                item.AlterarPeriodo(request.DataInicio.Date, request.DataFim.Date);

                //Altera o item de catalogo no banco de dados
                PactoTrabalhoRepository.Atualizar(item);
                UnitOfWork.Commit(false);

                result.Result = true;
                result.SetHttpStatusToOk("Plano de trabalho alterado com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = false;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }
예제 #6
0
        public async Task <IActionResult> Handle(ProporExcluirAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            try
            {
                //Monta os dados do pacto de trabalho
                var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

                if (pacto.ExisteSolicitacaoPendenteExclusaoMesmaAtividade(request.PactoTrabalhoAtividadeId))
                {
                    throw new SISRH.Domain.Exceptions.SISRHDomainException(@"
                        Já existe solicitação ainda não analisada de exclusão da mesma atividade. 
                        Aguarde até que a solicitação anterior tenha sido analisada para que possa fazer nova solicitação de exclusão da mesma atividade.
                    ");
                }

                //Armazena o id do item de catálogo para poder mostrar na tela caso ele seja excluído
                var atividade = pacto.Atividades.FirstOrDefault(p => p.PactoTrabalhoAtividadeId == request.PactoTrabalhoAtividadeId);
                request.ItemCatalogo = atividade.ItemCatalogo.TituloCompletoComTempos;

                //Serializa a requisição
                var dados = JsonConvert.SerializeObject(request);

                //Cria a solicitação
                pacto.AdicionarSolicitacao(TipoSolicitacaoPactoTrabalhoEnum.ExcluirAtividade, request.UsuarioLogadoId.ToString(), dados, request.Justificativa);

                //Altera o pacto de trabalho no banco de dados
                PactoTrabalhoRepository.Atualizar(pacto);
                UnitOfWork.Commit(false);

                //Envia os emails aos envolvidos
                await EnviarEmail(request.PactoTrabalhoId, pacto.PessoaId, pacto.UnidadeId);

                result.Result = true;
                result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = false;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }
예제 #7
0
        public async Task <IActionResult> Handle(AlterarPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta o objeto com os dados do catalogo
            var item = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Altera a situação
            //item.AlterarSituacao(request.SituacaoId, request.UsuarioLogado, request.Observacoes);

            //Altera o item de catalogo no banco de dados
            PactoTrabalhoRepository.Atualizar(item);
            UnitOfWork.Commit(false);

            result.Result = true;
            result.SetHttpStatusToOk("Plano de trabalho alterado com sucesso.");
            return(result);
        }
예제 #8
0
        public async Task <IActionResult> Handle(ExcluirPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta o objeto com os dados do catalogo
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Remove a atividade
            pacto.RemoverAtividade(request.PactoTrabalhoAtividadeId);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
예제 #9
0
        public async Task <IActionResult> Handle(ResponderSolitacaoPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            if (!await validarPermissoes(request))
            {
                result.SetHttpStatusToForbidden("O usuário logado não possui permissão suficientes para executar a ação.");
                return(result);
            }

            //Monta os dados do pacto de trabalho
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            if (request.AjustarPrazo)
            {
                //Obtém os dias não úteis da pessoa
                var dias = diasAumentoPrazo(pacto, request.PactoTrabalhoSolicitacaoId);

                if (dias == null)
                {
                    result.SetHttpStatusToBadRequest("Não foi possível recuperar os dias de aumento de prazo.");
                    return(result);
                }

                var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(pacto.PessoaId, pacto.DataInicio, pacto.DataFim.AddDays(Convert.ToDouble(Decimal.Round(dias.Value))));

                pacto.DiasNaoUteis = diasNaoUteis.Result.ToList();
            }

            //Responde a solicitação
            pacto.ResponderSolicitacao(request.PactoTrabalhoSolicitacaoId, request.UsuarioLogadoId.ToString(), request.Aprovado, request.AjustarPrazo, request.Descricao);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            //Envia os emails aos envolvidos
            await EnviarEmail(pacto.PessoaId, pacto.UnidadeId);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(AvaliarAtividadePactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta os dados do pacto de trabalho
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Altera a atividade
            pacto.AvaliarAtividade(request.PactoTrabalhoAtividadeId, request.Nota, request.Justificativa);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            //Envia os emails aos envolvidos
            await EnviarEmail(pacto.PessoaId, pacto.UnidadeId);

            result.Result = true;
            result.SetHttpStatusToOk("Atividade avaliada com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(AlterarAndamentoPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta os dados do pacto de trabalho
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Obtém os dias não úteis da pessoa
            var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(pacto.PessoaId, pacto.DataInicio, pacto.DataFim);

            pacto.DiasNaoUteis = diasNaoUteis.Result.ToList();

            //Altera a atividade
            pacto.AlterarAndamentoAtividade(request.PactoTrabalhoAtividadeId, request.SituacaoId, request.DataInicio, request.DataFim, request.TempoRealizado, consideracoes: request.Consideracoes);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
예제 #12
0
        public async Task <IActionResult> Handle(ExcluirPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta o objeto com os dados do catalogo
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            if (pacto.SituacaoId >= (int)Domain.Enums.SituacaoPactoTrabalhoEnum.EmExecucao)
            {
                result.Validations = new List <string> {
                    "Não é é possível excluir um plano que já tenha iniciado a execução"
                };
                return(result);
            }

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Excluir(pacto);
            UnitOfWork.Commit(false);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
예제 #13
0
        public async Task <IActionResult> Handle(ProporPactoTrabalhoPrazoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            try
            {
                //Monta os dados do pacto de trabalho
                var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

                //Serializa a requisição
                var dados = JsonConvert.SerializeObject(request);

                //Cria a solicitação
                pacto.AdicionarSolicitacao(TipoSolicitacaoPactoTrabalhoEnum.AlterarPrazo, request.UsuarioLogadoId.ToString(), dados, request.Descricao);

                //Altera o pacto de trabalho no banco de dados
                PactoTrabalhoRepository.Atualizar(pacto);
                UnitOfWork.Commit(false);

                //Envia os emails aos envolvidos
                await EnviarEmail(request.PactoTrabalhoId, pacto.PessoaId, pacto.UnidadeId);

                result.Result = true;
                result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = false;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }
예제 #14
0
        public async Task <IActionResult> Handle(ProporPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

            //Monta os dados do pacto de trabalho
            var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

            //Serializa a requisição
            var dados = JsonConvert.SerializeObject(request);

            //Cria a solicitação
            pacto.AdicionarSolicitacao(TipoSolicitacaoPactoTrabalhoEnum.NovaAtividade, request.UsuarioLogadoId.ToString(), dados, request.Descricao);

            //Altera o pacto de trabalho no banco de dados
            PactoTrabalhoRepository.Atualizar(pacto);
            UnitOfWork.Commit(false);

            //Envia os emails aos envolvidos
            await EnviarEmail(pacto.PessoaId, pacto.UnidadeId);

            result.Result = true;
            result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(ResponderSolitacaoPactoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            var result = new ApplicationResult <PactoTrabalhoViewModel>(request);

            try
            {
                if (!await validarPermissoes(request))
                {
                    result.SetHttpStatusToForbidden("O usuário logado não possui permissão suficientes para executar a ação.");
                    return(result);
                }

                //Monta os dados do pacto de trabalho
                var pacto = await PactoTrabalhoRepository.ObterAsync(request.PactoTrabalhoId);

                //Obtém os dados da solicitação
                var solicitacao = pacto.Solicitacoes.Where(s => s.PactoTrabalhoSolicitacaoId == request.PactoTrabalhoSolicitacaoId).FirstOrDefault();

                var dataFim = pacto.DataFim;

                Susep.SISRH.Domain.AggregatesModel.CatalogoAggregate.ItemCatalogo itemCatalogo = null;
                if (request.AjustarPrazo)
                {
                    //Obtém os dias não úteis da pessoa
                    var dias = diasAumentoPrazo(pacto, solicitacao);

                    if (dias == null)
                    {
                        result.SetHttpStatusToBadRequest("Não foi possível recuperar os dias de aumento de prazo.");
                        return(result);
                    }

                    dataFim = pacto.DataFim.AddDays(Convert.ToDouble(Decimal.Round(dias.Value)));
                }

                dynamic dadosSolicitacao = JsonConvert.DeserializeObject(solicitacao.DadosSolicitacao);
                switch (solicitacao.TipoSolicitacaoId)
                {
                case (int)SISRH.Domain.Enums.TipoSolicitacaoPactoTrabalhoEnum.AlterarPrazo:
                    dataFim = (DateTime)dadosSolicitacao.dataFim;
                    break;

                case (int)SISRH.Domain.Enums.TipoSolicitacaoPactoTrabalhoEnum.NovaAtividade:
                    Guid itemCatalogoId = dadosSolicitacao.itemCatalogoId;
                    itemCatalogo = await ItemCatalogoRepository.ObterAsync(itemCatalogoId);

                    break;
                }

                var diasNaoUteis = await PessoaQuery.ObterDiasNaoUteisAsync(pacto.PessoaId, pacto.DataInicio, dataFim);

                pacto.DiasNaoUteis = diasNaoUteis.Result.ToList();

                //Responde a solicitação
                pacto.ResponderSolicitacao(request.PactoTrabalhoSolicitacaoId, request.UsuarioLogadoId.ToString(), request.Aprovado, request.AjustarPrazo, request.Descricao, itemCatalogo);

                //Altera o pacto de trabalho no banco de dados
                PactoTrabalhoRepository.Atualizar(pacto);
                UnitOfWork.Commit(false);

                //Envia os emails aos envolvidos
                await EnviarEmail(request.PactoTrabalhoId, pacto.PessoaId, pacto.UnidadeId);

                var dadosPacto = await PactoTrabalhoQuery.ObterPorChaveAsync(request.PactoTrabalhoId);

                result.Result = dadosPacto.Result;
                result.SetHttpStatusToOk("Pacto de trabalho alterado com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = null;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }