dockerapps/tv7playlist
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

First running version with all fields, sync, m3u generation and without old controller

Browse Source
This commit is contained in:
Philipp Häfelfinger
2019-01-25 22:52:37 +01:00
parent 99430d9292
commit 0b53b6f697
19 changed files with 321 additions and 231 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
Tv7Playlist.Core/IPlaylistBuilder.cs Normal file
View File

@@ -0,0 +1,10 @@
using System.IO;
using System.Threading.Tasks;
namespace Tv7Playlist.Core
{
public interface IPlaylistBuilder
{
Task<Stream> GeneratePlaylistAsync();
}
}

9
Tv7Playlist.Core/IPlaylistSynchronizer.cs Normal file
View File

@@ -0,0 +1,9 @@
using System.Threading.Tasks;
namespace Tv7Playlist.Core
{
public interface IPlaylistSynchronizer
{
Task SynchronizeAsync();
}
}

4
Tv7Playlist.Core/LoggingEvents.cs
View File

@@ -4,8 +4,8 @@ namespace Tv7Playlist.Core
{
public const int Startup = 1000;
public const int Playlist = 1001;
public const int ParsingM3uPlayList = 1002;
public const int ParsingM3UPlayList = 1002;
public const int Synchronize = 1003;
public const int PlaylistNotFound = 4000;
}
}

8
Tv7Playlist.Core/M3UConstants.cs Normal file
View File

@@ -0,0 +1,8 @@
namespace Tv7Playlist.Core
{
internal static class M3UConstants
{
public const string ExtInfStartTag = "#EXTINF:";
public const string ExtFileStartTag = "#EXTM3U";
}
}

22
Tv7Playlist.Core/Parsers/M3u/M3UParser.cs
View File

@@ -8,8 +8,6 @@ namespace Tv7Playlist.Core.Parsers.M3u
{
public class M3UParser : IPlaylistParser
{
private const string ExtInfStartTag = "#EXTINF:";
private const string ExtFileStartTag = "#EXTM3U";
private const int IdStartNumber = 1000;
private const int IdIncrementNumber = 5;
@@ -24,7 +22,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
{
if (stream == null) throw new ArgumentNullException(nameof(stream));
_logger.LogInformation(LoggingEvents.ParsingM3uPlayList, "Parsing m3u file content");
_logger.LogInformation(LoggingEvents.ParsingM3UPlayList, "Parsing m3u file content");
EnsureStreamIsAtBeginning(stream);
@@ -32,7 +30,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
{
var tracks = await ParseTracksFromStreamAsync(reader);
_logger.LogInformation(LoggingEvents.ParsingM3uPlayList, "Parsing m3u file finished");
_logger.LogInformation(LoggingEvents.ParsingM3UPlayList, "Parsing m3u file finished");
return tracks;
}
@@ -44,7 +42,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
if (!await StreamHasValidStartTagAsync(reader))
{
_logger.LogError(LoggingEvents.ParsingM3uPlayList, $"Could not parse stream as it did not start with {ExtFileStartTag}");
_logger.LogError(LoggingEvents.ParsingM3UPlayList, $"Could not parse stream as it did not start with {M3UConstants.ExtFileStartTag}");
return new List<ParsedTrack>(300);
}
@@ -63,7 +61,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
private static async Task<bool> StreamHasValidStartTagAsync(StreamReader reader)
{
var startLine = await ReadLineSafeAsync(reader);
var stramHasValidStartTag = !startLine.Trim().ToUpper().Equals(ExtInfStartTag);
var stramHasValidStartTag = !startLine.Trim().ToUpper().Equals(M3UConstants.ExtInfStartTag);
return stramHasValidStartTag;
}
@@ -71,7 +69,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
{
if (stream.Position == 0) return;
_logger.LogWarning(LoggingEvents.ParsingM3uPlayList, "Stream not positioned at the beginning. Repositioning!");
_logger.LogWarning(LoggingEvents.ParsingM3UPlayList, "Stream not positioned at the beginning. Repositioning!");
stream.Position = 0;
}
@@ -82,9 +80,9 @@ namespace Tv7Playlist.Core.Parsers.M3u
if (currentId <= 0) throw new ArgumentOutOfRangeException(nameof(currentId));
var metaLine = await ReadLineSafeAsync(reader);
if (!metaLine.StartsWith(ExtInfStartTag))
if (!metaLine.StartsWith(M3UConstants.ExtInfStartTag))
{
_logger.LogDebug(LoggingEvents.ParsingM3uPlayList,
_logger.LogDebug(LoggingEvents.ParsingM3UPlayList,
"Line {lineNumber} {metaLine} is not a valid start channel start line",
currentId.ToString(), metaLine);
return;
@@ -95,11 +93,11 @@ namespace Tv7Playlist.Core.Parsers.M3u
if (track != null)
{
tracks.Add(track);
_logger.LogDebug(LoggingEvents.ParsingM3uPlayList, "Parsed track {track}", track);
_logger.LogDebug(LoggingEvents.ParsingM3UPlayList, "Parsed track {track}", track);
}
else
{
_logger.LogWarning(LoggingEvents.ParsingM3uPlayList,
_logger.LogWarning(LoggingEvents.ParsingM3UPlayList,
"Could not parse lines {metaLine} with url {url}", metaLine, url);
}
}
@@ -123,7 +121,7 @@ namespace Tv7Playlist.Core.Parsers.M3u
//TODO: Check line parsing of https://github.com/tellytv/telly/blob/dev/internal/m3uplus/main.go
//format is base for telly to export.
var fields = metaLine.Replace(ExtInfStartTag, string.Empty).Split(',');
var fields = metaLine.Replace(M3UConstants.ExtInfStartTag, string.Empty).Split(',');
var name = fields.Length >= 2 ? fields[1] : $"{currentId}-unknown";
return new ParsedTrack(currentId, name, url);

57
Tv7Playlist.Core/PlaylistBuilder.cs Normal file
View File

@@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Tv7Playlist.Data;
namespace Tv7Playlist.Core
{
public class PlaylistBuilder : IPlaylistBuilder
{
private readonly ILogger<PlaylistBuilder> _logger;
private readonly PlaylistContext _playlistContext;
public PlaylistBuilder(ILogger<PlaylistBuilder> logger, PlaylistContext playlistContext)
{
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_playlistContext = playlistContext ?? throw new ArgumentNullException(nameof(playlistContext));
}
public async Task<Stream> GeneratePlaylistAsync()
{
_logger.LogInformation(LoggingEvents.Playlist, "Building m3u file content");
var playlistEntries = await _playlistContext.PlaylistEntries.Where(e => e.IsAvailable).Where(e => e.IsEnabled)
.OrderBy(e => e.Position).AsNoTracking().ToListAsync();
return await CreatePlaylistStreamAsync(playlistEntries);
}
private static async Task<MemoryStream> CreatePlaylistStreamAsync(IEnumerable<PlaylistEntry> playlistEntries)
{
var outStream = new MemoryStream();
var outWriter = new StreamWriter(outStream);
await outWriter.WriteLineAsync(M3UConstants.ExtFileStartTag);
foreach (var entry in playlistEntries) await WriteEntryAsync(outWriter, entry);
outStream.Seek(0, SeekOrigin.Begin);
return outStream;
}
private static async Task WriteEntryAsync(TextWriter outWriter, PlaylistEntry entry)
{
const int duration = -1;
var number = entry.TrackNumberOverride != 0 ? entry.TrackNumberOverride : entry.TrackNumber;
var extInfo = $"{M3UConstants.ExtInfStartTag}{duration},{number},{entry.Name}";
await outWriter.WriteLineAsync(extInfo);
await outWriter.WriteLineAsync(entry.Url);
}
}
}

126
Tv7Playlist.Core/PlaylistSynchronizer.cs Normal file
View File

@@ -0,0 +1,126 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Tv7Playlist.Core.Parsers;
using Tv7Playlist.Data;
namespace Tv7Playlist.Core
{
public class PlaylistSynchronizer : IPlaylistSynchronizer
{
private static readonly Regex MultiCastRegex = new Regex(@"(udp\:\/\/@)([0-9.:]+)",
RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.IgnoreCase);
private readonly IAppConfig _appConfig;
private readonly ILogger<PlaylistSynchronizer> _logger;
private readonly PlaylistContext _playlistContext;
private readonly IPlaylistLoader _playlistLoader;
private readonly string _proxyUrl;
public PlaylistSynchronizer(ILogger<PlaylistSynchronizer> logger, IAppConfig appConfig, IPlaylistLoader playlistLoader,
PlaylistContext playlistContext)
{
_playlistContext = playlistContext ?? throw new ArgumentNullException(nameof(playlistContext));
_appConfig = appConfig ?? throw new ArgumentNullException(nameof(appConfig));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_playlistLoader = playlistLoader ?? throw new ArgumentNullException(nameof(playlistLoader));
_proxyUrl = GetProxyUrl();
}
public async Task SynchronizeAsync()
{
_logger.LogDebug(LoggingEvents.Synchronize, "Synchronizing playlist from server...");
var tv7Url = GetTv7SourceUrl();
var existingEntries = await _playlistContext.PlaylistEntries.ToDictionaryAsync(e => e.TrackNumber);
var tracks = await _playlistLoader.LoadPlaylistFromUrl(tv7Url);
MarkNotAvailableEntries(existingEntries, tracks);
AddOrUpdateEntries(existingEntries, tracks);
_logger.LogDebug("Synchronizing playlist completed saving changes...");
await _playlistContext.SaveChangesAsync();
_logger.LogDebug("Playlist changes saved successfully...");
}
private void AddOrUpdateEntries(IReadOnlyDictionary<int, PlaylistEntry> existingEntries, IEnumerable<ParsedTrack> tracks)
{
foreach (var track in tracks)
{
if (!existingEntries.TryGetValue(track.Id, out var entry))
{
_logger.LogInformation(LoggingEvents.Synchronize, $"Adding playlist entry {track.Id} - {track.Name}");
entry = new PlaylistEntry
{
Id = Guid.NewGuid(), Position = track.Id, TrackNumber = track.Id, IsEnabled = true
};
_playlistContext.PlaylistEntries.Add(entry);
}
else
{
_logger.LogInformation(LoggingEvents.Synchronize, $"Updating playlist entry {track.Id} - {track.Name}");
}
entry.IsAvailable = true;
entry.Name = track.Name;
entry.UrlOriginal = track.Url;
entry.Url = BuildUrl(entry);
}
}
private string BuildUrl(PlaylistEntry entry)
{
return MultiCastRegex.Replace(entry.UrlOriginal, $"{_proxyUrl}/$2/");
}
private string GetProxyUrl()
{
var proxyUrl = _appConfig.UdpxyUrl;
if (string.IsNullOrWhiteSpace(proxyUrl))
{
_logger.LogInformation(LoggingEvents.Synchronize, "No proxy URL set in the application config. Using original URLs");
return string.Empty;
}
if (!Uri.IsWellFormedUriString(proxyUrl, UriKind.Absolute))
{
var message = $"The proxyUrl is set to {proxyUrl}. This is not a well formed uri!";
_logger.LogError(LoggingEvents.Synchronize, message);
throw new ApplicationException(message);
}
return proxyUrl;
}
private string GetTv7SourceUrl()
{
var tv7Url = _appConfig.TV7Url;
if (!Uri.IsWellFormedUriString(tv7Url, UriKind.Absolute))
{
var message = $"The TV7Url is set to {tv7Url}. This is not a well formed uri!";
_logger.LogError(LoggingEvents.Synchronize, message);
throw new ApplicationException(message);
}
return tv7Url;
}
private void MarkNotAvailableEntries(Dictionary<int, PlaylistEntry> existingEntries,
IReadOnlyCollection<ParsedTrack> tracks)
{
var unavailableEntries = existingEntries.Where(e => tracks.All(t => t.Id != e.Key)).Select(e => e.Value);
foreach (var entry in unavailableEntries)
{
_logger.LogInformation(LoggingEvents.Synchronize, $"Channel {entry.TrackNumber} - {entry.Name} is no longer available.");
entry.IsAvailable = false;
}
}
}
}

7
Tv7Playlist.Core/Tv7Playlist.Core.csproj
View File

@@ -1,11 +1,16 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>netstandard2.0</TargetFramework>
<TargetFramework>netcoreapp2.2</TargetFramework>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="2.2.1" />
<PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.2.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Tv7Playlist.Data\Tv7Playlist.Data.csproj" />
</ItemGroup>
</Project>