Reward model, viewmodel, controller & AppDbContext (latest working v1.0 after changes)

//Models
public class Reward
{
    [Key]
    public int Reward_ID { get; set; }

    [Required]
    public DateTime Reward_Issue_Date { get; set; }

    public bool IsPosted { get; set; } // New property to track posted status

    public int Reward_Type_ID { get; set; }

    [ForeignKey(nameof(Reward_Type_ID))]
    public Reward_Type Reward_Type { get; set; }

}

public class Reward_Member
{
    [Key]
    public int Reward_Member_ID { get; set; }

    public bool IsRedeemed { get; set; } // New property to track redemption status

    public int Member_ID { get; set; }

    [ForeignKey(nameof(Member_ID))]

    public Member Member { get; set; }


    public int Reward_ID { get; set; }

    [ForeignKey(nameof(Reward_ID))]

    public Reward Reward { get; set; }
}

//ViewModels
public class RewardRedeemViewModel
{

    public int MemberId { get; set; }

    public int RewardId { get; set; }
}

public class RewardSetViewModel
{
    public DateTime Reward_Issue_Date { get; set; }

    public int Reward_Type_ID { get; set; }

    public bool IsPosted { get; set; } = false;
}

public class RewardPostViewModel
{
    public int RewardId { get; set; }
}

//Controller

[Route("api/[controller]")]
[ApiController]
public class RewardController : ControllerBase
{
  private readonly AppDbContext _appDbContext;

  public RewardController(AppDbContext appDbContext)
  {
    _appDbContext = appDbContext;
  }
  
      [HttpGet]
    [Route("getRewardById/{id}")]
    public async Task<IActionResult> GetRewardById(int id)
    {
        try
        {
            var reward = await _appDbContext.Rewards.FindAsync(id);

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

            return Ok(reward);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpGet]
    [Route("getAllRewards")]
    public async Task<IActionResult> GetAllRewards()
    {
        try
        {
            var rewards = await _appDbContext.Rewards.ToListAsync();
            return Ok(rewards);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpPost]
    [Route("redeemReward")]
    public async Task<IActionResult> RedeemReward([FromBody] RewardRedeemViewModel request)
    {
        try
        {
            // Fetch the reward by ID
            var reward = await _appDbContext.Reward_Members
                                            .FirstOrDefaultAsync(r => r.Reward_ID == request.RewardId && r.Member_ID == request.MemberId);

            if (reward == null)
            {
                return NotFound("Reward not found or not eligible for the member.");
            }

            // Check if the reward is already redeemed
            if (reward.IsRedeemed)
            {
                return BadRequest("Reward is already redeemed.");
            }

            // Mark the reward as redeemed
            reward.IsRedeemed = true;
            _appDbContext.Entry(reward).State = EntityState.Modified;
            await _appDbContext.SaveChangesAsync();

            return Ok(new { Status = "Success", Message = "Reward redeemed successfully!" });
        }
        catch (Exception)
        {
            return BadRequest("An error occurred while redeeming the reward.");
        }
    }

    [HttpPost]
    [Route("setReward")]
    public async Task<IActionResult> SetReward(RewardSetViewModel r)
    {
        try
        {
            var reward = new Reward
            {
                Reward_Issue_Date = r.Reward_Issue_Date,
                Reward_Type_ID = r.Reward_Type_ID,
                IsPosted = r.IsPosted
            };
            _appDbContext.Rewards.Add(reward);
            await _appDbContext.SaveChangesAsync();

            return CreatedAtAction(nameof(GetRewardById), new { id = reward.Reward_ID }, reward);
        }
        catch (Exception)
        {
            return BadRequest();
        }
    }

    [HttpPost]
    [Route("postReward")]
    public async Task<IActionResult> PostReward([FromBody] RewardPostViewModel request)
    {
        try
        {
            // Fetch the reward by ID
            var reward = await _appDbContext.Rewards
                                            .FirstOrDefaultAsync(r => r.Reward_ID == request.RewardId);

            if (reward == null)
            {
                return NotFound("Reward not found.");
            }

            // Check if the reward is already posted
            if (reward.IsPosted)
            {
                return BadRequest("Reward is already posted.");
            }

            // Mark the reward as posted
            reward.IsPosted = true;
            _appDbContext.Entry(reward).State = EntityState.Modified;
            await _appDbContext.SaveChangesAsync();

            return Ok(new { Status = "Success", Message = "Reward posted successfully!" });
        }
        catch (Exception)
        {
            return BadRequest("An error occurred while posting the reward.");
        }
    }
}

//AppDbContext
var Rewards = new Reward[]
{
    new Reward { Reward_ID = 1, IsPosted = false, Reward_Issue_Date = new DateTime(2024, 4, 10), Reward_Type_ID = 1 }

};
builder.Entity<Reward>().HasData(Rewards);

var Reward_Members = new Reward_Member[]
{
    new Reward_Member{ Reward_Member_ID = 1, IsRedeemed = false, Member_ID = 1, Reward_ID = 1}
};
builder.Entity<Reward_Member>().HasData(Reward_Members);