示例#1
0
        /// <summary>
        /// Método para validar se a situação planejamento de uma tarefa é válida
        /// </summary>
        /// <param name="tipo">Tipo de situação planejamento</param>
        /// <param name="situacoesPlanejamento">lista das situações planejamento existentes</param>
        /// <param name="horaRealizada">Esforco realizado</param>
        /// <param name="horasRestantes">Esforço restante</param>
        /// <param name="tarefa">Tarefa</param>
        /// <returns></returns>
        public static bool ValidarSituacaoPlanejamento(CsTipoPlanejamento tipo, List <SituacaoPlanejamentoDTO> situacoesPlanejamento, TimeSpan horaRealizada, TimeSpan horaRestante, CronogramaTarefaDecorator tarefa)
        {
            SituacaoPlanejamentoDTO situacao = situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == tipo);

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

            TimeSpan horasRealizadas = tarefa.Realizado;

            horasRealizadas += horaRealizada;
            switch (situacao.CsTipo)
            {
            case CsTipoPlanejamento.Encerramento:
                return(horasRealizadas > TimeSpan.Zero && horaRestante <= TimeSpan.Zero);

            case CsTipoPlanejamento.Execução:
                return(horaRestante > TimeSpan.Zero);

            case CsTipoPlanejamento.Planejamento:
                return(horasRealizadas == TimeSpan.Zero);

            case CsTipoPlanejamento.Cancelamento:
                return(horaRestante == TimeSpan.Zero);

            case CsTipoPlanejamento.Impedimento:
                //Não há regras para ir para impedimento
                return(true);
            }
            return(false);
        }
示例#2
0
        /// <summary>
        /// Retornar se a situação de uma situação planejamento é válida
        /// </summary>
        /// <param name="tipo">tipo de situação</param>
        /// <param name="decorator">tarefa com os dados para serem validados</param>
        /// <returns></returns>
        public bool ValidarSituacaoPlanejamento(CsTipoPlanejamento tipo, CronogramaTarefaDecorator decorator)
        {
            SituacaoPlanejamentoDTO situacao = situacoesPlanejamento.FirstOrDefault(o => o.CsTipo == tipo);

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

            switch (situacao.CsTipo)
            {
            case CsTipoPlanejamento.Encerramento:
                return(PossuiEsforcoRealizado(decorator) && NaoPossuiHorasRestantes(decorator));

            case CsTipoPlanejamento.Execução:
                return(PossuiEstimativaInicial(decorator) && PossuiHorasRestantes(decorator));

            case CsTipoPlanejamento.Planejamento:
                return(NaoPossuiEsforcoRealizado(decorator));

            case CsTipoPlanejamento.Cancelamento:
                return(NaoPossuiHorasRestantes(decorator));

            case CsTipoPlanejamento.Impedimento:
                return(true);
            }
            return(false);
        }
示例#3
0
        /// <summary>
        /// Factory para criação de situação planejamento
        /// </summary>
        /// <param name="contexto">Contexto do banco</param>
        /// <param name="txDescricao">descrição para descrição da situação planejamento</param>
        /// <param name="csSituacao">enum de situacao</param>
        /// <param name="csTipo">enum de tipo</param>
        /// <param name="padraoSistema">Verifica se é padrão do sistema</param>
        /// <param name="save">verificação se é necessário salvar o objeto</param>
        /// <returns>Objeto de Situação Planejamento</returns>
        public static SituacaoPlanejamento CriarSituacaoPlanejamento(WexDb contexto,
                                                                     String txDescricao = "",
                                                                     CsTipoSituacaoPlanejamento csSituacao = CsTipoSituacaoPlanejamento.Ativo,
                                                                     CsTipoPlanejamento csTipo             = CsTipoPlanejamento.Execução,
                                                                     CsPadraoSistema padraoSistema         = CsPadraoSistema.Não,
                                                                     bool save = true)
        {
            SituacaoPlanejamento situacaoPlanejamento = new SituacaoPlanejamento
            {
                TxDescricao = txDescricao,
                CsPadrao    = padraoSistema,
                TxKeys      = ((Shortcut)(contadorAtalhos + seedShortcut)).ToString(),
                KeyPress    = contadorAtalhos + seedShortcut,
                CsSituacao  = csSituacao,
                CsTipo      = csTipo
            };

            if (save)
            {
                contexto.SituacaoPlanejamento.Add(situacaoPlanejamento);
                contexto.SaveChanges();
            }
            contadorAtalhos++;

            return(situacaoPlanejamento);
        }
示例#4
0
 public void QuandoOColaboradorAlterarASituacaoDaTarefaParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
 {
     situacaoSelecionadaAnterior  = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
     situacaoSelecionada          = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
     view.OidSituacaoPlanejamento = situacaoSelecionada.Oid;
     presenter.AlterarSituacaoPlanejamento();
 }
示例#5
0
        /// <summary>
        /// Validar se um tipo de situação planejamento é ou não válido considerando as estimativas atuais
        /// </summary>
        /// <param name="tipo">Tipo de situação planejamento</param>
        /// <returns> True para tipo de situação planejamento válido em relação as estimativas e  False para não válido</returns>
        public bool ValidarSituacaoPlanejamento(CsTipoPlanejamento tipo)
        {
            TimeSpan horaRealizada = GetValorHoraRealizadoView();
            TimeSpan horaRestante  = GetValorHoraRestanteView();

            return(ValidarSituacaoPlanejamento(tipo, situacoesPlanejamento, horaRealizada, horaRestante, cronogramaTarefa));
        }
        public void DeveConsultarASituacaoPlanejamentoPadraoQuandoHouveremOutrasSituacoesPlanejamentoCadastradas()
        {
            //Criando varias situações planejamento
            var situacaoPlanejamento = CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Não);

            SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);

            situacaoPlanejamento = CriarSituacaoPlanejamento("Pronto", CsTipoPlanejamento.Encerramento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Não);
            SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);

            situacaoPlanejamento = CriarSituacaoPlanejamento("Cancelado", CsTipoPlanejamento.Cancelamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Não);
            SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);

            situacaoPlanejamento = CriarSituacaoPlanejamento("Impedido", CsTipoPlanejamento.Impedimento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Não);
            SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);

            //Criando a situação planejamento padrão
            const string       txDescricaoSituacaoPadrao = "Em Andamento";
            CsTipoPlanejamento tipoPlanejamentoPadrao    = CsTipoPlanejamento.Execução;

            situacaoPlanejamento = CriarSituacaoPlanejamento(txDescricaoSituacaoPadrao, CsTipoPlanejamento.Execução, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
            Guid oidSituacaoPlanejamentoPadrao = situacaoPlanejamento.Oid;

            SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);

            //Pesquisando a situação planejamento padrão
            var situacaoPlanejamentoEsperada = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);

            Assert.IsNotNull(situacaoPlanejamentoEsperada, "Deveria ter encontrado a situação planejamento padrão");
            Assert.AreEqual(txDescricaoSituacaoPadrao, situacaoPlanejamentoEsperada.TxDescricao, string.Format("A situação planejamento esperada deveria ser {0}", txDescricaoSituacaoPadrao));
            Assert.AreEqual(oidSituacaoPlanejamentoPadrao, situacaoPlanejamentoEsperada.Oid, string.Format("O oid da situação planejamento padrão deveria ser {0}", oidSituacaoPlanejamentoPadrao));
            Assert.AreEqual(tipoPlanejamentoPadrao, situacaoPlanejamentoEsperada.CsTipo, string.Format("O tipo de planejamento padrão deveria ser {0}", tipoPlanejamentoPadrao.ToString()));
        }
示例#7
0
        /// <summary>
        /// Validar se um tipo de situação planejamento é ou não válido considerando as estimativas atuais
        /// </summary>
        /// <param name="tipo">Tipo de situação planejamento</param>
        /// <returns> True para tipo de situação planejamento válido em relação as estimativas e  False para não válido</returns>
        public bool ValidarSituacaoPlanejamento()
        {
            CsTipoPlanejamento tipo          = situacoesPlanejamento.First(o => o.Oid.Equals(view.OidSituacaoPlanejamento)).CsTipo;
            TimeSpan           horaRealizada = GetValorHoraRealizadoView();
            TimeSpan           horaRestante  = GetValorHoraRestanteView();

            return(ValidarSituacaoPlanejamento(tipo, situacoesPlanejamento, horaRealizada, horaRestante, cronogramaTarefa));
        }
 /// <summary>
 /// Método auxiliar para criar uma instancia de situação planejamento
 /// </summary>
 /// <param name="descricao">descrição da situação planejamento</param>
 /// <param name="tipoSituacao">tipo de situação</param>
 /// <param name="ativo">estado da situação planejamento</param>
 /// <param name="padrao">verificar se a situação é padrão</param>
 /// <returns></returns>
 public static SituacaoPlanejamento CriarSituacaoPlanejamento(string descricao,
                                                              CsTipoPlanejamento tipoSituacao, CsTipoSituacaoPlanejamento ativo, CsPadraoSistema padrao)
 {
     return(new SituacaoPlanejamento()
     {
         TxDescricao = descricao, CsTipo = tipoSituacao, CsPadrao = padrao, CsSituacao = ativo
     });
 }
示例#9
0
        /// <summary>
        /// Retornar o guid de identifação da situação planejamento pelo tipo selecionado
        /// </summary>
        /// <param name="tipo"></param>
        /// <returns></returns>
        private Guid GetOidSituacaoPlanejamentoPorTipo(CsTipoPlanejamento tipo)
        {
            SituacaoPlanejamentoDTO situacao = situacoesPlanejamento.FirstOrDefault(o => o.CsTipo.Equals(tipo));

            if (situacao != null)
            {
                return(situacao.Oid);
            }
            return(new Guid());
        }
示例#10
0
        public void DadoQueExistaMASSituacaoOesDePlanejamentoASeguir(Table table)
        {
            CsPadraoSistema    padraoSistema    = CsPadraoSistema.Não;
            CsTipoPlanejamento tipoPlanejamento = CsTipoPlanejamento.Cancelamento;

            for (int i = 0; i < table.RowCount; i++)
            {
                padraoSistema = SituacaoPlanejamentoBddHelper.ConverterSituacaoPadraoSistemaStrinParaSituacaoPadraoSistemaDomain(table.Rows[i][table.Header.ToList()[3]]);

                tipoPlanejamento = SituacaoPlanejamentoBddHelper.ConverterTipoPlanejamentoStringParaTipoPlanejamentoDomain(table.Rows[i][table.Header.ToList()[0]]);

                CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, table.Rows[i][table.Header.ToList()[1]], CsTipoSituacaoPlanejamento.Ativo, tipoPlanejamento, padraoSistema);
            }
        }
        /// <summary>
        /// Resgata a situação
        /// </summary>
        /// <param name="contexto">Sessão</param>
        /// <param name="tipo">Tipo da situação</param>
        /// <returns>Situação baseada nos parametros acima</returns>
        public static SituacaoPlanejamento ConsultarSituacao(Session session, CsTipoPlanejamento tipo)
        {
            SortingCollection sortCollection = new SortingCollection();

            ICollection collection = session.GetObjects(session.GetClassInfo <SituacaoPlanejamento>(),
                                                        CriteriaOperator.Parse(String.Format("CsSituacao = '{0}' AND CsTipo = '{1}'",
                                                                                             CsTipoSituacaoPlanejamento.Ativo, tipo)), sortCollection, 1, false, true);

            foreach (SituacaoPlanejamento ct in collection)
            {
                return(ct);
            }

            return(null);
        }
示例#12
0
        /// <summary>
        /// Método que verifica se tarefa atual pode receber um tipo de situacaoPlanejamento
        /// </summary>
        /// <param name="tarefa">instancia da tarefa</param>
        /// <param name="tipo">tipo de planejamento que irá receber</param>
        protected bool ValidarEdicaoSituacaoPlanejamento(CronogramaTarefaDto tarefa, CsTipoPlanejamento tipo, out string motivo)
        {
            motivo = null;
            if (tarefa == null)
            {
                return(false);
            }

            switch (tipo)
            {
            case CsTipoPlanejamento.Encerramento:
                if (PossuiEstimativaInicial(tarefa))
                {
                    return(true);
                }

                motivo = Resources.Alerta_DevePossuirDuracaoTarefa;
                return(false);

            case CsTipoPlanejamento.Execução:

                if (PossuiHorasRestantes(tarefa))
                {
                    return(true);
                }

                motivo = Resources.Alerta_DevePossuirDuracaoTarefa;
                return(false);

            case CsTipoPlanejamento.Planejamento:
                if (!PossuiEsforcoRealizado(tarefa))
                {
                    return(true);
                }

                motivo = Resources.Alerta_PossuiEsforcoRealizadoCadastrado;
                return(false);

            default:
                return(true);
            }
        }
示例#13
0
        public void EntaoASituacaoPlanejamentoDeveraSerDoTipoPois(CsTipoPlanejamento tipoSituacaoPlanejamento, string motivo)
        {
            SituacaoPlanejamentoDTO situacao = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);

            Assert.AreEqual(tipoSituacaoPlanejamento, situacao.CsTipo, motivo);
        }
示例#14
0
        public void QuandoOColaboradorAlterarASituacaoPlanejamentoDaTarefaDiretamenteParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
        {
            Guid oidSituacaoPlanejamentoAnterior = view.OidSituacaoPlanejamento;

            situacaoSelecionada = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
            presenter.AlterarSituacaoPlanejamento();
        }
示例#15
0
 /// <summary>
 /// Selecionar situação por tipo
 /// </summary>
 /// <param name="tipo">tipo da situação planejamento</param>
 /// <returns>retornar a situação planejamento em que o tipo seja igual ao tipo esperado</returns>
 public SituacaoPlanejamentoDTO GetSituacaoPlanejamento(CsTipoPlanejamento tipo)
 {
     return(planejamentoServiceStub.ConsultarSituacoesPlanejamentoTipadas().FirstOrDefault(o => o.CsTipo == tipo));
 }
 /// <summary>
 /// Consultar Situação Planejamento por Tipo.
 /// </summary>
 /// <param name="tipo">Tipo da situação</param>
 /// <returns>Situação Planejamento</returns>
 public static WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento ConsultarSituacaoPorTipo(CsTipoPlanejamento tipo)
 {
     using (WexDb contexto = ContextFactoryManager.CriarWexDb())
     {
         return(contexto.SituacaoPlanejamento.FirstOrDefault(o => o.CsSituacao == CsTipoSituacaoPlanejamento.Ativo && o.CsTipo == tipo));
     }
 }
 /// <summary>
 /// Método para retornar uma situação planejamento de acordo com o tipo determinado em uma determinada lista de situações planejamento
 /// </summary>
 /// <param name="situacoes">Instância da Lista de situações planejamento</param>
 /// <param name="tipo">Tipo de situação planejamento</param>
 /// <returns></returns>
 public static SituacaoPlanejamentoDTO OndeOTipoFor(this List <SituacaoPlanejamentoDTO> situacoes, CsTipoPlanejamento tipo)
 {
     if (situacoes == null || tipo == null)
     {
         return(null);
     }
     return(situacoes.FirstOrDefault(o => o.CsTipo == tipo));
 }
示例#18
0
        public void EntaoASituacaoPlanejamentoDeveraSerDoTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
        {
            SituacaoPlanejamentoDTO situacao = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);

            Assert.AreEqual(tipoSituacaoPlanejamento, situacao.CsTipo, string.Format("A situação planejamento deveria ser do tipo {2} (Situação Selecionada:{0} | Tipo:{1})", situacao.TxDescricao, situacao.CsTipo, tipoSituacaoPlanejamento));
        }
示例#19
0
 /// <summary>
 /// Validar situacaoPlanejamento
 /// </summary>
 /// <param name="tipo"></param>
 /// <returns></returns>
 public bool ValidarSituacaoPlanejamento(CsTipoPlanejamento tipo)
 {
     return(ValidarSituacaoPlanejamento(tipo, decorator));
 }
示例#20
0
        /// <summary>
        /// Criar uma nova situação planejamento
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        public static SituacaoPlanejamentoDTO CriarSituacaoPlanejamento(string Descricao, CsTipoPlanejamento tipo, bool ativo = true)
        {
            Random random = new Random();
            CsTipoSituacaoPlanejamento statusSituacao;

            if (ativo)
            {
                statusSituacao = CsTipoSituacaoPlanejamento.Ativo;
            }
            else
            {
                statusSituacao = CsTipoSituacaoPlanejamento.Inativo;
            }
            SituacaoPlanejamentoDTO situacao = new SituacaoPlanejamentoDTO()
            {
                Oid         = Guid.NewGuid(),
                TxDescricao = Descricao,
                CsPadrao    = (CsPadraoSistema)random.Next(0, 1),
                CsSituacao  = statusSituacao,
                CsTipo      = tipo,
                TxKeys      = ((Shortcut)(contadorAtalhos + seedShortcut)).ToString(),
                KeyPress    = (Shortcut)(contadorAtalhos + seedShortcut),
                BlImagemSituacaoPlanejamento = null
            };

            contadorAtalhos++;
            return(situacao);
        }