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()));
}
public void NaoDevePermitirSalvarMaisQueUmaSituacaoPlanejamentoPadrao()
{
//Criando uma situação planejamento padrão
var situacaoPlanejamento = CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);
}
public void DeveConsultarSituacoesPlanejamentoInativasQuandoHouverSituacoesInativasCadastradasEAtivas()
{
#region Criação do Cenário
List <SituacaoPlanejamento> situacoesPlanejamento = new List <SituacaoPlanejamento>();
//Criando uma situação planejamento padrão
situacoesPlanejamento.Add(CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim));
situacoesPlanejamento.Add(CriarSituacaoPlanejamento("Em Andamento", CsTipoPlanejamento.Execução, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Não));
situacoesPlanejamento.Add(CriarSituacaoPlanejamento("Cancelado", CsTipoPlanejamento.Cancelamento, CsTipoSituacaoPlanejamento.Inativo, CsPadraoSistema.Não));
for (int i = 0; i < situacoesPlanejamento.Count; i++)
{
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacoesPlanejamento[i]);
}
#endregion
#region Testando regra
List <SituacaoPlanejamento> situacoesPlanejamentoConsultadas = SituacaoPlanejamentoDAO.ConsultarSituacoesInativas();
#endregion
#region Validação
Assert.AreEqual(1, situacoesPlanejamentoConsultadas.Count, "Deve possuir 1 situação inativa, pois foi criado somente uma.");
#endregion
}
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 editar uma tarefa
/// </summary>
/// <param name="contexto">Sessão corrente</param>
/// <param name="oidCronogramaTarefa">Oid (Guid) da tarefa a ser editada</param>
/// <param name="txDescricao">Descrição da tarefa alterada</param>
/// <param name="oidSituacaoPlanejamento">Oid (Guid) da tarefa editada</param>
/// <param name="dataInicio">Data de Inicio da tarefa editada</param>
/// <param name="login">Login do usuário que editou a tarefa</param>
/// <param name="txObservacao">Observação da tarefa editada</param>
/// <param name="responsaveis">array de responsáveis pela tarefa</param>
/// <param name="nbEstimativaInicial">Estimativa inicial da tarefa</param>
/// <param name="nbEstimativaRestante">Estimativa restante da tarefa</param>
/// <param name="nbRealizado">Horas realizadas da tarefa</param>
/// <param name="csLinhaBaseSalva">Boolean afirmando se a tarefa foi salva a linda de base</param>
/// <returns>Retorna uma Hash contendo dados de atualizado em, atualizado por e confirmação da edição</returns>
public static Hashtable EditarTarefa(string oidCronogramaTarefa, string txDescricao, string oidSituacaoPlanejamento,
string login, string txObservacao, string responsaveis,
Int16 nbEstimativaInicial, TimeSpan nbEstimativaRestante, TimeSpan nbRealizado, bool csLinhaBaseSalva, DateTime dataInicio)
{
if (oidCronogramaTarefa == null || txDescricao == null || oidSituacaoPlanejamento == null ||
login == null)
{
throw new ArgumentException("Os parâmetros OidCronogramaTarefa, TxDescricao, DataInício, SituacaoPlanejamento, login e TxObservação são obrigatórios.");
}
Hashtable dadosEdicaoTarefa = new Hashtable();
CronogramaTarefa cronogramaTarefa = CronogramaTarefaDao.ConsultarCronogramaTarefaPorOid(Guid.Parse(oidCronogramaTarefa), o => o.Tarefa.SituacaoPlanejamento, o => o.Tarefa.AtualizadoPor.Usuario.Person);
if (cronogramaTarefa == null)
{
dadosEdicaoTarefa.Add("EdicaoStatus", false);
return(dadosEdicaoTarefa);
}
Tarefa tarefaAntiga = cronogramaTarefa.Tarefa.Clone();
Colaborador colaborador = ColaboradorDAO.ConsultarColaborador(login, o => o.Usuario.Person);
SituacaoPlanejamento situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPlanejamentoPorOid(Guid.Parse(oidSituacaoPlanejamento));
if (colaborador != null)
{
cronogramaTarefa.Tarefa.OidAtualizadoPor = colaborador.Oid;
cronogramaTarefa.Tarefa.AtualizadoPor = null;
}
if (situacaoPlanejamento != null)
{
cronogramaTarefa.Tarefa.OidSituacaoPlanejamento = situacaoPlanejamento.Oid;
cronogramaTarefa.Tarefa.SituacaoPlanejamento = null;
}
cronogramaTarefa.Tarefa.CsLinhaBaseSalva = csLinhaBaseSalva;
cronogramaTarefa.Tarefa.NbEstimativaInicial = nbEstimativaInicial;
cronogramaTarefa.Tarefa.EstimativaRealizadoHora = nbRealizado;
cronogramaTarefa.Tarefa.TxDescricao = txDescricao;
cronogramaTarefa.Tarefa.TxObservacao = txObservacao;
cronogramaTarefa.Tarefa.DtAtualizadoEm = DateTime.Now;
cronogramaTarefa.Tarefa.TxResponsaveis = responsaveis;
cronogramaTarefa.Tarefa.DtInicio = dataInicio;
EstimarHorasRestantesSugeridaPorTipoSituacaoPlanejamento(cronogramaTarefa.Tarefa, nbEstimativaRestante.Ticks, situacaoPlanejamento);
TarefaDao.SalvarTarefa(cronogramaTarefa.Tarefa);
TarefaHistoricoEstimativaBo.CriarHistorico(DateUtil.ConsultarDataHoraAtual(), cronogramaTarefa.Tarefa.Oid, cronogramaTarefa.Tarefa.NbEstimativaRestante);
TarefaLogAlteracaoBo.CriarLogTarefa(cronogramaTarefa.Tarefa, tarefaAntiga);
dadosEdicaoTarefa.Add("EdicaoStatus", true);
dadosEdicaoTarefa.Add("DtAtualizadoEm", cronogramaTarefa.Tarefa.DtAtualizadoEm);
dadosEdicaoTarefa.Add("TxAtualizadoPor", colaborador.NomeCompleto);
return(dadosEdicaoTarefa);
}
/// <summary>
/// Método responsável por criar um histórico para uma determinada tarefa.
/// </summary>
///
/// <param name="oidTarefa">Oid da Tarefa</param>
/// <param name="login">Login do usuário</param>
/// <param name="nbHoraRealizado">Horas realizadas na atividade.</param>
/// <param name="dtRealizado">Data de realização da atividade.</param>
/// <param name="nbHoraInicial">Hora Inicial da atividade</param>
/// <param name="nbHoraFinal">Hora Final da atividade</param>
/// <param name="txComentario">Comentário da atividade</param>
/// <param name="nbHoraRestante">Horas restantes da atividade</param>
/// <param name="oidSituacaoPlanejamento">Oid da Situação Planejamento da atividade</param>
/// <param name="txJustificativaReducao">Justificativa de redução da atividade</param>
public static void CriarHistoricoTarefa(Guid oidTarefa, string login, TimeSpan nbHoraRealizado, DateTime dtRealizado, TimeSpan nbHoraInicial, TimeSpan nbHoraFinal, string txComentario, TimeSpan nbHoraRestante, Guid oidSituacaoPlanejamento, string txJustificativaReducao)
{
if (oidTarefa == new Guid() || String.IsNullOrEmpty(login))
{
throw new ArgumentException("Os parâmetros Login e OidTarefa não podem ser nulos.");
}
TarefaHistoricoTrabalho historico = new TarefaHistoricoTrabalho();
Tarefa tarefa = TarefaDao.ConsultarTarefaPorOid(oidTarefa);
Colaborador colaborador = ColaboradorDAO.ConsultarColaborador(login, o => o.Usuario.Person);
if (tarefa == null)
{
return;
}
SituacaoPlanejamento situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPlanejamentoPorOid(oidSituacaoPlanejamento);
if (tarefa.NbEstimativaInicial <= 0 && (situacaoPlanejamento.CsTipo == CsTipoPlanejamento.Cancelamento || situacaoPlanejamento.CsTipo == CsTipoPlanejamento.Planejamento))
{
TarefaBo.AtualizarDadosTarefa(tarefa.Oid, colaborador, situacaoPlanejamento, nbHoraRealizado, nbHoraRestante, tarefa.CsLinhaBaseSalva);
return;
}
// Caso não possua estimativa inicial não deve salvar historico da tarefa
if (tarefa.NbEstimativaInicial <= 0 && situacaoPlanejamento.CsTipo != CsTipoPlanejamento.Impedimento)
{
throw new EstimativaInicialInvalidaException("Histórico da Tarefa não pode ser salvo, pois não foi estimado um tempo inicial para realização da tarefa");
}
if (!tarefa.CsLinhaBaseSalva)
{
TarefaBo.SalvarLinhaBaseTarefa(tarefa);
}
historico.OidTarefa = tarefa.Oid;
historico.HoraRealizado = nbHoraRealizado;
historico.DtRealizado = dtRealizado;
historico.HoraInicio = nbHoraInicial;
historico.HoraFinal = nbHoraFinal;
historico.TxComentario = txComentario;
historico.HoraRestante = nbHoraRestante;
historico.TxJustificativaReducao = txJustificativaReducao;
historico.OidColaborador = colaborador.Oid;
historico.OidSituacaoPlanejamento = situacaoPlanejamento.Oid;
historico.TxComentario = txComentario;
historico.TxJustificativaReducao = txJustificativaReducao;
using (WexDb contexto = ContextFactoryManager.CriarWexDb())
{
contexto.TarefaHistoricoTrabalho.Add(historico);
contexto.SaveChanges();
}
//Atualiza os dados da tarefa a partir dos dados salvos no histórico.
TarefaBo.AtualizarDadosTarefa(tarefa.Oid, colaborador, situacaoPlanejamento, historico.HoraRealizado, historico.HoraRestante, tarefa.CsLinhaBaseSalva);
}
/// <summary>
/// Método responsável por criar uma tarefa dependente de projeto e cronograma.
/// É acessado pelo serviço de planejamento quando solicitado pela tela de cronograma.
/// </summary>
/// <param name="contexto">Contexto do banco</param>
/// <param name="login">Login do usuario</param>
/// <param name="oidCronograma"> oid cronograma</param>
/// <param name="txDescricaoTarefa"> descrição da tarefa </param>
/// <param name="txObservacaoTarefa">observações da tarefa</param>
/// <param name="oidSituacao">oid situação da tarefa</param>
/// <param name="responsaveis">responsáveis pela tarefa</param>
/// <param name="nbEstimativaInicial"> horas estimadas inicialmente</param>
/// <param name="dtInicio"> data de inicio da tarefa</param>
/// <param name="oidTarefaSelecionada">oid da tarefa</param>
/// <param name="salvar"> condição para indicar se irá salvar ou não a tarefa dentro da classe tarefa</param>
/// <returns>hash contendo informações sobre a tarefa e lista das tarefas impactadas</returns>
public static CronogramaTarefa CriarTarefa(Guid oidCronograma, string txDescricaoTarefa, string oidSituacao, DateTime dtInicio, string login, string txObservacaoTarefa, string responsaveis, out List <CronogramaTarefa> tarefasImpactadas, ref DateTime dataHoraAcao, Int16 nbEstimativaInicial = 0, short nbIDReferencia = 0)
{
if (oidCronograma == null || oidCronograma == new Guid() || String.IsNullOrEmpty(oidSituacao))
{
throw new ArgumentException("Os parametros session, oidCronograma sao obrigatorios.");
}
SituacaoPlanejamento situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPlanejamentoPorOid(Guid.Parse(oidSituacao));
CronogramaTarefa novaTarefa = CronogramaTarefaBo.CriarCronogramaTarefa(oidCronograma, txDescricaoTarefa, situacaoPlanejamento, dtInicio, responsaveis, login, out tarefasImpactadas, ref dataHoraAcao, txObservacaoTarefa, nbEstimativaInicial, nbIDReferencia);
return(novaTarefa);
}
/// <summary>
/// Método responsável por buscar a situaçao de planejamento padrão
/// É acionado pelo serviço, acessa a classe SituaçãoPlanejamento
/// </summary>
/// <param name="session">Sessão Corrente</param>
/// <returns>Objeto SituaçãoPlanejamento</returns>
public static SituacaoPlanejamentoDTO ConsultarSituacaoPadrao( )
{
using (WexDb contexto = new WexDb())
{
WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
if (situacaoPlanejamento != null)
{
return(SituacaoPlanejamentoDAO.DtoFactory(situacaoPlanejamento));
}
return(null);
}
}
public void DeveConsultarASituacaoPlanejamentoPadraoCadastrada()
{
const string txDescricao = "Não iniciado";
var situacaoPlanejamento = CriarSituacaoPlanejamento(txDescricao, CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
Guid oidSituacaoPlanejamento = situacaoPlanejamento.Oid;
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);
var situacaoPlanejamentoEsperada = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
Assert.IsNotNull(situacaoPlanejamentoEsperada, "Deveria ter encontrado a situação planejamento padrão");
Assert.AreEqual(txDescricao, situacaoPlanejamentoEsperada.TxDescricao, string.Format("A situação planejamento esperada deveria ser {0}", txDescricao));
Assert.AreEqual(oidSituacaoPlanejamento, situacaoPlanejamentoEsperada.Oid, string.Format("O oid da situação planejamento padrão deveria ser {0}", oidSituacaoPlanejamento));
}
public void DeveCriarEArmazenarUmaSituacaoPlanejamento()
{
const string txDescricao = "Não iniciado";
Guid fixedOid = Guid.NewGuid();
var situacaoPlanejamento = new SituacaoPlanejamento();
situacaoPlanejamento.Oid = fixedOid;
situacaoPlanejamento.TxDescricao = txDescricao;
situacaoPlanejamento.CsPadrao = CsPadraoSistema.Sim;
situacaoPlanejamento.CsSituacao = CsTipoSituacaoPlanejamento.Ativo;
situacaoPlanejamento.CsTipo = CsTipoPlanejamento.Planejamento;
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);
Assert.AreEqual(1, contexto.SituacaoPlanejamento.Local.Count, "Deveria conter uma nova situação planejamento");
Assert.AreEqual(txDescricao, contexto.SituacaoPlanejamento.Find(fixedOid).TxDescricao, string.Format("Deveria ter encontrado uma situação com a seguinte descrição {0}", txDescricao));
}
/// <summary>
/// Consultar Situações Ativas e transformá-las em DTO
/// </summary>
/// <returns>Lista de Objetos SituacaoPlanejamentoDTO</returns>
public static List <SituacaoPlanejamentoDTO> ConsultarSituacoesAtivas()
{
List <SituacaoPlanejamentoDTO> situacoesPlanejamentoDTO = new List <SituacaoPlanejamentoDTO>();
List <WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento> situacoesPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacoesAtivas();
if (situacoesPlanejamento.Count > 0)
{
for (int i = 0; i < situacoesPlanejamento.Count; i++)
{
situacoesPlanejamentoDTO.Add(SituacaoPlanejamentoDAO.DtoFactory(situacoesPlanejamento[i]));
}
}
return(situacoesPlanejamentoDTO);
}
public void DeveConsultarSituacaoPlanejamentoPadraoQuandoNaoHouveremSituacoesPadraoCadastradas()
{
//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);
//Pesquisando a situação planejamento padrão
var situacaoPlanejamentoEsperada = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
Assert.IsNull(situacaoPlanejamentoEsperada, "Não deveria ter encontrado a situação planejamento padrão pois não existem situações planejamento ativas");
Assert.AreEqual(4, contexto.SituacaoPlanejamento.Local.Count, "Deveriam estar cadastradas 4 situações planejamento");
}
/// <summary>
/// Realiza a troca de padrão quando um novo registro é definido como padrão
/// </summary>
public static void DesabilitarSituacaoPlanejamentoPadraoAnterior(Session session, Guid oidSituacaoPlanejamentoPadraoAtual)
{
List <SituacaoPlanejamento> situacoesPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacoesAtivas(session).ToList();
if (situacoesPlanejamento != null && situacoesPlanejamento.Count > 0)
{
SituacaoPlanejamento situacaoPadraoAtual = situacoesPlanejamento.Where(o => o.Oid == oidSituacaoPlanejamentoPadraoAtual).FirstOrDefault();
if (situacaoPadraoAtual != null)
{
situacoesPlanejamento.Remove(situacaoPadraoAtual);
}
foreach (SituacaoPlanejamento situacao in situacoesPlanejamento)
{
if (situacao.CsPadrao == CsPadraoSistema.Sim)
{
situacao.CsPadrao = CsPadraoSistema.Não;
situacao.Save();
}
}
}
}
public void DeveRetirarUmaSituacaoQueEPadraoParaQueNaoSejaPadraoQuandoSolicitado()
{
#region Criação do Cenário
//Criando uma situação planejamento padrão
CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
#endregion
#region Testando regra
SituacaoPlanejamentoBO.RetirarSituacaoPlanejamentoPadrao(contexto);
var situacaoPlanejamentoConsultada = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
#endregion
#region Validação
Assert.IsNull(situacaoPlanejamentoConsultada, "Não deve existir uma SituaçãoPlanejamento padrão, pois foi retirada.");
#endregion
}
public void DeveConsultarUmaSituacaoPorTipoQuandoExistirUmaSituacaoCadastradaComOMesmoTipo()
{
#region Criação do Cenário
//Criando uma situação planejamento padrão
var situacaoPlanejamento = CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);
#endregion
#region Testando regra
var situacaoPlanejamentoConsultada = SituacaoPlanejamentoDAO.ConsultarSituacaoPorTipo(CsTipoPlanejamento.Planejamento);
#endregion
#region Validação
Assert.AreEqual(situacaoPlanejamento.Oid, situacaoPlanejamentoConsultada.Oid, "Devem ser iguais, pois são do mesmo Oid.");
#endregion
}
public void CriarTarefaQuandoSituacaoPlanejamentoForPadraoTest()
{
//Situação planejamento
SituacaoPlanejamento situacaoPlanejamento1 = CronogramaFactoryEntity.CriarSituacaoPlanejamento(contexto,
"S1", CsTipoSituacaoPlanejamento.Ativo, CsTipoPlanejamento.Execução, CsPadraoSistema.Sim, true);
Colaborador colaborador1 = ColaboradorFactoryEntity.CriarColaborador(contexto, "anderson.lins", true);
Colaborador colaborador2 = ColaboradorFactoryEntity.CriarColaborador(contexto, "pedro.lins", true);
colaborador2.Usuario.UserName = "******";
string responsaveis = String.Format("{0},{1}", colaborador1.NomeCompleto, colaborador2.NomeCompleto);
//iníco tarefa
DateTime dtInicio = new DateTime();
//cria tarefa
Tarefa tarefa1 = new Tarefa();
tarefa1 = TarefaBo.CriarTarefa("Tarefa 01", situacaoPlanejamento1, dtInicio, colaborador1.Usuario.UserName, "Criar método1", responsaveis, 3);
//busca tarefa criada
Tarefa tarefaCriada1 = contexto.Tarefa.FirstOrDefault(o => o.Oid == tarefa1.Oid);
//verifica se existe
Assert.IsNotNull(tarefaCriada1, "Deveria retornar uma tarefa.");
Assert.AreEqual(tarefa1.Oid, tarefaCriada1.Oid, "Deveria ter criado uma tarefa com os mesmos dados");
//verifica se os responsáveis são os mesmos.
Assert.AreEqual("Anderson Lins,Pedro Lins", tarefa1.TxResponsaveis, "Deveria retornar 3 responsáveis cadastrados na tarefa.");
//Verifica Situação Planejamento
Assert.AreEqual(situacaoPlanejamento1.Oid, tarefa1.OidSituacaoPlanejamento);
Assert.AreEqual(SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto).Oid, tarefa1.OidSituacaoPlanejamento);
}
public void DeveConsultarUmaSituacaoPlanejamentoPorOidQuandoExistirUmaSituacaoPlanejamentoCadastrada()
{
#region Criação do Cenário
//Criando uma situação planejamento padrão
var situacaoPlanejamento = CriarSituacaoPlanejamento("Não iniciado", CsTipoPlanejamento.Planejamento, CsTipoSituacaoPlanejamento.Ativo, CsPadraoSistema.Sim);
SituacaoPlanejamentoDAO.CriarSituacaoPlanejamento(contexto, situacaoPlanejamento);
#endregion
#region Testando regra
var situacaoPlanejamentoConsultada = SituacaoPlanejamentoDAO.ConsultarSituacaoPlanejamentoPorOid(situacaoPlanejamento.Oid);
#endregion
#region Validação
Assert.IsNotNull(situacaoPlanejamento, "Não deve ser nulo, pois foi criada uma SituaçãoPlanejamento.");
Assert.AreEqual(situacaoPlanejamento.Oid, situacaoPlanejamentoConsultada.Oid);
#endregion
}
/// <summary>
/// Método que salva uma nova Situação Padrão para o sistema e altera a antiga Situação Planejamento que está como padrão para que não seja padrão.
/// </summary>
public static void RetirarSituacaoPlanejamentoPadrao(WexDb contexto)
{
WexProject.BLL.Entities.Planejamento.SituacaoPlanejamento antigaSituacaoPlanejamentoPadrao = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
if (antigaSituacaoPlanejamentoPadrao != null)
{
antigaSituacaoPlanejamentoPadrao.CsPadrao = CsPadraoSistema.Não;
contexto.SaveChanges();
}
}
public void DeveConsultarASituacaoPlanejamentoERetornarNullQuandoNaoHouverSituacoesPlanejamentoCadastradas()
{
var situacaoPlanejamento = SituacaoPlanejamentoDAO.ConsultarSituacaoPadraoEntity(contexto);
Assert.IsNull(situacaoPlanejamento, "Não deveria ter localizado nenhuma situação planejamento");
}
