ttrss-co-pilot/Program.cs

using Newtonsoft.Json;
using System.Linq;
using System.Diagnostics;

namespace ttrss_co_client
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var conf = Configure();
            var ttrssClient = new ttrss.ApiClient(conf.BaseURI);
            await ttrssClient.Login(conf.Username, conf.Password);

            var loggedin = await ttrssClient.IsLoggedIn();
            Console.WriteLine($"logged in: {loggedin}");

            var miscTasks = new List<Task>();
            var unreadFeeds = await ttrssClient.GetFeeds(cat_id: -3, unread_only: true);
            foreach (var uf in unreadFeeds)
            {
                Console.WriteLine($"unread feed: {uf.title}");
                var headlines = await ttrssClient.GetHeadlines(uf.id, view_mode: ttrss.ApiClient.VIEWMODE.Unread, include_attachments: true);
                foreach (var hl in headlines)
                {
                    var labelsWRTFeed = (await ttrssClient.GetLabels(hl.id));
                    var actionsForFeed = conf.feedActions.Where(fa =>
                        labelsWRTFeed.Where(l => l.@checked).Select(l => l.caption).Contains(fa.triggerlabelCaption))?.ToList();
                    if (actionsForFeed != null && actionsForFeed.Any())
                    {
                        foreach (var action in actionsForFeed)
                        {
                            Console.WriteLine($"    {hl.title} -> action: {action.command}");
                            var noteString = hl.note;
                            ttrss.datastructures.Label nameLabel;
                            string podcastName;
                            if (!string.IsNullOrWhiteSpace(noteString))
                            {
                                noteString += $"{hl.note}\n";
                            }
                            switch (action.command)
                            {
                                case "dl":
                                    var stdDLResult = await standardDL(hl.link.ToString());
                                    miscTasks.Add(ttrssClient.UpdateArticleNote($"{noteString}[{DateTime.Now.ToLongTimeString()}] - {stdDLResult.Item2}", hl.id));
                                    if (stdDLResult.Item1 == true)
                                    {
                                        Console.WriteLine($"    {hl.title} -> dl success, removing label");
                                        miscTasks.Add(
                                            ttrssClient.SetArticleLabel(
                                                labelsWRTFeed.First(l => l.caption == action.triggerlabelCaption).id,
                                                false,
                                                hl.id));
                                    }
                                    else
                                    {
                                        Console.WriteLine($"    {hl.title} -> dl failed");
                                    }
                                    break;
                                case "podcastifyYT":
                                    nameLabel = labelsWRTFeed.FirstOrDefault(l => l.caption?.StartsWith(conf.PodcastTitlePrefix) == true && l.@checked);
                                    podcastName = nameLabel?.caption.Substring(conf.PodcastTitlePrefix.Length)
                                        ?? hl.feed_title;
                                    var YTpodcastifyResult = await podcastifyYT(hl.link.ToString(), podcastName);
                                    miscTasks.Add(ttrssClient.UpdateArticleNote($"{noteString}[{DateTime.Now.ToLongTimeString()}] - {YTpodcastifyResult.Item2}", hl.id));
                                    if (YTpodcastifyResult.Item1 == true)
                                    {
                                        Console.WriteLine($"    {hl.title} -> podcastify (YT) success, removing labels");
                                        miscTasks.Add(
                                            ttrssClient.SetArticleLabel(
                                                labelsWRTFeed.First(l => l.caption == action.triggerlabelCaption).id,
                                                false,
                                                hl.id));
                                        if (nameLabel != null)
                                        {
                                            miscTasks.Add(ttrssClient.SetArticleLabel(nameLabel.id, false, hl.id));
                                        }
                                    }
                                    else
                                    {
                                        Console.WriteLine($"    {hl.title} -> podcastify (YT) failed");
                                    }
                                    break;
                                case "podcastifyAttachment":
                                    nameLabel = labelsWRTFeed.FirstOrDefault(l => l.caption?.StartsWith(conf.PodcastTitlePrefix) == true && l.@checked);
                                    podcastName = nameLabel?.caption.Substring(conf.PodcastTitlePrefix.Length)
                                        ?? hl.feed_title;
                                    var attachmentLink = hl.attachments.Select(a => a.content_url)?.FirstOrDefault();
                                    var ATTpodcastifyResult = await podcastifyAttachment(attachmentLink.ToString(), podcastName, hl.title);
                                    miscTasks.Add(ttrssClient.UpdateArticleNote($"{noteString}[{DateTime.Now.ToLongTimeString()}] - {ATTpodcastifyResult.Item2}", hl.id));
                                    if (ATTpodcastifyResult.Item1 == true)
                                    {
                                        Console.WriteLine($"    {hl.title} -> podcastify (att) success, removing labels");
                                        miscTasks.Add(
                                            ttrssClient.SetArticleLabel(
                                                labelsWRTFeed.First(l => l.caption == action.triggerlabelCaption).id,
                                                false,
                                                hl.id));
                                        if (nameLabel != null)
                                        {
                                            miscTasks.Add(ttrssClient.SetArticleLabel(nameLabel.id, false, hl.id));
                                        }
                                    }
                                    else
                                    {
                                        Console.WriteLine($"    {hl.title} -> podcastify (att) failed");
                                    }
                                    break;
                                default:
                                    noteString += $"[{DateTime.Now.ToLongTimeString()}] - feed configured but action not recognized";
                                    break;
                            }
                            miscTasks.Add(ttrssClient.UpdateArticleNote(noteString, hl.id));
                        }
                    }
                }
            }


            Console.WriteLine($"awaiting remaining download tasks");
            Task.WaitAll(miscTasks.ToArray());
            await ttrssClient.Logout();
            Console.WriteLine($"done, moving files from temporary location");

            var resulted = Directory.GetFiles("tmp", "*.*", SearchOption.AllDirectories);
            if (resulted.Count() > 0)
            {
                foreach (var f in resulted)
                {
                    var moveTarget = Path.Combine(conf.OnDoneCopy, f.Substring("tmp/".Length));
                    if (!Path.Exists(Path.GetDirectoryName(moveTarget)))
                    {
                        Directory.CreateDirectory(Path.GetDirectoryName(moveTarget));
                    }
                    File.Move(f, moveTarget);
                }
            }
            Console.WriteLine($"done for real");
        }
        static Configuration Configure(string configurationPath = "appsettings.json")
        {
            if (!File.Exists(configurationPath))
            {
                Console.Error.WriteLine($"could not find configuration at {configurationPath}! copying sample to that spot.");
                File.Copy("sample-appsettings.json", configurationPath); //and you know what, if that explodes at the OS level, the OS should give you an error
                return null;
            }
            var fileContents = File.ReadAllText(configurationPath);
            if (string.IsNullOrWhiteSpace(fileContents))
            {
                Console.Error.WriteLine($"configuration file at {configurationPath} was empty! overwriting with sample settings.");
                File.Copy("sample-appsettings.json", configurationPath, true);
                return null;
            }

            var conf = JsonConvert.DeserializeObject<Configuration>(fileContents);

            if (conf == null)
            {
                Console.Error.WriteLine($"configuration file at {configurationPath} was empty! overwriting with sample settings.");
                File.Copy("sample-appsettings.json", configurationPath, true);
                return null;
            }

            return conf;
        }

        private static async Task<Tuple<bool, string>> standardDL(string articleLink)
        {
            Console.WriteLine($"   standard downloading {articleLink}");
            try
            {
                var ytdl = new YoutubeDLSharp.YoutubeDL();
                ytdl.YoutubeDLPath = "yt-dlp";
                ytdl.FFmpegPath = "ffmpeg";
                ytdl.OutputFolder = "./tmp/recent episodes";
                ytdl.OutputFileTemplate = "%(upload_date)s - %(title)s - [%(id)s].%(ext)s";
                var sw = new Stopwatch();
                sw.Start();
                var res = await ytdl.RunVideoDownload(articleLink);
                sw.Stop();
                var outputStr = $"{(res.Success ? "Success" : "fail")} in {sw.Elapsed}";
                if (res.ErrorOutput != null && res.ErrorOutput.Length > 0)
                {
                    outputStr += "\n" + string.Join('\n', res.ErrorOutput);
                }
                Console.WriteLine($"    download {(res.Success ? "success" : "failed")}: {articleLink} -> {res.Data}");
                if (!res.Data.EndsWith(".mp4"))
                {
                    Console.WriteLine("    must convert video");
                    sw.Reset();
                    var outputFilename = res.Data.Substring(0, res.Data.LastIndexOf('.')) + ".mp4";
                    sw.Start();
                    var conversionProc = Process.Start("ffmpeg", $"-y -i \"{res.Data}\" \"{outputFilename}\"");
                    conversionProc.WaitForExit();
                    sw.Stop();
                    Console.WriteLine($"    converted {res.Data} -> {outputFilename}");
                    File.Delete(res.Data);
                    outputStr += $"\nconverted in {sw.Elapsed}";
                }
                return new Tuple<bool, string>(res.Success, outputStr);

            }
            catch (Exception e)
            {
                Console.Error.WriteLine($"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
                return new Tuple<bool, string>(false, $"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
            }
        }
        private static async Task<Tuple<bool, string>> podcastifyYT(string articleLink, string podcastName)
        {
            Console.WriteLine($"   youtube-podcastifying {articleLink} ({podcastName})");
            try
            {
                var ytdl = new YoutubeDLSharp.YoutubeDL();
                ytdl.YoutubeDLPath = "yt-dlp";
                ytdl.FFmpegPath = "ffmpeg";
                ytdl.OutputFolder = $"./tmp/podcasts/{podcastName}";
                ytdl.OutputFileTemplate = "%(upload_date)s - %(title)s - [%(id)s].%(ext)s";
                var sw = new Stopwatch();
                sw.Start();
                var res = await ytdl.RunAudioDownload(articleLink);
                sw.Stop();
                var outputStr = $"{(res.Success ? "Success" : "fail")} in {sw.Elapsed}";
                if (res.ErrorOutput != null && res.ErrorOutput.Length > 0)
                {
                    outputStr += "\n" + string.Join('\n', res.ErrorOutput);
                }
                Console.WriteLine($"    {(res.Success ? "Success" : "fail")} in {sw.Elapsed} - {res.Data}");
                if (res.Success && !res.Data.EndsWith(".mp3"))
                {
                    Console.WriteLine("    must convert audio");
                    sw.Reset();
                    var outputFilename = res.Data.Substring(0, res.Data.LastIndexOf('.')) + ".mp3";
                    sw.Start();
                    var conversionProc = Process.Start("ffmpeg", $"-y -i \"{res.Data}\" \"{outputFilename}\"");
                    conversionProc.WaitForExit();
                    sw.Stop();
                    File.Delete(res.Data);
                    outputStr += $"\nconverted in {sw.Elapsed}";
                }
                return new Tuple<bool, string>(res.Success, outputStr);
            }
            catch (Exception e)
            {
                Console.Error.WriteLine($"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
                return new Tuple<bool, string>(false, $"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
            }
        }
        private static async Task<Tuple<bool, string>> podcastifyAttachment(string attachmentLink, string podcastName, string episodeTitle)
        {
            Console.WriteLine($"   attachment-podcastifying {attachmentLink} ({podcastName})");
            try
            {
                var extensionUpstream = attachmentLink.Substring(attachmentLink.LastIndexOf('.'));
                var containingDirectory = $"./tmp/podcasts/{podcastName}/";
                var outputFilename = $"{containingDirectory}{episodeTitle}{extensionUpstream}";
                if(!Directory.Exists(containingDirectory))
                {
                    Directory.CreateDirectory(containingDirectory);
                }
                var downloader = new HttpClient();
                var sw = new Stopwatch();
                sw.Start();
                File.WriteAllBytes(outputFilename, await (await downloader.GetAsync(attachmentLink)).Content.ReadAsByteArrayAsync());
                sw.Stop();
                var outputStr = $"{(File.Exists(outputFilename) ? "Success" : "fail")} in {sw.Elapsed}";
                Console.WriteLine($"    {outputStr} - {outputFilename}");
                if (File.Exists(outputFilename) && extensionUpstream != ".mp3")
                {
                    Console.WriteLine("    must convert audio");
                    sw.Reset();
                    var targetFilename = outputFilename.Substring(0, outputFilename.LastIndexOf('.')) + ".mp3";
                    sw.Start();
                    var conversionProc = Process.Start("ffmpeg", $"-y -i \"{outputFilename}\" \"{targetFilename}\"");
                    conversionProc.WaitForExit();
                    sw.Stop();
                    File.Delete(outputFilename);
                    outputStr += $"\nconverted in {sw.Elapsed}";
                }
                return new Tuple<bool, string>(true, outputStr);
            }
            catch (Exception e)
            {
                Console.Error.WriteLine($"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
                return new Tuple<bool, string>(false, $"{e.ToString()}: {e.Message}.\n{e.StackTrace}");
            }
        }
    }
}