AuthenticationContextFactory.cs

Go to the documentation of this file.

using Microsoft.EntityFrameworkCore;
using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Host.Models;

namespace Tgstation.Server.Host.Security
{
    sealed class AuthenticationContextFactory : IAuthenticationContextFactory, IDisposable
    {
        public IAuthenticationContext CurrentAuthenticationContext { get; private set; }

        readonly ISystemIdentityFactory systemIdentityFactory;

        readonly IDatabaseContext databaseContext;

        readonly IIdentityCache identityCache;

        public AuthenticationContextFactory(ISystemIdentityFactory systemIdentityFactory, IDatabaseContext databaseContext, IIdentityCache identityCache)
        {
            this.systemIdentityFactory = systemIdentityFactory ?? throw new ArgumentNullException(nameof(systemIdentityFactory));
            this.databaseContext = databaseContext ?? throw new ArgumentNullException(nameof(databaseContext));
            this.identityCache = identityCache ?? throw new ArgumentNullException(nameof(identityCache));
        }

        public void Dispose() => CurrentAuthenticationContext?.Dispose();

        public async Task CreateAuthenticationContext(long userId, long? instanceId, DateTimeOffset validAfter, CancellationToken cancellationToken)
        {
            if (CurrentAuthenticationContext != null)
                throw new InvalidOperationException("Authentication context has already been loaded");

            var userQuery = databaseContext.Users.Where(x => x.Id == userId)
                .Include(x => x.CreatedBy)
                .FirstOrDefaultAsync(cancellationToken);

            var instanceUserQuery = instanceId.HasValue ? databaseContext.InstanceUsers
                .Where(x => x.UserId == userId && x.InstanceId == instanceId && x.Instance.Online.Value)
                .Include(x => x.Instance)
                .FirstOrDefaultAsync(cancellationToken) : Task.FromResult<InstanceUser>(null);

            var user = await userQuery.ConfigureAwait(false);
            if (user == default)
            {
                CurrentAuthenticationContext = new AuthenticationContext();
                return;
            }

            ISystemIdentity systemIdentity;
            if (user.SystemIdentifier != null)
                systemIdentity = identityCache.LoadCachedIdentity(user);
            else
            {
                if (user.LastPasswordUpdate.HasValue && user.LastPasswordUpdate > validAfter)
                {
                    CurrentAuthenticationContext = new AuthenticationContext();
                    return;
                }
                systemIdentity = null;
            }

            try
            {
                var instanceUser = await instanceUserQuery.ConfigureAwait(false);

                CurrentAuthenticationContext = new AuthenticationContext(systemIdentity, user, instanceUser);
            }
            catch
            {
                systemIdentity?.Dispose();
                throw;
            }
        }
    }
}