Stream custom live channels using your own media
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

600 lines
22 KiB

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using ErsatzTV.Core;
using ErsatzTV.Core.Domain;
using ErsatzTV.Core.Emby;
using ErsatzTV.Core.Interfaces.Emby;
using ErsatzTV.Core.Interfaces.Metadata;
using ErsatzTV.Infrastructure.Emby.Models;
using LanguageExt;
using Microsoft.Extensions.Logging;
using Refit;
using static LanguageExt.Prelude;
namespace ErsatzTV.Infrastructure.Emby
{
public class EmbyApiClient : IEmbyApiClient
{
private readonly IFallbackMetadataProvider _fallbackMetadataProvider;
private readonly ILogger<EmbyApiClient> _logger;
public EmbyApiClient(IFallbackMetadataProvider fallbackMetadataProvider, ILogger<EmbyApiClient> logger)
{
_fallbackMetadataProvider = fallbackMetadataProvider;
_logger = logger;
}
public async Task<Either<BaseError, EmbyServerInformation>> GetServerInformation(
string address,
string apiKey)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(5));
return await service.GetSystemInformation(apiKey, cts.Token)
.Map(response => new EmbyServerInformation(response.ServerName, response.OperatingSystem));
}
catch (OperationCanceledException ex)
{
_logger.LogError(ex, "Timeout getting emby server name");
return BaseError.New("Emby did not respond in time");
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby server name");
return BaseError.New(ex.Message);
}
}
public async Task<Either<BaseError, List<EmbyLibrary>>> GetLibraries(string address, string apiKey)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
List<EmbyLibraryResponse> libraries = await service.GetLibraries(apiKey);
return libraries
.Map(Project)
.Somes()
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby libraries");
return BaseError.New(ex.Message);
}
}
public async Task<Either<BaseError, List<EmbyMovie>>> GetMovieLibraryItems(
string address,
string apiKey,
int mediaSourceId,
string libraryId)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
EmbyLibraryItemsResponse items = await service.GetMovieLibraryItems(apiKey, libraryId);
return items.Items
.Map(ProjectToMovie)
.Somes()
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby movie library items");
return BaseError.New(ex.Message);
}
}
public async Task<Either<BaseError, List<EmbyShow>>> GetShowLibraryItems(
string address,
string apiKey,
int mediaSourceId,
string libraryId)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
EmbyLibraryItemsResponse items = await service.GetShowLibraryItems(apiKey, libraryId);
return items.Items
.Map(ProjectToShow)
.Somes()
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby show library items");
return BaseError.New(ex.Message);
}
}
public async Task<Either<BaseError, List<EmbySeason>>> GetSeasonLibraryItems(
string address,
string apiKey,
int mediaSourceId,
string showId)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
EmbyLibraryItemsResponse items = await service.GetSeasonLibraryItems(apiKey, showId);
return items.Items
.Map(ProjectToSeason)
.Somes()
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby show library items");
return BaseError.New(ex.Message);
}
}
public async Task<Either<BaseError, List<EmbyEpisode>>> GetEpisodeLibraryItems(
string address,
string apiKey,
int mediaSourceId,
string seasonId)
{
try
{
IEmbyApi service = RestService.For<IEmbyApi>(address);
EmbyLibraryItemsResponse items = await service.GetEpisodeLibraryItems(apiKey, seasonId);
return items.Items
.Map(ProjectToEpisode)
.Somes()
.ToList();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error getting emby episode library items");
return BaseError.New(ex.Message);
}
}
private static Option<EmbyLibrary> Project(EmbyLibraryResponse response) =>
response.CollectionType?.ToLowerInvariant() switch
{
"tvshows" => new EmbyLibrary
{
ItemId = response.ItemId,
Name = response.Name,
MediaKind = LibraryMediaKind.Shows,
ShouldSyncItems = false,
Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
},
"movies" => new EmbyLibrary
{
ItemId = response.ItemId,
Name = response.Name,
MediaKind = LibraryMediaKind.Movies,
ShouldSyncItems = false,
Paths = new List<LibraryPath> { new() { Path = $"emby://{response.ItemId}" } }
},
// TODO: ??? for music libraries
_ => None
};
private Option<EmbyMovie> ProjectToMovie(EmbyLibraryItemResponse item)
{
try
{
if (item.MediaSources.Any(ms => ms.Protocol != "File"))
{
return None;
}
var version = new MediaVersion
{
Name = "Main",
Duration = TimeSpan.FromTicks(item.RunTimeTicks),
DateAdded = item.DateCreated.UtcDateTime,
MediaFiles = new List<MediaFile>
{
new()
{
Path = item.Path
}
},
Streams = new List<MediaStream>()
};
MovieMetadata metadata = ProjectToMovieMetadata(item);
var movie = new EmbyMovie
{
ItemId = item.Id,
Etag = item.Etag,
MediaVersions = new List<MediaVersion> { version },
MovieMetadata = new List<MovieMetadata> { metadata },
TraktListItems = new List<TraktListItem>()
};
return movie;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Error projecting Emby movie");
return None;
}
}
private MovieMetadata ProjectToMovieMetadata(EmbyLibraryItemResponse item)
{
DateTime dateAdded = item.DateCreated.UtcDateTime;
// DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
var metadata = new MovieMetadata
{
MetadataKind = MetadataKind.External,
Title = item.Name,
SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
Plot = item.Overview,
Year = item.ProductionYear,
Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
DateAdded = dateAdded,
ContentRating = item.OfficialRating,
Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList(),
Artwork = new List<Artwork>(),
Guids = GuidsFromProviderIds(item.ProviderIds)
};
// set order on actors
for (var i = 0; i < metadata.Actors.Count; i++)
{
metadata.Actors[i].Order = i;
}
if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
{
metadata.ReleaseDate = releaseDate;
}
if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
{
var poster = new Artwork
{
ArtworkKind = ArtworkKind.Poster,
Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
DateAdded = dateAdded
};
metadata.Artwork.Add(poster);
}
if (item.BackdropImageTags.Any())
{
var fanArt = new Artwork
{
ArtworkKind = ArtworkKind.FanArt,
Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
DateAdded = dateAdded
};
metadata.Artwork.Add(fanArt);
}
return metadata;
}
private Option<Actor> ProjectToActor(EmbyPersonResponse person, DateTime dateAdded)
{
if (person.Type?.ToLowerInvariant() != "actor")
{
return None;
}
var actor = new Actor { Name = person.Name, Role = person.Role };
if (!string.IsNullOrWhiteSpace(person.Id) && !string.IsNullOrWhiteSpace(person.PrimaryImageTag))
{
actor.Artwork = new Artwork
{
Path = $"emby://Items/{person.Id}/Images/Primary?tag={person.PrimaryImageTag}",
ArtworkKind = ArtworkKind.Thumbnail,
DateAdded = dateAdded
};
}
return actor;
}
private static Option<Director> ProjectToDirector(EmbyPersonResponse person)
{
if (person.Type?.ToLowerInvariant() != "director")
{
return None;
}
return new Director { Name = person.Name };
}
private static Option<Writer> ProjectToWriter(EmbyPersonResponse person)
{
if (person.Type?.ToLowerInvariant() != "writer")
{
return None;
}
return new Writer { Name = person.Name };
}
private Option<EmbyShow> ProjectToShow(EmbyLibraryItemResponse item)
{
try
{
ShowMetadata metadata = ProjectToShowMetadata(item);
var show = new EmbyShow
{
ItemId = item.Id,
Etag = item.Etag,
ShowMetadata = new List<ShowMetadata> { metadata },
TraktListItems = new List<TraktListItem>()
};
return show;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Error projecting Emby show");
return None;
}
}
private ShowMetadata ProjectToShowMetadata(EmbyLibraryItemResponse item)
{
DateTime dateAdded = item.DateCreated.UtcDateTime;
// DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
var metadata = new ShowMetadata
{
MetadataKind = MetadataKind.External,
Title = item.Name,
SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
Plot = item.Overview,
Year = item.ProductionYear,
Tagline = Optional(item.Taglines).Flatten().HeadOrNone().IfNone(string.Empty),
DateAdded = dateAdded,
ContentRating = item.OfficialRating,
Genres = Optional(item.Genres).Flatten().Map(g => new Genre { Name = g }).ToList(),
Tags = Optional(item.Tags).Flatten().Map(t => new Tag { Name = t }).ToList(),
Studios = Optional(item.Studios).Flatten().Map(s => new Studio { Name = s.Name }).ToList(),
Actors = Optional(item.People).Flatten().Collect(r => ProjectToActor(r, dateAdded)).ToList(),
Artwork = new List<Artwork>(),
Guids = GuidsFromProviderIds(item.ProviderIds)
};
// set order on actors
for (var i = 0; i < metadata.Actors.Count; i++)
{
metadata.Actors[i].Order = i;
}
if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
{
metadata.ReleaseDate = releaseDate;
}
if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
{
var poster = new Artwork
{
ArtworkKind = ArtworkKind.Poster,
Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
DateAdded = dateAdded
};
metadata.Artwork.Add(poster);
}
if (!string.IsNullOrWhiteSpace(item.ImageTags.Thumb))
{
var thumb = new Artwork
{
ArtworkKind = ArtworkKind.Thumbnail,
Path = $"emby://Items/{item.Id}/Images/Thumb?tag={item.ImageTags.Thumb}",
DateAdded = dateAdded
};
metadata.Artwork.Add(thumb);
}
if (item.BackdropImageTags.Any())
{
var fanArt = new Artwork
{
ArtworkKind = ArtworkKind.FanArt,
Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
DateAdded = dateAdded
};
metadata.Artwork.Add(fanArt);
}
return metadata;
}
private Option<EmbySeason> ProjectToSeason(EmbyLibraryItemResponse item)
{
try
{
DateTime dateAdded = item.DateCreated.UtcDateTime;
// DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(response.UpdatedAt).DateTime;
var metadata = new SeasonMetadata
{
MetadataKind = MetadataKind.External,
Title = item.Name,
SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
Year = item.ProductionYear,
DateAdded = dateAdded,
Artwork = new List<Artwork>(),
Guids = GuidsFromProviderIds(item.ProviderIds)
};
if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
{
var poster = new Artwork
{
ArtworkKind = ArtworkKind.Poster,
Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
DateAdded = dateAdded
};
metadata.Artwork.Add(poster);
}
if (item.BackdropImageTags.Any())
{
var fanArt = new Artwork
{
ArtworkKind = ArtworkKind.FanArt,
Path = $"emby://Items/{item.Id}/Images/Backdrop?tag={item.BackdropImageTags.Head()}",
DateAdded = dateAdded
};
metadata.Artwork.Add(fanArt);
}
var season = new EmbySeason
{
ItemId = item.Id,
Etag = item.Etag,
SeasonMetadata = new List<SeasonMetadata> { metadata },
TraktListItems = new List<TraktListItem>()
};
if (item.IndexNumber.HasValue)
{
season.SeasonNumber = item.IndexNumber.Value;
}
return season;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Error projecting Emby show");
return None;
}
}
private Option<EmbyEpisode> ProjectToEpisode(EmbyLibraryItemResponse item)
{
try
{
if (item.LocationType == "Virtual")
{
return None;
}
var version = new MediaVersion
{
Name = "Main",
Duration = TimeSpan.FromTicks(item.RunTimeTicks),
DateAdded = item.DateCreated.UtcDateTime,
MediaFiles = new List<MediaFile>
{
new()
{
Path = item.Path
}
},
Streams = new List<MediaStream>()
};
EpisodeMetadata metadata = ProjectToEpisodeMetadata(item);
var episode = new EmbyEpisode
{
ItemId = item.Id,
Etag = item.Etag,
MediaVersions = new List<MediaVersion> { version },
EpisodeMetadata = new List<EpisodeMetadata> { metadata },
TraktListItems = new List<TraktListItem>()
};
return episode;
}
catch (Exception ex)
{
_logger.LogWarning(ex, "Error projecting Emby movie");
return None;
}
}
private EpisodeMetadata ProjectToEpisodeMetadata(EmbyLibraryItemResponse item)
{
DateTime dateAdded = item.DateCreated.UtcDateTime;
// DateTime lastWriteTime = DateTimeOffset.FromUnixTimeSeconds(item.UpdatedAt).DateTime;
var metadata = new EpisodeMetadata
{
MetadataKind = MetadataKind.External,
Title = item.Name,
SortTitle = _fallbackMetadataProvider.GetSortTitle(item.Name),
Plot = item.Overview,
Year = item.ProductionYear,
DateAdded = dateAdded,
Genres = new List<Genre>(),
Tags = new List<Tag>(),
Studios = new List<Studio>(),
Actors = new List<Actor>(),
Artwork = new List<Artwork>(),
Guids = GuidsFromProviderIds(item.ProviderIds),
Directors = Optional(item.People).Flatten().Collect(r => ProjectToDirector(r)).ToList(),
Writers = Optional(item.People).Flatten().Collect(r => ProjectToWriter(r)).ToList()
};
if (item.IndexNumber.HasValue)
{
metadata.EpisodeNumber = item.IndexNumber.Value;
}
if (DateTime.TryParse(item.PremiereDate, out DateTime releaseDate))
{
metadata.ReleaseDate = releaseDate;
}
if (!string.IsNullOrWhiteSpace(item.ImageTags.Primary))
{
var thumbnail = new Artwork
{
ArtworkKind = ArtworkKind.Thumbnail,
Path = $"emby://Items/{item.Id}/Images/Primary?tag={item.ImageTags.Primary}",
DateAdded = dateAdded
};
metadata.Artwork.Add(thumbnail);
}
return metadata;
}
private List<MetadataGuid> GuidsFromProviderIds(EmbyProviderIdsResponse providerIds)
{
var result = new List<MetadataGuid>();
if (providerIds != null)
{
if (!string.IsNullOrWhiteSpace(providerIds.Imdb))
{
result.Add(new MetadataGuid { Guid = $"imdb://{providerIds.Imdb}" });
}
if (!string.IsNullOrWhiteSpace(providerIds.Tmdb))
{
result.Add(new MetadataGuid { Guid = $"tmdb://{providerIds.Tmdb}" });
}
if (!string.IsNullOrWhiteSpace(providerIds.Tvdb))
{
result.Add(new MetadataGuid { Guid = $"tvdb://{providerIds.Tvdb}" });
}
}
return result;
}
}
}