public MontarHistoricoEscolarQuery(Dre dre, Ue ue, IEnumerable <AreaDoConhecimento> areasConhecimento,
IEnumerable <IGrouping <string, ComponenteCurricularPorTurma> > componentesCurricularesTurmas,
IEnumerable <AlunoTurmasHistoricoEscolarDto> alunosTurmas,
IEnumerable <MediaFrequencia> mediasFrequencia,
IEnumerable <IGrouping <string, NotasAlunoBimestre> > notas,
IEnumerable <IGrouping <string, FrequenciaAluno> > frequencias,
IEnumerable <TipoNotaCicloAno> tiposNota,
IEnumerable <TransferenciaDto> transferencias,
string[] turmasCodigo, CabecalhoDto cabecalho, LegendaDto legenda,
DadosDataDto dadosData, FuncionarioDto dadosDiretor, FuncionarioDto dadosSecretario,
IEnumerable <IGrouping <long, UeConclusaoPorAlunoAno> > historicoUes,
bool preencherDataImpressao, bool imprimirDadosResponsaveis)
{
Dre = dre;
Ue = ue;
AreasConhecimento = areasConhecimento;
ComponentesCurricularesTurmas = componentesCurricularesTurmas;
AlunosTurmas = alunosTurmas;
TurmasCodigo = turmasCodigo;
Cabecalho = cabecalho;
HistoricoUes = historicoUes;
Notas = notas;
Frequencias = frequencias;
MediasFrequencia = mediasFrequencia;
TiposNota = tiposNota;
Transferencias = transferencias;
Legenda = legenda;
DadosData = dadosData;
DadosDiretor = dadosDiretor;
DadosSecretario = dadosSecretario;
PreencherDataImpressao = preencherDataImpressao;
ImprimirDadosResponsaveis = imprimirDadosResponsaveis;
}
public void NaoDeveAdicionarUmNovoFuncionarioQuandoCpfInvalido()
{
FuncionarioDto funcionario = new FuncionarioDto
{
Nome = "Marvin",
Cpf = "",
Inativo = false,
CargoId = 1,
EhHomeOffice = false,
EmpresaId = 1
};
Cargo cargo = new Cargo("Tester");
Empresa empresa = new Empresa("Db1", new CNPJ("87717167000156"));
_empresaRepositoryMock = new Mock <IEmpresaRepository>();
_empresaRepositoryMock.Setup(mock => mock.ObterPorId(It.IsAny <int>())).Returns(empresa);
_cargoRepositoryMock = new Mock <ICargoRepository>();
_cargoRepositoryMock.Setup(mock => mock.ObterPorId(It.IsAny <int>())).Returns(cargo);
_funcionarioRepositoryMock = new Mock <IFuncionarioRepository>();
_funcionarioRepositoryMock.Setup(mock => mock.Adicionar(It.IsAny <Funcionario>()));
IFuncionarioService funcionarioService = new FuncionarioService(_empresaRepositoryMock.Object, _cargoRepositoryMock.Object, _funcionarioRepositoryMock.Object);
var mensagens = funcionarioService.Adicionar(funcionario);
_funcionarioRepositoryMock.Verify(mock => mock.Adicionar(It.IsAny <Funcionario>()), Times.Never());
Assert.Equal(1, mensagens.Count);
}
public async Task <FuncionarioDto> AddAsync(FuncionarioDto funcionarioDto)
{
var paciente = this.mapperFuncionario.MapperDtoToEntity(funcionarioDto);
var result = await this.serviceFuncionario.AddAsync(paciente);
return(this.mapperFuncionario.MapperEntityToDto(result));
}
public async Task ArmazenarAsync(FuncionarioDto funcionarioDto)
{
funcionarioDto = funcionarioDto ?? new FuncionarioDto();
var funcionario = funcionarioDto.Id == 0 ?
CriarUmNovoFuncionario(funcionarioDto) :
await _editarUmFuncionario.EditarAsync(funcionarioDto);
if (NotificacaoDeDominio.HasNotifications)
{
return;
}
if (!funcionario.Validar())
{
await NotificarValidacoesDeDominioAsync(funcionario.ValidationResult);
}
await _validadorCpfDaFuncionarioJaExistente.ValidarAsync(funcionario.Cpf, funcionario.Id);
if (!NotificacaoDeDominio.HasNotifications && funcionario.Id == 0)
{
await _funcionarioRepositorio.AdicionarAsync(funcionario);
}
}
public void NaoDeveAtualizarQuandoNaoEncontrarFuncionario()
{
FuncionarioDto funcionario = new FuncionarioDto
{
Nome = "Marvin",
Cpf = "12321025980",
Inativo = false,
CargoId = 1,
EhHomeOffice = false,
EmpresaId = 1
};
Cargo cargo = new Cargo("Tester");
Empresa empresa = new Empresa("DB1", new CNPJ(""));
_empresaRepositoryMock = new Mock <IEmpresaRepository>();
_empresaRepositoryMock.Setup(mock => mock.ObterPorId(It.IsAny <int>())).Returns(empresa);
_cargoRepositoryMock = new Mock <ICargoRepository>();
_cargoRepositoryMock.Setup(mock => mock.ObterPorId(It.IsAny <int>())).Returns(cargo);
_funcionarioRepositoryMock = new Mock <IFuncionarioRepository>();
_funcionarioRepositoryMock.Setup(mock => mock.Atualizar(It.IsAny <Funcionario>())).Throws(new Exception());
IFuncionarioService funcionarioService = new FuncionarioService(_empresaRepositoryMock.Object, _cargoRepositoryMock.Object, _funcionarioRepositoryMock.Object);
var mensagens = funcionarioService.Atualizar(funcionario, 1);
_funcionarioRepositoryMock.Verify(mock => mock.Atualizar(It.IsAny <Funcionario>()), Times.Never());
Assert.Equal(1, mensagens.Count);
}
public IList <string> Atualizar(FuncionarioDto obj, int id)
{
mensagens = new List <string>();
try
{
Cargo cargo = obterCargo(obj.CargoId);
Empresa empresa = obterEmpresa(obj.EmpresaId);
Funcionario funcionario = FuncionarioAdapter.Mapear(obj, cargo, empresa, id);
if (!funcionario.Validar())
{
mensagens.Add("Funcionario invalido");
}
if (mensagens.Count == 0)
{
_funcionarioRepository.Atualizar(funcionario);
}
}catch (Exception e)
{
mensagens.Add(e.Message);
}
return(mensagens);
}
public void NaoDeveVincularQuandoJaTemEmpresaVinculada()
{
//Given
var dto = new FuncionarioDto
{
Id = _faker.Random.Number(100),
IdEmpresa = _faker.Random.Number(100)
};
var funcionarioMock = FuncionarioBuilder.Novo().ComId(dto.Id).ComIdEmpresa(_faker.Random.Number(100)).Build();
var empresaMock = EmpresaBuilder.Novo().ComId(dto.IdEmpresa).Build();
_funcionarioRepositoryMock
.Setup(fr => fr.ObterPorId(dto.Id))
.Returns(funcionarioMock);
_empresaRepositoryMock
.Setup(cr => cr.ObterPorId(dto.IdCargo))
.Returns(empresaMock);
//When
_vinculacaoDeFuncionarioAEmpresa.VincularEmpresa(dto);
//Then
_funcionarioRepositoryMock.Verify(fr => fr.Atualizar(funcionarioMock), Times.Never);
}
public async Task <IActionResult> Put(int id, FuncionarioDto funcionarioDto)
{
funcionarioDto.Id = id;
await _armazenadorDeFuncionario.ArmazenarAsync(funcionarioDto);
return(Ok());
}
private void VerifyFuncionarioAdd(FuncionarioDto funcionarioDto, Times times)
{
_funcionarioRepository.Verify(r => r.Add(It.Is <Funcionario>(func =>
func.DataContratacao == funcionarioDto.DataContratacao &&
func.Cpf == funcionarioDto.Cpf &&
func.Nome == funcionarioDto.Nome)), times);
}
public void NaoDeveVincularCargoQuandoNaoTemEmpresa()
{
//Given
var dto = new FuncionarioDto
{
Id = _faker.Random.Number(100),
IdCargo = _faker.Random.Number(100)
};
var funcionarioMock = FuncionarioBuilder.Novo().ComId(dto.Id).Build();
var cargoMock = CargoBuilder.Novo().ComId(dto.IdCargo).Build();
_funcionarioRepositoryMock
.Setup(fr => fr.ObterPorId(dto.Id))
.Returns(funcionarioMock);
_cargoRepositoryMock
.Setup(cr => cr.ObterPorId(dto.IdCargo))
.Returns(cargoMock);
//When
_vinculacaoDeFuncionarioACargo.VincularCargo(dto);
//Then
_funcionarioRepositoryMock.Verify(fr => fr.Atualizar(funcionarioMock), Times.Never);
}
public async Task Armazenar(FuncionarioDto dto)
{
await ValidarFuncionarioComMesmoNome(dto);
if (!NotificacaoDeDominio.HasNotifications())
{
var funcionario = new Funcionario(dto.Nome, dto.Cpf);
if (dto.Id > 0)
{
funcionario = await _funcionarioRepositorio.ObterPorIdAsync(dto.Id);
funcionario.AlterarNome(dto.Nome);
funcionario.AlterarCpf(dto.Cpf);
}
funcionario.AlterarDataContratacao(dto.DataContratacao);
if (funcionario.Validar() && funcionario.Id == 0)
{
await _funcionarioRepositorio.AdicionarAsync(funcionario);
}
else
{
await NotificarValidacoesDeDominio(funcionario.ValidationResult);
}
}
}
public async Task <FuncionarioDto> Salvar(FuncionarioDto funcionarioDto)
{
Funcionario funcionario = new(funcionarioDto.Id, funcionarioDto.Codigo, funcionarioDto.Nome, funcionarioDto.Cpf, funcionarioDto.Rg, funcionarioDto.Sexo, funcionarioDto.EstadoCivil, funcionarioDto.Email, funcionarioDto.Telefone1, funcionarioDto.TipoTelefone1, funcionarioDto.Telefone2, funcionarioDto.TipoTelefone2, funcionarioDto.Nascimento, funcionarioDto.Cadastro, funcionarioDto.Alteracao, funcionarioDto.EnderecoId, funcionarioDto.Funcao, funcionarioDto.Ativo);
Funcionario resultado;
if (funcionarioDto.Id.Equals(0))
{
resultado = await _repositorio.Adicionar(funcionario);
if (resultado is null)
{
throw new Exception("Erro ao cadastrar, contate o administrador do sistema.");
}
funcionarioDto.Id = resultado.Id;
funcionarioDto.Codigo = resultado.Codigo;
return(funcionarioDto);
}
else
{
resultado = await _repositorio.Atualizar(funcionario);
if (resultado is null)
{
throw new Exception("Erro ao atualizar, contate o administrador do sistema.");
}
funcionarioDto.Alteracao = resultado.Alteracao;
return(funcionarioDto);
}
}
public void VincularCargo(FuncionarioDto dto)
{
var funcionario = _funcionarioRepository.ObterPorId(dto.Id);
var cargo = _cargoRepository.ObterPorId(dto.IdCargo);
if (cargo == null)
{
_notificationContext.AddNotification("500", FuncionarioResource.CargoNaoCadastrado);
return;
}
if (funcionario.IdEmpresa == null)
{
_notificationContext.AddNotification("500", FuncionarioResource.FuncionarioSemEmpresa);
return;
}
if (funcionario.CargosVinculados.Any(c => c.IdCargo == dto.IdCargo))
{
_notificationContext.AddNotification("500", FuncionarioResource.FuncionarioJaPossuiCargo);
return;
}
FuncionarioCargo cargoVinculado = new FuncionarioCargo()
{
IdFuncionario = funcionario.Id,
IdCargo = cargo.Id,
DataVinculo = DateTime.Now
};
funcionario.AdicionarCargo(cargoVinculado);
_funcionarioRepository.Atualizar(funcionario);
}
public async Task <IActionResult> Put(long id, [FromBody] FuncionarioDto funcionario)
{
funcionario.Id = id;
await _armazenadorDeFuncionario.Armazenar(funcionario);
return(Ok());
}
public bool VerificarSeDataContratacaoEstaPreenchido(FuncionarioDto funcionarioDto)
{
if (funcionarioDto.DataContratacao == new DateTime())
{
return(false);
}
return(true);
}
public static Funcionario Mapear(FuncionarioDto funcionarioDto, Cargo cargo, Empresa empresa)
{
return(new Funcionario(funcionarioDto.Nome,
funcionarioDto.EhHomeOffice,
new CPF(funcionarioDto.Cpf),
cargo,
empresa));
}
public void DeveNotificarErrosDeServicoQuandoExistir()
{
var dto = new FuncionarioDto();
_vinculacaoDeFuncionarioACargo.VincularCargo(dto);
Assert.True(_notificationContextMock.Object.HasNotifications);
}
public FuncionarioDto Alterar(FuncionarioDto funcionarioDto)
{
var funcionario = _funcionarioRepository.BuscarPorId(funcionarioDto.Id);
funcionario.Update(funcionarioDto.Nome, funcionarioDto.DataContratacao, funcionarioDto.EmpresaId);
_funcionarioRepository.Alterador(funcionario);
return(funcionarioDto);
}
public bool VerificarSeEmpresaIdEstaPreenchido(FuncionarioDto funcionarioDto)
{
if (funcionarioDto.EmpresaId <= 0)
{
return(false);
}
return(true);
}
public bool VerificarSeNomeEstaPreenchido(FuncionarioDto funcionarioDto)
{
if (string.IsNullOrWhiteSpace(funcionarioDto.Nome))
{
return(false);
}
return(true);
}
private async Task VerifyInsertFuncionario(Funcionario funcionario, FuncionarioDto funcionarioDto)
{
await _armazenadorDeFuncionario.Armazenar(funcionarioDto);
VerifyFuncionarioAdd(funcionarioDto, Times.Never());
Assert.False(funcionario.Valid);
Assert.True(funcionario.ValidationResult.Errors.Count > 0);
}
public ActionResult Editar(FuncionarioModel model)
{
//Se não tiver login, encaminhar para a tela de login
if (string.IsNullOrWhiteSpace(SessaoUsuario.SessaoLogin.Identificacao))
{
return(RedirectToAction("Login", "Usuario"));
}
if (!SessaoUsuario.SessaoLogin.Administrador)
{
ViewBag.MensagemErro = "Para editar um funcionario é necessário " +
$"logar com um funcionario administrador.";
return(View("SemPermissao"));
}
//Valida a entidade recebida
if (!ModelState.IsValid)
{
return(View(model));
}
//Converte para DTO
FuncionarioDto funcionarioDto = new FuncionarioDto();
string mensagemErro = "";
if (!model.ConverterModelParaDto(ref funcionarioDto, ref mensagemErro))
{
ViewBag.Mensagem = mensagemErro;
return(View("Erro"));
}
//Preparar requisição e retorno
RetornoDto retorno = new RetornoDto();
RequisicaoEntidadeDto <FuncionarioDto> requisicaoDto = new RequisicaoEntidadeDto <FuncionarioDto>()
{
EntidadeDto = funcionarioDto,
Identificacao = SessaoUsuario.SessaoLogin.Identificacao,
IdUsuario = SessaoUsuario.SessaoLogin.IdUsuario
};
//Consumir o serviço
FuncionarioBll funcionarioBll = new FuncionarioBll(true);
funcionarioBll.Editar(requisicaoDto, ref retorno);
//Tratar o retorno
if (retorno.Retorno == false)
{
ModelState.AddModelError("", retorno.Mensagem);
return(View(model));
}
TempData["Retorno"] = "ALTERADO";
//Voltar para o visualizar do funcionario
return(RedirectToAction("Index"));
}
public async Task DeveNotificarErrosDeDominioQuandoExistir()
{
var funcionarioDto = new FuncionarioDto();
await _armazenadorDeFuncionario.Armazenar(funcionarioDto);
_notificacaoDeDominioMock.Verify(notificacao =>
notificacao.HandleAsync(It.Is <DomainNotification>(d => d.Key == TipoDeNotificacao.ErroDeDominio.ToString())));
}
private async Task ValidarFuncionarioComMesmoNome(FuncionarioDto dto)
{
var funcionarioComMesmoNome = await _funcionarioRepositorio.ObterPorNomeAsync(dto.Nome);
if (funcionarioComMesmoNome != null && funcionarioComMesmoNome.Id != dto.Id)
{
await NotificarValidacaoDeServico(string.Format(CommonResources.MsgDominioComMesmoNomeNoMasculino, CommonResources.FuncionarioDominio));
}
}
public FuncionarioDto IncluirFuncionario(FuncionarioDto funcionarioDto)
{
if (_validadorDeFuncionario.Validar(funcionarioDto))
{
var funcionario = new Funcionario(funcionarioDto.Id, funcionarioDto.Nome, funcionarioDto.DataContratacao, funcionarioDto.EmpresaId);
_funcionarioRepository.Armazenar(funcionario);
return(funcionarioDto);
}
return(null);
}
private bool ValidarId(int id, FuncionarioDto funcionarioDto)
{
if (id != funcionarioDto.Id)
{
_notificationContext.AddNotification("", Resource.FuncionarioNaoIdentificado);
return(false);
}
return(true);
}
public async Task NaoDeveAdicionarUmFuncionarioInvalido()
{
var funcionarioDto = new FuncionarioDto();
_notificacaoDeDominioMock.Setup(notificacao => notificacao.HasNotifications()).Returns(true);
await _armazenadorDeFuncionario.Armazenar(funcionarioDto);
_funcionarioRepositorioMock.Verify(repositorio =>
repositorio.AdicionarAsync(It.IsAny <Funcionario>()), Times.Never());
}
public async Task <IActionResult> Post([FromBody] FuncionarioDto dto)
{
await _armazenadorDeFuncionario.Armazenar(dto);
if (!OperacaoValida())
{
return(BadRequestResponse());
}
return(Ok(true));
}
public async Task <ActionResult <FuncionarioDto> > Put(Guid id, [FromBody] FuncionarioDto funcionarioDto)
{
try
{
return(await this.applicationServiceFuncionario.UpdateAsync(id, funcionarioDto));
}
catch (Exception ex)
{
throw ex;
}
}
public async Task Armazenar(FuncionarioDto funcionarioDto)
{
if (funcionarioDto.Id == 0)
{
await NovoFuncionario(funcionarioDto);
}
else
{
await EditarFuncionario(funcionarioDto);
}
}
