2014-10-11 16:38:13 -04:00
|
|
|
using System;
|
2020-11-19 09:38:54 -05:00
|
|
|
using System.Collections.Concurrent;
|
2014-10-11 16:38:13 -04:00
|
|
|
using System.Linq;
|
2021-04-10 16:17:36 -04:00
|
|
|
using System.Threading.Tasks;
|
2020-05-15 17:20:07 -04:00
|
|
|
using Jellyfin.Data.Entities;
|
2021-04-10 16:17:36 -04:00
|
|
|
using Jellyfin.Data.Entities.Security;
|
2020-07-29 19:25:47 -04:00
|
|
|
using Jellyfin.Data.Enums;
|
2020-08-13 20:48:28 -04:00
|
|
|
using Jellyfin.Data.Events;
|
2021-05-20 23:56:59 -04:00
|
|
|
using Jellyfin.Data.Queries;
|
2019-01-13 14:20:41 -05:00
|
|
|
using MediaBrowser.Controller.Devices;
|
|
|
|
using MediaBrowser.Controller.Library;
|
|
|
|
using MediaBrowser.Model.Devices;
|
|
|
|
using MediaBrowser.Model.Querying;
|
|
|
|
using MediaBrowser.Model.Session;
|
2021-04-10 16:17:36 -04:00
|
|
|
using Microsoft.EntityFrameworkCore;
|
2014-10-11 16:38:13 -04:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
namespace Jellyfin.Server.Implementations.Devices
|
2014-10-11 16:38:13 -04:00
|
|
|
{
|
2021-04-10 17:11:59 -04:00
|
|
|
/// <summary>
|
|
|
|
/// Manages the creation, updating, and retrieval of devices.
|
|
|
|
/// </summary>
|
2014-10-11 16:38:13 -04:00
|
|
|
public class DeviceManager : IDeviceManager
|
|
|
|
{
|
2021-04-10 16:17:36 -04:00
|
|
|
private readonly JellyfinDbProvider _dbProvider;
|
2014-10-11 16:38:13 -04:00
|
|
|
private readonly IUserManager _userManager;
|
2020-11-19 09:38:54 -05:00
|
|
|
private readonly ConcurrentDictionary<string, ClientCapabilities> _capabilitiesMap = new ();
|
2018-09-12 13:26:21 -04:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <summary>
|
|
|
|
/// Initializes a new instance of the <see cref="DeviceManager"/> class.
|
|
|
|
/// </summary>
|
|
|
|
/// <param name="dbProvider">The database provider.</param>
|
|
|
|
/// <param name="userManager">The user manager.</param>
|
|
|
|
public DeviceManager(JellyfinDbProvider dbProvider, IUserManager userManager)
|
2014-10-11 16:38:13 -04:00
|
|
|
{
|
2021-04-10 16:17:36 -04:00
|
|
|
_dbProvider = dbProvider;
|
2014-10-11 16:38:13 -04:00
|
|
|
_userManager = userManager;
|
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
|
|
|
public event EventHandler<GenericEventArgs<Tuple<string, DeviceOptions>>>? DeviceOptionsUpdated;
|
2020-11-19 09:38:54 -05:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2018-09-12 13:26:21 -04:00
|
|
|
public void SaveCapabilities(string deviceId, ClientCapabilities capabilities)
|
2014-10-11 16:38:13 -04:00
|
|
|
{
|
2020-11-19 09:38:54 -05:00
|
|
|
_capabilitiesMap[deviceId] = capabilities;
|
2018-09-12 13:26:21 -04:00
|
|
|
}
|
2014-10-11 16:38:13 -04:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2021-07-13 19:30:11 -04:00
|
|
|
public async Task UpdateDeviceOptions(string deviceId, string deviceName)
|
2018-09-12 13:26:21 -04:00
|
|
|
{
|
2021-04-10 16:17:36 -04:00
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
2021-06-19 15:24:26 -04:00
|
|
|
var deviceOptions = await dbContext.DeviceOptions.AsQueryable().FirstOrDefaultAsync(dev => dev.DeviceId == deviceId).ConfigureAwait(false);
|
|
|
|
if (deviceOptions == null)
|
|
|
|
{
|
|
|
|
deviceOptions = new DeviceOptions(deviceId);
|
|
|
|
dbContext.DeviceOptions.Add(deviceOptions);
|
|
|
|
}
|
|
|
|
|
2021-07-13 19:30:11 -04:00
|
|
|
deviceOptions.CustomName = deviceName;
|
2021-06-19 15:24:26 -04:00
|
|
|
await dbContext.SaveChangesAsync().ConfigureAwait(false);
|
2014-10-11 16:38:13 -04:00
|
|
|
|
2021-07-13 19:30:11 -04:00
|
|
|
DeviceOptionsUpdated?.Invoke(this, new GenericEventArgs<Tuple<string, DeviceOptions>>(new Tuple<string, DeviceOptions>(deviceId, deviceOptions)));
|
2018-09-12 13:26:21 -04:00
|
|
|
}
|
2014-10-11 16:38:13 -04:00
|
|
|
|
2021-05-20 23:56:59 -04:00
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task<Device> CreateDevice(Device device)
|
|
|
|
{
|
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
|
|
|
|
|
|
|
dbContext.Devices.Add(device);
|
|
|
|
|
|
|
|
await dbContext.SaveChangesAsync().ConfigureAwait(false);
|
|
|
|
return device;
|
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2021-06-27 16:42:26 -04:00
|
|
|
public async Task<DeviceOptions> GetDeviceOptions(string deviceId)
|
2018-09-12 13:26:21 -04:00
|
|
|
{
|
2021-04-10 16:57:25 -04:00
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
2021-06-27 16:42:26 -04:00
|
|
|
var deviceOptions = await dbContext.DeviceOptions
|
2021-04-10 16:17:36 -04:00
|
|
|
.AsQueryable()
|
2021-04-10 16:57:25 -04:00
|
|
|
.FirstOrDefaultAsync(d => d.DeviceId == deviceId)
|
|
|
|
.ConfigureAwait(false);
|
2021-06-27 16:42:26 -04:00
|
|
|
|
|
|
|
return deviceOptions ?? new DeviceOptions(deviceId);
|
2018-09-12 13:26:21 -04:00
|
|
|
}
|
2014-10-11 16:38:13 -04:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2021-04-10 17:11:59 -04:00
|
|
|
public ClientCapabilities GetCapabilities(string deviceId)
|
2018-09-12 13:26:21 -04:00
|
|
|
{
|
2021-04-10 17:11:59 -04:00
|
|
|
return _capabilitiesMap.TryGetValue(deviceId, out ClientCapabilities? result)
|
2020-11-19 09:38:54 -05:00
|
|
|
? result
|
|
|
|
: new ClientCapabilities();
|
2014-10-11 16:38:13 -04:00
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task<DeviceInfo?> GetDevice(string id)
|
2014-10-11 16:38:13 -04:00
|
|
|
{
|
2021-04-10 16:17:36 -04:00
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
|
|
|
var device = await dbContext.Devices
|
|
|
|
.AsQueryable()
|
|
|
|
.Where(d => d.DeviceId == id)
|
|
|
|
.OrderByDescending(d => d.DateLastActivity)
|
|
|
|
.Include(d => d.User)
|
|
|
|
.FirstOrDefaultAsync()
|
|
|
|
.ConfigureAwait(false);
|
|
|
|
|
|
|
|
var deviceInfo = device == null ? null : ToDeviceInfo(device);
|
|
|
|
|
|
|
|
return deviceInfo;
|
2014-10-11 16:38:13 -04:00
|
|
|
}
|
|
|
|
|
2021-05-20 23:56:59 -04:00
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task<QueryResult<Device>> GetDevices(DeviceQuery query)
|
|
|
|
{
|
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
|
|
|
|
|
|
|
var devices = dbContext.Devices.AsQueryable();
|
|
|
|
|
|
|
|
if (query.UserId.HasValue)
|
|
|
|
{
|
|
|
|
devices = devices.Where(device => device.UserId == query.UserId.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (query.DeviceId != null)
|
|
|
|
{
|
|
|
|
devices = devices.Where(device => device.DeviceId == query.DeviceId);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (query.AccessToken != null)
|
|
|
|
{
|
|
|
|
devices = devices.Where(device => device.AccessToken == query.AccessToken);
|
|
|
|
}
|
|
|
|
|
2021-06-19 15:24:42 -04:00
|
|
|
var count = await devices.CountAsync().ConfigureAwait(false);
|
|
|
|
|
2021-05-20 23:56:59 -04:00
|
|
|
if (query.Skip.HasValue)
|
|
|
|
{
|
|
|
|
devices = devices.Skip(query.Skip.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (query.Limit.HasValue)
|
|
|
|
{
|
|
|
|
devices = devices.Take(query.Limit.Value);
|
|
|
|
}
|
|
|
|
|
|
|
|
return new QueryResult<Device>
|
|
|
|
{
|
|
|
|
Items = await devices.ToListAsync().ConfigureAwait(false),
|
|
|
|
StartIndex = query.Skip ?? 0,
|
|
|
|
TotalRecordCount = count
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task<QueryResult<DeviceInfo>> GetDeviceInfos(DeviceQuery query)
|
|
|
|
{
|
|
|
|
var devices = await GetDevices(query).ConfigureAwait(false);
|
|
|
|
|
|
|
|
return new QueryResult<DeviceInfo>
|
|
|
|
{
|
2021-06-21 19:01:34 -04:00
|
|
|
Items = devices.Items.Select(device => ToDeviceInfo(device)).ToList(),
|
2021-05-20 23:56:59 -04:00
|
|
|
StartIndex = devices.StartIndex,
|
|
|
|
TotalRecordCount = devices.TotalRecordCount
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2021-05-20 20:39:22 -04:00
|
|
|
public async Task<QueryResult<DeviceInfo>> GetDevicesForUser(Guid? userId, bool? supportsSync)
|
2014-10-11 16:38:13 -04:00
|
|
|
{
|
2021-04-10 16:17:36 -04:00
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
|
|
|
var sessions = dbContext.Devices
|
2021-06-26 15:17:57 -04:00
|
|
|
.Include(d => d.User)
|
2021-04-10 16:17:36 -04:00
|
|
|
.AsQueryable()
|
|
|
|
.OrderBy(d => d.DeviceId)
|
|
|
|
.ThenByDescending(d => d.DateLastActivity)
|
|
|
|
.AsAsyncEnumerable();
|
2019-01-07 18:27:46 -05:00
|
|
|
|
2021-05-20 20:39:22 -04:00
|
|
|
if (supportsSync.HasValue)
|
2014-12-15 00:49:04 -05:00
|
|
|
{
|
2021-05-20 20:39:22 -04:00
|
|
|
sessions = sessions.Where(i => GetCapabilities(i.DeviceId).SupportsSync == supportsSync.Value);
|
2014-12-15 00:49:04 -05:00
|
|
|
}
|
|
|
|
|
2021-05-20 20:39:22 -04:00
|
|
|
if (userId.HasValue)
|
2014-12-12 22:56:30 -05:00
|
|
|
{
|
2021-05-20 20:39:22 -04:00
|
|
|
var user = _userManager.GetUserById(userId.Value);
|
2014-12-12 22:56:30 -05:00
|
|
|
|
2020-02-19 15:56:35 -05:00
|
|
|
sessions = sessions.Where(i => CanAccessDevice(user, i.DeviceId));
|
2014-12-31 01:24:49 -05:00
|
|
|
}
|
|
|
|
|
2021-06-21 19:01:34 -04:00
|
|
|
var array = await sessions.Select(device => ToDeviceInfo(device)).ToArrayAsync().ConfigureAwait(false);
|
2015-01-26 11:47:15 -05:00
|
|
|
|
2020-02-19 15:56:35 -05:00
|
|
|
return new QueryResult<DeviceInfo>(array);
|
2014-10-11 16:38:13 -04:00
|
|
|
}
|
|
|
|
|
2021-05-20 23:56:59 -04:00
|
|
|
/// <inheritdoc />
|
|
|
|
public async Task DeleteDevice(Device device)
|
|
|
|
{
|
|
|
|
await using var dbContext = _dbProvider.CreateContext();
|
2021-06-19 15:24:53 -04:00
|
|
|
dbContext.Devices.Remove(device);
|
|
|
|
await dbContext.SaveChangesAsync().ConfigureAwait(false);
|
2021-05-20 23:56:59 -04:00
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
/// <inheritdoc />
|
2018-09-12 13:26:21 -04:00
|
|
|
public bool CanAccessDevice(User user, string deviceId)
|
2014-12-29 15:18:48 -05:00
|
|
|
{
|
2018-09-12 13:26:21 -04:00
|
|
|
if (user == null)
|
2014-12-29 15:18:48 -05:00
|
|
|
{
|
2018-09-12 13:26:21 -04:00
|
|
|
throw new ArgumentException("user not found");
|
2014-12-29 15:18:48 -05:00
|
|
|
}
|
2020-06-15 17:43:52 -04:00
|
|
|
|
2018-09-12 13:26:21 -04:00
|
|
|
if (string.IsNullOrEmpty(deviceId))
|
2014-12-29 15:18:48 -05:00
|
|
|
{
|
2019-01-06 15:50:43 -05:00
|
|
|
throw new ArgumentNullException(nameof(deviceId));
|
2014-12-29 15:18:48 -05:00
|
|
|
}
|
|
|
|
|
2020-05-20 19:47:41 -04:00
|
|
|
if (user.HasPermission(PermissionKind.EnableAllDevices) || user.HasPermission(PermissionKind.IsAdministrator))
|
2020-05-12 22:10:35 -04:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
return user.GetPreference(PreferenceKind.EnabledDevices).Contains(deviceId, StringComparer.OrdinalIgnoreCase)
|
|
|
|
|| !GetCapabilities(deviceId).SupportsPersistentIdentifier;
|
|
|
|
}
|
2014-12-29 15:18:48 -05:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
private DeviceInfo ToDeviceInfo(Device authInfo)
|
|
|
|
{
|
|
|
|
var caps = GetCapabilities(authInfo.DeviceId);
|
2014-12-29 15:18:48 -05:00
|
|
|
|
2021-04-10 16:17:36 -04:00
|
|
|
return new DeviceInfo
|
|
|
|
{
|
|
|
|
AppName = authInfo.AppName,
|
|
|
|
AppVersion = authInfo.AppVersion,
|
|
|
|
Id = authInfo.DeviceId,
|
|
|
|
LastUserId = authInfo.UserId,
|
|
|
|
LastUserName = authInfo.User.Username,
|
|
|
|
Name = authInfo.DeviceName,
|
|
|
|
DateLastActivity = authInfo.DateLastActivity,
|
|
|
|
IconUrl = caps.IconUrl
|
|
|
|
};
|
2014-12-29 15:18:48 -05:00
|
|
|
}
|
2018-09-12 13:26:21 -04:00
|
|
|
}
|
2018-12-28 10:48:26 -05:00
|
|
|
}
|