private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue && itemStubType.Value == StubType.People)
{
if (item is Video)
{
return(_localization.GetLocalizedString("HeaderCastCrew"));
}
return(_localization.GetLocalizedString("HeaderPeople"));
}
var episode = item as Episode;
var season = context as Season;
if (episode != null && season != null)
{
// This is a special embedded within a season
if (item.ParentIndexNumber.HasValue && item.ParentIndexNumber.Value == 0)
{
if (season.IndexNumber.HasValue && season.IndexNumber.Value != 0)
{
return(string.Format(_localization.GetLocalizedString("ValueSpecialEpisodeName"), item.Name));
}
}
if (item.IndexNumber.HasValue)
{
var number = item.IndexNumber.Value.ToString("00").ToString(CultureInfo.InvariantCulture);
if (episode.IndexNumberEnd.HasValue)
{
number += "-" + episode.IndexNumberEnd.Value.ToString("00").ToString(CultureInfo.InvariantCulture);
}
return(number + " - " + item.Name);
}
}
return(item.Name);
}
/// <inheritdoc />
public async Task OnEvent(SessionEndedEventArgs eventArgs)
{
if (string.IsNullOrEmpty(eventArgs.Argument.UserName))
{
return;
}
await _activityManager.CreateAsync(new ActivityLog(
string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("UserOfflineFromDevice"),
eventArgs.Argument.UserName,
eventArgs.Argument.DeviceName),
"SessionEnded",
eventArgs.Argument.UserId)
{
ShortOverview = string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("LabelIpAddressValue"),
eventArgs.Argument.RemoteEndPoint),
}).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task OnEvent(UserLockedOutEventArgs eventArgs)
{
await _activityManager.CreateAsync(new ActivityLog(
string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("UserLockedOutWithName"),
eventArgs.Argument.Username),
NotificationType.UserLockedOut.ToString(),
eventArgs.Argument.Id)
{
LogSeverity = LogLevel.Error
}).ConfigureAwait(false);
}
/// <summary>
/// Resolves the specified args.
/// </summary>
/// <param name="args">The args.</param>
/// <returns>Season.</returns>
protected override Season Resolve(ItemResolveArgs args)
{
if (args.Parent is Series && args.IsDirectory)
{
var namingOptions = ((LibraryManager)_libraryManager).GetNamingOptions();
var series = ((Series)args.Parent);
var path = args.Path;
var season = new Season
{
IndexNumber = new SeasonPathParser(namingOptions, new RegexProvider()).Parse(path, true, true).SeasonNumber,
SeriesId = series.Id,
SeriesName = series.Name
};
if (season.IndexNumber.HasValue)
{
var resolver = new Emby.Naming.TV.EpisodeResolver(namingOptions);
var folderName = System.IO.Path.GetFileName(path);
var testPath = "\\\\test\\" + folderName;
var episodeInfo = resolver.Resolve(testPath, true);
if (episodeInfo != null)
{
if (episodeInfo.EpisodeNumber.HasValue && episodeInfo.SeasonNumber.HasValue)
{
_logger.Info("Found folder underneath series with episode number: {0}. Season {1}. Episode {2}",
path,
episodeInfo.SeasonNumber.Value,
episodeInfo.EpisodeNumber.Value);
return(null);
}
}
var seasonNumber = season.IndexNumber.Value;
season.Name = seasonNumber == 0 ?
args.LibraryOptions.SeasonZeroDisplayName :
string.Format(_localization.GetLocalizedString("NameSeasonNumber"), seasonNumber.ToString(UsCulture), args.GetLibraryOptions().PreferredMetadataLanguage);
}
return(season);
}
return(null);
}
private void OnProgress(double newPercentCommplete)
{
if (EnableUnavailableMessage)
{
var html = "<!doctype html><html><head><title>Emby</title></head><body>";
var text = _localization.GetLocalizedString("DbUpgradeMessage");
html += string.Format(text, newPercentCommplete.ToString("N2", CultureInfo.InvariantCulture));
html += "<script>setTimeout(function(){window.location.reload(true);}, 5000);</script>";
html += "</body></html>";
_httpServer.GlobalResponse = html;
}
}
/// <inheritdoc />
public async Task OnEvent(SubtitleDownloadFailureEventArgs eventArgs)
{
await _activityManager.CreateAsync(new ActivityLog(
string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("SubtitleDownloadFailureFromForItem"),
eventArgs.Provider,
GetItemName(eventArgs.Item)),
"SubtitleDownloadFailure",
Guid.Empty)
{
ItemId = eventArgs.Item.Id.ToString("N", CultureInfo.InvariantCulture),
ShortOverview = eventArgs.Exception.Message
}).ConfigureAwait(false);
}
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 void LocalizeText()
{
_uiCulture = _configurationManager.Configuration.UICulture;
cmdExit.Text = _localization.GetLocalizedString("LabelExit");
cmdCommunity.Text = _localization.GetLocalizedString("LabelVisitCommunity");
cmdPremiere.Text = _localization.GetLocalizedString("Emby Premiere");
cmdBrowse.Text = _localization.GetLocalizedString("LabelBrowseLibrary");
cmdConfigure.Text = _localization.GetLocalizedString("LabelConfigureServer");
cmdRestart.Text = _localization.GetLocalizedString("LabelRestartServer");
}
private void NormalizeChapterNames(ChapterInfo[] chapters)
{
for (int i = 0; i < chapters.Length; i++)
{
string name = chapters[i].Name;
// Check if the name is empty and/or if the name is a time
// Some ripping programs do that.
if (string.IsNullOrWhiteSpace(name) ||
TimeSpan.TryParse(name, out _))
{
chapters[i].Name = string.Format(
CultureInfo.InvariantCulture,
_localization.GetLocalizedString("ChapterNameValue"),
(i + 1).ToString(CultureInfo.InvariantCulture));
}
}
}
/// <summary>
/// Executes the middleware action.
/// </summary>
/// <param name="httpContext">The current HTTP context.</param>
/// <param name="serverApplicationHost">The server application host.</param>
/// <param name="localizationManager">The localization manager.</param>
/// <returns>The async task.</returns>
public async Task Invoke(
HttpContext httpContext,
IServerApplicationHost serverApplicationHost,
ILocalizationManager localizationManager)
{
if (serverApplicationHost.CoreStartupHasCompleted)
{
await _next(httpContext).ConfigureAwait(false);
return;
}
var message = localizationManager.GetLocalizedString("StartupEmbyServerIsLoading");
httpContext.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
httpContext.Response.ContentType = MediaTypeNames.Text.Html;
await httpContext.Response.WriteAsync(message, httpContext.RequestAborted).ConfigureAwait(false);
}
/// <inheritdoc />
public async Task OnEvent(TaskCompletionEventArgs eventArgs)
{
var result = eventArgs.Result;
var task = eventArgs.Task;
if (task.ScheduledTask is IConfigurableScheduledTask activityTask &&
!activityTask.IsLogged)
{
return;
}
var time = result.EndTimeUtc - result.StartTimeUtc;
var runningTime = string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("LabelRunningTimeValue"),
ToUserFriendlyString(time));
if (result.Status == TaskCompletionStatus.Failed)
{
var vals = new List <string>();
if (!string.IsNullOrEmpty(eventArgs.Result.ErrorMessage))
{
vals.Add(eventArgs.Result.ErrorMessage);
}
if (!string.IsNullOrEmpty(eventArgs.Result.LongErrorMessage))
{
vals.Add(eventArgs.Result.LongErrorMessage);
}
await _activityManager.CreateAsync(new ActivityLog(
string.Format(CultureInfo.InvariantCulture, _localizationManager.GetLocalizedString("ScheduledTaskFailedWithName"), task.Name),
NotificationType.TaskFailed.ToString(),
Guid.Empty)
{
LogSeverity = LogLevel.Error,
Overview = string.Join(Environment.NewLine, vals),
ShortOverview = runningTime
}).ConfigureAwait(false);
}
}
/// <inheritdoc />
public async Task OnEvent(PlaybackStopEventArgs eventArgs)
{
var item = eventArgs.MediaInfo;
if (item == null)
{
_logger.LogWarning("PlaybackStopped reported with null media info.");
return;
}
if (eventArgs.Item != null && eventArgs.Item.IsThemeMedia)
{
// Don't report theme song or local trailer playback
return;
}
if (eventArgs.Users.Count == 0)
{
return;
}
var user = eventArgs.Users[0];
var notificationType = GetPlaybackStoppedNotificationType(item.MediaType);
if (notificationType == null)
{
return;
}
await _activityManager.CreateAsync(new ActivityLog(
string.Format(
CultureInfo.InvariantCulture,
_localizationManager.GetLocalizedString("UserStoppedPlayingItemWithValues"),
user.Username,
GetItemName(item),
eventArgs.DeviceName),
notificationType,
user.Id))
.ConfigureAwait(false);
}
public HttpListenerHost(
IServerApplicationHost applicationHost,
ILogger <HttpListenerHost> logger,
IServerConfigurationManager config,
IConfiguration configuration,
INetworkManager networkManager,
ILocalizationManager localizationManager,
IHostEnvironment hostEnvironment,
ILoggerFactory loggerFactory)
{
_appHost = applicationHost;
_logger = logger;
_config = config;
_defaultRedirectPath = configuration[DefaultRedirectKey];
_baseUrlPrefix = _config.Configuration.BaseUrl;
_networkManager = networkManager;
_hostEnvironment = hostEnvironment;
_loggerFactory = loggerFactory;
Instance = this;
GlobalResponse = localizationManager.GetLocalizedString("StartupEmbyServerIsLoading");
}
/// <summary>
/// Adds the season.
/// </summary>
/// <param name="series">The series.</param>
/// <param name="seasonNumber">The season number.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>Task{Season}.</returns>
public async Task <Season> AddSeason(Series series,
int?seasonNumber,
CancellationToken cancellationToken)
{
var seasonName = seasonNumber == 0 ?
_config.Configuration.SeasonZeroDisplayName :
(seasonNumber.HasValue ? string.Format(_localization.GetLocalizedString("NameSeasonNumber"), seasonNumber.Value.ToString(_usCulture)) : _localization.GetLocalizedString("NameSeasonUnknown"));
_logger.Info("Creating Season {0} entry for {1}", seasonName, series.Name);
var season = new Season
{
Name = seasonName,
IndexNumber = seasonNumber,
Parent = series,
Id = (series.Id + (seasonNumber ?? -1).ToString(_usCulture) + seasonName).GetMBId(typeof(Season))
};
await series.AddChild(season, cancellationToken).ConfigureAwait(false);
await season.RefreshMetadata(new MetadataRefreshOptions(), cancellationToken).ConfigureAwait(false);
return(season);
}
private Task <UserView> GetUserView(string type, User user, CancellationToken cancellationToken)
{
var name = _localizationManager.GetLocalizedString("ViewType" + type);
return(_libraryManager.GetNamedView(name, type, string.Empty, cancellationToken));
}
public IEnumerable <NotificationTypeInfo> GetNotificationTypes()
{
var knownTypes = new List <NotificationTypeInfo>
{
new NotificationTypeInfo
{
Type = NotificationType.ApplicationUpdateInstalled.ToString(),
DefaultDescription = "{ReleaseNotes}",
DefaultTitle = "A new version of Emby Server has been installed.",
Variables = new string[] { "Version" }
},
new NotificationTypeInfo
{
Type = NotificationType.InstallationFailed.ToString(),
DefaultTitle = "{Name} installation failed.",
Variables = new string[] { "Name", "Version" }
},
new NotificationTypeInfo
{
Type = NotificationType.PluginInstalled.ToString(),
DefaultTitle = "{Name} was installed.",
Variables = new string[] { "Name", "Version" }
},
new NotificationTypeInfo
{
Type = NotificationType.PluginError.ToString(),
DefaultTitle = "{Name} has encountered an error.",
DefaultDescription = "{ErrorMessage}",
Variables = new string[] { "Name", "ErrorMessage" }
},
new NotificationTypeInfo
{
Type = NotificationType.PluginUninstalled.ToString(),
DefaultTitle = "{Name} was uninstalled.",
Variables = new string[] { "Name", "Version" }
},
new NotificationTypeInfo
{
Type = NotificationType.PluginUpdateInstalled.ToString(),
DefaultTitle = "{Name} was updated.",
DefaultDescription = "{ReleaseNotes}",
Variables = new string[] { "Name", "ReleaseNotes", "Version" }
},
new NotificationTypeInfo
{
Type = NotificationType.ServerRestartRequired.ToString(),
DefaultTitle = "Please restart Emby Server to finish updating."
},
new NotificationTypeInfo
{
Type = NotificationType.TaskFailed.ToString(),
DefaultTitle = "{Name} failed.",
DefaultDescription = "{ErrorMessage}",
Variables = new string[] { "Name", "ErrorMessage" }
},
new NotificationTypeInfo
{
Type = NotificationType.NewLibraryContent.ToString(),
DefaultTitle = "{Name} has been added to your media library.",
Variables = new string[] { "Name" }
},
new NotificationTypeInfo
{
Type = NotificationType.AudioPlayback.ToString(),
DefaultTitle = "{UserName} is playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.GamePlayback.ToString(),
DefaultTitle = "{UserName} is playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.VideoPlayback.ToString(),
DefaultTitle = "{UserName} is playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.AudioPlaybackStopped.ToString(),
DefaultTitle = "{UserName} has finished playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.GamePlaybackStopped.ToString(),
DefaultTitle = "{UserName} has finished playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.VideoPlaybackStopped.ToString(),
DefaultTitle = "{UserName} has finished playing {ItemName} on {DeviceName}.",
Variables = new string[] { "UserName", "ItemName", "DeviceName", "AppName" }
},
new NotificationTypeInfo
{
Type = NotificationType.CameraImageUploaded.ToString(),
DefaultTitle = "A new camera image has been uploaded from {DeviceName}.",
Variables = new string[] { "DeviceName" }
},
new NotificationTypeInfo
{
Type = NotificationType.UserLockedOut.ToString(),
DefaultTitle = "{UserName} has been locked out.",
Variables = new string[] { "UserName" }
}
};
if (!_appHost.CanSelfUpdate)
{
knownTypes.Add(new NotificationTypeInfo
{
Type = NotificationType.ApplicationUpdateAvailable.ToString(),
DefaultTitle = "A new version of Emby Server is available for download."
});
}
foreach (var type in knownTypes)
{
Update(type);
}
var systemName = _localization.GetLocalizedString("System");
return(knownTypes.OrderByDescending(i => string.Equals(i.Category, systemName, StringComparison.OrdinalIgnoreCase))
.ThenBy(i => i.Category)
.ThenBy(i => i.Name));
}
void _deviceManager_CameraImageUploaded(object sender, GenericEventArgs <CameraImageUploadInfo> e)
{
CreateLogEntry(new ActivityLogEntry
{
Name = string.Format(_localization.GetLocalizedString("CameraImageUploadedFrom"), e.Argument.Device.Name),
Type = NotificationType.CameraImageUploaded.ToString()
});
}
private void OnCameraImageUploaded(object sender, GenericEventArgs <CameraImageUploadInfo> e)
{
CreateLogEntry(new ActivityLogEntry
{
Name = string.Format(
CultureInfo.InvariantCulture,
_localization.GetLocalizedString("CameraImageUploadedFrom"),
e.Argument.Device.Name),
Type = NotificationType.CameraImageUploaded.ToString()
});
}
private async void OnUserLockedOut(object sender, GenericEventArgs <MediaBrowser.Controller.Entities.User> e)
{
await CreateLogEntry(new ActivityLog(
string.Format(
CultureInfo.InvariantCulture,
_localization.GetLocalizedString("UserLockedOutWithName"),
e.Argument.Name),
NotificationType.UserLockedOut.ToString(),
e.Argument.Id))
.ConfigureAwait(false);
}
public Task <UserView> GetUserView(string parentId, string type, User user, string sortName, CancellationToken cancellationToken)
{
var name = _localizationManager.GetLocalizedString("ViewType" + type);
return(GetUserView(name, parentId, type, user, sortName, cancellationToken));
}
private string GetDisplayName(BaseItem item, StubType?itemStubType, BaseItem context)
{
if (itemStubType.HasValue)
{
switch (itemStubType.Value)
{
case StubType.Latest: return(_localization.GetLocalizedString("Latest"));
case StubType.Playlists: return(_localization.GetLocalizedString("Playlists"));
case StubType.AlbumArtists: return(_localization.GetLocalizedString("HeaderAlbumArtists"));
case StubType.Albums: return(_localization.GetLocalizedString("Albums"));
case StubType.Artists: return(_localization.GetLocalizedString("Artists"));
case StubType.Songs: return(_localization.GetLocalizedString("Songs"));
case StubType.Genres: return(_localization.GetLocalizedString("Genres"));
case StubType.FavoriteAlbums: return(_localization.GetLocalizedString("HeaderFavoriteAlbums"));
case StubType.FavoriteArtists: return(_localization.GetLocalizedString("HeaderFavoriteArtists"));
case StubType.FavoriteSongs: return(_localization.GetLocalizedString("HeaderFavoriteSongs"));
case StubType.ContinueWatching: return(_localization.GetLocalizedString("HeaderContinueWatching"));
case StubType.Movies: return(_localization.GetLocalizedString("Movies"));
case StubType.Collections: return(_localization.GetLocalizedString("Collections"));
case StubType.Favorites: return(_localization.GetLocalizedString("Favorites"));
case StubType.NextUp: return(_localization.GetLocalizedString("HeaderNextUp"));
case StubType.FavoriteSeries: return(_localization.GetLocalizedString("HeaderFavoriteShows"));
case StubType.FavoriteEpisodes: return(_localization.GetLocalizedString("HeaderFavoriteEpisodes"));
case StubType.Series: return(_localization.GetLocalizedString("Shows"));
default: break;
}
}
return(item is Episode episode
? GetEpisodeDisplayName(episode, context)
: item.Name);
}
