/// <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);
}
/// <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);
}
/// <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);
}
public void QuandoOColaboradorAlterarASituacaoDaTarefaParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
{
situacaoSelecionadaAnterior = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
situacaoSelecionada = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
view.OidSituacaoPlanejamento = situacaoSelecionada.Oid;
presenter.AlterarSituacaoPlanejamento();
}
/// <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()));
}
/// <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
});
}
/// <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());
}
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);
}
/// <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);
}
}
public void EntaoASituacaoPlanejamentoDeveraSerDoTipoPois(CsTipoPlanejamento tipoSituacaoPlanejamento, string motivo)
{
SituacaoPlanejamentoDTO situacao = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
Assert.AreEqual(tipoSituacaoPlanejamento, situacao.CsTipo, motivo);
}
public void QuandoOColaboradorAlterarASituacaoPlanejamentoDaTarefaDiretamenteParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
{
Guid oidSituacaoPlanejamentoAnterior = view.OidSituacaoPlanejamento;
situacaoSelecionada = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
presenter.AlterarSituacaoPlanejamento();
}
/// <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));
}
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));
}
/// <summary>
/// Validar situacaoPlanejamento
/// </summary>
/// <param name="tipo"></param>
/// <returns></returns>
public bool ValidarSituacaoPlanejamento(CsTipoPlanejamento tipo)
{
return(ValidarSituacaoPlanejamento(tipo, decorator));
}
/// <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);
}