/// <summary>
        /// Método responsável por editar os dados de um cronograma
        /// </summary>
        /// <param name="cronogramaDto">dados do cronograma editado</param>
        /// <returns>verdadeiro caso tenha sido editado e falso caso contrário</returns>
        public static bool EditarCronograma(CronogramaDto cronogramaDto)
        {
            if (cronogramaDto == null || cronogramaDto.Oid == new Guid())
            {
                return(false);
            }

            var cronograma = CronogramaDao.ConsultarCronogramaPorOid(cronogramaDto.Oid, o => o.SituacaoPlanejamento.Cronogramas);

            if (cronograma == null)
            {
                return(false);
            }

            var dtoCronogramaBaseDados = CronogramaBo.DtoFactory(cronograma);

            if (ComparadorGenerico.HouveMudancaEm(dtoCronogramaBaseDados, cronogramaDto, o => o.TxDescricao))
            {
                return(AlterarDescricaoCronograma(cronogramaDto.Oid, cronogramaDto.TxDescricao));
            }

            if (!ValidarDatasCronograma(cronogramaDto) || !ComparadorGenerico.HouveMudancaEm(dtoCronogramaBaseDados, cronogramaDto, o => o.OidSituacaoPlanejamento, o => o.DtInicio, o => o.DtFinal))
            {
                return(false);
            }

            AtualizarDadosCronograma(cronograma, cronogramaDto);
            return(CronogramaDao.SalvarCronograma(cronograma));
        }
        /// <summary>
        /// Método responsável por buscar todos os cronogramas
        /// É usado pela tela de cronograma
        /// </summary>
        /// <param name="session">Sessão Corrente</param>
        /// <returns>Lista de Objetos de CronogramaDTO</returns>
        public static List <CronogramaDto> ConsultarCronogramasDto()
        {
            List <CronogramaDto> cronogramasDTO = new List <CronogramaDto>();

            List <Cronograma> cronogramas = new List <Cronograma>();

            cronogramas = CronogramaDao.ConsultarCronogramas();

            if (cronogramas.Count > 0)
            {
                foreach (Cronograma cronograma in cronogramas)
                {
                    CronogramaDto cronoDTO = new CronogramaDto()
                    {
                        Oid                             = cronograma.Oid,
                        TxDescricao                     = cronograma.TxDescricao,
                        OidSituacaoPlanejamento         = cronograma.SituacaoPlanejamento.Oid,
                        TxDescricaoSituacaoPlanejamento = cronograma.TxDescricaoSituacaoPlanejamento,
                        DtInicio                        = (DateTime)cronograma.DtInicio,
                        DtFinal                         = (DateTime)cronograma.DtFinal
                    };

                    cronogramasDTO.Add(cronoDTO);
                }
            }

            return(cronogramasDTO);
        }
        public static Cronograma CriarCronogramaPadrao()
        {
            using (WexDb contexto = ContextFactoryManager.CriarWexDb())
            {
                bool valido = false;

                //TODO: Quando associar ao projeto deverá ser mudada a pesquisa
                List <Cronograma> cronogramas = CronogramaDao.ConsultarCronogramas();
                int contador = cronogramas.Count;

                Cronograma cronograma = new Cronograma();

                if (cronogramas.Count < 10)
                {
                    cronograma.TxDescricao = "Wex Cronograma " + String.Format("{00:00}", (cronogramas.Count + 1));
                }
                else
                {
                    cronograma.TxDescricao = "Wex Cronograma " + String.Format("{0}", (cronogramas.Count + 1));
                }
                do
                {
                    Cronograma cronogramaResultado = CronogramaDao.ConsultarCronogramaPorNome(contexto, cronograma.TxDescricao);

                    if (cronogramaResultado == null)
                    {
                        valido = true;
                    }
                    else
                    {
                        //TODO: Quando associar ao projeto deverá ser mudada a pesquisa
                        if (cronogramas.Count < 10)
                        {
                            cronograma.TxDescricao = "Wex Cronograma " + String.Format("{00:00}", (contador + 1));
                        }

                        else
                        {
                            cronograma.TxDescricao = "Wex Cronograma " + String.Format("{0}", (contador + 1));
                        }

                        valido = false;
                    }

                    contador++;
                } while(valido == false);

                cronograma.SituacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
                cronograma.DtInicio             = DateTime.Now;
                cronograma.DtFinal = DateTime.Now;

                contexto.Cronograma.Add(cronograma);
                contexto.SaveChanges();

                return(cronograma);
            }
        }
        /// <summary>
        /// Método responsável por efetuar alteração na descrição do cronograma
        /// </summary>
        /// <param name="oidCronograma"> oid do cronograma que terá o nome alterado</param>
        /// <param name="novaDescricaoCronograma">novo nome do cronograma</param>
        public static bool AlterarDescricaoCronograma(Guid oidCronograma, string novaDescricaoCronograma)
        {
            if (oidCronograma == new Guid())
            {
                throw new ArgumentException("Erro de argumento, a oidCronograma não pode ser nulo");
            }

            if (string.IsNullOrEmpty(novaDescricaoCronograma))
            {
                throw new ArgumentException("Erro de argumento, a descrição da tarefa não pode ser nula");
            }

            Cronograma cronogramaSelecionado = CronogramaDao.ConsultarCronogramaPorOid(oidCronograma, o => o.SituacaoPlanejamento);

            if (cronogramaSelecionado == null)
            {
                return(false);
            }

            semaforoAlteracaoNomeCronograma.WaitOne();

            string descricaoValida = ValidarDescricaoCronograma(novaDescricaoCronograma);

            using (WexDb contexto = ContextFactoryManager.CriarWexDb())
            {
                bool cronogramaComMesmoNome = contexto.Cronograma.Existe(o => o.TxDescricao == descricaoValida && !o.CsExcluido);

                if (cronogramaComMesmoNome)
                {
                    semaforoAlteracaoNomeCronograma.Release();
                    return(false);
                }

                cronogramaSelecionado.TxDescricao = descricaoValida;
                contexto.Cronograma.Attach(cronogramaSelecionado);
                contexto.Entry(cronogramaSelecionado).State = EntityState.Modified;
                contexto.Entry(cronogramaSelecionado.SituacaoPlanejamento).State = EntityState.Unchanged;
                contexto.SaveChanges();
                semaforoAlteracaoNomeCronograma.Release();
                return(true);
            }
        }
Exemple #5
0
        /// <summary>
        /// Método responsável por realizar os cálculos necessários para formar o gráfico de Burndown
        /// </summary>
        /// <returns>Lista contendo os dados calculados que formam o gráfico</returns>
        public BurndownGraficoDto CalcularDadosGraficoBurndown(Guid oidCronograma)
        {
            List <BurndownDadosDto> dadosGrafico = new List <BurndownDadosDto>();

            Cronograma cronograma = CronogramaDao.ConsultarCronogramaPorOid(oidCronograma, o => o.CronogramaTarefas);

            var diasUteis = CalendarioBo.CalcularDiasUteis(cronograma.DtInicio, cronograma.DtFinal);

            double totalHorasCronograma = TarefaHistoricoEstimativaDao.ConsultarTotalHorasPlanejadasCronograma(oidCronograma);

            totalHorasCronograma = totalHorasCronograma.ToTimeSpan().TotalHours;

            double cargaDiaria    = DividirCargaHoraria(totalHorasCronograma, diasUteis.Count - 1);
            double horasRestantes = totalHorasCronograma;

            diasUteis.ForEach(data => dadosGrafico.Add(CriarDtoPlanejamentoGraficoBurndown(cargaDiaria, ref horasRestantes, data)));

            var somatorios = TarefaHistoricoEstimativaDao.ConsultarTotalHorasRealizadasCronograma(oidCronograma, cronograma.DtInicio, cronograma.DtFinal);

            if (somatorios.Count > 0)
            {
                diasUteis = diasUteis.Union(somatorios.Keys.Where(o => o.Date <= DateUtil.ConsultarDataHoraAtual().Date)).OrderBy(o => o).ToList();
                var ultimaEstimativa     = somatorios.LastOrDefault();
                var dataUltimaEstimativa = ultimaEstimativa.Key.AddDays(1);
                var somaUltimaEstimativa = ultimaEstimativa.Value;

                while (dataUltimaEstimativa.Date <= cronograma.DtFinal && dataUltimaEstimativa.Date <= DateUtil.ConsultarDataHoraAtual().Date)
                {
                    if (diasUteis.Any(o => o.Date.Equals(dataUltimaEstimativa) && o.Date <= DateUtil.ConsultarDataHoraAtual().Date))
                    {
                        somatorios.Add(dataUltimaEstimativa, somaUltimaEstimativa);
                    }
                    dataUltimaEstimativa = dataUltimaEstimativa.AddDays(1);
                }
                dadosGrafico.AddRange(CriarDtoRealizadoGraficoBurndown(somatorios));
            }
            double desvio = CalcularDesvio(dadosGrafico);

            return(new BurndownGraficoDto {
                DadosBurndown = dadosGrafico, Desvio = desvio
            });
        }
        /// <summary>
        /// Método responsável por buscar um cronograma pelo nome.
        /// </summary>
        /// <param name="session">Sessão Corrente</param>
        /// <param name="txDescricaoCronograma">Nome do Cronograma</param>
        /// <returns>Objeto cronograma</returns>
        public static CronogramaDto ConsultarCronogramaPorOidDto(Guid oidCronograma)
        {
            CronogramaDto cronogramaDto = new CronogramaDto();

            Cronograma cronograma = CronogramaDao.ConsultarCronogramaPorOid(oidCronograma, o => o.SituacaoPlanejamento);

            if (cronograma != null)
            {
                cronogramaDto.Oid = cronograma.Oid;
                cronogramaDto.OidSituacaoPlanejamento         = cronograma.OidSituacaoPlanejamento;
                cronogramaDto.TxDescricao                     = cronograma.TxDescricao;
                cronogramaDto.TxDescricaoSituacaoPlanejamento = cronograma.SituacaoPlanejamento.TxDescricao;
                cronogramaDto.DtInicio = (DateTime)cronograma.DtInicio;
                cronogramaDto.DtFinal  = (DateTime)cronograma.DtFinal;

                return(cronogramaDto);
            }

            return(null);
        }
        /// <summary>
        /// Método responsável por buscar um cronograma pelo nome.
        /// </summary>
        /// <param name="session">Sessão Corrente</param>
        /// <param name="txDescricaoCronograma">Nome do Cronograma</param>
        /// <returns>Objeto cronograma</returns>
        public static CronogramaDto ConsultarCronogramaPorNomeDto(WexDb contexto, string txDescricaoCronograma)
        {
            CronogramaDto cronogramaDto = new CronogramaDto();

            Cronograma cronograma = CronogramaDao.ConsultarCronogramaPorNome(contexto, txDescricaoCronograma);

            if (cronograma != null)
            {
                cronogramaDto.Oid = cronograma.Oid;
                cronogramaDto.OidSituacaoPlanejamento         = cronograma.SituacaoPlanejamento.Oid;
                cronogramaDto.TxDescricao                     = cronograma.TxDescricao;
                cronogramaDto.TxDescricaoSituacaoPlanejamento = cronograma.SituacaoPlanejamento.TxDescricao;
                cronogramaDto.DtInicio = (DateTime)cronograma.DtInicio;
                cronogramaDto.DtFinal  = (DateTime)cronograma.DtFinal;

                return(cronogramaDto);
            }

            return(null);
        }
        /// <summary>
        /// Método responsável por excluir um cronograma.
        /// Antes faz uma verificação para analisar se existem tarefas associadas ao cronograma
        /// caso não tenha, exclui as ultimas seleções dos usuários para aquele cronograma
        /// para então excluí-lo.
        /// </summary>
        /// <param name="session">Sessão Corrente</param>
        /// <param name="oidCronograma">Guid (ID) do cronograma a ser excluido</param>
        /// <returns>Boolean confirmando ou não a exclusão</returns>
        public static bool ExcluirCronograma(WexDb contexto, Guid oidCronograma)
        {
            if (contexto == null || oidCronograma == null)
            {
                throw new ArgumentException("Os parâmetros Session e OidCronograma não podem ser nulos.");
            }

            Cronograma cronograma = CronogramaDao.ConsultarCronogramaCronogramaTarefasETarefasPodOidCronograma(contexto, oidCronograma);

            if (cronograma != null)
            {
                if (cronograma.CronogramaTarefas.Any())
                {
                    List <CronogramaTarefa> cronogramaTarefasParaExcluir = CronogramaTarefaDao.ConsultarCronogramaTarefasPorOidCronograma(cronograma.Oid, o => o.Tarefa.TarefaHistoricoTrabalhos);
                    for (int i = 0; i < cronogramaTarefasParaExcluir.Count; i++)
                    {
                        if (cronogramaTarefasParaExcluir[i].Tarefa.TarefaHistoricoTrabalhos != null)
                        {
                            List <TarefaHistoricoTrabalho> historicosParaExcluir = cronogramaTarefasParaExcluir[i].Tarefa.TarefaHistoricoTrabalhos.ToList();

                            for (int j = 0; j < historicosParaExcluir.Count; j++)
                            {
                                historicosParaExcluir[j].CsExcluido = true;
                            }

                            cronogramaTarefasParaExcluir[i].Tarefa.TarefaHistoricoTrabalhos = null;
                        }
                        cronogramaTarefasParaExcluir[i].CsExcluido        = true;
                        cronogramaTarefasParaExcluir[i].Tarefa.CsExcluido = true;
                    }
                }
                CronogramaBo.RemoverSelecoesAssociadasAoCronograma(contexto, cronograma.Oid);
                cronograma.CsExcluido = true;
                contexto.SaveChanges();

                return(true);
            }

            return(false);
        }