JobController.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Response;
using Tgstation.Server.Host.Components;
using Tgstation.Server.Host.Controllers.Results;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Models;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route(Routes.Jobs)]
    public sealed class JobController : InstanceRequiredController
    {
        readonly IJobManager jobManager;
 
        public JobController(
            IDatabaseContext databaseContext,
            IAuthenticationContext authenticationContext,
            ILogger<JobController> logger,
            IInstanceManager instanceManager,
            IJobManager jobManager,
            IApiHeadersProvider apiHeaders)
            : base(
                  databaseContext,
                  authenticationContext,
                  logger,
                  instanceManager,
                  apiHeaders)
        {
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
        }
 
        [HttpGet]
        [TgsAuthorize]
        [ProducesResponseType(typeof(PaginatedResponse<JobResponse>), 200)]
        public ValueTask<IActionResult> Read([FromQuery] int? page, [FromQuery] int? pageSize, CancellationToken cancellationToken)
            => Paginated<Job, JobResponse>(
                () => ValueTask.FromResult<PaginatableResult<Job>?>(
                    new PaginatableResult<Job>(
                        DatabaseContext
                        .Jobs
                        .Include(x => x.StartedBy)
                        .Include(x => x.CancelledBy)
                        .Include(x => x.Instance)
                        .Where(x => x.Instance!.Id == Instance.Id && !x.StoppedAt.HasValue)
                        .OrderByDescending(x => x.StartedAt))),
                AddJobProgressResponseTransformer,
                page,
                pageSize,
                cancellationToken);
 
        [HttpGet(Routes.List)]
        [TgsAuthorize]
        [ProducesResponseType(typeof(PaginatedResponse<JobResponse>), 200)]
        public ValueTask<IActionResult> List([FromQuery] int? page, [FromQuery] int? pageSize, CancellationToken cancellationToken)
            => Paginated<Job, JobResponse>(
                () => ValueTask.FromResult<PaginatableResult<Job>?>(
                    new PaginatableResult<Job>(
                        DatabaseContext
                        .Jobs
                        .Include(x => x.StartedBy)
                        .Include(x => x.CancelledBy)
                        .Include(x => x.Instance)
                        .Where(x => x.Instance!.Id == Instance.Id)
                        .OrderByDescending(x => x.StartedAt))),
                AddJobProgressResponseTransformer,
                page,
                pageSize,
                cancellationToken);
 
        [HttpDelete("{id}")]
        [TgsAuthorize]
        [ProducesResponseType(typeof(JobResponse), 202)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 404)]
        public async ValueTask<IActionResult> Delete(long id, CancellationToken cancellationToken)
        {
            // don't care if an instance post or not at this point
            var job = await DatabaseContext
                .Jobs
                .Include(x => x.StartedBy)
                .Include(x => x.Instance)
                .Where(x => x.Id == id && x.Instance!.Id == Instance.Id)
                .FirstOrDefaultAsync(cancellationToken);
            if (job == default)
                return NotFound();
 
            if (job.StoppedAt != null)
                return Conflict(new ErrorMessageResponse(ErrorCode.JobStopped));
 
            if (job.CancelRight.HasValue && job.CancelRightsType.HasValue && (AuthenticationContext.GetRight(job.CancelRightsType.Value) & job.CancelRight.Value) == 0)
                return Forbid();
 
            var updatedJob = await jobManager.CancelJob(job, AuthenticationContext.User, false, cancellationToken);
            return updatedJob != null ? Accepted(updatedJob.ToApi()) : this.Gone();
        }
 
        [HttpGet("{id}")]
        [TgsAuthorize]
        [ProducesResponseType(typeof(JobResponse), 200)]
        [ProducesResponseType(typeof(ErrorMessageResponse), 404)]
        public async ValueTask<IActionResult> GetId(long id, CancellationToken cancellationToken)
        {
            var job = await DatabaseContext
                .Jobs
                .Where(x => x.Id == id && x.Instance!.Id == Instance.Id)
                .Include(x => x.StartedBy)
                .Include(x => x.CancelledBy)
                .Include(x => x.Instance)
                .FirstOrDefaultAsync(cancellationToken);
            if (job == default)
                return NotFound();
            var api = job.ToApi();
            jobManager.SetJobProgress(api);
            return Json(api);
        }
 
        ValueTask AddJobProgressResponseTransformer(JobResponse jobResponse)
        {
            jobManager.SetJobProgress(jobResponse);
            return ValueTask.CompletedTask;
        }
    }
}