public async Task <IActionResult> Put(Guid id, [FromBody] RecursoProjeto obj)
    {
        if (!ModelState.IsValid)
        {
            return(BadRequest(ModelState));
        }

        if (id != obj.Id)
        {
            return(BadRequest());
        }

        try
        {
            _unitOfWork.RecursoProjetoRepository.Update(obj);

            await _unitOfWork.SaveChangesAsync();
        }
        catch (Exception)
        {
            if (!await ObjExists(id))
            {
                return(NotFound());
            }
            else
            {
                throw;
            }
        }

        return(NoContent());
    }
    public async Task <ActionResult <RecursoProjeto> > Post([FromBody] RecursoProjeto obj)
    {
        if (!ModelState.IsValid)
        {
            return(BadRequest(ModelState));
        }

        try
        {
            obj = await _unitOfWork.RecursoProjetoRepository.AddAsync(obj);

            await _unitOfWork.SaveChangesAsync();
        }
        catch (Exception)
        {
            if (await ObjExists(obj.Id))
            {
                return(Conflict());
            }
            else
            {
                throw;
            }
        }

        return(CreatedAtRoute("GetRecursoProjeto", new { id = obj.Id }, obj));
    }
    public async Task <ActionResult <RecursoProjeto> > Get(Guid id)
    {
        RecursoProjeto recursoProjeto = await _unitOfWork.RecursoProjetoRepository.GetAsync(id);

        if (recursoProjeto == null)
        {
            return(NotFound());
        }

        return(Ok(recursoProjeto));
    }
    public async Task UpdateRecursoProjetoCommand_Handle()
    {
        // Arrange
        IUnitOfWork unitOfWork = DbContextHelper.GetContext();
        IMapper     mapper     = AutoMapperHelper.GetMappings();

        Guid sistemaId = Guid.NewGuid();
        await unitOfWork.SistemaRepository.AddAsync(MockEntityHelper.GetNewSistema(sistemaId));

        Guid projetoId = Guid.NewGuid();
        await unitOfWork.ProjetoRepository.AddAsync(MockEntityHelper.GetNewProjeto(sistemaId, projetoId));

        Guid workflowId = Guid.NewGuid();
        await unitOfWork.WorkflowRepository.AddAsync(MockEntityHelper.GetNewWorkflow(workflowId));

        Guid recursoId = Guid.NewGuid();
        await unitOfWork.RecursoRepository.AddAsync(MockEntityHelper.GetNewRecurso(recursoId));

        Guid           recursoProjetoId = Guid.NewGuid();
        DateTime       dataInclusao     = DateTime.Now;
        RecursoProjeto recursoProjeto   = MockEntityHelper.GetNewRecursoProjeto(projetoId, recursoId, recursoProjetoId);

        await unitOfWork.RecursoProjetoRepository.AddAsync(recursoProjeto);

        await unitOfWork.SaveChangesAsync();

        unitOfWork.RecursoProjetoRepository.Detatch(recursoProjeto);

        UpdateRecursoProjetoCommand request = new()
        {
            RecursoProjeto = MockViewModelHelper.GetNewRecursoProjeto(projetoId, recursoId, recursoProjetoId, dataInclusao)
        };

        GetRecursoProjetoQuery request2 = new()
        {
            Id = recursoProjetoId
        };

        // Act
        RecursoProjetoHandler handler  = new(unitOfWork, mapper);
        OperationResult       response = await handler.Handle(request, CancellationToken.None);

        RecursoProjetoViewModel response2 = await handler.Handle(request2, CancellationToken.None);

        // Assert
        Assert.True(response == OperationResult.Success);
        Assert.True(response2 != null);
        Assert.True(response2.Id == recursoProjetoId);
        Assert.True(response2.DataInclusao.Ticks == dataInclusao.Ticks);
    }
}
    public async Task <IActionResult> Delete(Guid id)
    {
        RecursoProjeto obj = await _unitOfWork.RecursoProjetoRepository.GetAsync(id);

        if (obj == null)
        {
            return(NotFound());
        }

        await _unitOfWork.RecursoProjetoRepository.RemoveAsync(id);

        await _unitOfWork.SaveChangesAsync();

        return(NoContent());
    }
    public async Task <OperationResult> Handle(RemoveRecursoProjetoCommand request, CancellationToken cancellationToken)
    {
        RecursoProjeto obj = await _unitOfWork.RecursoProjetoRepository.GetAsync(request.Id);

        if (obj == null)
        {
            return(OperationResult.NotFound);
        }

        await _unitOfWork.RecursoProjetoRepository.RemoveAsync(request.Id);

        bool success = await _unitOfWork.SaveChangesAsync();

        OperationResult result = success ? OperationResult.Success : OperationResult.Failed;

        return(result);
    }