Progresss

KTUSAPS/Controllers/AuthMetadataController.cs

@@ -41,7 +41,6 @@ namespace KTUSAPS.Controllers
         /// <response code="200">Provided token is correct.</response>
         /// <response code="401">No valid token provided.</response>
         [Authorize]
-        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [HttpGet("Authed")]
         public bool IsAuthed() => true;

KTUSAPS/Controllers/GlueController.cs

@@ -0,0 +1,303 @@
+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();
+        }
+    }
+}

KTUSAPS/Controllers/IssueTypesController.cs

@@ -58,11 +58,11 @@ namespace KTUSAPS.Controllers
             if (issueType == null)
                 return NotFound();
 
-            return issueType;
+            return Ok(issueType);
         }
 
         [HttpPatch("{id}")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
         public async Task<IActionResult> UpdateIssueType(int id, IssueType issueType)
         {
@@ -79,7 +79,7 @@ namespace KTUSAPS.Controllers
 
             await _context.SaveChangesAsync();
 
-            return NoContent();
+            return Ok(eIssueType.Entity);
         }
 
         

KTUSAPS/Controllers/IssuesController.cs

@@ -77,7 +77,7 @@ namespace KTUSAPS.Controllers
                 nameof(databaseIssue.Publishable)
             });
             await dataContext.SaveChangesAsync();
-            return NoContent();
+            return Ok(eIssue.Entity);
         }
 
         [HttpDelete("{id}")]

KTUSAPS/Controllers/PublishedFeedbacksController.cs

@@ -61,9 +61,9 @@ namespace KTUSAPS.Controllers
         }
 
         [HttpPatch("{id}")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<IActionResult> UpdatePublishedFeedback(int id, PublishedFeedback publishedFeedback)
+        public async Task<ActionResult<PublishedFeedback>> UpdatePublishedFeedback(int id, PublishedFeedback publishedFeedback)
         {
             var databasePublishedFeedback = await _context.PublishedFeedbacks.FindAsync(id);
             if (databasePublishedFeedback == default)
@@ -81,7 +81,7 @@ namespace KTUSAPS.Controllers
 
             await _context.SaveChangesAsync();
 
-            return NoContent();
+            return Ok(ePublishedFeedback.Entity);
         }
 
 

KTUSAPS/Controllers/PublishedProblemsController.cs

@@ -39,7 +39,7 @@ namespace KTUSAPS.Controllers
             if (publishedProblem.Id != default)
                 return BadRequest("Id has been set on create request, please do not do that, set id to 0 or ommit it.");
             if (publishedProblem.Issue != null || publishedProblem.Solution != null || publishedProblem.Votes != null)
-                return BadRequest("Do not privide navigation property values.");
+                return BadRequest("Do not provide navigation property values.");
 
             _context.PublishedProblems.Add(publishedProblem);
             await _context.SaveChangesAsync();
@@ -61,9 +61,9 @@ namespace KTUSAPS.Controllers
         }
 
         [HttpPatch("{id}")]
-        [ProducesResponseType(StatusCodes.Status204NoContent)]
+        [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
-        public async Task<IActionResult> UpdatePublishedProblem(int id, PublishedProblem publishedProblem)
+        public async Task<ActionResult<PublishedProblem>> UpdatePublishedProblem(int id, PublishedProblem publishedProblem)
         {
             var databasePublishedProblem = await _context.PublishedProblems.FindAsync(id);
             if (databasePublishedProblem == default)
@@ -82,7 +82,7 @@ namespace KTUSAPS.Controllers
 
             await _context.SaveChangesAsync();
 
-            return NoContent();
+            return Ok(ePublishedProblem.Entity);
         }
 
         
@@ -118,7 +118,7 @@ namespace KTUSAPS.Controllers
         }
 
         [HttpPost("{id}/Votes")]
-        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status201Created)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
         public async Task<ActionResult<Vote>> Vote(int id, Vote vote)