mirror of
https://github.com/jellyfin/jellyfin.git
synced 2024-08-31 08:34:33 +02:00
334 lines
11 KiB
C#
334 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Jellyfin.Data.Events;
|
|
using MediaBrowser.Common.Configuration;
|
|
using MediaBrowser.Controller;
|
|
using MediaBrowser.Controller.Entities;
|
|
using MediaBrowser.Controller.Entities.Audio;
|
|
using MediaBrowser.Controller.Entities.TV;
|
|
using MediaBrowser.Controller.Library;
|
|
using MediaBrowser.Controller.Notifications;
|
|
using MediaBrowser.Controller.Plugins;
|
|
using MediaBrowser.Model.Activity;
|
|
using MediaBrowser.Model.Globalization;
|
|
using MediaBrowser.Model.Notifications;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace Emby.Notifications
|
|
{
|
|
/// <summary>
|
|
/// Creates notifications for various system events.
|
|
/// </summary>
|
|
public class NotificationEntryPoint : IServerEntryPoint
|
|
{
|
|
private readonly ILogger<NotificationEntryPoint> _logger;
|
|
private readonly IActivityManager _activityManager;
|
|
private readonly ILocalizationManager _localization;
|
|
private readonly INotificationManager _notificationManager;
|
|
private readonly ILibraryManager _libraryManager;
|
|
private readonly IServerApplicationHost _appHost;
|
|
private readonly IConfigurationManager _config;
|
|
|
|
private readonly object _libraryChangedSyncLock = new object();
|
|
private readonly List<BaseItem> _itemsAdded = new List<BaseItem>();
|
|
|
|
private Timer? _libraryUpdateTimer;
|
|
|
|
private string[] _coreNotificationTypes;
|
|
|
|
private bool _disposed = false;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of the <see cref="NotificationEntryPoint" /> class.
|
|
/// </summary>
|
|
/// <param name="logger">The logger.</param>
|
|
/// <param name="activityManager">The activity manager.</param>
|
|
/// <param name="localization">The localization manager.</param>
|
|
/// <param name="notificationManager">The notification manager.</param>
|
|
/// <param name="libraryManager">The library manager.</param>
|
|
/// <param name="appHost">The application host.</param>
|
|
/// <param name="config">The configuration manager.</param>
|
|
public NotificationEntryPoint(
|
|
ILogger<NotificationEntryPoint> logger,
|
|
IActivityManager activityManager,
|
|
ILocalizationManager localization,
|
|
INotificationManager notificationManager,
|
|
ILibraryManager libraryManager,
|
|
IServerApplicationHost appHost,
|
|
IConfigurationManager config)
|
|
{
|
|
_logger = logger;
|
|
_activityManager = activityManager;
|
|
_localization = localization;
|
|
_notificationManager = notificationManager;
|
|
_libraryManager = libraryManager;
|
|
_appHost = appHost;
|
|
_config = config;
|
|
|
|
_coreNotificationTypes = new CoreNotificationTypes(localization).GetNotificationTypes().Select(i => i.Type).ToArray();
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public Task RunAsync()
|
|
{
|
|
_libraryManager.ItemAdded += OnLibraryManagerItemAdded;
|
|
_appHost.HasPendingRestartChanged += OnAppHostHasPendingRestartChanged;
|
|
_appHost.HasUpdateAvailableChanged += OnAppHostHasUpdateAvailableChanged;
|
|
_activityManager.EntryCreated += OnActivityManagerEntryCreated;
|
|
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private async void OnAppHostHasPendingRestartChanged(object? sender, EventArgs e)
|
|
{
|
|
var type = NotificationType.ServerRestartRequired.ToString();
|
|
|
|
var notification = new NotificationRequest
|
|
{
|
|
NotificationType = type,
|
|
Name = string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
_localization.GetLocalizedString("ServerNameNeedsToBeRestarted"),
|
|
_appHost.Name)
|
|
};
|
|
|
|
await SendNotification(notification, null).ConfigureAwait(false);
|
|
}
|
|
|
|
private async void OnActivityManagerEntryCreated(object? sender, GenericEventArgs<ActivityLogEntry> e)
|
|
{
|
|
var entry = e.Argument;
|
|
|
|
var type = entry.Type;
|
|
|
|
if (string.IsNullOrEmpty(type) || !_coreNotificationTypes.Contains(type, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var userId = e.Argument.UserId;
|
|
|
|
if (!userId.Equals(Guid.Empty) && !GetOptions().IsEnabledToMonitorUser(type, userId))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var notification = new NotificationRequest
|
|
{
|
|
NotificationType = type,
|
|
Name = entry.Name,
|
|
Description = entry.Overview
|
|
};
|
|
|
|
await SendNotification(notification, null).ConfigureAwait(false);
|
|
}
|
|
|
|
private NotificationOptions GetOptions()
|
|
{
|
|
return _config.GetConfiguration<NotificationOptions>("notifications");
|
|
}
|
|
|
|
private async void OnAppHostHasUpdateAvailableChanged(object? sender, EventArgs e)
|
|
{
|
|
if (!_appHost.HasUpdateAvailable)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var type = NotificationType.ApplicationUpdateAvailable.ToString();
|
|
|
|
var notification = new NotificationRequest
|
|
{
|
|
Description = "Please see jellyfin.org for details.",
|
|
NotificationType = type,
|
|
Name = _localization.GetLocalizedString("NewVersionIsAvailable")
|
|
};
|
|
|
|
await SendNotification(notification, null).ConfigureAwait(false);
|
|
}
|
|
|
|
private void OnLibraryManagerItemAdded(object? sender, ItemChangeEventArgs e)
|
|
{
|
|
if (!FilterItem(e.Item))
|
|
{
|
|
return;
|
|
}
|
|
|
|
lock (_libraryChangedSyncLock)
|
|
{
|
|
if (_libraryUpdateTimer == null)
|
|
{
|
|
_libraryUpdateTimer = new Timer(
|
|
LibraryUpdateTimerCallback,
|
|
null,
|
|
5000,
|
|
Timeout.Infinite);
|
|
}
|
|
else
|
|
{
|
|
_libraryUpdateTimer.Change(5000, Timeout.Infinite);
|
|
}
|
|
|
|
_itemsAdded.Add(e.Item);
|
|
}
|
|
}
|
|
|
|
private bool FilterItem(BaseItem item)
|
|
{
|
|
if (item.IsFolder)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!item.HasPathProtocol)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (item is IItemByName)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return item.SourceType == SourceType.Library;
|
|
}
|
|
|
|
private async void LibraryUpdateTimerCallback(object? state)
|
|
{
|
|
List<BaseItem> items;
|
|
|
|
lock (_libraryChangedSyncLock)
|
|
{
|
|
items = _itemsAdded.ToList();
|
|
_itemsAdded.Clear();
|
|
_libraryUpdateTimer!.Dispose(); // Shouldn't be null as it just set off this callback
|
|
_libraryUpdateTimer = null;
|
|
}
|
|
|
|
if (items.Count > 10)
|
|
{
|
|
items = items.GetRange(0, 10);
|
|
}
|
|
|
|
foreach (var item in items)
|
|
{
|
|
var notification = new NotificationRequest
|
|
{
|
|
NotificationType = NotificationType.NewLibraryContent.ToString(),
|
|
Name = string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
_localization.GetLocalizedString("ValueHasBeenAddedToLibrary"),
|
|
GetItemName(item)),
|
|
Description = item.Overview
|
|
};
|
|
|
|
await SendNotification(notification, item).ConfigureAwait(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a human readable name for the item.
|
|
/// </summary>
|
|
/// <param name="item">The item.</param>
|
|
/// <returns>A human readable name for the item.</returns>
|
|
public static string GetItemName(BaseItem item)
|
|
{
|
|
var name = item.Name;
|
|
if (item is Episode episode)
|
|
{
|
|
if (episode.IndexNumber.HasValue)
|
|
{
|
|
name = string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
"Ep{0} - {1}",
|
|
episode.IndexNumber.Value,
|
|
name);
|
|
}
|
|
|
|
if (episode.ParentIndexNumber.HasValue)
|
|
{
|
|
name = string.Format(
|
|
CultureInfo.InvariantCulture,
|
|
"S{0}, {1}",
|
|
episode.ParentIndexNumber.Value,
|
|
name);
|
|
}
|
|
}
|
|
|
|
if (item is IHasSeries hasSeries)
|
|
{
|
|
name = hasSeries.SeriesName + " - " + name;
|
|
}
|
|
|
|
if (item is IHasAlbumArtist hasAlbumArtist)
|
|
{
|
|
var artists = hasAlbumArtist.AlbumArtists;
|
|
|
|
if (artists.Count > 0)
|
|
{
|
|
name = artists[0] + " - " + name;
|
|
}
|
|
}
|
|
else if (item is IHasArtist hasArtist)
|
|
{
|
|
var artists = hasArtist.Artists;
|
|
|
|
if (artists.Count > 0)
|
|
{
|
|
name = artists[0] + " - " + name;
|
|
}
|
|
}
|
|
|
|
return name;
|
|
}
|
|
|
|
private async Task SendNotification(NotificationRequest notification, BaseItem? relatedItem)
|
|
{
|
|
try
|
|
{
|
|
await _notificationManager.SendNotification(notification, relatedItem, CancellationToken.None).ConfigureAwait(false);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_logger.LogError(ex, "Error sending notification");
|
|
}
|
|
}
|
|
|
|
/// <inheritdoc />
|
|
public void Dispose()
|
|
{
|
|
Dispose(true);
|
|
GC.SuppressFinalize(this);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Releases unmanaged and optionally managed resources.
|
|
/// </summary>
|
|
/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
|
protected virtual void Dispose(bool disposing)
|
|
{
|
|
if (_disposed)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (disposing)
|
|
{
|
|
_libraryUpdateTimer?.Dispose();
|
|
}
|
|
|
|
_libraryUpdateTimer = null;
|
|
|
|
_libraryManager.ItemAdded -= OnLibraryManagerItemAdded;
|
|
_appHost.HasPendingRestartChanged -= OnAppHostHasPendingRestartChanged;
|
|
_appHost.HasUpdateAvailableChanged -= OnAppHostHasUpdateAvailableChanged;
|
|
_activityManager.EntryCreated -= OnActivityManagerEntryCreated;
|
|
|
|
_disposed = true;
|
|
}
|
|
}
|
|
}
|