RootController.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
 
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Tgstation.Server.Api;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Controllers
{
    [Route("/")]
    [ApiExplorerSettings(IgnoreApi = true)]
    public sealed class RootController : Controller
    {
        const string LogoSvgWindowsName = "0176d5d8b7d307f158e0";
 
        const string LogoSvgLinuxName = "b5616c99bf2052a6bbd7";
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IWebHostEnvironment hostEnvironment;
 
        readonly IOptions<GeneralConfiguration> generalConfigurationOptions;
 
        readonly IOptions<ControlPanelConfiguration> controlPanelConfigurationOptions;
 
        readonly IOptions<InternalConfiguration> internalConfigurationOptions;
 
        readonly ILogger<RootController> logger;
 
        static Tuple<string, string?> GetControlPanelActionLink(Expression<Func<ControlPanelController, IActionResult>> actionExpression)
        {
            var memberSelectorExpression = (MethodCallExpression)actionExpression.Body;
            var method = memberSelectorExpression.Method;
 
            var controllerName = typeof(ControlPanelController).Name;
 
            const string ControllerSuffix = nameof(Controller);
            if (controllerName.EndsWith(ControllerSuffix, StringComparison.Ordinal))
                controllerName = controllerName.Substring(0, controllerName.Length - ControllerSuffix.Length);
 
            var actionName = method.Name;
 
            return Tuple.Create<string, string?>(controllerName, actionName);
        }
 
        public RootController(
            IAssemblyInformationProvider assemblyInformationProvider,
            IPlatformIdentifier platformIdentifier,
            IWebHostEnvironment hostEnvironment,
            ILogger<RootController> logger,
            IOptions<GeneralConfiguration> generalConfigurationOptions,
            IOptions<ControlPanelConfiguration> controlPanelConfigurationOptions,
            IOptions<InternalConfiguration> internalConfigurationOptions)
        {
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.hostEnvironment = hostEnvironment ?? throw new ArgumentNullException(nameof(hostEnvironment));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.generalConfigurationOptions = generalConfigurationOptions ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            this.controlPanelConfigurationOptions = controlPanelConfigurationOptions ?? throw new ArgumentNullException(nameof(controlPanelConfigurationOptions));
            this.internalConfigurationOptions = internalConfigurationOptions ?? throw new ArgumentNullException(nameof(internalConfigurationOptions));
        }
 
        [HttpGet]
        [AllowAnonymous]
        public IActionResult Index()
        {
            var panelEnabled = controlPanelConfigurationOptions.Value.Enable;
            var apiDocsEnabled = generalConfigurationOptions.Value.HostApiDocumentation;
 
            var controlPanelRoute = $"{ControlPanelController.ControlPanelRoute.TrimStart('/')}/";
            if (panelEnabled && !apiDocsEnabled)
                return Redirect(controlPanelRoute);
 
            Dictionary<string, string>? links = null;
 
            if (panelEnabled || apiDocsEnabled)
            {
                links = new Dictionary<string, string>();
 
                if (panelEnabled)
                    links.Add("Web Control Panel", controlPanelRoute);
 
                if (apiDocsEnabled)
                {
                    if (internalConfigurationOptions.Value.EnableGraphQL)
                        links.Add("GraphQL API Documentation", Routes.GraphQL);
 
                    links.Add("REST API Documentation", SwaggerConfiguration.DocumentationSiteRouteExtension);
                }
            }
            else
                links = null;
 
            var model = new
            {
                Links = links,
                Title = assemblyInformationProvider.VersionString,
            };
 
            return View(model);
        }
 
        [HttpGet("logo.svg")]
        public IActionResult GetLogo()
        {
            // these are different because of motherfucking line endings -_-
            if (platformIdentifier.IsWindows)
            {
                VirtualFileResult? result = this.TryServeFile(hostEnvironment, logger, $"{LogoSvgWindowsName}.svg");
                if (result != null)
                    return result;
 
                // BUT THE UPDATE PACKAGES ARE BUILT ON LINUX RAAAAAGH
            }
 
            return (IActionResult?)this.TryServeFile(hostEnvironment, logger, $"{LogoSvgLinuxName}.svg") ?? NotFound();
        }
 
        [HttpGet(ControlPanelController.ChannelJsonRoute)]
        public RedirectToActionResult WebpanelChannelRedirect()
        {
            var actionTuple = GetControlPanelActionLink(controller => controller.GetChannelJson());
 
            return RedirectToActionPermanent(
                actionTuple.Item2,
                actionTuple.Item1);
        }
    }
}