public void DeveCalcularDeTimeSpanOFormatoStringAQuantidadeDeHorasInformada()
{
Assert.AreEqual("24:50", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(24, 50, 0)));
Assert.AreEqual("99:00", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(99, 0, 0)));
Assert.AreEqual("99:00", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(98, 60, 0)));
Assert.AreEqual("99:00", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(98, 60, 15)));
}
/// <summary>
/// Método Responsável por realizar atualização da view
/// </summary>
private void AtualizarValoresHorariosDaView()
{
view.NbHoraFinal = horaFinal.ToString(@"hh\:mm");
view.NbHoraInicial = horaInicial.ToString(@"hh\:mm");
view.NbHoraRealizado = horaRealizada.ToString(@"hh\:mm");
view.NbHoraRestante = ConversorTimeSpan.CalcularStringHoras(horaRestante);
}
public void DeveCalcularDoFormatoStringParaOFormatoTimeSpanAQuantidadeDeHorasInformadas()
{
Assert.AreEqual(new TimeSpan(1, 0, 0), ConversorTimeSpan.CalcularHorasTimeSpan("01:00"));
Assert.AreEqual(new TimeSpan(2, 30, 0), ConversorTimeSpan.CalcularHorasTimeSpan("02:30"));
Assert.AreEqual(new TimeSpan(1, 1, 0, 0), ConversorTimeSpan.CalcularHorasTimeSpan("25:00"));
Assert.AreEqual(new TimeSpan(35, 0, 0), ConversorTimeSpan.CalcularHorasTimeSpan("35:00"));
Assert.AreEqual(new TimeSpan(99, 99, 0), ConversorTimeSpan.CalcularHorasTimeSpan("99:99"));
}
public void DeveDesconsiderarDoCalculoHorasAcimaDe9999()
{
//Tamanho máximo permitido 99:00
Assert.AreEqual("99:99", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(200, 0, 0)));
Assert.AreEqual("99:60", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(100, 0, 0)));
Assert.AreEqual("99:99", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(99, 100, 0)));
Assert.AreEqual("99:60", ConversorTimeSpan.CalcularStringHoras(new TimeSpan(99, 60, 0)));
}
/// <summary>
/// Método responsável por calcular o valor da hora final
/// </summary>
public bool CalcularHoraFinal()
{
TimeSpan inicioPeriodo, fimPeriodo;
horaFinal = horaInicial + horaRealizada;
int quantidadePeriodos = 0;
long horasIntervalo = 0;
if (PeriodosDeTrabalho != null && PeriodosDeTrabalho.Length > 1)
{
foreach (var periodo in PeriodosDeTrabalho)
{
inicioPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraInicial);
fimPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraFinal);
if (horaInicial > fimPeriodo)
{
continue;
}
quantidadePeriodos++;
if (quantidadePeriodos > 1)
{
for (int i = 0; i < quantidadePeriodos; i++)
{
if (i + 1 < quantidadePeriodos)
{
TimeSpan _horaInicio = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i + 1].HoraInicial);
TimeSpan _horaFinal = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i].HoraFinal);
horasIntervalo += _horaInicio.Ticks - _horaFinal.Ticks;
}
}
}
if (horaFinal <= fimPeriodo)
{
break;
}
}
}
horaFinal += new TimeSpan(horasIntervalo);
if (horaFinal.Days > 0)
{
//calculando a diferenca que será subtraída do esforço realizado restando apenas o esforço máximo atual
TimeSpan diferenca = horaFinal - new TimeSpan(24, 0, 0);
horaFinal -= diferenca;
horaRealizada -= diferenca;
horaRestante += diferenca;
if (diferenca > TimeSpan.Zero)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Método responsável por calcular o valor da hora final
/// </summary>
public void CalcularHoraFinal()
{
TimeSpan inicioPeriodo, fimPeriodo;
horaFinal = horaInicial + horaRealizada;
int quantidadePeriodos = 0;
long horasIntervalo = 0;
if (PeriodosDeTrabalho != null && PeriodosDeTrabalho.Length > 1)
{
foreach (var periodo in PeriodosDeTrabalho)
{
inicioPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraInicial);
fimPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraFinal);
if (horaInicial > fimPeriodo)
{
continue;
}
quantidadePeriodos++;
if (quantidadePeriodos > 1)
{
for (int i = 0; i < quantidadePeriodos; i++)
{
if (i + 1 < quantidadePeriodos)
{
TimeSpan hi = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i + 1].HoraInicial);
TimeSpan hf = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i].HoraFinal);
horasIntervalo += hi.Ticks - hf.Ticks;
}
}
}
if (horaFinal <= fimPeriodo)
{
break;
}
}
}
horaFinal += new TimeSpan(horasIntervalo);
if (horaFinal.Days > 0)
{
//calculando a diferenca que será subtraída do esforço realizado restando apenas o esforço máximo atual
TimeSpan diferenca = horaFinal - new TimeSpan(24, 0, 0);
horaFinal -= diferenca;
horaRealizada -= diferenca;
horaRestante += diferenca;
if (diferenca > new TimeSpan(0))
{
if (QuandoHoraFinalUltrapassarMeiaNoite != null)
{
QuandoHoraFinalUltrapassarMeiaNoite(diferenca);
}
}
}
AtualizarValoresHorariosDaView();
}
public void DadoQueExistaATarefa(Table table)
{
TarefaEstimativaHelper tarefaHelper = table.CreateInstance <TarefaEstimativaHelper>();
tarefaAtual = planejamentoServiceStub.CriarTarefa(tarefaHelper.Descricao);
tarefaAtual.NbEstimativaInicial = tarefaHelper.EstimativaInicial;
tarefaAtual.NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks(tarefaHelper.Realizado);
tarefaAtual.NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks(tarefaHelper.Restante);
}
/// <summary>
/// Método responsável por calcular o valor da hora final
/// </summary>
public TimeSpan CalcularHoraFinal(PeriodoTrabalhoDto[] PeriodosDeTrabalho, TimeSpan horaInicio, ref TimeSpan esforcoRealizado, ref TimeSpan horaRestante, ref bool ultrapassouLimiteDia)
{
TimeSpan inicioPeriodo, fimPeriodo;
TimeSpan horaFinal = horaInicio + esforcoRealizado;
int quantidadePeriodos = 0;
long horasIntervalo = 0;
if (PeriodosDeTrabalho != null && PeriodosDeTrabalho.Length > 1)
{
foreach (var periodo in PeriodosDeTrabalho)
{
inicioPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraInicial);
fimPeriodo = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(periodo.HoraFinal);
if (horaInicio > fimPeriodo)
{
continue;
}
quantidadePeriodos++;
if (quantidadePeriodos > 1)
{
for (int i = 0; i < quantidadePeriodos; i++)
{
if (i + 1 < quantidadePeriodos)
{
TimeSpan hi = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i + 1].HoraInicial);
TimeSpan hf = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(PeriodosDeTrabalho[i].HoraFinal);
horasIntervalo += hi.Ticks - hf.Ticks;
}
}
}
if (horaFinal <= fimPeriodo)
{
break;
}
}
}
horaFinal += new TimeSpan(horasIntervalo);
if (horaFinal.Days > 0)
{
//calculando a diferenca que será subtraída do esforço realizado restando apenas o esforço máximo atual
TimeSpan diferenca = horaFinal - new TimeSpan(24, 0, 0);
horaFinal -= diferenca;
esforcoRealizado -= diferenca;
horaRestante += diferenca;
if (diferenca > TimeSpan.Zero)
{
ultrapassouLimiteDia = true;
}
}
return(horaFinal);
}
public void DeveConverterParaStringEDepoisRetornarParaTimeSpanUmValorTimesPan()
{
TimeSpan tempo = new TimeSpan(99, 99, 0);
TimeSpan tempoConvertido;
string tempoEmString = ConversorTimeSpan.CalcularStringHoras(tempo);
tempoConvertido = ConversorTimeSpan.CalcularHorasTimeSpan(tempoEmString);
Assert.AreEqual(tempo, tempoConvertido, "Deveria totalizar o mesmo valor");
Assert.AreEqual("99:99", tempoEmString);
}
public void DevePermitirEdicaoSituacaoPlanejamentoParaAndamentoApenasQuandoPossuirHorasParaConsumir()
{
CronogramaTarefaDto novaTarefa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 0,
NbEstimativaRestante = 0,
NbRealizado = 0,
};
CronogramaTarefaDto novaTarefaComEstimativa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("8:00"),
NbRealizado = 0,
};
CronogramaTarefaDto tarefaConsumidaParcialmente = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = true,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
};
CronogramaTarefaDto tarefaPronta = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = true,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = 0,
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("8:00"),
};
CronogramaTarefaDto tarefaCancelada = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = 0,
NbRealizado = 0,
};
string mensagem;
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefa, CsTipoPlanejamento.Execução, out mensagem), "Não deveria permitir setar a situação como execução pois não foi estimada uma quantidade de horas a ser realizada a tarefa.");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefaComEstimativa, CsTipoPlanejamento.Execução, out mensagem), "Deveria permitir setar a situação como execução pois foi estimada uma quantidade de horas a ser realizada a tarefa.");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaConsumidaParcialmente, CsTipoPlanejamento.Execução, out mensagem), "Deveria permitir setar a situação como execução pois ainda há horas restantes para executar a tarefa.");
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaPronta, CsTipoPlanejamento.Execução, out mensagem), "Não deveria permitir setar a situação como execução pois foram consumidas todas as horas de execução da tarefa.");
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaCancelada, CsTipoPlanejamento.Execução, out mensagem), "Não deveria permitir setar a situação como execução pois após o cancelamento não há horas restantes para trabalhar na tarefa.");
}
public void ConverterHorasDeStringParaTicksTest()
{
long estimativaAtual, estimativaEsperada;
estimativaEsperada = 361200000000;
estimativaAtual = ConversorTimeSpan.ConverterHorasDeStringParaTicks("10:02");
Assert.AreEqual(estimativaEsperada, estimativaAtual, "A estimativa convertida deveria ser a mesma da estimativaAtual");
estimativaEsperada = 180000000000;
estimativaAtual = ConversorTimeSpan.ConverterHorasDeStringParaTicks("5:00");
Assert.AreEqual(estimativaEsperada, estimativaAtual, "A estimativa convertida deveria ser a mesma da estimativaAtual");
}
public void DeveConverterOsMinutosInformadosParaHorasQuandoMinutosNaoUltrapassaremUmaHora()
{
const int quantidade1 = 0;
const int quantidade2 = 1;
const int quantidade3 = 30;
const int quantidade4 = 59;
Assert.AreEqual(0, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade1), string.Format("Deveria ter convertido {0} minuto(s) para 0(zero) horas.", quantidade1));
Assert.AreEqual(0, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade2), string.Format("Deveria ter convertido {0} minuto(s) para 0(zero) horas.", quantidade2));
Assert.AreEqual(0, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade3), string.Format("Deveria ter convertido {0} minuto(s) para 0(zero) horas.", quantidade3));
Assert.AreEqual(0, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade4), string.Format("Deveria ter convertido {0} minuto(s) para 0(zero) horas.", quantidade4));
}
public void HouveMudancasEsforcoRealizadoModificadaTest()
{
CronogramaTarefaGridItem tarefaAtual;
Guid oidCronograma = Guid.NewGuid();
Guid oidSituacaoPlanejamento = Guid.NewGuid();
tarefaAtual = CriarTarefa(oidCronograma, oidSituacaoPlanejamento);
TarefaEditada tarefaEmEdicao = new TarefaEditada(tarefaAtual);
tarefaAtual.NbRealizado = 0;
Assert.IsFalse(tarefaEmEdicao.HouveMudancas(tarefaAtual), "As mudanças nulas não devem ser registradas");
tarefaAtual.NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("12:00");
Assert.IsTrue(tarefaEmEdicao.HouveMudancas(tarefaAtual), "Deveria alertar que houve mudança, pois foi modificado esforço realizado da tarefa");
}
/// <summary>
/// Méetodo responsável por retornar ocorrencia da primeira hora de trabalho dos periodos de trabalho atuais
/// </summary>
/// <returns>hora de inicio do dia de trabalho</returns>
public TimeSpan GetHoraInicioPrimeiroPeriodoDeTrabalho()
{
TimeSpan horaInicioDiaDeTrabalho;
if (PeriodosDeTrabalho != null && PeriodosDeTrabalho.Length > 0)
{
horaInicioDiaDeTrabalho = PeriodosDeTrabalho.Min(o => ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(o.HoraInicial));
}
else
{
horaInicioDiaDeTrabalho = new TimeSpan(0);
}
return(horaInicioDiaDeTrabalho);
}
public void DeveConverterOsMinutosInformadosParaHorasQuandoMinutosUltrapassaremUmaHora()
{
const int quantidade1 = 60;
const int quantidade2 = 120;
const int quantidade3 = 1200;
const int resultado1 = 1;
const int resultado2 = 2;
const int resultado3 = 20;
Assert.AreEqual(resultado1, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade1), string.Format("Deveria ter convertido {0} minuto(s) para {1} hora(s).", quantidade1, resultado1));
Assert.AreEqual(resultado2, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade2), string.Format("Deveria ter convertido {0} minuto(s) para {1} hora(s).", quantidade2, resultado2));
Assert.AreEqual(resultado3, ConversorTimeSpan.ConverterMinutosParaHorasInteiras(quantidade3), string.Format("Deveria ter convertido {0} minuto(s) para {1} hora(s).", quantidade3, resultado3));
}
/// <summary>
/// Método responsável por selecionar o periodo de trabalho do dia atual
/// </summary>
public void SelecionarPeriodoTrabalhoDiaAtual()
{
if (DiaTrabalhoAtual != null)
{
PeriodosDeTrabalho = DiaTrabalhoAtual.PeriodosTrabalho.OrderBy(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraInicial)).ToArray();
HoraInicioExpediente = new TimeSpan(PeriodosDeTrabalho.Min(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraInicial)));
HoraFinalExpediente = new TimeSpan(PeriodosDeTrabalho.Max(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraFinal)));
}
else
{
PeriodoTrabalhoDto periodo = new PeriodoTrabalhoDto("08:00", "18:00");
PeriodosDeTrabalho = new PeriodoTrabalhoDto[1];
PeriodosDeTrabalho[0] = periodo;
}
}
public void ConverterHorasDeTicksParaStringTest()
{
string estimativaAtual, estimativaEsperada;
estimativaEsperada = "05:00";
estimativaAtual = ConversorTimeSpan.ConverterHorasDeTicksParaString(180000000000);
Assert.AreEqual(estimativaEsperada, estimativaAtual, "A estimativa convertida deveria ser a mesma da estimativaAtual");
estimativaEsperada = "10:02";
estimativaAtual = ConversorTimeSpan.ConverterHorasDeTicksParaString(361200000000);
Assert.AreEqual(estimativaEsperada, estimativaAtual, "A estimativa convertida deveria ser a mesma da estimativaAtual");
estimativaEsperada = "05:00";
estimativaAtual = ConversorTimeSpan.ConverterHorasDeTicksParaString(180000000000);
Assert.AreEqual(estimativaEsperada, estimativaAtual, "A estimativa convertida deveria ser a mesma da estimativaAtual pois foi arredondado");
}
public void DevePermitirEdicaoSituacaoPlanejamentoParaProntoSePossuirEstimativaInicial()
{
CronogramaTarefaDto novaTarefa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 0,
NbEstimativaRestante = 0,
NbRealizado = 0,
};
CronogramaTarefaDto novaTarefaComEstimativa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("8:00"),
NbRealizado = 0,
};
CronogramaTarefaDto tarefaConsumidaParcialmente = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = true,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
};
CronogramaTarefaDto tarefaCanceladaParcialmenteRealizada = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("6:00"),
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("2:00"),
};
string mensagem;
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefa, CsTipoPlanejamento.Encerramento, out mensagem), "Não deve permitir ir para o estado de pronto pois não possui uma estimativa inicial de duração");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefaComEstimativa, CsTipoPlanejamento.Encerramento, out mensagem), "Deve permitir pois a tarefa já possui uma estimativa inicial de duração.");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaConsumidaParcialmente, CsTipoPlanejamento.Encerramento, out mensagem), "Deve permitir pois a tarefa já possui uma estimativa inicial de duração");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaCanceladaParcialmenteRealizada, CsTipoPlanejamento.Encerramento, out mensagem), "Deve permitir a edição pois a tarefa já possui uma estimativa inicial de duração.");
}
/// <summary>
/// Método responsável por selecionar o periodo de trabalho do dia atual
/// </summary>
public PeriodoTrabalhoDto[] SelecionarPeriodoTrabalhoDiaAtual(DiaTrabalhoDto diaTrabalho, out TimeSpan horaInicioExpediente, out TimeSpan horaFimExpediente)
{
PeriodoTrabalhoDto[] periodos;
if (diaTrabalho != null)
{
periodos = diaTrabalho.PeriodosTrabalho.OrderBy(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraInicial)).ToArray();
horaInicioExpediente = new TimeSpan(periodos.Min(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraInicial)));
horaFimExpediente = new TimeSpan(periodos.Max(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraFinal)));
}
else
{
PeriodoTrabalhoDto periodo = new PeriodoTrabalhoDto("08:00", "18:00");
horaInicioExpediente = new TimeSpan(8, 0, 0);
horaFimExpediente = new TimeSpan(18, 0, 0);
periodos = new PeriodoTrabalhoDto[] { periodo };
}
return(periodos);
}
/// <summary>
/// Método para preencher uma inicialização do dia selecionado
/// </summary>
/// <param name="semanaTrabalho">semana de trabalho do colaborador</param>
/// <param name="dataSelecionada">data de selecao</param>
/// <returns></returns>
private static InicializadorEstimativaDto PreencherInicializacaoDiaSelecionado(SemanaTrabalho semanaTrabalho, DateTime dataSelecionada)
{
InicializadorEstimativaDto inicializadorDto = new InicializadorEstimativaDto();
if (SemanaTrabalhoBo.DiaAtualPossuiPeriodoTrabalho(semanaTrabalho, dataSelecionada.DayOfWeek))
{
inicializadorDto.DataEstimativa = dataSelecionada;
DiaTrabalho dia = SemanaTrabalhoDao.SelecionarDiaTrabalho(semanaTrabalho, dataSelecionada.DayOfWeek);
long ticks = dia.PeriodosDeTrabalho.Min(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraInicial));
inicializadorDto.HoraInicialEstimativa = new TimeSpan(ticks);
}
else
{
inicializadorDto = new InicializadorEstimativaDto()
{
DataEstimativa = dataSelecionada, HoraInicialEstimativa = new TimeSpan(8, 0, 0)
}
};
inicializadorDto.DiaAtual = TarefaHistoricoTrabalhoDao.ConsultarDiaAtualDeTrabalhoDto(dataSelecionada.DayOfWeek, semanaTrabalho);
return(inicializadorDto);
}
/// <summary>
/// Método responsável por capturar a horaInicial da view
/// </summary>
/// <returns>Estrutura timespan com o tempo atual da view</returns>
public virtual TimeSpan GetValorHoraInicialView()
{
return(ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(view.NbHoraInicial));
}
public void DadoQueOUltimoEsforcoEstimadoPeloColaboradorSejaNoDiaAs(DateTime dataAtual, string horaInicio)
{
inicializadorDeEstimativa = new InicializadorEstimativaDto()
{
DataEstimativa = dataAtual, DiaAtual = diaTrabalhoAtual, HoraInicialEstimativa = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(horaInicio)
};
planejamentoServiceStub.RetornoInicializadorEstimativa = inicializadorDeEstimativa;
}
/// <summary>
/// Método responsável por efetuar a seleção da hora de inicio da estimativa de uma tarefa para o colaborador
/// </summary>
/// <param name="contexto">sessão atual do banco</param>
/// <param name="loginColaborador">login do colaborador atual</param>
/// <returns>tarefaHistorico preenchida com</returns>
public static InicializadorEstimativaDto SelecionarInicializadorEstimativaDto(string loginColaborador, DateTime dataSolicitacao, SemanaTrabalho semanaTrabalho)
{
WexDb contexto = ContextFactoryManager.CriarWexDb();
TarefaHistoricoTrabalho ultimoHistoricoTrabalho = TarefaHistoricoTrabalhoDao.ConsultarUltimoEsforcoRealizadoColaborador(contexto, loginColaborador, dataSolicitacao);
InicializadorEstimativaDto inicializadorEstimativaDto = new InicializadorEstimativaDto();
DateTime dataSelecionada;
if (!ValidarTarefaHistoricoTrabalho(ultimoHistoricoTrabalho))
{
dataSelecionada = dataSolicitacao.Date;
SelecionarDataDiaUtilInicial(semanaTrabalho, ref dataSelecionada);
return(PreencherInicializacaoDiaSelecionado(semanaTrabalho, dataSelecionada));
}
bool ultrapassouLimiteDia = ultimoHistoricoTrabalho.HoraFinal.Days > 0;
dataSelecionada = new DateTime(ultimoHistoricoTrabalho.DtRealizado.Ticks);
if (ultrapassouLimiteDia)
{
dataSelecionada = SelecionarDataProximoDiaUtil(semanaTrabalho, dataSelecionada);
return(PreencherInicializacaoDiaSelecionado(semanaTrabalho, dataSelecionada));
}
SelecionarDataDiaUtilInicial(semanaTrabalho, ref dataSelecionada);
if (dataSelecionada.Equals(dataSolicitacao.Date))
{
if (dataSelecionada.Equals(ultimoHistoricoTrabalho.DtRealizado))
{
inicializadorEstimativaDto.DataEstimativa = dataSelecionada;
inicializadorEstimativaDto.HoraInicialEstimativa = ultimoHistoricoTrabalho.HoraFinal;
inicializadorEstimativaDto.DiaAtual = TarefaHistoricoTrabalhoDao.ConsultarDiaAtualDeTrabalhoDto(dataSelecionada.DayOfWeek, semanaTrabalho);
return(inicializadorEstimativaDto);
}
return(PreencherInicializacaoDiaSelecionado(semanaTrabalho, dataSelecionada));
}
else
{
if (SemanaTrabalhoBo.DiaAtualPossuiPeriodoTrabalho(semanaTrabalho, dataSelecionada.DayOfWeek))
{
DiaTrabalho dia = SemanaTrabalhoDao.SelecionarDiaTrabalho(semanaTrabalho, dataSelecionada.DayOfWeek);
long ticks = dia.PeriodosDeTrabalho.Max(o => ConversorTimeSpan.ConverterHorasDeStringParaTicks(o.HoraFinal));
TimeSpan horaFinalExpediente = new TimeSpan(ticks);
if (ultimoHistoricoTrabalho.HoraFinal >= horaFinalExpediente)
{
dataSelecionada = SelecionarDataProximoDiaUtil(semanaTrabalho, dataSelecionada);
return(PreencherInicializacaoDiaSelecionado(semanaTrabalho, dataSelecionada));
}
if (dataSelecionada.Equals(ultimoHistoricoTrabalho.DtRealizado))
{
inicializadorEstimativaDto.DataEstimativa = dataSelecionada;
inicializadorEstimativaDto.HoraInicialEstimativa = ultimoHistoricoTrabalho.HoraFinal;
inicializadorEstimativaDto.DiaAtual = TarefaHistoricoTrabalhoDao.ConsultarDiaAtualDeTrabalhoDto(dataSelecionada.DayOfWeek, semanaTrabalho);
return(inicializadorEstimativaDto);
}
return(PreencherInicializacaoDiaSelecionado(semanaTrabalho, dataSelecionada));
}
else
{
inicializadorEstimativaDto.DataEstimativa = dataSolicitacao.Date;
inicializadorEstimativaDto.HoraInicialEstimativa = new TimeSpan(8, 0, 0);
inicializadorEstimativaDto.DiaAtual = TarefaHistoricoTrabalhoDao.ConsultarDiaAtualDeTrabalhoDto(dataSolicitacao.DayOfWeek, semanaTrabalho);
}
return(inicializadorEstimativaDto);
}
}
public TarefaHistoricoTrabalhoDtoDataBuilder Restaram(string horaRestante)
{
historico.NbRestante = ConversorTimeSpan.CalcularHorasTimeSpan(horaRestante);
return(this);
}
public TarefaHistoricoTrabalhoDtoDataBuilder Realizou(string horaRealizado)
{
historico.NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTimeSpan(horaRealizado);
return(this);
}
/// <summary>
/// Método para verificar se a hora inicial informada é a mesma que a sugerida pelo serviço
/// </summary>
/// <param name="horaInicial"></param>
/// <returns></returns>
public bool HoraInicialForAHoraInicialSugerida(string horaInicial)
{
return(!string.IsNullOrEmpty(horaInicial) && HoraInicialSugerida == ConversorTimeSpan.CalcularHorasTimeSpan(horaInicial));
}
/// <summary>
/// Método responsável por capturar o NbHoraRealizado da view
/// </summary>
/// <returns>Estrutura timespan com o tempo atual da view</returns>
public virtual TimeSpan GetValorHoraRealizadoView()
{
return(ConversorTimeSpan.CalcularHorasTimeSpan(view.NbHoraRealizado));
}
public void RnValidarTarefaEditadaQuandoSituacaoEEstimativasSejamAlteradasTest()
{
//cria situação planejamento
SituacaoPlanejamento situacaoPlanejamento1 = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S1",
CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução,
CsPadraoSistema.Sim, true);
//cria situação planejamento
SituacaoPlanejamento situacaoPlanejamento2 = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto, "S2",
CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Cancelamento,
CsPadraoSistema.Não, true);
//cria cronograma
Cronograma cronograma1 = CronogramaFactoryEntity.CriarCronograma(contexto, "Cronograma 01", situacaoPlanejamento1, new DateTime(),
new DateTime(), true);
//cria colaborador
Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);
//adiciona colaborador como responsável pela tarefa
string responsaveis = colaborador1.NomeCompleto;
List <CronogramaTarefa> tarefasImpactadas;
DateTime dataHoraAcao = new DateTime();
//cria tarefa a partir da RnIncluirTarefa em CronogramaTarefa
CronogramaTarefa novaTarefa = CronogramaTarefaBo.CriarCronogramaTarefa(cronograma1.Oid, "Tarefa 01", situacaoPlanejamento1, DateTime.Now, responsaveis, colaborador1.Usuario.UserName, out tarefasImpactadas, ref dataHoraAcao, "Criar método1", 3, 0);
//recupera a tarefa criada
CronogramaTarefa tarefa = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(novaTarefa.Oid, o => o.Tarefa.SituacaoPlanejamento);
//criar um Dto da tarefa e repassa as informações para poder utilizar o método que está sendo testado
CronogramaTarefaGridItem tarefaDto = new CronogramaTarefaGridItem();
tarefaDto.OidCronogramaTarefa = tarefa.Oid;
tarefaDto.TxDescricaoSituacaoPlanejamentoTarefa = tarefa.Tarefa.SituacaoPlanejamento.TxDescricao;
tarefaDto.NbEstimativaInicial = tarefa.Tarefa.NbEstimativaInicial;
tarefaDto.NbEstimativaRestante = tarefa.Tarefa.NbEstimativaRestante;
//adiciona tarefa na lista de tarefas antigas (antes de serem alteradas)
List <CronogramaTarefaGridItem> tarefasAntigas = new List <CronogramaTarefaGridItem>();
tarefasAntigas.Add(tarefaDto);
//cria uma tarefa Dto alterada e modifica o campo situação de planejamento
CronogramaTarefaGridItem tarefaDtoAlterada = new CronogramaTarefaGridItem();
tarefaDtoAlterada.OidCronogramaTarefa = tarefaDto.OidCronogramaTarefa;
tarefaDtoAlterada.TxDescricaoSituacaoPlanejamentoTarefa = situacaoPlanejamento2.TxDescricao;
tarefaDtoAlterada.NbEstimativaInicial = 18;
tarefaDtoAlterada.NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("5:00");
//adiciona a tarefa na lista de tarefas modificadas.
List <CronogramaTarefaGridItem> tarefasAtualizadas = new List <CronogramaTarefaGridItem>();
tarefasAtualizadas.Add(tarefaDtoAlterada);
//valida os campos alterados
Hashtable camposAlterados = TarefaEditada.ValidarCamposRelevantesAlterados(tarefasAntigas, tarefasAtualizadas);
List <int> campos = new List <int>();
campos = (List <int>)camposAlterados[tarefaDto.OidCronogramaTarefa];
Assert.AreEqual(3, campos.Count, "Deveriam ter sido alterados 3 campos.");
Assert.AreEqual((int)CsTipoCampoEditado.SituacaoPlanejamento, campos[0], "O campo alterado deveria ser do mesmo Tipo");
Assert.AreEqual((int)CsTipoCampoEditado.EstimativaInicial, campos[1], "O campo alterado deveria ser do mesmo Tipo");
Assert.AreEqual((int)CsTipoCampoEditado.EstimativaRestante, campos[2], "O campo alterado deveria ser do mesmo Tipo");
Assert.AreNotEqual(tarefaDto.TxDescricaoSituacaoPlanejamentoTarefa, tarefaDtoAlterada.TxDescricaoSituacaoPlanejamentoTarefa, "Não deveriam ser iguais, pois o campo foi alterado.");
Assert.AreNotEqual(tarefaDto.NbEstimativaInicial, tarefaDtoAlterada.NbEstimativaInicial, "Não deveriam ser iguais, pois o campo foi alterado.");
Assert.AreNotEqual(tarefaDto.NbEstimativaRestante, tarefaDtoAlterada.NbEstimativaRestante, "Não deveriam ser iguais, pois o campo foi alterado.");
}
/// <summary>
/// Método responsável por capturar o NbHoraRealizado da view
/// </summary>
/// <returns>Estrutura timespan com o tempo atual da view</returns>
public virtual TimeSpan GetValorHoraRestanteView()
{
return(ConversorTimeSpan.CalcularHorasTimeSpan(view.NbHoraRestante));
}
public void DevePermitirEdicaoSituacaoPlanejamentoParaNaoIniciadoApenasQuandoNaoFoiRealizadoNenhumEsforco()
{
CronogramaTarefaDto novaTarefa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 0,
NbEstimativaRestante = 0,
NbRealizado = 0,
};
CronogramaTarefaDto novaTarefaComEstimativa = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("8:00"),
NbRealizado = 0,
};
CronogramaTarefaDto tarefaConsumidaParcialmente = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = true,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("4:00"),
};
CronogramaTarefaDto tarefaPronta = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = true,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = 0,
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("8:00"),
};
CronogramaTarefaDto tarefaCancelada = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = 0,
NbRealizado = 0,
};
CronogramaTarefaDto tarefaCanceladaParcialmenteRealizada = new CronogramaTarefaDto()
{
CsLinhaBaseSalva = false,
DtAtualizadoEm = DateTime.Now,
NbEstimativaInicial = 8,
NbEstimativaRestante = ConversorTimeSpan.ConverterHorasDeStringParaTicks("6:00"),
NbRealizado = ConversorTimeSpan.ConverterHorasDeStringParaTicks("2:00"),
};
string mensagem;
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefa, CsTipoPlanejamento.Planejamento, out mensagem), "Deve poder estar na situação de não iniciado pois não foi realizado nenhum esforço");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(novaTarefaComEstimativa, CsTipoPlanejamento.Planejamento, out mensagem), "Deve poder estar na situação de não iniciado pois não foi realizado nenhum esforço.");
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaConsumidaParcialmente, CsTipoPlanejamento.Planejamento, out mensagem), "Não deve poder estar na situação de não iniciado pois foi estimado um esforço realizado.");
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaPronta, CsTipoPlanejamento.Planejamento, out mensagem), "Não deve poder estar na situação de não iniciado pois a tarefa já foi executada.");
Assert.IsTrue(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaCancelada, CsTipoPlanejamento.Planejamento, out mensagem), "Deve poder estar na situação de não iniciado pois não foi realizado nenhum esforço.");
Assert.IsFalse(TarefaEditada.ValidarEdicaoSituacaoPlanejamento(tarefaCanceladaParcialmenteRealizada, CsTipoPlanejamento.Planejamento, out mensagem), "Não deve poder estar na situação de não iniciado pois foi realizado um esforço parcial na tarefa.");
}