304 lines
15 KiB
C#
304 lines
15 KiB
C#
using KTUSAPS.Data.Model;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System.Collections.Generic;
|
|
using System.Threading.Tasks;
|
|
using Microsoft.AspNetCore.Http;
|
|
using System.Linq;
|
|
using Microsoft.AspNetCore.Mvc.Infrastructure;
|
|
|
|
namespace KTUSAPS.Controllers
|
|
{
|
|
[Route("api")]
|
|
[ApiController]
|
|
[Produces("application/json")]
|
|
public class GlueController : ControllerBase
|
|
{
|
|
private readonly Data.SAPSDataContext dataContext;
|
|
private readonly IssuesController issuesController;
|
|
private readonly PublishedProblemsController publishedProblemsController;
|
|
private readonly PublishedFeedbacksController publishedFeedbacksController;
|
|
|
|
public GlueController(Data.SAPSDataContext dataContext, IssuesController issuesController, PublishedProblemsController publishedProblemsController, PublishedFeedbacksController publishedFeedbacksController)
|
|
{
|
|
this.dataContext = dataContext;
|
|
this.issuesController = issuesController;
|
|
this.publishedProblemsController = publishedProblemsController;
|
|
this.publishedFeedbacksController = publishedFeedbacksController;
|
|
}
|
|
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<IEnumerable<Issue>>> GetIssueTypeIssuesAsync(int typeId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
return Ok(issueType.Issues);
|
|
}
|
|
|
|
[HttpPost("IssueTypes/{typeId}/Issues")]
|
|
[ProducesResponseType(StatusCodes.Status201Created)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status400BadRequest)]
|
|
public async Task<ActionResult<Issue>> CreateIssueTypeIssueAsync(int typeId, [FromBody] Issue issueToCreate)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
issueToCreate.IssueTypeId = issueType.Id;
|
|
var createResult = await issuesController.CreateIssueAsync(issueToCreate);
|
|
if(createResult.Result is CreatedAtActionResult actionResult && actionResult.Value is Issue createdIssue)
|
|
return CreatedAtAction(nameof(GetIssueTypeIssueAsync), new { typeId = typeId, issueId = createdIssue.Id }, createdIssue);
|
|
return createResult;
|
|
}
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues/{issueId}")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<Issue>> GetIssueTypeIssueAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
|
|
return Ok(issue);
|
|
}
|
|
|
|
[HttpPatch("IssueTypes/{typeId}/Issues/{issueId}")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<Issue>> UpdateIssueTypeIssueAsync(int typeId, int issueId, [FromBody] Issue issue)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var dbIssue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (dbIssue == null)
|
|
return NotFound();
|
|
return await issuesController.UpdateIssueAsync(dbIssue.Id, issue);
|
|
}
|
|
|
|
[HttpDelete("IssueTypes/{typeId}/Issues/{issueId}")]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> DeleteIssueTypeIssueAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
return await issuesController.DeleteIssueAsync(issue.Id);
|
|
}
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues/{issueId}/Problem")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<PublishedProblem>> GetIssueTypeIssueProblemAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
|
|
return Ok(issue.Problem);
|
|
}
|
|
|
|
[HttpPost("IssueTypes/{typeId}/Issues/{issueId}/Problem")]
|
|
[ProducesResponseType(StatusCodes.Status201Created)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status409Conflict)]
|
|
public async Task<ActionResult<PublishedProblem>> CreateIssueTypeIssueProblemAsync(int typeId, int issueId, [FromBody] PublishedProblem publishedProblem)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem != null)
|
|
return Conflict();
|
|
publishedProblem.IssueId = issue.Id;
|
|
var createResult = await publishedProblemsController.CreatePublishedProblem(publishedProblem);
|
|
if (createResult.Result is CreatedAtActionResult actionResult && actionResult.Value is PublishedProblem createdProblem)
|
|
return CreatedAtAction(nameof(GetIssueTypeIssueProblemAsync), new { typeId = typeId, issueId = issue.Id }, createdProblem);
|
|
return createResult;
|
|
}
|
|
|
|
[HttpDelete("IssueTypes/{typeId}/Issues/{issueId}/Problem")]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> DeleteIssueTypeIssueProblemAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
|
|
dataContext.PublishedProblems.Remove(issue.Problem);
|
|
await dataContext.SaveChangesAsync();
|
|
return NoContent();
|
|
}
|
|
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues/{issueId}/Feedback")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<PublishedProblem>> GetIssueTypeIssueFeedbackAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Feedback).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Feedback == null)
|
|
return NotFound();
|
|
|
|
return Ok(issue.Feedback);
|
|
}
|
|
|
|
[HttpPost("IssueTypes/{typeId}/Issues/{issueId}/Feedback")]
|
|
[ProducesResponseType(StatusCodes.Status201Created)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status409Conflict)]
|
|
public async Task<ActionResult<PublishedFeedback>> CreateIssueTypeIssueFeedbackAsync(int typeId, int issueId, PublishedFeedback publishedFeedback)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Feedback).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Feedback != null)
|
|
return Conflict();
|
|
|
|
publishedFeedback.IssueId = issue.Id;
|
|
var createResult = await publishedFeedbacksController.PostPublishedFeedback(publishedFeedback);
|
|
if (createResult.Result is CreatedAtActionResult actionResult && actionResult.Value is PublishedFeedback createdFeedback)
|
|
return CreatedAtAction(nameof(GetIssueTypeIssueFeedbackAsync), new { typeId = typeId, issueId = issue.Id }, createdFeedback);
|
|
return createResult;
|
|
}
|
|
|
|
[HttpDelete("IssueTypes/{typeId}/Issues/{issueId}/Feedback")]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<IActionResult> DeleteIssueTypeIssueFeedbackAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Feedback == null)
|
|
return NotFound();
|
|
|
|
dataContext.PublishedFeedbacks.Remove(issue.Feedback);
|
|
await dataContext.SaveChangesAsync();
|
|
return NoContent();
|
|
}
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues/{issueId}/Problem/Votes")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<IEnumerable<Vote>>> GetIssueTypeIssueProblemVotesAsync(int typeId, int issueId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).ThenInclude(p => p.Votes).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
|
|
return Ok(issue.Problem.Votes);
|
|
}
|
|
|
|
[HttpPost("IssueTypes/{typeId}/Issues/{issueId}/Problem/Votes")]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
[ProducesResponseType(StatusCodes.Status400BadRequest)]
|
|
[ProducesResponseType(StatusCodes.Status201Created)]
|
|
public async Task<ActionResult<Vote>> CreateIssueTypeIssueProblemVotesAsync(int typeId, int issueId, Vote vote)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).ThenInclude(p => p.Votes).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
|
|
// TODO: Get user id from auth claims
|
|
if (vote.UserId == default)
|
|
return BadRequest("Please provide user id");
|
|
|
|
vote.Problem = issue.Problem;
|
|
dataContext.Votes.Add(vote);
|
|
await dataContext.SaveChangesAsync();
|
|
|
|
return CreatedAtAction(nameof(GetIssueTypeIssueProblemVoteAsync), new { typeId = typeId, issueId = issue.Id, userId = vote.UserId }, vote);
|
|
}
|
|
|
|
[HttpGet("IssueTypes/{typeId}/Issues/{issueId}/Problem/Votes/{userId}")]
|
|
[ProducesResponseType(StatusCodes.Status200OK)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<Vote>> GetIssueTypeIssueProblemVoteAsync(int typeId, int issueId, string userId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).ThenInclude(p => p.Votes).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
var vote = issue.Problem.Votes.FirstOrDefault(v => v.UserId == userId);
|
|
if(vote == default)
|
|
return NotFound();
|
|
|
|
return Ok(vote);
|
|
}
|
|
|
|
[HttpDelete("IssueTypes/{typeId}/Issues/{issueId}/Problem/Votes/{userId}")]
|
|
[ProducesResponseType(StatusCodes.Status204NoContent)]
|
|
[ProducesResponseType(StatusCodes.Status404NotFound)]
|
|
public async Task<ActionResult<Vote>> DeleteIssueTypeIssueProblemVoteAsync(int typeId, int issueId, string userId)
|
|
{
|
|
var issueType = await dataContext.IssueTypes.Include(t => t.Issues).ThenInclude(i => i.Problem).ThenInclude(p => p.Votes).FirstOrDefaultAsync(t => t.Id == typeId);
|
|
if (issueType == default)
|
|
return NotFound();
|
|
var issue = issueType.Issues.FirstOrDefault(i => i.Id == issueId);
|
|
if (issue == null)
|
|
return NotFound();
|
|
if (issue.Problem == null)
|
|
return NotFound();
|
|
var vote = issue.Problem.Votes.FirstOrDefault(v => v.UserId == userId);
|
|
if (vote == default)
|
|
return NotFound();
|
|
|
|
dataContext.Votes.Remove(vote);
|
|
await dataContext.SaveChangesAsync();
|
|
|
|
return NoContent();
|
|
}
|
|
}
|
|
}
|