/// <summary>
/// Initializes a new instance of the <see cref="Notifier"/> class.
/// </summary>
/// <param name="logger">Instance of the <see cref="ILogger{Notifier}"/> interface.</param>
/// <param name="serverConfiguration">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
/// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
/// <param name="localizationManager">Instance of the <see cref="ILocalizationManager"/> interface.</param>
/// <param name="userViewManager">Instance of the <see cref="IUserViewManager"/> interface.</param>
/// <param name="httpClient">Instance of the <see cref="IHttpClient"/> interface.</param>
/// <param name="applicationHost">Instance of the <see cref="IApplicationHost"/> interface.</param>
public Notifier(
ILogger <Notifier> logger,
IServerConfigurationManager serverConfiguration,
ILibraryManager libraryManager,
ILocalizationManager localizationManager,
IUserViewManager userViewManager,
IHttpClient httpClient,
IApplicationHost applicationHost)
{
_logger = logger;
_serverConfiguration = serverConfiguration;
_libraryManager = libraryManager;
_localizationManager = localizationManager;
_userViewManager = userViewManager;
_httpClient = httpClient;
_applicationHost = applicationHost;
_jsonSerializerOptions = JsonDefaults.GetOptions();
_jsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
_queuedMessageHandler = new System.Timers.Timer(Constants.MessageQueueSendInterval);
_queuedMessageHandler.AutoReset = true;
_queuedMessageHandler.Elapsed += QueuedMessageSender;
_queuedMessageHandler.Start();
_queuedUpdateHandler = new System.Timers.Timer(Constants.RecheckIntervalMs);
_queuedUpdateHandler.AutoReset = true;
_queuedUpdateHandler.Elapsed += CheckForMetadata;
_queuedUpdateHandler.Start();
_libraryManager.ItemAdded += ItemAddHandler;
_logger.LogDebug("Registered ItemAdd handler");
}
public PluginManager(
ILogger <PluginManager> logger,
IApplicationHost appHost,
ServerConfiguration config,
string pluginsPath,
Version appVersion)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_pluginsPath = pluginsPath;
_appVersion = appVersion ?? throw new ArgumentNullException(nameof(appVersion));
_jsonOptions = new JsonSerializerOptions(JsonDefaults.GetOptions())
{
WriteIndented = true
};
// We need to use the default GUID converter, so we need to remove any custom ones.
for (int a = _jsonOptions.Converters.Count - 1; a >= 0; a--)
{
if (_jsonOptions.Converters[a] is JsonGuidConverter convertor)
{
_jsonOptions.Converters.Remove(convertor);
break;
}
}
_config = config;
_appHost = appHost;
_minimumVersion = new Version(0, 0, 0, 1);
_plugins = Directory.Exists(_pluginsPath) ? DiscoverPlugins().ToList() : new List <LocalPlugin>();
}
public KodiSyncQueueController(ILogger <KodiSyncQueueController> logger, IUserManager userManager, ILibraryManager libraryManager)
{
_logger = logger;
_userManager = userManager;
_libraryManager = libraryManager;
_jsonSerializerOptions = JsonDefaults.GetOptions();
}
public DbRepo(string dPath, ILogger <DbRepo> logger)
{
_logger = logger;
_logger.LogInformation("Creating DB Repository...");
Directory.CreateDirectory(dPath);
_liteDb = new LiteDatabase($"filename={dPath}/kodisyncqueue.db;mode=exclusive");
_jsonSerializerOptions = JsonDefaults.GetOptions();
}
public NotificationController(
ILogger <NotificationController> logger,
IHttpClientFactory httpClientFactory)
{
_logger = logger;
_httpClientFactory = httpClientFactory;
_jsonSerializerOptions = JsonDefaults.GetOptions();
}
public static async Task <T> DeserializeFromHttp <T>(HttpResponseMessage response)
{
var contentStream = await response.Content.ReadAsStreamAsync();
var result = await JsonSerializer.DeserializeAsync <T>(contentStream, JsonDefaults.GetOptions());
return(result);
}
public SqliteDisplayPreferencesRepository(ILogger <SqliteDisplayPreferencesRepository> logger, IApplicationPaths appPaths, IFileSystem fileSystem)
: base(logger)
{
_fileSystem = fileSystem;
_jsonOptions = JsonDefaults.GetOptions();
DbFilePath = Path.Combine(appPaths.DataPath, "displaypreferences.db");
}
public SqliteUserRepository(
ILogger <SqliteUserRepository> logger,
IServerApplicationPaths appPaths)
: base(logger)
{
_jsonOptions = JsonDefaults.GetOptions();
DbFilePath = Path.Combine(appPaths.DataPath, "users.db");
}
public Bf4Client()
{
_httpClient = new HttpClient()
{
BaseAddress = new Uri("https://battlelog.battlefield.com")
};
_jsonOptions = JsonDefaults.GetOptions();
}
/// <summary>
/// Initializes a new instance of the <see cref="PluginsController"/> class.
/// </summary>
/// <param name="installationManager">Instance of the <see cref="IInstallationManager"/> interface.</param>
/// <param name="pluginManager">Instance of the <see cref="IPluginManager"/> interface.</param>
/// <param name="config">Instance of the <see cref="IConfigurationManager"/> interface.</param>
public PluginsController(
IInstallationManager installationManager,
IPluginManager pluginManager,
IConfigurationManager config)
{
_installationManager = installationManager;
_pluginManager = pluginManager;
_serializerOptions = JsonDefaults.GetOptions();
_config = config;
}
public OmdbProvider(IHttpClientFactory httpClientFactory, IFileSystem fileSystem, IApplicationHost appHost, IServerConfigurationManager configurationManager)
{
_httpClientFactory = httpClientFactory;
_fileSystem = fileSystem;
_configurationManager = configurationManager;
_appHost = appHost;
_jsonOptions = new JsonSerializerOptions(JsonDefaults.GetOptions());
_jsonOptions.Converters.Add(new JsonOmdbNotAvailableStringConverter());
_jsonOptions.Converters.Add(new JsonOmdbNotAvailableInt32Converter());
}
/// <summary>
/// Initializes a new instance of the <see cref="NotificationsService"/> class.
/// </summary>
/// <param name="logger">Instance of the <see cref="ILogger{NoticiationsService}"/> interface.</param>
/// <param name="serverConfiguration">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
/// <param name="httpClient">Instance of the <see cref="IHttpClient"/> interface.</param>
public NotificationsService(
ILogger <NotificationsService> logger,
IServerConfigurationManager serverConfiguration,
IHttpClient httpClient)
{
_logger = logger;
_serverConfiguration = serverConfiguration;
_httpClient = httpClient;
_jsonSerializerOptions = JsonDefaults.GetOptions();
_jsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
}
public async Task Format(Uri url, EventInfo info)
{
var body = new PlexFormatPayload
{
@event = GetEventName(info.Event),
user = true,
owner = info.User.HasPermission(Data.Enums.PermissionKind.IsAdministrator),
Account = new
{
id = info.User.Id,
title = info.User.Username
},
Server = new
{
title = info.Server.Name,
uuid = info.Server.Id
},
Player = new
{
local = true,
publicAddress = info.Session?.RemoteEndPoint,
title = info.Session?.DeviceName,
uuid = info.Session?.Id,
},
Metadata = new
{
librarySectionType = GetSectionType(info.Item),
guid = GetGuid(info.Item),
title = info.Item.Name,
type = GetMediaType(info.Item),
parentTitle = info.Item.DisplayParent.Name,
grandparentTitle = info.Item.DisplayParent.DisplayParent.Name,
addedAt = ((DateTimeOffset)info.Item.DateCreated).ToUnixTimeSeconds(),
updatedAt = ((DateTimeOffset)info.Item.DateModified).ToUnixTimeSeconds(),
year = info.Item.ProductionYear,
duration = info.Item.RunTimeTicks / 1000,
}
};
var content = JsonSerializer.Serialize(body, JsonDefaults.GetOptions());
var form = new MultipartFormDataContent
{
{ new StringContent(content), "payload" }
};
using (var httpClient = new HttpClient())
{
var response = await httpClient.PostAsync(url, form);
response.EnsureSuccessStatusCode();
var status = await response.Content.ReadAsStringAsync();
// status from SIMKL can be "OK" or "FAIL"
}
}
public WebSocketConnection(
ILogger <WebSocketConnection> logger,
WebSocket socket,
IPAddress?remoteEndPoint,
IQueryCollection query)
{
_logger = logger;
_socket = socket;
RemoteEndPoint = remoteEndPoint;
QueryString = query;
_jsonOptions = JsonDefaults.GetOptions();
LastActivityDate = DateTime.Now;
}
/// <summary>
/// Initializes a new instance of the <see cref="OmdbItemProvider"/> class.
/// </summary>
/// <param name="httpClientFactory">Instance of the <see cref="IHttpClientFactory"/> interface.</param>
/// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
/// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
/// <param name="configurationManager">Instance of the <see cref="IServerConfigurationManager"/> interface.</param>
public OmdbItemProvider(
IHttpClientFactory httpClientFactory,
ILibraryManager libraryManager,
IFileSystem fileSystem,
IServerConfigurationManager configurationManager)
{
_httpClientFactory = httpClientFactory;
_libraryManager = libraryManager;
_fileSystem = fileSystem;
_configurationManager = configurationManager;
_jsonOptions = new JsonSerializerOptions(JsonDefaults.GetOptions());
_jsonOptions.Converters.Add(new JsonOmdbNotAvailableStringConverter());
_jsonOptions.Converters.Add(new JsonOmdbNotAvailableStructConverter <int>());
}
private async Task <BookResult> FetchBookData(string googleBookId, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var url = string.Format(GoogleApiUrls.DetailsUrl, googleBookId);
var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
using (var response = await httpClient.GetAsync(url).ConfigureAwait(false))
{
await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(await JsonSerializer.DeserializeAsync <BookResult>(stream, JsonDefaults.GetOptions()).ConfigureAwait(false));
}
}
public async Task Format(Uri url, EventInfo info)
{
var item = _dto.GetBaseItemDto(info.Item, new DtoOptions(true), info.User);
var user = _users.GetUserDto(info.User);
var body = new DefaultFormatPayload
{
Event = info.Event,
Item = item,
Session = info.Session,
User = user,
Server = info.Server
};
var content = new StringContent(JsonSerializer.Serialize(body, JsonDefaults.GetOptions()), Encoding.UTF8, "application/json");
await _http.PostAsync(url, content);
}
public MediaEncoder(
ILogger <MediaEncoder> logger,
IServerConfigurationManager configurationManager,
IFileSystem fileSystem,
ILocalizationManager localization,
Lazy <EncodingHelper> encodingHelperFactory,
IConfiguration config)
{
_logger = logger;
_configurationManager = configurationManager;
_fileSystem = fileSystem;
_localization = localization;
_encodingHelperFactory = encodingHelperFactory;
_startupOptionFFmpegPath = config.GetValue <string>(Controller.Extensions.ConfigurationExtensions.FfmpegPathKey) ?? string.Empty;
_jsonSerializerOptions = JsonDefaults.GetOptions();
}
private async Task <SearchResult> GetSearchResultsInternal(BookInfo item, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
// pattern match the filename
// year can be included for better results
GetBookMetadata(item);
var url = string.Format(GoogleApiUrls.SearchUrl, WebUtility.UrlEncode(item.Name), 0, 20);
var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
using (var response = await httpClient.GetAsync(url).ConfigureAwait(false))
{
await using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(await JsonSerializer.DeserializeAsync <SearchResult>(stream, JsonDefaults.GetOptions()).ConfigureAwait(false));
}
}
public HdHomerunHost(
IServerConfigurationManager config,
ILogger <HdHomerunHost> logger,
IFileSystem fileSystem,
IHttpClientFactory httpClientFactory,
IServerApplicationHost appHost,
ISocketFactory socketFactory,
INetworkManager networkManager,
IStreamHelper streamHelper,
IMemoryCache memoryCache)
: base(config, logger, fileSystem, memoryCache)
{
_httpClientFactory = httpClientFactory;
_appHost = appHost;
_socketFactory = socketFactory;
_networkManager = networkManager;
_streamHelper = streamHelper;
_jsonOptions = JsonDefaults.GetOptions();
}
/// <summary>
/// Adds the images.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="path">The path.</param>
/// <param name="releaseId">The release identifier.</param>
/// <param name="releaseGroupId">The release group identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
private async Task AddImages(List <RemoteImageInfo> list, string path, string releaseId, string releaseGroupId, CancellationToken cancellationToken)
{
Stream fileStream = File.OpenRead(path);
var obj = await JsonSerializer.DeserializeAsync <ArtistProvider.ArtistResponse>(fileStream, JsonDefaults.GetOptions()).ConfigureAwait(false);
if (obj.albums != null)
{
var album = obj.albums.FirstOrDefault(i => string.Equals(i.release_group_id, releaseGroupId, StringComparison.OrdinalIgnoreCase));
if (album != null)
{
PopulateImages(list, album.albumcover, ImageType.Primary, 1000, 1000);
PopulateImages(list, album.cdart, ImageType.Disc, 1000, 1000);
}
}
}
private SmartMatchResult GetResultSmartMatch(IReadOnlyList <IResultSetValue> reader)
{
var index = 0;
var result = new SmartMatchResult
{
Id = reader[0].ReadGuidFromBlob()
};
index++;
result.ItemName = reader[index].ToString();
index++;
result.DisplayName = reader[index].ToString();
index++;
result.OrganizerType = (FileOrganizerType)Enum.Parse(typeof(FileOrganizerType), reader[index].ToString(), true);
index++;
if (reader[index].SQLiteType != SQLiteType.Null)
{
result.MatchStrings.AddRange(JsonSerializer.Deserialize <List <string> >(reader[index].ToString(), JsonDefaults.GetOptions()));
}
return(result);
}
/// <summary>
/// Adds the images.
/// </summary>
/// <param name="list">The list.</param>
/// <param name="path">The path.</param>
/// <param name="cancellationToken">The cancellation token.</param>
private async Task AddImages(List <RemoteImageInfo> list, string path, CancellationToken cancellationToken)
{
Stream fileStream = File.OpenRead(path);
var obj = await JsonSerializer.DeserializeAsync <ArtistResponse>(fileStream, JsonDefaults.GetOptions()).ConfigureAwait(false);
PopulateImages(list, obj.artistbackground, ImageType.Backdrop, 1920, 1080);
PopulateImages(list, obj.artistthumb, ImageType.Primary, 500, 281);
PopulateImages(list, obj.hdmusiclogo, ImageType.Logo, 800, 310);
PopulateImages(list, obj.musicbanner, ImageType.Banner, 1000, 185);
PopulateImages(list, obj.musiclogo, ImageType.Logo, 400, 155);
PopulateImages(list, obj.hdmusicarts, ImageType.Art, 1000, 562);
PopulateImages(list, obj.musicarts, ImageType.Art, 500, 281);
}
/// <summary>
/// Downloads the artist data.
/// </summary>
/// <param name="musicBrainzId">The music brainz id.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{System.Boolean}.</returns>
internal async Task DownloadArtistJson(string musicBrainzId, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var url = string.Format(
CultureInfo.InvariantCulture,
Plugin.BaseUrl,
Plugin.ApiKey,
musicBrainzId,
"music");
var clientKey = Plugin.Instance.Configuration.PersonalApiKey;
if (!string.IsNullOrWhiteSpace(clientKey))
{
url += "&client_key=" + clientKey;
}
var jsonPath = GetArtistJsonPath(_config.ApplicationPaths, musicBrainzId);
Directory.CreateDirectory(Path.GetDirectoryName(jsonPath));
try
{
var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
using (var httpResponse = await httpClient.GetAsync(new Uri(url), cancellationToken).ConfigureAwait(false))
using (var response = httpResponse.Content)
using (var saveFileStream = new FileStream(jsonPath, FileMode.Create, FileAccess.Write, FileShare.Read, IODefaults.FileStreamBufferSize, FileOptions.Asynchronous))
{
await response.CopyToAsync(saveFileStream, CancellationToken.None).ConfigureAwait(false);
}
}
catch (HttpRequestException ex)
{
if (ex.StatusCode.HasValue && ex.StatusCode.Value == HttpStatusCode.NotFound)
{
Stream fileStream = File.OpenWrite(jsonPath);
await JsonSerializer.SerializeAsync(fileStream, new ArtistResponse(), JsonDefaults.GetOptions()).ConfigureAwait(false);
}
else
{
throw;
}
}
}
/// <summary>
/// Downloads the series json.
/// </summary>
/// <param name="tvdbId">The TVDB identifier.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task.</returns>
internal async Task DownloadSeriesJson(string tvdbId, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var url = string.Format(
CultureInfo.InvariantCulture,
Plugin.BaseUrl,
Plugin.ApiKey,
tvdbId,
"tv");
var clientKey = Plugin.Instance.Configuration.PersonalApiKey;
if (!string.IsNullOrWhiteSpace(clientKey))
{
url += "&client_key=" + clientKey;
}
var path = GetJsonPath(tvdbId);
Directory.CreateDirectory(Path.GetDirectoryName(path));
try
{
var httpClient = _httpClientFactory.CreateClient(NamedClient.Default);
using (var httpResponse = await httpClient.GetAsync(new Uri(url), cancellationToken).ConfigureAwait(false))
using (var response = httpResponse.Content)
using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.Read, IODefaults.FileStreamBufferSize, FileOptions.Asynchronous))
{
await response.CopyToAsync(fileStream, CancellationToken.None).ConfigureAwait(false);
}
}
catch (HttpRequestException exception)
{
if (exception.StatusCode.HasValue && exception.StatusCode.Value == HttpStatusCode.NotFound)
{
// If the user has automatic updates enabled, save a dummy object to prevent repeated download attempts
Stream fileStream = File.OpenWrite(path);
await JsonSerializer.SerializeAsync(fileStream, new RootObject(), JsonDefaults.GetOptions()).ConfigureAwait(false);
return;
}
throw;
}
}
private async Task AddImages(List <RemoteImageInfo> list, string path)
{
Stream fileStream = File.OpenRead(path);
var root = await JsonSerializer.DeserializeAsync <RootObject>(fileStream, JsonDefaults.GetOptions()).ConfigureAwait(false);
AddImages(list, root);
}
public async Task Test(string fileName)
{
var path = Path.Join("Test Data", fileName);
using (var stream = File.OpenRead(path))
{
await JsonSerializer.DeserializeAsync <InternalMediaInfoResult>(stream, JsonDefaults.GetOptions()).ConfigureAwait(false);
}
}
private async Task AddImages(List <RemoteImageInfo> list, int seasonNumber, string path, CancellationToken cancellationToken)
{
Stream fileStream = File.OpenRead(path);
var root = await JsonSerializer.DeserializeAsync <SeriesProvider.RootObject>(fileStream, JsonDefaults.GetOptions()).ConfigureAwait(false);
AddImages(list, root, seasonNumber, cancellationToken);
}
/// <inheritdoc/>
public void Perform()
{
var dataPath = _paths.DataPath;
_logger.LogInformation("Migrating the user database may take a while, do not stop Jellyfin.");
using (var connection = SQLite3.Open(Path.Combine(dataPath, DbFilename), ConnectionFlags.ReadOnly, null))
{
var dbContext = _provider.CreateContext();
var queryResult = connection.Query("SELECT * FROM LocalUsersv2");
dbContext.RemoveRange(dbContext.Users);
dbContext.SaveChanges();
foreach (var entry in queryResult)
{
UserMockup?mockup = JsonSerializer.Deserialize <UserMockup>(entry[2].ToBlob(), JsonDefaults.GetOptions());
if (mockup == null)
{
continue;
}
var userDataDir = Path.Combine(_paths.UserConfigurationDirectoryPath, mockup.Name);
var config = File.Exists(Path.Combine(userDataDir, "config.xml"))
? (UserConfiguration)_xmlSerializer.DeserializeFromFile(typeof(UserConfiguration), Path.Combine(userDataDir, "config.xml"))
: new UserConfiguration();
var policy = File.Exists(Path.Combine(userDataDir, "policy.xml"))
? (UserPolicy)_xmlSerializer.DeserializeFromFile(typeof(UserPolicy), Path.Combine(userDataDir, "policy.xml"))
: new UserPolicy();
policy.AuthenticationProviderId = policy.AuthenticationProviderId?.Replace(
"Emby.Server.Implementations.Library",
"Jellyfin.Server.Implementations.Users",
StringComparison.Ordinal)
?? typeof(DefaultAuthenticationProvider).FullName;
policy.PasswordResetProviderId = typeof(DefaultPasswordResetProvider).FullName;
int?maxLoginAttempts = policy.LoginAttemptsBeforeLockout switch
{
-1 => null,
0 => 3,
_ => policy.LoginAttemptsBeforeLockout
};
var user = new User(mockup.Name, policy.AuthenticationProviderId, policy.PasswordResetProviderId)
{
Id = entry[1].ReadGuidFromBlob(),
InternalId = entry[0].ToInt64(),
MaxParentalAgeRating = policy.MaxParentalRating,
EnableUserPreferenceAccess = policy.EnableUserPreferenceAccess,
RemoteClientBitrateLimit = policy.RemoteClientBitrateLimit,
InvalidLoginAttemptCount = policy.InvalidLoginAttemptCount,
LoginAttemptsBeforeLockout = maxLoginAttempts,
SubtitleMode = config.SubtitleMode,
HidePlayedInLatest = config.HidePlayedInLatest,
EnableLocalPassword = config.EnableLocalPassword,
PlayDefaultAudioTrack = config.PlayDefaultAudioTrack,
DisplayCollectionsView = config.DisplayCollectionsView,
DisplayMissingEpisodes = config.DisplayMissingEpisodes,
AudioLanguagePreference = config.AudioLanguagePreference,
RememberAudioSelections = config.RememberAudioSelections,
EnableNextEpisodeAutoPlay = config.EnableNextEpisodeAutoPlay,
RememberSubtitleSelections = config.RememberSubtitleSelections,
SubtitleLanguagePreference = config.SubtitleLanguagePreference,
Password = mockup.Password,
EasyPassword = mockup.EasyPassword,
LastLoginDate = mockup.LastLoginDate,
LastActivityDate = mockup.LastActivityDate
};
if (mockup.ImageInfos.Length > 0)
{
ItemImageInfo info = mockup.ImageInfos[0];
user.ProfileImage = new ImageInfo(info.Path)
{
LastModified = info.DateModified
};
}
user.SetPermission(PermissionKind.IsAdministrator, policy.IsAdministrator);
user.SetPermission(PermissionKind.IsHidden, policy.IsHidden);
user.SetPermission(PermissionKind.IsDisabled, policy.IsDisabled);
user.SetPermission(PermissionKind.EnableSharedDeviceControl, policy.EnableSharedDeviceControl);
user.SetPermission(PermissionKind.EnableRemoteAccess, policy.EnableRemoteAccess);
user.SetPermission(PermissionKind.EnableLiveTvManagement, policy.EnableLiveTvManagement);
user.SetPermission(PermissionKind.EnableLiveTvAccess, policy.EnableLiveTvAccess);
user.SetPermission(PermissionKind.EnableMediaPlayback, policy.EnableMediaPlayback);
user.SetPermission(PermissionKind.EnableAudioPlaybackTranscoding, policy.EnableAudioPlaybackTranscoding);
user.SetPermission(PermissionKind.EnableVideoPlaybackTranscoding, policy.EnableVideoPlaybackTranscoding);
user.SetPermission(PermissionKind.EnableContentDeletion, policy.EnableContentDeletion);
user.SetPermission(PermissionKind.EnableContentDownloading, policy.EnableContentDownloading);
user.SetPermission(PermissionKind.EnableSyncTranscoding, policy.EnableSyncTranscoding);
user.SetPermission(PermissionKind.EnableMediaConversion, policy.EnableMediaConversion);
user.SetPermission(PermissionKind.EnableAllChannels, policy.EnableAllChannels);
user.SetPermission(PermissionKind.EnableAllDevices, policy.EnableAllDevices);
user.SetPermission(PermissionKind.EnableAllFolders, policy.EnableAllFolders);
user.SetPermission(PermissionKind.EnableRemoteControlOfOtherUsers, policy.EnableRemoteControlOfOtherUsers);
user.SetPermission(PermissionKind.EnablePlaybackRemuxing, policy.EnablePlaybackRemuxing);
user.SetPermission(PermissionKind.ForceRemoteSourceTranscoding, policy.ForceRemoteSourceTranscoding);
user.SetPermission(PermissionKind.EnablePublicSharing, policy.EnablePublicSharing);
foreach (var policyAccessSchedule in policy.AccessSchedules)
{
user.AccessSchedules.Add(policyAccessSchedule);
}
user.SetPreference(PreferenceKind.BlockedTags, policy.BlockedTags);
user.SetPreference(PreferenceKind.EnabledChannels, policy.EnabledChannels?.Select(i => i.ToString("N", CultureInfo.InvariantCulture)).ToArray());
user.SetPreference(PreferenceKind.EnabledDevices, policy.EnabledDevices);
user.SetPreference(PreferenceKind.EnabledFolders, policy.EnabledFolders?.Select(i => i.ToString("N", CultureInfo.InvariantCulture)).ToArray());
user.SetPreference(PreferenceKind.EnableContentDeletionFromFolders, policy.EnableContentDeletionFromFolders);
user.SetPreference(PreferenceKind.OrderedViews, config.OrderedViews);
user.SetPreference(PreferenceKind.GroupedFolders, config.GroupedFolders);
user.SetPreference(PreferenceKind.MyMediaExcludes, config.MyMediaExcludes);
user.SetPreference(PreferenceKind.LatestItemExcludes, config.LatestItemsExcludes);
dbContext.Users.Add(user);
}
dbContext.SaveChanges();
}
try
{
File.Move(Path.Combine(dataPath, DbFilename), Path.Combine(dataPath, DbFilename + ".old"));
var journalPath = Path.Combine(dataPath, DbFilename + "-journal");
if (File.Exists(journalPath))
{
File.Move(journalPath, Path.Combine(dataPath, DbFilename + ".old-journal"));
}
}
catch (IOException e)
{
_logger.LogError(e, "Error renaming legacy user database to 'users.db.old'");
}
}
#nullable disable
/// <inheritdoc/>
public void SaveResult(SmartMatchResult result, CancellationToken cancellationToken)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
cancellationToken.ThrowIfCancellationRequested();
using (WriteLock.Write())
{
using (var connection = CreateConnection())
{
connection.RunInTransaction(
db =>
{
var commandText = "replace into SmartMatch (Id, ItemName, DisplayName, OrganizerType, MatchStrings) values (@Id, @ItemName, @DisplayName, @OrganizerType, @MatchStrings)";
using (var statement = db.PrepareStatement(commandText))
{
statement.TryBind("@Id", result.Id.ToGuidBlob());
statement.TryBind("@ItemName", result.ItemName);
statement.TryBind("@DisplayName", result.DisplayName);
statement.TryBind("@OrganizerType", result.OrganizerType.ToString());
statement.TryBind("@MatchStrings", JsonSerializer.Serialize(result.MatchStrings, JsonDefaults.GetOptions()));
statement.MoveNext();
}
},
TransactionMode);
}
}
}
