strataspheredatamanagement/src/Strata.Stratasphere.Api/Controllers/QueriesController.cs

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Strata.Stratasphere.Biz.DataManagement;
using Strata.Stratasphere.Biz.DataManagement.Models;
using Strata.Stratasphere.Biz.Queries;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace Strata.Stratasphere.Api.Controllers
{
    [ApiController]
    [ApiVersion("1.0")]
    [Route("api/v{api-version:apiVersion}/[controller]")]
    public class QueriesController : ControllerBase
    {
        private readonly DataManagementContext _dataManagementContext;
        private readonly IQueryService _queryService;

        private bool QueryExists(int queryId) => _dataManagementContext.Queries.Any(e => e.QueryId == queryId);

        public QueriesController(DataManagementContext dataManagementContext, IQueryService queryService)
        {
            _dataManagementContext = dataManagementContext;
            _queryService = queryService;
        }

        [HttpGet]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public async Task<IEnumerable<Query>> GetAll(CancellationToken cancellationToken)
        {
            var queries = await _dataManagementContext.Queries.ToListAsync(cancellationToken);

            return queries;
        }

        [HttpGet("{queryId}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<Query>> GetById(int queryId, CancellationToken cancellationToken)
        {
            var query = await _dataManagementContext.Queries.SingleOrDefaultAsync(p => p.QueryId == queryId, cancellationToken);

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

            return query;
        }

        [HttpGet("{queryId}/[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<Query>> Copy(int queryId, CancellationToken cancellationToken)
        {
            return await _queryService.Copy(queryId, cancellationToken);
        }

        [HttpPost]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesDefaultResponseType]
        public async Task<ActionResult<Query>> Create([FromBody] Query query, CancellationToken cancellationToken)
        {
            return await _queryService.Create(query, cancellationToken);
        }

        [HttpPut("{queryId}")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<IActionResult> Update(int queryId, Query queryDto, CancellationToken cancellationToken)
        {
            if (queryId != queryDto.QueryId) { return BadRequest(); }

            var updated = await _queryService.Update(queryDto, cancellationToken);
            if (!updated) { return NotFound(); }

            return NoContent();
        }

        [HttpGet("{queryId}/[action]")]
        public async Task<bool> SaveToGithub(int queryId, CancellationToken cancellationToken)
        {
            if (queryId < 0) { return false; }
            var user = User?.Identity?.Name ?? "";
            return await _queryService.SaveToGithub(queryId, user, cancellationToken);
        }

        [HttpDelete("{queryId}")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<IActionResult> Delete(int queryId, CancellationToken token)
        {
            var query = await _dataManagementContext.Queries.SingleOrDefaultAsync(p => p.QueryId == queryId, token);

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

            _dataManagementContext.Remove(query);

            await _dataManagementContext.SaveChangesAsync(token);

            return NoContent();
        }

        [HttpGet("{queryId}/[action]")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesDefaultResponseType]
        public async Task<IActionResult> History(int queryId, CancellationToken cancellationToken)
            => Ok(await _queryService.History(queryId, User?.Identity?.Name ?? ""));
    }

}