public async Task <AtivoViewDto> PesquisarAtivoPorIncAsync(int incAtivo)
{
try
{
AtivoViewDto result = new AtivoViewDto();
result = await _context.Ativos
.Where(ati => ati.IncAtivo == incAtivo)
.Include(ati => ati.SetorId)
.DefaultIfEmpty()
.Select(ati => new AtivoViewDto
{
Id = ati.Id,
IncAtivo = ati.IncAtivo,
Nome = ati.Nome,
Descricao = ati.Descricao,
DataHoraCadastro = ati.DataHoraCadastro,
DataHoraUltimaAtualizacao = ati.DataHoraUltimaAtualizacao,
StatusAtivo = ati.StatusAtivo.Value,
CriticidadeAtivo = ati.CriticidadeAtivo.Value,
DescricaoStatusAtivo = result.descricaoStatusAtivoEnum(ati.StatusAtivo.Value.ToString()),
DescricaoCriticidadeAtivo = result.descricaoCriticidadeAtivoEnum(ati.CriticidadeAtivo.Value.ToString()),
SetorId = Guid.Parse(ati.SetorId.ToString()),
DescricaoSetor = ati.Setor.IncSetor.ToString() + " - " + ati.Setor.Nome,
}).SingleAsync();
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <List <AtivoViewDto> > PesquisarAtivosPorSetorAsync(Guid setorId)
{
try
{
AtivoViewDto aux = new AtivoViewDto();
List <AtivoViewDto> listaResult = await _context.Ativos
.Where(ati => ati.SetorId.Equals(setorId))
.Include(ativ => ativ.SetorId)
.DefaultIfEmpty()
.Select(ati => new AtivoViewDto
{
Id = ati.Id,
IncAtivo = ati.IncAtivo,
Nome = ati.Nome,
Descricao = ati.Descricao,
DataHoraCadastro = ati.DataHoraCadastro,
DataHoraUltimaAtualizacao = ati.DataHoraUltimaAtualizacao,
StatusAtivo = ati.StatusAtivo.Value,
CriticidadeAtivo = ati.CriticidadeAtivo.Value,
DescricaoStatusAtivo = aux.descricaoStatusAtivoEnum(ati.StatusAtivo.Value.ToString()),
DescricaoCriticidadeAtivo = aux.descricaoCriticidadeAtivoEnum(ati.CriticidadeAtivo.Value.ToString()),
SetorId = Guid.Parse(ati.SetorId.ToString()),
DescricaoSetor = ati.Setor.IncSetor.ToString() + " - " + ati.Setor.Nome,
}).ToListAsync();
return(listaResult);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ActionResult> ExcluirAtivo(Guid ativoId)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
AtivoViewDto viewDto = await _ativoService.PesquisarAtivoPorIdAsync(ativoId);
if (viewDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O ativo informado não foi encontrado!",
}));
}
await _ativoService.ExcluirAtivoAsync(ativoId);
return(CustomResponse(new {
mensagem = "Ativo foi excluído com sucesso!",
}));
}
public async Task <ActionResult> EditarAtivo(Guid ativoId, [FromBody] AtivoPutDto ativoPutDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
if (ativoId != ativoPutDto.Id)
{
NotificarErro("Id da request diferente do Id da Entidade!");
return(CustomResponse(ativoPutDto));
}
AtivoViewDto viewDto = await _ativoService.PesquisarAtivoPorIdAsync(ativoId);
if (viewDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O ativo informado não foi encontrado!",
}));
}
await _ativoService.EditarAtivoAsync(ativoPutDto, viewDto);
return(CustomResponse(new
{
Inc = viewDto.IncAtivo,
mensagem = "Ativo foi editado com sucesso!",
}));
}
public Ativo(AtivoPutDto ativoPutDto, AtivoViewDto viewDto)
{
Id = viewDto.Id;
IncAtivo = viewDto.IncAtivo;
Nome = ativoPutDto.Nome;
Descricao = ativoPutDto.Descricao;
DataHoraCadastro = viewDto.DataHoraCadastro;
DataHoraUltimaAtualizacao = DateTime.Parse(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"));
StatusAtivo = ativoPutDto.StatusAtivo;
CriticidadeAtivo = ativoPutDto.CriticidadeAtivo;
SetorId = ativoPutDto.SetorId;
}
private async Task <bool> EhListaAtivoValida(ICollection <AtivoOcorrenciaPostDto> listaAtivosDto)
{
int qtdAtivoPrincipal = 0;
foreach (AtivoOcorrenciaPostDto itemAtivoDto in listaAtivosDto)
{
AtivoViewDto viewDto = await _ativoRepository.PesquisarAtivoPorIdAsync(itemAtivoDto.Id);
if (viewDto == null)
{
Notificar("Existe um ativo na lista com Id inexistente!");
return(false);
}
if (itemAtivoDto.Principal.Equals(true))
{
qtdAtivoPrincipal++;
}
if (itemAtivoDto.Principal.Equals(true))
{
// verificar se há ocorrencia em aberto com este ativo
ICollection <OcorrenciaAtivo> listaOcorrenciaAtivo = await _ocorrenciaAtivoRepository.PesquisarOcorrenciaAtivoPorAtivo(itemAtivoDto.Id);
if (listaOcorrenciaAtivo.Count >= 1 && !listaOcorrenciaAtivo.Contains(null))
{
Notificar("Existe uma ocorrência com mesmo ativo principal!");
return(false);
}
}
}
if (qtdAtivoPrincipal == 0)
{
Notificar("Não existe ativo principal na ocorrência!");
return(false);
}
if (qtdAtivoPrincipal > 1)
{
Notificar("Existem mais de um ativo principal na lista!");
return(false);
}
return(true);
}
public async Task <ActionResult> CadastrarAtivo([FromBody] AtivoPostDto ativoPostDto)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _ativoService.CadastrarAtivoAsync(ativoPostDto);
AtivoViewDto viewDto = await _ativoService.PesquisarAtivoPorIdAsync(ativoPostDto.Id);
return(CustomResponse(new
{
Inc = viewDto.IncAtivo,
mensagem = "Ativo foi cadastrado com sucesso!",
}));
}
public async Task <bool> EditarAtivoAsync(AtivoPutDto ativoPutDto, AtivoViewDto viewDto)
{
// validação domínio
if (!ExecutarValidacao(new AtivoPutDtoValidation(), ativoPutDto))
{
return(false);
}
// validação regra de negócio
if (!await EhSetorValido(ativoPutDto.SetorId))
{
return(false);
}
Ativo ativo = new Ativo(ativoPutDto, viewDto);
await _ativoRepository.EditarAsync(ativo);
return(true);
}
public async Task <ActionResult> PesquisarAtivoPorInc(int incAtivo)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
AtivoViewDto viewDto = await _ativoService.PesquisarAtivoPorIncAsync(incAtivo);
if (viewDto == null)
{
return(NotFound(new
{
success = true,
status = 404,
mensagem = "O ativo informado não foi encontrado!",
}));
}
return(CustomResponse(viewDto));
}
