jellyfin/MediaBrowser.Controller/Entities/User.cs

329 lines
9.7 KiB
C#
Raw Normal View History

2014-12-20 06:06:27 +00:00
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Providers;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Configuration;
2014-09-14 18:47:48 +00:00
using MediaBrowser.Model.Connect;
2013-03-13 05:19:03 +00:00
using MediaBrowser.Model.Serialization;
2014-11-30 19:01:33 +00:00
using MediaBrowser.Model.Users;
2013-02-21 01:33:05 +00:00
using System;
using System.IO;
using System.Linq;
2013-02-21 01:33:05 +00:00
using System.Runtime.Serialization;
using System.Threading;
using System.Threading.Tasks;
namespace MediaBrowser.Controller.Entities
{
/// <summary>
/// Class User
/// </summary>
public class User : BaseItem
{
public static IUserManager UserManager { get; set; }
public static IXmlSerializer XmlSerializer { get; set; }
2014-09-14 15:10:51 +00:00
/// <summary>
/// From now on all user paths will be Id-based.
/// This is for backwards compatibility.
/// </summary>
public bool UsesIdForConfigurationPath { get; set; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the password.
/// </summary>
/// <value>The password.</value>
public string Password { get; set; }
2015-01-29 06:06:24 +00:00
public string EasyPassword { get; set; }
2013-02-21 01:33:05 +00:00
2014-09-14 15:10:51 +00:00
public string ConnectUserName { get; set; }
public string ConnectUserId { get; set; }
2014-10-14 04:22:17 +00:00
public UserLinkType? ConnectLinkType { get; set; }
2014-09-14 15:10:51 +00:00
public string ConnectAccessKey { get; set; }
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets or sets the path.
/// </summary>
/// <value>The path.</value>
2013-12-29 14:12:29 +00:00
[IgnoreDataMember]
2013-02-21 01:33:05 +00:00
public override string Path
{
get
{
// Return this so that metadata providers will look in here
return ConfigurationDirectoryPath;
}
set
{
base.Path = value;
}
}
2015-10-27 17:26:04 +00:00
private string _name;
/// <summary>
/// Gets or sets the name.
/// </summary>
/// <value>The name.</value>
public override string Name
{
get
{
return _name;
}
set
{
_name = value;
// lazy load this again
SortName = null;
}
}
/// <summary>
/// Returns the folder containing the item.
/// If the item is a folder, it returns the folder itself
/// </summary>
/// <value>The containing folder path.</value>
2015-01-26 22:47:16 +00:00
[IgnoreDataMember]
public override string ContainingFolderPath
{
get
{
return Path;
}
}
/// <summary>
/// Gets a value indicating whether this instance is owned item.
/// </summary>
/// <value><c>true</c> if this instance is owned item; otherwise, <c>false</c>.</value>
2015-01-26 22:47:16 +00:00
[IgnoreDataMember]
public override bool IsOwnedItem
{
get
{
return false;
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the root folder.
/// </summary>
/// <value>The root folder.</value>
[IgnoreDataMember]
2014-02-21 05:04:11 +00:00
public Folder RootFolder
2013-02-21 01:33:05 +00:00
{
get
{
2014-02-21 05:04:11 +00:00
return LibraryManager.GetUserRootFolder();
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets or sets the last login date.
/// </summary>
/// <value>The last login date.</value>
public DateTime? LastLoginDate { get; set; }
/// <summary>
/// Gets or sets the last activity date.
/// </summary>
/// <value>The last activity date.</value>
public DateTime? LastActivityDate { get; set; }
2014-12-20 06:06:27 +00:00
private UserConfiguration _config;
private readonly object _configSyncLock = new object();
2013-02-21 01:33:05 +00:00
[IgnoreDataMember]
public UserConfiguration Configuration
{
get
{
2014-12-20 06:06:27 +00:00
if (_config == null)
{
lock (_configSyncLock)
{
if (_config == null)
{
_config = UserManager.GetUserConfiguration(this);
}
}
}
2013-02-21 01:33:05 +00:00
2014-12-20 06:06:27 +00:00
return _config;
2013-02-21 01:33:05 +00:00
}
2014-12-20 06:06:27 +00:00
set { _config = value; }
2013-02-21 01:33:05 +00:00
}
2014-12-16 05:01:57 +00:00
private UserPolicy _policy;
private readonly object _policySyncLock = new object();
[IgnoreDataMember]
public UserPolicy Policy
{
get
{
if (_policy == null)
{
lock (_policySyncLock)
{
if (_policy == null)
{
_policy = UserManager.GetUserPolicy(this);
}
}
}
return _policy;
}
set { _policy = value; }
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Renames the user.
/// </summary>
/// <param name="newName">The new name.</param>
/// <returns>Task.</returns>
/// <exception cref="System.ArgumentNullException"></exception>
public Task Rename(string newName)
2013-02-21 01:33:05 +00:00
{
if (string.IsNullOrEmpty(newName))
{
2014-09-14 15:10:51 +00:00
throw new ArgumentNullException("newName");
2013-02-21 01:33:05 +00:00
}
// If only the casing is changing, leave the file system alone
2015-01-27 22:45:59 +00:00
if (!UsesIdForConfigurationPath && !string.Equals(newName, Name, StringComparison.OrdinalIgnoreCase))
2013-02-21 01:33:05 +00:00
{
2014-09-14 15:10:51 +00:00
UsesIdForConfigurationPath = true;
2013-02-21 01:33:05 +00:00
// Move configuration
var newConfigDirectory = GetConfigurationDirectoryPath(newName);
2013-12-29 17:07:29 +00:00
var oldConfigurationDirectory = ConfigurationDirectoryPath;
2013-02-21 01:33:05 +00:00
// Exceptions will be thrown if these paths already exist
2015-09-13 21:32:02 +00:00
if (FileSystem.DirectoryExists(newConfigDirectory))
2013-02-21 01:33:05 +00:00
{
FileSystem.DeleteDirectory(newConfigDirectory, true);
2013-02-21 01:33:05 +00:00
}
2013-12-29 17:07:29 +00:00
2015-09-13 21:32:02 +00:00
if (FileSystem.DirectoryExists(oldConfigurationDirectory))
2013-12-29 17:07:29 +00:00
{
2015-09-13 21:32:02 +00:00
FileSystem.MoveDirectory(oldConfigurationDirectory, newConfigDirectory);
2013-12-29 17:07:29 +00:00
}
else
{
2015-09-13 21:32:02 +00:00
FileSystem.CreateDirectory(newConfigDirectory);
2013-12-29 17:07:29 +00:00
}
2013-02-21 01:33:05 +00:00
}
Name = newName;
2015-09-13 21:32:02 +00:00
return RefreshMetadata(new MetadataRefreshOptions(new DirectoryService(FileSystem))
{
ReplaceAllMetadata = true,
ImageRefreshMode = ImageRefreshMode.FullRefresh,
2014-09-14 15:10:51 +00:00
MetadataRefreshMode = MetadataRefreshMode.FullRefresh,
ForceSave = true
}, CancellationToken.None);
2013-02-21 01:33:05 +00:00
}
public override Task UpdateToRepository(ItemUpdateType updateReason, CancellationToken cancellationToken)
{
return UserManager.UpdateUser(this);
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the path to the user's configuration directory
/// </summary>
/// <value>The configuration directory path.</value>
2013-12-29 17:07:29 +00:00
[IgnoreDataMember]
2014-12-16 05:01:57 +00:00
public string ConfigurationDirectoryPath
2013-02-21 01:33:05 +00:00
{
get
{
2013-12-29 17:07:29 +00:00
return GetConfigurationDirectoryPath(Name);
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Gets the configuration directory path.
/// </summary>
/// <param name="username">The username.</param>
/// <returns>System.String.</returns>
private string GetConfigurationDirectoryPath(string username)
{
2014-09-14 15:10:51 +00:00
var parentPath = ConfigurationManager.ApplicationPaths.UserConfigurationDirectoryPath;
// Legacy
if (!UsesIdForConfigurationPath)
{
2015-01-27 06:50:40 +00:00
if (string.IsNullOrEmpty(username))
{
throw new ArgumentNullException("username");
}
2014-09-14 15:10:51 +00:00
var safeFolderName = FileSystem.GetValidFilename(username);
return System.IO.Path.Combine(ConfigurationManager.ApplicationPaths.UserConfigurationDirectoryPath, safeFolderName);
}
2013-02-21 01:33:05 +00:00
2014-09-14 15:10:51 +00:00
return System.IO.Path.Combine(parentPath, Id.ToString("N"));
2013-02-21 01:33:05 +00:00
}
public bool IsParentalScheduleAllowed()
{
return IsParentalScheduleAllowed(DateTime.UtcNow);
}
public bool IsParentalScheduleAllowed(DateTime date)
{
2014-12-20 06:06:27 +00:00
var schedules = Policy.AccessSchedules;
if (schedules.Length == 0)
{
return true;
}
return schedules.Any(i => IsParentalScheduleAllowed(i, date));
}
private bool IsParentalScheduleAllowed(AccessSchedule schedule, DateTime date)
{
if (date.Kind != DateTimeKind.Utc)
{
throw new ArgumentException("Utc date expected");
}
var localTime = date.ToLocalTime();
2014-11-30 19:01:33 +00:00
return DayOfWeekHelper.GetDaysOfWeek(schedule.DayOfWeek).Contains(localTime.DayOfWeek) &&
2014-10-16 03:26:39 +00:00
IsWithinTime(schedule, localTime);
}
private bool IsWithinTime(AccessSchedule schedule, DateTime localTime)
{
var hour = localTime.TimeOfDay.TotalHours;
return hour >= schedule.StartHour && hour <= schedule.EndHour;
}
2015-05-08 19:10:53 +00:00
public bool IsFolderGrouped(Guid id)
{
var config = Configuration;
if (config.ExcludeFoldersFromGrouping != null)
{
return !config.ExcludeFoldersFromGrouping.Select(i => new Guid(i)).Contains(id);
}
return config.GroupedFolders.Select(i => new Guid(i)).Contains(id);
}
2015-06-29 01:10:45 +00:00
[IgnoreDataMember]
public override bool SupportsPeople
{
get
{
return false;
}
}
2013-02-21 01:33:05 +00:00
}
}