public bool PodeEditar(Pacto pacto, Usuario usuariologado, bool isDirigente, bool unidadePactoEhSubordinadaUnidadeUsuario)
{
#region MESMA UNIDADE
if (pacto.IdPacto != 0 && !unidadePactoEhSubordinadaUnidadeUsuario)
{
return(false);
}
if (pacto.IdPacto == 0)
{
return(true);
}
#endregion
#region PERMISSÕES DE AÇÕES DO SOLICITANTE
bool possuiPermissoesSolicitante = PodeEditarPermissoesSolicitante(pacto, usuariologado, isDirigente);
if (possuiPermissoesSolicitante)
{
return(true);
}
#endregion
#region PERMISSÕES DE AÇÕES DO DIRIGENTE
bool possuiPermissoesDirigente = PodeEditarPermissoesDirigente(pacto, usuariologado, isDirigente);
if (possuiPermissoesDirigente)
{
return(true);
}
#endregion
return(false);
}
public void GerarLogAcaoException()
{
var usuario = _usuarioService.ObterPorCPF("11391275861");
var os = _osService.ObterOrdemVigente();
var pacto = new Pacto
{
Nome = "Francir Borges Silva",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "(11) 11111-1111",
TelefoneMovelServidor = "(22) 22222-2222",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now,
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CargaHoraria = 8,
CpfUsuarioCriador = usuario.CPF
};
_uow.BeginTransaction();
var resultado = _logService.Logar(null, usuario.CPF, "Edição");
_uow.Commit();
Assert.IsTrue(resultado.ValidationResult.Message.Contains("sucesso"));
}
private static bool PodeEditarPermissoesDirigente(Pacto pacto, Usuario usuariologado, bool isDirigente)
{
bool possuiPermissoesDirigente = false;
if (isDirigente && pacto.CpfUsuario != usuariologado.Cpf)
{
if (pacto.IdSituacaoPacto == (int)eSituacaoPacto.AIniciar)
{
possuiPermissoesDirigente = true;
}
if (pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Suspenso)
{
List <int> situacoesInvalidas = new List <int>()
{
(int)eSituacaoPacto.Excluido, (int)eSituacaoPacto.Negado, (int)eSituacaoPacto.Interrompido, (int)eSituacaoPacto.Avaliado
};
if (!situacoesInvalidas.Contains(pacto.IdSituacaoPacto) && pacto.DataPrevistaInicio > DateTime.Now)
{
possuiPermissoesDirigente = true;
}
}
}
return(possuiPermissoesDirigente);
}
public void TestUpdate()
{
InitializaNinject();
var usuario = _usuarioService.ObterPorCPF("02941397450");
var pactoService = kernel.Get <IPactoService>();
var os = _osService.ObterOrdemVigente();
var pacto = new Pacto
{
IdPacto = idPacto,
Nome = "Francir Borges Silvério",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "(11) 3333-3333",
TelefoneMovelServidor = "(22) 4444-4444",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now,
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CargaHoraria = 8,
CpfUsuarioCriador = usuario.CPF,
IdTipoPacto = 1
};
pactoService.Atualizar(pacto);
_uow.Commit();
Assert.IsTrue(true);
}
public void TestInsert()
{
InitializaNinject();
var usuario = _usuarioService.ObterPorCPF("02941397450");
var os = _osService.ObterOrdemVigente();
var pacto = new Pacto
{
Nome = "Francir Pacto Insert",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "(11) 11111-1111",
TelefoneMovelServidor = "(22) 22222-2222",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now,
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CargaHoraria = 8,
CpfUsuarioCriador = usuario.CPF,
IdTipoPacto = 1,
IndVisualizacaoRestrita = false
};
_uow.BeginTransaction();
var resultado = _pactoService.Adicionar(pacto);
_uow.Commit();
idPacto = pacto.IdPacto;
Assert.IsTrue(resultado.ValidationResult.Message.Contains("sucesso"));
}
private void ValidarPactosPendentesAssinatura(Pacto pacto, List <Pacto> pactosServidor)
{
var parametroBloquearSeHouverPactoPendenteDeAssinatura = _parametroSistemaService.ObterPorId((int)eParametrosSistema.BloquearSeHouverPactosPendentesDeAssinatura);
if (parametroBloquearSeHouverPactoPendenteDeAssinatura != null && parametroBloquearSeHouverPactoPendenteDeAssinatura.BoolValue.GetValueOrDefault())
{
string urlPacto = System.Configuration.ConfigurationManager.AppSettings["URL_PGD"].ToString() + "Pacto/Solicitar/";
var pactosSemAssinatura = pactosServidor.Where(p => (p.IdSituacaoPacto == (int)eSituacaoPacto.PendenteDeAssinatura && !p.DataAprovacaoDirigente.HasValue && !p.DataAprovacaoSolicitante.HasValue));
if (pactosSemAssinatura.Any())
{
string mensagem = $"Usuário impossibilitado de solicitar novo plano de trabalho em razão de uma das pendências a seguir: Existe(m) plano(s) de trabalho(s) do servidor sem assinaturas. ({ string.Join(",", pactosSemAssinatura.Select(p => $"<a href='{ urlPacto }{p.IdPacto}' target='_blank'>{p.IdPacto}</a>")) })";
pacto.ValidationResult.Add(new DomainValidation.Validation.ValidationError(mensagem));
}
var parametroQuantidadeDiasBloqueioPactoSemAssinatura = _parametroSistemaService.ObterPorId((int)eParametrosSistema.TempoMaximoPendenteAssinatura);
var dataInicioBloqueio = DateTime.Now.AddDays(parametroQuantidadeDiasBloqueioPactoSemAssinatura.IntValue.GetValueOrDefault() * -1);
var pactosPendentesAssinatura = pactosServidor.Where(p => p.IdSituacaoPacto == (int)eSituacaoPacto.PendenteDeAssinatura && (!p.DataAprovacaoDirigente.HasValue || !p.DataAprovacaoSolicitante.HasValue) &&
((p.DataAprovacaoSolicitante.HasValue && p.DataAprovacaoSolicitante < dataInicioBloqueio) ||
p.DataAprovacaoDirigente.HasValue && p.DataAprovacaoDirigente < dataInicioBloqueio)).ToList();
if (pactosPendentesAssinatura.Any())
{
string mensagem = $"Usuário impossibilitado de solicitar novo plano de trabalho em razão de uma das pendências a seguir: Existe(m) plano(s) de trabalho(s) com assinatura pendente há mais de XX dias ({ string.Join(",", pactosPendentesAssinatura.Select(p => $"<a href='{ urlPacto }{p.IdPacto}' target='_blank'>{p.IdPacto}</a>")) })";
pacto.ValidationResult.Add(new DomainValidation.Validation.ValidationError(mensagem));
}
}
}
public ValidationResult ValidarDataHoraSuspensaoInterrupcao(Pacto pacto, DateTime dataInicioSuspensao, TimeSpan horasConsideradas, Enums.Operacao operacao)
{
if (TimeSpan.FromHours(pacto.CargaHoraria) < horasConsideradas)
{
return(new ValidationResult("A quantidade de horas deve ser igual ou menor que a carga horaria diária do servidor."));
}
DateTime dataMinimoPacto = ObterDataMinimaSuspensaoPacto();
if (pacto.DataPrevistaInicio > dataMinimoPacto)
{
dataMinimoPacto = pacto.DataPrevistaInicio;
}
if (dataInicioSuspensao < dataMinimoPacto)
{
return(new ValidationResult($"A data de {operacao.ToString()} deve ser maior ou igual à { dataMinimoPacto.ToShortDateString() } ."));
}
DateTime dataMaximaPacto = pacto.Cronogramas.Max(c => c.DataCronograma);
if (dataInicioSuspensao > dataMaximaPacto)
{
return(new ValidationResult($"A data de {operacao.ToString()} deve ser menor ou igual à { dataMaximaPacto.ToShortDateString() } ."));
}
return(null);
}
private static bool PodeEditarPermissoesSolicitante(Pacto pacto, Usuario usuariologado, bool isDirigente)
{
bool possuiPermissoesSolicitante = false;
if (!isDirigente && pacto.CpfUsuario == usuariologado.Cpf)
{
if (pacto.IdSituacaoPacto == (int)eSituacaoPacto.AIniciar || (pacto.IdSituacaoPacto == (int)eSituacaoPacto.PendenteDeAssinatura && pacto.StatusAprovacaoSolicitante.GetValueOrDefault() == 0))
{
possuiPermissoesSolicitante = true;
}
if (pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Suspenso)
{
List <int> situacoesInvalidas = new List <int>()
{
(int)eSituacaoPacto.Excluido, (int)eSituacaoPacto.Negado, (int)eSituacaoPacto.Interrompido, (int)eSituacaoPacto.Avaliado
};
if (!situacoesInvalidas.Contains(pacto.IdSituacaoPacto) && pacto.DataPrevistaInicio > DateTime.Now)
{
possuiPermissoesSolicitante = true;
}
}
}
return(possuiPermissoesSolicitante);
}
public bool PodeAvaliar(Pacto pacto, Usuario usuariologado, bool isDirigente, bool unidadePactoEhSubordinadaUnidadeUsuario)
{
#region PERMISSÕES DE AÇÕES DO DIRIGENTE
if (isDirigente && unidadePactoEhSubordinadaUnidadeUsuario && pacto.CpfUsuario != usuariologado.Cpf)
{
if (pacto.IdSituacaoPacto == (int)PGD.Domain.Enums.eSituacaoPacto.Avaliado)
{
return(false);
}
else
{
var assinatura = BuscaStatusAssinatura(pacto);
//Disponível para pactos que já foram iniciados e que foram assinados pelo Solicitante e pelo Dirigente.
//Se um pacto for avaliado, nenhuma outra opção de ação é exibida.Caso o pacto tenha sido avaliado, negado, interrompido ou esteja suspenso,
//esta opção não é exibida.Opção só é exibida para o dirigente(ou administrador / dirigente) responsável pelo pacto e para dirigentes hierarquicamente superiores à unidade.
if (pacto.DataPrevistaInicio <= DateTime.Now && assinatura == (int)PGD.Domain.Enums.eAssinatura.AssinadoPorTodos &&
(pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Avaliado &&
pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Negado &&
pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Interrompido &&
pacto.IdSituacaoPacto != (int)PGD.Domain.Enums.eSituacaoPacto.Excluido))
{
return(true);
}
}
}
#endregion
return(false);
}
public void TestInsertCamposObrigatoriosOK()
{
InitializaNinject();
var usuario = _usuarioService.ObterPorCPF("02941397450");
var os = _osService.ObterOrdemVigente();
var pacto = new Pacto
{
Nome = "Francir Pacto Insert - Campo Obrigatório",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "",
TelefoneMovelServidor = "",
PactoExecutadoNoExterior = false,
ProcessoSEI = "Teste",
Motivo = "Motivo de Tetste",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now,
CargaHoraria = 10,
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CpfUsuarioCriador = usuario.CPF
};
var resultado = _pactoService.Adicionar(pacto);
Assert.IsTrue(resultado.ValidationResult.IsValid);
}
private void ConfiguraProximoStatusAssinando(Pacto pacto, Usuario usuariologado, bool isDirigente)
{
#region Muda a situação para A INICIAR ou EM ANDAMENTO (caso todos os aprovadores tenham assinado)
var assinatura = BuscaStatusAssinatura(pacto);
//A Iniciar
if (assinatura == (int)eAssinatura.AssinadoPorTodos && pacto.DataPrevistaInicio > DateTime.Now)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.AIniciar;
}
//Em Andamento
else if (assinatura == (int)eAssinatura.AssinadoPorTodos && pacto.DataPrevistaInicio <= DateTime.Now)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.EmAndamento;
}
if (!isDirigente)
{
if (pacto.StatusAprovacaoSolicitante == null && pacto.DataPrevistaInicio > DateTime.Now)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.AIniciar;
pacto.CpfUsuarioSolicitante = usuariologado.Cpf;
pacto.StatusAprovacaoSolicitante = 1;
pacto.DataAprovacaoSolicitante = DateTime.Now;
}
if (pacto.StatusAprovacaoSolicitante == null && pacto.DataPrevistaInicio <= DateTime.Now)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.EmAndamento;
pacto.CpfUsuarioSolicitante = usuariologado.Cpf;
pacto.StatusAprovacaoSolicitante = 1;
pacto.DataAprovacaoSolicitante = DateTime.Now;
}
}
#endregion
}
public void TestSuspenderErro()
{
InitializaNinject();
var usuario = _usuarioService.ObterPorCPF("11391275861");
var pactoService = kernel.Get <IPactoService>();
var os = _osService.ObterOrdemVigente();
var pacto = new Pacto
{
Nome = "Francir Borges Silvério",
MatriculaSIAPE = "123456",
UnidadeExercicio = 5,
TelefoneFixoServidor = "(11) 11111-1111",
TelefoneMovelServidor = "(22) 22222-2222",
PossuiCargaHoraria = false,
DataPrevistaInicio = DateTime.Now,
DataPrevistaTermino = DateTime.Now.AddDays(10),
CargaHorariaTotal = 190,
IdSituacaoPacto = 1,
CpfUsuario = usuario.CPF,
IdOrdemServico = os.IdOrdemServico,
CargaHoraria = 8,
CpfUsuarioCriador = usuario.CPF
};
var userAssinante = _usuarioService.ObterPorCPF("11391275861");
List <Enums.Perfil> perfis = new List <Enums.Perfil>();
perfis.Add(Enums.Perfil.Dirigente);
var resultado = pactoService.AtualizarSuspender(pacto, userAssinante, perfis);
Assert.IsTrue(resultado.ValidationResult.Erros.FirstOrDefault().Message.Contains("não pode assinar"));
}
private bool PodeAssinarSolicitante(Pacto pacto, Usuario usuariologado)
{
bool podeAssinarSolicitante = false;
if (usuariologado.Cpf == pacto.CpfUsuario || usuariologado.Cpf == pacto.CpfUsuarioCriador)
{
//Opção disponível para os pactos até o dia de início do pacto ou enquanto não tiver sido assinado.
//Opção só é exibida para o solicitante(ou administrador / solicitante) do pacto ou o dirigente(ou administrador / dirigente) responsável pelo pacto e para dirigentes hierarquicamente
//superiores à unidade.
var assinatura = BuscaStatusAssinatura(pacto);
if (pacto.CpfUsuarioSolicitante == usuariologado.Cpf)
{
podeAssinarSolicitante = false;
}
if (pacto.DataPrevistaInicio >= DateTime.Today && assinatura == (int)PGD.Domain.Enums.eAssinatura.NaoAssinado && pacto.IdSituacaoPacto != (int)eSituacaoPacto.Excluido && pacto.IdSituacaoPacto != (int)eSituacaoPacto.Negado && pacto.IdSituacaoPacto != (int)eSituacaoPacto.Suspenso &&
(pacto.StatusAprovacaoSolicitante != 1))
{
podeAssinarSolicitante = true;
}
}
else if (pacto.IdPacto == 0)
{
podeAssinarSolicitante = true;
}
return(podeAssinarSolicitante);
}
private static bool ConfiguraProximoPassoIniciando(Pacto pacto)
{
bool ignorarValidacoes = true;
pacto.IdSituacaoPacto = (int)eSituacaoPacto.EmAndamento;
return(ignorarValidacoes);
}
public Pacto AtualizarStatus(Pacto pacto, Usuario usr, eAcaoPacto eAcao, bool isDirigente, bool commit = true)
{
bool ignorarValidacoes = false;
ignorarValidacoes = ConfiguraProximoStatus(pacto, usr, eAcao, isDirigente, ignorarValidacoes);
if (!ignorarValidacoes)
{
ValidarPacto(pacto);
if (!pacto.ValidationResult.IsValid)
{
return(pacto);
}
TratarInclusaoHistoricoAtualizacaoStatus(pacto, eAcao);
}
AtualizaEstadoEntidadesRelacionadas(pacto);
pacto.ValidationResult.Message = Mensagens.MS_004;
if (commit)
{
return(_classRepository.Atualizar(pacto, pacto.IdPacto));
}
else
{
return(pacto);
}
}
public Pacto RemoverAtrasado(Pacto obj)
{
obj.IdSituacaoPacto = (int)eSituacaoPacto.Excluido;
obj.ValidationResult.Message = Mensagens.MS_004;
return(_classRepository.Atualizar(obj));
}
private static bool ConfiguraProximoPassoExcluindo(Pacto pacto)
{
#region Muda a situação para EXCLUIDO
bool ignorarValidacoes = true;
pacto.IdSituacaoPacto = (int)eSituacaoPacto.Excluido;
#endregion
return(ignorarValidacoes);
}
private static bool PodeDeletarPermissaoSolicitante(Pacto pacto, Usuario usuariologado, bool isDirigente)
{
bool usuarioLogadoECriador = (usuariologado.Cpf == pacto.CpfUsuario || (usuariologado.Cpf == pacto.CpfUsuarioCriador));
bool situacaoElegivel = (pacto.DataPrevistaInicio > DateTime.Now && pacto.IdSituacaoPacto != (int)eSituacaoPacto.Excluido && pacto.IdSituacaoPacto != (int)eSituacaoPacto.Negado) ||
pacto.IdSituacaoPacto == (int)eSituacaoPacto.PendenteDeAssinatura;
return(!isDirigente && usuarioLogadoECriador && situacaoElegivel);
}
private static bool ConfiguraProximoPassoFinalizando(Pacto pacto)
{
#region Muda a situação para PENDENTE DE AVALIAÇÃO
bool ignorarValidacoes = true;
pacto.IdSituacaoPacto = (int)eSituacaoPacto.PendenteDeAvaliacao;
#endregion
return(ignorarValidacoes);
}
public Pacto Remover(Pacto obj)
{
var pacto = ObterPorId(obj.IdPacto);
pacto.IdSituacaoPacto = (int)eSituacaoPacto.Excluido;
_classRepository.Atualizar(pacto);
obj.ValidationResult.Message = Mensagens.MS_005;
return(obj);
}
private static void ConfiguraProximoPassoAvaliandoParcialmente(Pacto pacto)
{
#region Muda a situação para AVALIADO PARCIALMENTE;
//Quando suspenso e for avaliado parcialmente, manter situação como suspenso.
if (pacto.IdSituacaoPacto != (int)eSituacaoPacto.Suspenso)
{
pacto.IdSituacaoPacto = (int)eSituacaoPacto.AvaliadoParcialmente;
}
#endregion
}
public void TesteDataInicioSupensao()
{
InitializaNinject();
Pacto pacto = MontarPactoParaTeste(DateTime.Now, DateTime.Now.AddDays(5), eSituacaoPacto.EmAndamento);
Assert.IsTrue(_pactoService.ValidarDataHoraSuspensaoInterrupcao(pacto, DateTime.MinValue, TimeSpan.FromHours(3), Enums.Operacao.Suspensão) != null);
Assert.IsTrue(_pactoService.ValidarDataHoraSuspensaoInterrupcao(pacto, DateTime.MinValue, TimeSpan.FromHours(3), Enums.Operacao.Suspensão).ErrorMessage.StartsWith("A data de Suspensão deve ser maior ou igual à"));
Assert.IsNull(_pactoService.ValidarDataHoraSuspensaoInterrupcao(pacto, DateTime.Now, TimeSpan.FromHours(3), Enums.Operacao.Suspensão));
}
public void TesteDataConclusaoAntecipada()
{
InitializaNinject();
Pacto pacto = MontarPactoParaTeste(DateTime.Now, DateTime.Now.AddDays(5), eSituacaoPacto.EmAndamento);
Assert.IsTrue(_pactoService.ValidarDataConclusaoAntecipada(pacto, DateTime.MinValue) != null);
Assert.IsTrue(_pactoService.ValidarDataConclusaoAntecipada(pacto, DateTime.MinValue).ErrorMessage.StartsWith("A data de conclusão antecipada deve ser maior ou igual à"));
Assert.IsNull(_pactoService.ValidarDataConclusaoAntecipada(pacto, DateTime.Now));
}
public bool PodeCancelarAvaliacao(Pacto pacto, Usuario usuariologado, bool isDirigente, bool unidadePactoEhSubordinadaUnidadeUsuario)
{
if (isDirigente && unidadePactoEhSubordinadaUnidadeUsuario && pacto.CpfUsuario != usuariologado.Cpf &&
(pacto.IdSituacaoPacto == (int)PGD.Domain.Enums.eSituacaoPacto.Avaliado))
{
return(true);
}
return(false);
}
public Pacto Atualizar(Pacto pacto, int idPacto)
{
AtualizaEstadoEntidadesRelacionadas(pacto);
ValidarPacto(pacto);
if (!pacto.ValidationResult.IsValid)
{
return(pacto);
}
return(_classRepository.Atualizar(pacto, idPacto));
}
public bool PodeEditarObservacaoProduto(Pacto pactoVM, Usuario usr, bool isDirigente, bool unidadePactoEhSubordinadaUnidadeUsuario)
{
if ((isDirigente && unidadePactoEhSubordinadaUnidadeUsuario) || (usr.Cpf.Equals(pactoVM.CpfUsuario)) &&
(pactoVM.IdSituacaoPacto == (int)eSituacaoPacto.EmAndamento ||
pactoVM.IdSituacaoPacto == (int)eSituacaoPacto.AvaliadoParcialmente ||
pactoVM.IdSituacaoPacto == (int)eSituacaoPacto.PendenteDeAvaliacao))
{
return(true);
}
return(false);
}
public bool PodeVisualizarPactuadoAvaliado(Pacto pacto)
{
if (pacto.IdSituacaoPacto == (int)PGD.Domain.Enums.eSituacaoPacto.AIniciar ||
pacto.IdSituacaoPacto == (int)PGD.Domain.Enums.eSituacaoPacto.PendenteDeAssinatura)
{
return(false);
}
return(true);
}
private static void TratarSituacaoPactoAtualizacaoEditando(eAcaoPacto eAcao, Pacto pacto)
{
if (eAcao == eAcaoPacto.Editando)
{
pacto.CpfUsuarioDirigente = null;
pacto.StatusAprovacaoDirigente = null;
pacto.DataAprovacaoDirigente = (DateTime?)null;
pacto.IdSituacaoPacto = (int)eSituacaoPacto.PendenteDeAssinatura;
}
}
public void TestNaoPodeAvaliar()
{
InitializaNinject();
var userLogado = _usuarioService.ObterPorCPF("11391275861");
var pacto = new Pacto {
IdSituacaoPacto = (int)eSituacaoPacto.Interrompido, DataPrevistaInicio = DateTime.Now.AddDays(5), CpfUsuario = userLogado.CPF
};
Assert.IsFalse(_pactoService.PodeAvaliar(pacto, userLogado, false, true));
Assert.IsFalse(_pactoService.PodeAvaliar(pacto, userLogado, false, false));
}
public void ValidarInclusaoPacto(Pacto pacto)
{
ValidarPacto(pacto);
if (pacto.ValidationResult.IsValid && pacto.IdPacto == 0)
{
var pactosServidor = _classRepository.Buscar(p => p.CpfUsuario == pacto.CpfUsuario).ToList();
ValidarPactosSuspensos(pacto, pactosServidor);
ValidarPactosPendentesAvaliacao(pacto, pactosServidor);
ValidarPactosPendentesAssinatura(pacto, pactosServidor);
}
}
