/// <summary>
/// Método responsável por validar e alterar a situação planejamento, quando outros campos influenciarem a situação de planejamento, de acordo com a hora restante e hora realizado.
/// </summary>
public virtual void CalcularSituacaoPlanejamento(ref Guid oidSituacaoPlanejamento)
{
SituacaoPlanejamentoDTO situacaoPlanejamentoAtual = GetSituacaoPlajenamentoAtual();
if (ValidarSituacaoPlanejamento(situacaoPlanejamentoAtual.CsTipo))
{
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Planejamento))
{
view.OidSituacaoPlanejamento = GetOidSituacaoPlanejamentoTipoPlanejamento();
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Execução))
{
view.OidSituacaoPlanejamento = GetOidSituacaoPlanejamentoTipoExecucao();
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Encerramento))
{
view.OidSituacaoPlanejamento = GetOidSituacaoPlanejamentoTipoEncerramento();
return;
}
}
/// <summary>
/// Método responsável por inicializar os valores dos campos do popup a partir do último histórico de uma tarefa, caso não tenha inicializa valores padrões.
/// </summary>
/// <param name="oidCronogramaTarefa">Oid da Tarefa</param>
/// <param name="nbEstimativaInicial">Estimativa Inicial (Hora) da tarefa</param>
/// <param name="oidSituacaoPlanejamento">oid da situação planejamento que foi setado</param>
public virtual void InicializarHistoricoTarefa(CronogramaTarefaDecorator cronogramaTarefaDto, string login, Guid oidSituacaoPlanejamento, bool aoIniciarView = false)
{
InicializarHistoricoTarefa(cronogramaTarefaDto, login);
SituacaoPlanejamentoDTO situacaoPlanejamento = situacoesPlanejamento.First(o => o.Oid.Equals(oidSituacaoPlanejamento));
switch (situacaoPlanejamento.CsTipo)
{
case CsTipoPlanejamento.Encerramento:
SetarTarefaComoEmEncerramento(aoIniciarView);
break;
case CsTipoPlanejamento.Execução:
SetarTarefaComoEmExecucao(aoIniciarView);
break;
case CsTipoPlanejamento.Impedimento:
SetarTarefaComoEmImpedimento(aoIniciarView);
break;
case CsTipoPlanejamento.Planejamento:
SetarTarefaComoEmPlanejamento(aoIniciarView);
break;
case CsTipoPlanejamento.Cancelamento:
SetarTarefaComoEmCancelamento();
break;
default:
return;
}
}
/// <summary>
/// Método responsável por iniciar e chamar outras validações para situação planejamento
/// </summary>
/// <param name="oidSituacaoPlanejamentoAlterada">Oid situação planejamento desejada</param>
/// <param name="decorator">Objeto Tarefa</param>
/// <returns>Validação</returns>
public override CsSituacaoPlanejamentoTipoRetorno Executar(Guid oidSituacaoPlanejamentoAlterada, CronogramaTarefaDecorator decorator)
{
SituacaoPlanejamentoDTO situacaoAlterada = GetSituacaoPlanejamentoSelecionada(oidSituacaoPlanejamentoAlterada);
if (situacaoAlterada.Oid == decorator.OidSituacaoPlanejamentoTarefa)
{
situacaoController.ForcarFimEdicao();
}
switch (situacaoAlterada.CsTipo)
{
case CsTipoPlanejamento.Encerramento:
return(AlterarParaEncerramento(decorator, situacaoAlterada));
case CsTipoPlanejamento.Execução:
return(AlterarParaExecucao(decorator, situacaoAlterada));
case CsTipoPlanejamento.Impedimento:
return(AlterarParaImpedimento(decorator, situacaoAlterada));
case CsTipoPlanejamento.Planejamento:
return(AlterarParaPlanejamento(decorator, situacaoAlterada));
case CsTipoPlanejamento.Cancelamento:
return(AlterarParaCancelamento(decorator, situacaoAlterada));
default:
return(CsSituacaoPlanejamentoTipoRetorno.SituacaoPlanejamentoRecusada);
}
}
/// <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>
/// 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);
}
/// <summary>
/// Calcula a situação planejamento ideal conforme os dados da tarefa
/// </summary>
/// <param name="decorator"></param>
public void CalcularSituacaoPlanejamentoIdeal(CronogramaTarefaDecorator decorator)
{
SituacaoPlanejamentoDTO situacaoSelecionada = GetSituacaoPlanejamentoSelecionada(decorator.OidSituacaoPlanejamentoTarefa);
if (ValidarSituacaoPlanejamento(situacaoSelecionada.CsTipo, decorator))
{
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Planejamento, decorator))
{
decorator.OidSituacaoPlanejamentoTarefa = GetOidSituacaoPlanejamentoPorTipo(CsTipoPlanejamento.Planejamento);
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Execução, decorator))
{
decorator.OidSituacaoPlanejamentoTarefa = GetOidSituacaoPlanejamentoPorTipo(CsTipoPlanejamento.Execução);
return;
}
if (ValidarSituacaoPlanejamento(CsTipoPlanejamento.Encerramento, decorator))
{
decorator.OidSituacaoPlanejamentoTarefa = GetOidSituacaoPlanejamentoPorTipo(CsTipoPlanejamento.Encerramento);
return;
}
}
public void QuandoOColaboradorAlterarASituacaoDaTarefaParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
{
situacaoSelecionadaAnterior = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
situacaoSelecionada = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
view.OidSituacaoPlanejamento = situacaoSelecionada.Oid;
presenter.AlterarSituacaoPlanejamento();
}
public void QuandoOColaboradorAlterarASituacaoPlanejamentoDaTarefaDiretamenteParaOTipo(CsTipoPlanejamento tipoSituacaoPlanejamento)
{
Guid oidSituacaoPlanejamentoAnterior = view.OidSituacaoPlanejamento;
situacaoSelecionada = GetSituacaoPlanejamento(tipoSituacaoPlanejamento);
presenter.AlterarSituacaoPlanejamento();
}
/// <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>
/// Método responsável por validar a situação planejamento quando o usuário alterar diretamente no combo de situações planejamento.
/// </summary>
/// <param name="autoCalcular">Indicar se deve ou não recalcular a situação planejamento caso seja inválida</param>
public void AlterarSituacaoPlanejamento(bool autoCalcular = true)
{
SituacaoPlanejamentoDTO viewSituacaoPlanejamento = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
switch (viewSituacaoPlanejamento.CsTipo)
{
case CsTipoPlanejamento.Encerramento:
SetarTarefaComoEmEncerramento(false, autoCalcular);
break;
case CsTipoPlanejamento.Execução:
SetarTarefaComoEmExecucao(false, autoCalcular);
break;
case CsTipoPlanejamento.Impedimento:
SetarTarefaComoEmImpedimento(false, autoCalcular);
break;
case CsTipoPlanejamento.Planejamento:
SetarTarefaComoEmPlanejamento(false, autoCalcular);
break;
case CsTipoPlanejamento.Cancelamento:
SetarTarefaComoEmCancelamento();
break;
}
}
/// <summary>
/// Método responsável tentar setar a situação planejamento como Cancelamento (Cancelado)
/// </summary>
public void SetarTarefaComoEmCancelamento()
{
SituacaoPlanejamentoDTO situacaoPlanejamento = situacoesPlanejamento.First(o => o.CsTipo.Equals(CsTipoPlanejamento.Cancelamento));
horaRestante = new TimeSpan(0);
view.OidSituacaoPlanejamento = situacaoPlanejamento.Oid;
horaFinal = horaInicial;
CalcularHoraFinal();
VerificarSeNecessitaJustificativa();
}
/// <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());
}
/////CRIAR REGRA NO ENTITY
///// <summary>
///// Função que não permite deletar uma situação de planejamento já usada
///// </summary>
//[RuleFromBoolProperty( "NaoPermitirDeletarSeTarefaAssociada", DefaultContexts.Delete,
// "A Situação não pode ser deletada pois está associada a uma tarefa." )]
//[NonPersistent, Browsable( false )]
//public bool NaoPermitirDeletarSeTarefaAssociada
//{
// get
// {
// return ConsultarSituacaoUsada( Session );
// }
//}
#region Factories
/// <summary>
/// Método responsável por criar um objeto SituacaoPlanejamentoDto a partir do Objeto SituacaoPlanejamento
/// </summary>
/// <param name="situacaoPlanejamento">Objeto SituacaoPlanejamento</param>
/// <returns>Objeto SituacaoPlanejamentoDto</returns>
public SituacaoPlanejamentoDTO DtoFactory()
{
SituacaoPlanejamentoDTO situacaoPlanejamentoDto = new SituacaoPlanejamentoDTO()
{
Oid = Oid,
TxDescricao = TxDescricao,
CsSituacao = CsSituacao,
CsTipo = CsTipo,
CsPadrao = CsPadrao,
KeyPress = KeyPress,
TxKeys = TxKeys
};
if (BlImagem != null)
{
situacaoPlanejamentoDto.BlImagemSituacaoPlanejamento = ImageUtil.ConverterImagemParaBytes(BlImagem);
}
return(situacaoPlanejamentoDto);
}
/// <summary>
/// Método responsável por buscar a situação planejamento de cada tipo ordenada por ordem alfabética.
/// </summary>
/// <param name="situacoesPlanejamento">Lista contendo todas as situações de planejamento</param>
public void CarregarSituacoesPlanejamentoPorTipo(List <SituacaoPlanejamentoDTO> situacoesPlanejamentoDto)
{
//preenche o atributo estático
situacoesPlanejamento = situacoesPlanejamentoDto;
//retirando valores de referência
List <SituacaoPlanejamentoDTO> situacoesAtivas = new List <SituacaoPlanejamentoDTO>(situacoesPlanejamento);
if (situacoesAtivas.Count <= 0)
{
return;
}
List <SituacaoPlanejamentoDTO> selecao = situacoesAtivas.GroupBy(o => o.CsTipo).Select(o => o.First()).ToList();
situacaoPlanejamentoTipoPlanejamento = selecao.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Planejamento));
situacaoPlanejamentoTipoExecucao = selecao.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Execução));
situacaoPlanejamentoTipoEncerramento = selecao.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Encerramento));
situacaoPlanejamentoTipoImpedimento = selecao.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Impedimento));
situacaoPlanejamentoTipoCancelamento = selecao.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Cancelamento));
}
/// <summary>
/// Método responsável por enviar a requisição para que um histórico seja criado para uma determinada tarefa.
/// Obs: ele pega todos os atributos com os valores atuais que se encontram no popup e os envia para que o histórico seja salvo.
/// </summary>
public void RnCriarHistoricoTarefa()
{
SituacaoPlanejamentoDTO situacaoAtual = GetSituacaoPlajenamentoAtual();
if (situacaoAtual != null && ValidarSituacaoPlanejamento(situacaoAtual.CsTipo))
{
if ((!situacaoAtual.CsTipo.Equals(CsTipoPlanejamento.Cancelamento) && (!situacaoAtual.CsTipo.Equals(CsTipoPlanejamento.Impedimento)) && !situacaoAtual.CsTipo.Equals(CsTipoPlanejamento.Planejamento)) && horaEstimativaInicial.Ticks <= 0)
{
NotificarMensagem(Resources.Caption_Atencao, "Não foi possível salvar a alteração, pois não foi estimado um tempo para a realização da tarefa.");
return;
}
if (!HoraInicialForAHoraInicialSugerida(view.NbHoraInicial) && horaRealizada.Ticks <= 0)
{
NotificarMensagem(Resources.Caption_Atencao, "Não foi possível salvar a alteração.\nNão é permitido alterar a hora inicial sem ter informado um esforço realizado.");
return;
}
if (ModoAtalho && situacaoAtual.CsTipo == CsTipoPlanejamento.Impedimento)
{
horaRealizada = TimeSpan.Zero;
}
servicoPlanejamento.CriarHistoricoTarefa(cronogramaTarefa.OidTarefa, loginColaborador, horaRealizada,
view.DtRealizado, horaInicial, horaFinal, view.TxComentario,
horaRestante, view.OidSituacaoPlanejamento, view.TxJustificativaDeReducao);
if (AoSalvarHistorico != null)
{
AoSalvarHistorico(cronogramaTarefa, new EventArgs());
}
}
else
{
if (!ModoAtalho)
{
NotificarMensagem(Resources.Caption_SituacaoPlanejamentoInvalida, Resources.Alerta_SituacaoPlanejamentoInvalidaAoSalvar);
}
}
}
/// <summary>
/// Método para gerar um Dto a partir da Entidade
/// </summary>
/// <param name="situacao">entidade situação planejamento</param>
/// <returns>Dto referente a entidade</returns>
public static SituacaoPlanejamentoDTO DtoFactory(WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento situacao)
{
if (situacao == null)
{
return(null);
}
SituacaoPlanejamentoDTO situacaoPlanejamentoDto = new SituacaoPlanejamentoDTO()
{
Oid = situacao.Oid,
TxDescricao = situacao.TxDescricao,
CsSituacao = situacao.CsSituacao,
CsTipo = situacao.CsTipo,
CsPadrao = situacao.CsPadrao,
KeyPress = (System.Windows.Forms.Shortcut)situacao.KeyPress,
TxKeys = situacao.TxKeys
};
if (situacao.BlImagem != null)
{
situacaoPlanejamentoDto.BlImagemSituacaoPlanejamento = situacao.BlImagem;
}
return(situacaoPlanejamentoDto);
}
/// <summary>
/// Método responsável por validar a regra quando for alterado para Planejamento
/// </summary>
/// <param name="decorator">Objeto Tarefa</param>
/// <param name="situacaoPlanejamento">Situação planejamento desejada</param>
/// <returns>Validação</returns>
protected override CsSituacaoPlanejamentoTipoRetorno AlterarParaPlanejamento(CronogramaTarefaDecorator decorator, SituacaoPlanejamentoDTO situacaoPlanejamento)
{
if (PossuiEsforcoRealizado(decorator))
{
situacaoController.RecusarSituacaoPlanejamento(decorator, situacaoPlanejamento.Oid);
situacaoController.NotificarMensagem(Resources.Caption_Atencao, Resources.Alerta_PossuiEsforcoRealizadoCadastrado);
situacaoController.LimparBarraStatus();
situacaoController.ForcarFimEdicao();
return(CsSituacaoPlanejamentoTipoRetorno.SituacaoPlanejamentoRecusada);
}
decorator.OidSituacaoPlanejamentoTarefa = situacaoPlanejamento.Oid;
return(CsSituacaoPlanejamentoTipoRetorno.NaoConsumiuHoras);
}
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));
}
public void EntaoASituacaoPlanejamentoDeveraSerDoTipoPois(CsTipoPlanejamento tipoSituacaoPlanejamento, string motivo)
{
SituacaoPlanejamentoDTO situacao = GetSituacaoPlanejamento(view.OidSituacaoPlanejamento);
Assert.AreEqual(tipoSituacaoPlanejamento, situacao.CsTipo, motivo);
}
public CronogramaTarefaDecoratorBuilder SituacaoPlanejamento(SituacaoPlanejamentoDTO situacao)
{
tarefaAtual.OidSituacaoPlanejamentoTarefa = situacao.Oid;
tarefaAtual.TxDescricaoSituacaoPlanejamentoTarefa = situacao.TxDescricao;
return(this);
}
public virtual void ListarSituacoesPlanejamento(List <SituacaoPlanejamentoDTO> situacoes, SituacaoPlanejamentoDTO situacaoPadrao)
{
//Implementar caso haja necessidade nos testes unitários
}
/// <summary> /// Método responsável por validar a regra quando for alterado para Impedimento /// </summary> /// <param name="decorator">Objeto Tarefa</param> /// <param name="situacaoPlanejamento">Situação planejamento desejada</param> /// <returns>Validação</returns> protected abstract CsSituacaoPlanejamentoTipoRetorno AlterarParaImpedimento(CronogramaTarefaDecorator decorator, SituacaoPlanejamentoDTO situacaoPlanejamento);
/// <summary>
/// Método responsável por validar a regra quando for alterado para Cancelamento
/// </summary>
/// <param name="decorator">Objeto Tarefa</param>
/// <param name="situacaoPlanejamento">Situação planejamento desejada</param>
/// <returns>Validação</returns>
protected override CsSituacaoPlanejamentoTipoRetorno AlterarParaCancelamento(CronogramaTarefaDecorator decorator, SituacaoPlanejamentoDTO situacaoPlanejamento)
{
decorator.NbEstimativaRestante = 0;
decorator.OidSituacaoPlanejamentoTarefa = situacaoPlanejamento.Oid;
return(CsSituacaoPlanejamentoTipoRetorno.NaoConsumiuHoras);
}
/// <summary>
/// Método responsável por validar a regra quando for alterado para Impedimento
/// </summary>
/// <param name="decorator">Objeto Tarefa</param>
/// <param name="situacaoPlanejamento">Situação planejamento desejada</param>
/// <returns>Validação</returns>
protected override CsSituacaoPlanejamentoTipoRetorno AlterarParaImpedimento(CronogramaTarefaDecorator decorator, SituacaoPlanejamentoDTO situacaoPlanejamento)
{
decorator.OidSituacaoPlanejamentoTarefa = situacaoPlanejamento.Oid;
return(CsSituacaoPlanejamentoTipoRetorno.NaoConsumiuHoras);
}
/// <summary>
/// Método para selecionar a situação planejamento escolhida na view
/// </summary>
/// <param name="oidSituacaoPlanejamento">oid de identificação da situação planejamento selecionada</param>
/// <returns>situação planejamento selecionada</returns>
public SituacaoPlanejamentoDTO GetSituacaoPlanejamento(Guid oidSituacaoPlanejamento)
{
SituacaoPlanejamentoDTO viewSituacaoPlanejamento = situacoesPlanejamento.First(o => o.Oid.Equals(oidSituacaoPlanejamento));
return(viewSituacaoPlanejamento);
}
/// <summary>
/// Método responsável por validar a regra quando for alterado para Execução
/// </summary>
/// <param name="decorator">Objeto Tarefa</param>
/// <param name="situacaoPlanejamento">Situação planejamento desejada</param>
/// <returns>Validação</returns>
protected override CsSituacaoPlanejamentoTipoRetorno AlterarParaExecucao(CronogramaTarefaDecorator decorator, SituacaoPlanejamentoDTO situacaoPlanejamento)
{
if (NaoPossuiEstimativaInicial(decorator))
{
situacaoController.RecusarSituacaoPlanejamento(decorator, situacaoPlanejamento.Oid);
situacaoController.NotificarMensagem(Resources.Caption_Atencao, Resources.Alerta_DevePossuirDuracaoTarefa);
situacaoController.ForcarFimEdicao();
return(CsSituacaoPlanejamentoTipoRetorno.SituacaoPlanejamentoRecusada);
}
else
{
if (NaoPossuiHorasRestantes(decorator))
{
if (decorator.EstimativaInicial.Ticks <= decorator.NbRealizado)
{
decorator.NbEstimativaRestante = decorator.EstimativaInicial.Ticks;
}
else
{
decorator.NbEstimativaRestante = decorator.EstimativaInicial.Ticks - decorator.NbRealizado;
}
situacaoController.InicializarFormularioHistoricoView(situacaoPlanejamento.Oid);
return(CsSituacaoPlanejamentoTipoRetorno.NaoConsumiuHoras);
}
else
{
decorator.OidSituacaoPlanejamentoTarefa = situacaoPlanejamento.Oid;
return(CsSituacaoPlanejamentoTipoRetorno.NaoConsumiuHoras);
}
}
}
/// <summary>
/// Selecionar uma situação planejamento padrao
/// </summary>
public void SelecionarSituacaoPlanejamentoPadrao()
{
situacaoPlanejamentoPadrao = situacoesPlanejamentoAtivas.FirstOrDefault(o => o.CsTipo.Equals(CsTipoPlanejamento.Planejamento));
}
