public async Task <IActionResult> Handle(AlterarObjetoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            //Recupera o objeto
            var objeto = await ObjetoRepository.ObterAsync(request.ObjetoId);

            //Monta o objeto
            objeto.Alterar(request.Chave, request.Descricao, request.Tipo, request.Ativo);

            try
            {
                await validarObjeto(objeto);
            }
            catch (SISRHDomainException e)
            {
                result.SetHttpStatusToBadRequest(e.Message);
                return(result);
            }

            //Altera o objeto no banco de dados
            ObjetoRepository.Atualizar(objeto);
            UnitOfWork.Commit(false);

            result.Result = objeto.ObjetoId;
            result.SetHttpStatusToOk("Objeto alterado com sucesso.");
            return(result);
        }
Exemple #2
0
        public async Task <IActionResult> Handle(CandidatarPlanoTrabalhoAtividadeCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

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

                //Remove a atividade
                item.RegistrarCandidaturaAtividade(request.PlanoTrabalhoAtividadeId, request.UsuarioLogadoId);

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

                //Envia email
                await EnviarEmail(request.PlanoTrabalhoAtividadeId, request.UsuarioLogadoId);

                result.Result = true;
                result.SetHttpStatusToOk("Candidatura registrada com sucesso.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.Result = false;
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }
        public async Task <IActionResult> Handle(CadastrarObjetoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            //Monta o objeto com os dados do assunto
            var objeto = Objeto.Criar(
                request.Chave.Replace("###", ""),
                request.Descricao,
                request.Tipo);

            try
            {
                await validarObjeto(objeto);
            } catch (SISRHDomainException e)
            {
                result.SetHttpStatusToBadRequest(e.Message);
                return(result);
            }

            //Adiciona o assunto no banco de dados
            await ObjetoRepository.AdicionarAsync(objeto);

            UnitOfWork.Commit(false);

            result.Result = objeto.ObjetoId;
            result.SetHttpStatusToOk("Objeto cadastrado com sucesso.");
            return(result);
        }
Exemple #4
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);
        }
        public async Task <IActionResult> Handle(CadastrarAssuntoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            //Monta o objeto com os dados do assunto
            var assunto = Domain.AggregatesModel.AssuntoAggregate.Assunto.Criar(
                request.Valor,
                request.AssuntoPaiId,
                true);

            try
            {
                await validarAssunto(assunto);
            } catch (SISRHDomainException e)
            {
                result.SetHttpStatusToBadRequest(e.Message);
                return(result);
            }

            //Adiciona o assunto no banco de dados
            await AssuntoRepository.AdicionarAsync(assunto);

            UnitOfWork.Commit(false);

            result.Result = assunto.AssuntoId;
            result.SetHttpStatusToOk("Assunto cadastrado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(AlterarAssuntoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            //Recupera o objeto assunto
            var assunto = await AssuntoRepository.ObterAsync(request.AssuntoId);

            var alterouPai = assunto.AssuntoPaiId != request.AssuntoPaiId;

            //Monta o objeto com os dados do assunto
            assunto.Alterar(request.Valor, request.AssuntoPaiId, request.Ativo);

            try
            {
                await validarAssunto(assunto, alterouPai);
            }
            catch (SISRHDomainException e)
            {
                result.SetHttpStatusToBadRequest(e.Message);
                return(result);
            }

            //Altera o assunto no banco de dados
            AssuntoRepository.Atualizar(assunto);
            UnitOfWork.Commit(false);

            result.Result = assunto.AssuntoId;
            result.SetHttpStatusToOk("Assunto alterado com sucesso.");
            return(result);
        }
        public async Task <IActionResult> Handle(CadastrarPlanoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

            try
            {
                var unidade = await UnidadeQuery.ObterQuantidadeServidoresPorChaveAsync(request.UnidadeId);

                var tempoComparecimento = request.TempoComparecimento;
                var termosAceite        = request.TermoAceite;

                if (Configuration.Value.TempoComparecimento > 0)
                {
                    tempoComparecimento = Configuration.Value.TempoComparecimento;
                }

                if (!String.IsNullOrEmpty(Configuration.Value.TermoAceite))
                {
                    termosAceite = Configuration.Value.TermoAceite;
                }

                //Monta o objeto com os dados do item de catalogo
                Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho item =
                    Domain.AggregatesModel.PlanoTrabalhoAggregate.PlanoTrabalho.Criar(
                        request.UnidadeId,
                        request.DataInicio,
                        request.DataFim,
                        tempoComparecimento,
                        request.TempoFaseHabilitacao,
                        unidade.Result.QuantidadeServidores,
                        request.UsuarioLogadoId.ToString(),
                        termosAceite);

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

                UnitOfWork.Commit(false);

                result.Result = item.PlanoTrabalhoId;
                result.SetHttpStatusToOk("Plano de trabalho cadastrado com sucesso.");
            }
            catch (SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.SetHttpStatusToBadRequest(ex.Message);
            }

            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);
        }
Exemple #9
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);
        }
        public async Task <IActionResult> Handle(AlterarSituacaoPlanoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <bool> result = new ApplicationResult <bool>(request);

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

            try
            {
                //Altera a situação do plano
                if (request.Deserto)
                {
                    item.AlterarSituacao((int)SituacaoPlanoTrabalhoEnum.Concluido, request.UsuarioLogadoId.ToString(), request.Observacoes, true);
                }
                else if (request.SituacaoId == (int)SituacaoPlanoTrabalhoEnum.EmExecucao)
                {
                    item.ConcluirHabilitacao(request.UsuarioLogadoId.ToString(), request.Observacoes, request.Aprovados);
                }
                else
                {
                    item.AlterarSituacao(request.SituacaoId, request.UsuarioLogadoId.ToString(), request.Observacoes);
                }

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

                //Notifica os envolvidos
                await EnviarEmails(item);

                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);
        }
Exemple #11
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(AlterarSituacaoPactoTrabalhoCommand 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();

                //Alterar a situação do plano de trabalho
                item.AlterarSituacao(request.SituacaoId, request.UsuarioLogadoId.ToString(), request.Observacoes);

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

                //Envia os emails aos envolvidos
                await EnviarEmail(request.PactoTrabalhoId, item.PessoaId, item.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);
        }
Exemple #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);
        }
        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);
        }
Exemple #15
0
        public async Task <IActionResult> Handle(CadastrarPactoTrabalhoCommand request, CancellationToken cancellationToken)
        {
            ApplicationResult <Guid> result = new ApplicationResult <Guid>(request);

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

                if (dadosPessoa.PactosTrabalho.Any(p => p.DataFim >= request.DataInicio.Date && p.DataInicio <= request.DataFim.Date))
                {
                    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 modalidadeExecucaoId = atividade.ModalidadeExecucaoId.HasValue ? atividade.ModalidadeExecucaoId.Value : pactoCopiar.ModalidadeExecucaoId;
                        var assuntosId           = atividade.Assuntos.Select(a => a.AssuntoId);
                        var objetosId            = atividade.Objetos.Select(o => o.PlanoTrabalhoObjetoId);
                        item.AdicionarAtividade(atividade.ItemCatalogo, atividade.Quantidade, modalidadeExecucaoId, 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.");
            }
            catch (SISRH.Domain.Exceptions.SISRHDomainException ex)
            {
                result.Validations = new List <string>()
                {
                    ex.Message
                };
                result.SetHttpStatusToBadRequest();
            }
            return(result);
        }